Where AI learns to feel,
and you shape what it becomes
Open Source. Open Senses. Open Future.
We are a growing collective of researchers, engineers, thinkers exploring the frontier of artificial intelligence, in the open, for everyone
👁 Person in white outfit running through a field of tall grass or wildflowers during sunset or dusk.
👁 Person in pink clothes running outdoors against a blue sky and green mountain background.
👁 Close-up of two hands clasped together against a blue sky background.
👁 Person reaching up towards a four-leaf clover against a clear blue sky.
👁 Young woman with dark hair laughing while being lifted into the air by friends under a blue sky with clouds.
👁 Person in black running rapidly across a dry, open landscape with hills in the background.
.webp){kind=link}
👁 Person in pink clothes running outdoors against a blue sky and green mountain background.
.webp){kind=link}
👁 Close-up of two hands clasped together against a blue sky background.
.webp){kind=link}
👁 Person reaching up towards a four-leaf clover against a clear blue sky.
.webp){kind=link}
👁 Young woman with dark hair laughing while being lifted into the air by friends under a blue sky with clouds.
.webp){kind=link}
👁 Person in black running rapidly across a dry, open landscape with hills in the background.
.webp){kind=link}
- RESEARCHERS
- BUILDERS
- CEOs
- FOUNDERS
- COMMUNITY BUILDERS
- ENGINEERS
import dspy
from roma_dspy import Aggregator, Atomizer, Executor, Planner, Verifier, SubTask
from roma_dspy.types import TaskType
# Optional tool that the Executor may call def get_weather(city: str) -> str: """Return a canned weather report for the city.""" return f"The weather in {city} is sunny."
# Executor geared toward ReAct with a Fireworks model executor_lm = dspy.LM( "fireworks_ai/accounts/fireworks/models/kimi-k2-instruct-0905", temperature=0.7, cache=True, ) executor = Executor( lm=executor_lm, prediction_strategy="react", tools=[get_weather], context_defaults={"track_usage": True}, )
# Atomizer decides when to branch into planning atomizer = Atomizer( lm=dspy.LM("openrouter/google/gemini-2.5-flash", temperature=0.6, cache=False), prediction_strategy="cot", context_defaults={"track_usage": True}, )
# Planner produces executable subtasks for non-atomic goals planner = Planner( lm=dspy.LM("openrouter/openai/gpt-4o-mini", temperature=0.85, cache=True), prediction_strategy="cot", context_defaults={"track_usage": True}, )
aggregator = Aggregator( lm=dspy.LM("openrouter/openai/gpt-4o-mini", temperature=0.65), prediction_strategy="cot", )
verifier = Verifier( lm=dspy.LM("openrouter/openai/gpt-4o-mini", temperature=0.0), )
def run_pipeline(goal: str) -> str: atomized = atomizer.forward(goal) if atomized.is_atomic or atomized.node_type.is_execute: execution = executor.forward(goal) candidate = execution.output else: plan = planner.forward(goal) results = [] for idx, subtask in enumerate(plan.subtasks, start=1): execution = executor.forward(subtask.goal) results.append( SubTask( goal=subtask.goal, task_type=subtask.task_type, dependencies=subtask.dependencies, ) ) aggregated = aggregator.forward(goal, results) candidate = aggregated.synthesized_result
verdict = verifier.forward(goal, candidate) if verdict.verdict: return candidate return f"Verifier flagged the output: {verdict.feedback or 'no feedback returned'}"
print(run_pipeline("Plan a weekend in Barcelona and include a packing list."))
# Optional tool that the Executor may call def get_weather(city: str) -> str: """Return a canned weather report for the city.""" return f"The weather in {city} is sunny."
# Executor geared toward ReAct with a Fireworks model executor_lm = dspy.LM( "fireworks_ai/accounts/fireworks/models/kimi-k2-instruct-0905", temperature=0.7, cache=True, ) executor = Executor( lm=executor_lm, prediction_strategy="react", tools=[get_weather], context_defaults={"track_usage": True}, )
# Atomizer decides when to branch into planning atomizer = Atomizer( lm=dspy.LM("openrouter/google/gemini-2.5-flash", temperature=0.6, cache=False), prediction_strategy="cot", context_defaults={"track_usage": True}, )
# Planner produces executable subtasks for non-atomic goals planner = Planner( lm=dspy.LM("openrouter/openai/gpt-4o-mini", temperature=0.85, cache=True), prediction_strategy="cot", context_defaults={"track_usage": True}, )
aggregator = Aggregator( lm=dspy.LM("openrouter/openai/gpt-4o-mini", temperature=0.65), prediction_strategy="cot", )
verifier = Verifier( lm=dspy.LM("openrouter/openai/gpt-4o-mini", temperature=0.0), )
def run_pipeline(goal: str) -> str: atomized = atomizer.forward(goal) if atomized.is_atomic or atomized.node_type.is_execute: execution = executor.forward(goal) candidate = execution.output else: plan = planner.forward(goal) results = [] for idx, subtask in enumerate(plan.subtasks, start=1): execution = executor.forward(subtask.goal) results.append( SubTask( goal=subtask.goal, task_type=subtask.task_type, dependencies=subtask.dependencies, ) ) aggregated = aggregator.forward(goal, results) candidate = aggregated.synthesized_result
verdict = verifier.forward(goal, candidate) if verdict.verdict: return candidate return f"Verifier flagged the output: {verdict.feedback or 'no feedback returned'}"
print(run_pipeline("Plan a weekend in Barcelona and include a packing list."))
Contact us to talk about how we can shape the Sentient Foundation together
Sentient grows with
every interaction
ROMA
Reasoning & Orchestration for Machine Agents
ROMA is an open framework for building multi-agent AI systems with structured reasoning and coordination.
OML
Open, Monetizable,
Loyal Models
OML proposes a new primitive for distributing AI models that balances openness, control, and sustainability.
ODS
Open Deep Search
Open Deep Search (ODS) is a framework for building search-augmented reasoning systems using open-source models.
Open research, in public through Sentient Labs
import dspy
from roma_dspy import Aggregator, Atomizer, Executor, Planner, Verifier, SubTask
from roma_dspy.types import TaskType
# Optional tool that the Executor may call def get_weather(city: str) -> str: """Return a canned weather report for the city.""" return f"The weather in {city} is sunny."
# Executor geared toward ReAct with a Fireworks model executor_lm = dspy.LM( "fireworks_ai/accounts/fireworks/models/kimi-k2-instruct-0905", temperature=0.7, cache=True, ) executor = Executor( lm=executor_lm, prediction_strategy="react", tools=[get_weather], context_defaults={"track_usage": True}, )
# Atomizer decides when to branch into planning atomizer = Atomizer( lm=dspy.LM("openrouter/google/gemini-2.5-flash", temperature=0.6, cache=False), prediction_strategy="cot", context_defaults={"track_usage": True}, )
# Planner produces executable subtasks for non-atomic goals planner = Planner( lm=dspy.LM("openrouter/openai/gpt-4o-mini", temperature=0.85, cache=True), prediction_strategy="cot", context_defaults={"track_usage": True}, )
aggregator = Aggregator( lm=dspy.LM("openrouter/openai/gpt-4o-mini", temperature=0.65), prediction_strategy="cot", )
verifier = Verifier( lm=dspy.LM("openrouter/openai/gpt-4o-mini", temperature=0.0), )
def run_pipeline(goal: str) -> str: atomized = atomizer.forward(goal) if atomized.is_atomic or atomized.node_type.is_execute: execution = executor.forward(goal) candidate = execution.output else: plan = planner.forward(goal) results = [] for idx, subtask in enumerate(plan.subtasks, start=1): execution = executor.forward(subtask.goal) results.append( SubTask( goal=subtask.goal, task_type=subtask.task_type, dependencies=subtask.dependencies, ) ) aggregated = aggregator.forward(goal, results) candidate = aggregated.synthesized_result
verdict = verifier.forward(goal, candidate) if verdict.verdict: return candidate return f"Verifier flagged the output: {verdict.feedback or 'no feedback returned'}"
print(run_pipeline("Plan a weekend in Barcelona and include a packing list."))
# Optional tool that the Executor may call def get_weather(city: str) -> str: """Return a canned weather report for the city.""" return f"The weather in {city} is sunny."
# Executor geared toward ReAct with a Fireworks model executor_lm = dspy.LM( "fireworks_ai/accounts/fireworks/models/kimi-k2-instruct-0905", temperature=0.7, cache=True, ) executor = Executor( lm=executor_lm, prediction_strategy="react", tools=[get_weather], context_defaults={"track_usage": True}, )
# Atomizer decides when to branch into planning atomizer = Atomizer( lm=dspy.LM("openrouter/google/gemini-2.5-flash", temperature=0.6, cache=False), prediction_strategy="cot", context_defaults={"track_usage": True}, )
# Planner produces executable subtasks for non-atomic goals planner = Planner( lm=dspy.LM("openrouter/openai/gpt-4o-mini", temperature=0.85, cache=True), prediction_strategy="cot", context_defaults={"track_usage": True}, )
aggregator = Aggregator( lm=dspy.LM("openrouter/openai/gpt-4o-mini", temperature=0.65), prediction_strategy="cot", )
verifier = Verifier( lm=dspy.LM("openrouter/openai/gpt-4o-mini", temperature=0.0), )
def run_pipeline(goal: str) -> str: atomized = atomizer.forward(goal) if atomized.is_atomic or atomized.node_type.is_execute: execution = executor.forward(goal) candidate = execution.output else: plan = planner.forward(goal) results = [] for idx, subtask in enumerate(plan.subtasks, start=1): execution = executor.forward(subtask.goal) results.append( SubTask( goal=subtask.goal, task_type=subtask.task_type, dependencies=subtask.dependencies, ) ) aggregated = aggregator.forward(goal, results) candidate = aggregated.synthesized_result
verdict = verifier.forward(goal, candidate) if verdict.verdict: return candidate return f"Verifier flagged the output: {verdict.feedback or 'no feedback returned'}"
print(run_pipeline("Plan a weekend in Barcelona and include a packing list."))
Open AGI Summit
A space for builders, founders, and researchers to discuss the future of open-source AI
Open AGI
Summit
02.19.2026
Bringing together researchers, developers, and communities united by the shared conviction that AGI must remain open and accessible to everyone.
Research releases, announcements, and milestones from Sentient Foundation
Sentient Foundation Commits $42 Million to Advance Open Source AGI
// Korea
//
One of the largest commitments dedicated exclusively to open-source AGI, supporting the developers, researchers, and startups building AI in the open.
.png){kind=link}
Sentient Expands Across Asia
// Korea
//Asia
Sentient continues its expansion across Asia, building partnerships with universities, researchers, and local communities. The initiative strengthens the foundation’s mission to advance open and collaborative AGI development.
Be the Sparks, Ignite with Sentient Sparks
// Korea
//Europe
Sentient Sparks is a community-driven initiative designed to empower contributors in the Open AGI ecosystem. The program encourages experimentation, collaboration, and the exchange of bold ideas.
