ROMA
Sentient (sentient-agi) · Coding · Other
ROMA is Sentient's open-source meta-agent framework. It splits a complex request into subtasks across a recursive agent tree, then merges the answers into one result.
About ROMA
What Is ROMA
ROMA stands for Recursive Open Meta-Agent, and it is a free, open-source framework for building multi-agent systems. Instead of wiring together one giant prompt, you give ROMA a goal and it decides how to get there. A parent node either solves the task directly or breaks it into smaller subtasks, hands each one down as context, and combines what comes back up the tree. The repo ships under the sentient-agi organization on GitHub, and you install it as a Python package called roma-dspy.
The framework targets a specific kind of failure. Single-step jobs like summarizing an article or answering a quick question are mostly solved. Long jobs that run through many steps are not, because small mistakes pile up until the whole run falls apart. ROMA answers that with structure: every node declares what it received and what it produced, so you can trace exactly where a run went wrong instead of staring at a black box.
Two limits matter before you commit. ROMA is still in beta, labeled v0.1 and then v0.2.0-beta, so the API can shift between releases. And it is a developer tool, not a finished app. You write Python, set an API key for a model provider, and choose your own agents and tools. If you don't code, the search agent built on top of it is the friendlier entry point.
Getting Started
- Install the package with
pip install roma-dspyoruv pip install roma-dspy, then set an API key such as OPENROUTER_API_KEY - Call
solve()on a task, or build a pipeline yourself from the Atomizer, Planner, Executor and Aggregator modules - Point each module at a model and a prediction strategy, and attach any tools the Executor should call
- Run the task, then read the node-by-node trace to see how the answer was reached and refine the prompts
- For production, bring up the Docker stack to add PostgreSQL persistence, the REST API server and MLflow observability
Product Information
A quick look at ROMA's pricing, supported platforms, and performance.
Best for
The users, tasks, and scenarios where this tool fits best.
Users
- AI developers and engineers
- Agent researchers
- Product teams shipping agent features
- Open-source contributors
Tasks
- Research and report writing
- Multi-source search
- Crypto and finance analysis
- Web and document tasks
- Custom pipelines
Scenarios
- A question that needs many steps to answer
- A run that fails partway
- Independent subtasks that can run at once
- A task that needs a human check
Key features
Recursive agent tree
ROMA models every task as a node that can execute, split itself into subtasks, or merge its children's work. The same decision logic runs at each level, so the tree grows as deep as the problem needs. That recursion is the core idea, and it is what lets one framework handle both a single question and a job with dozens of moving parts.
Four modules with one job each
The Atomizer decides if a task is small enough to solve directly. The Planner breaks the rest into ordered subtasks. The Executor runs each atomic piece, calling tools when needed. The Aggregator pulls the child results back into an answer for the parent task, not just a raw dump. An optional Verifier checks that final answer against the original goal before it ships.
Transparent stage tracing
Every node records its inputs and outputs, so the whole run is inspectable after the fact. You can see how the reasoning unfolded, where a prompt drifted and which agent produced a weak result. That trace is what makes debugging and prompt tuning practical, and it is the main difference from frameworks that hide their internal steps.
Plug in any agent, tool or model
Each node can run on a different model, provider or strategy, and you can attach tools or swap agents without touching the rest of the tree. Toolkits cover file operations, a calculator, code execution through E2B, web search, crypto data and any MCP server. Existing DSPy prediction strategies, from chain-of-thought to ReAct and CodeAct, are exposed as options.
Parallel execution and human checkpoints
When sibling subtasks don't depend on each other, ROMA runs them at the same time, which keeps big jobs quick. This agent orchestration also lets a person step in at any node, so they can verify facts, add context or confirm the plan before the run continues.
Proven search performance
Sentient built ROMA Search on the framework and measured it on SEAL-0, a hard slice of the SEALQA benchmark for multi-source reasoning. According to Sentient, it scored 45.6% accuracy, ahead of Kimi Researcher at 36% and more than double Gemini 2.5 Pro's 19.8%, making it the state of the art at the time of launch.
Docker stack for production
The quick start runs with no database at all, which suits experiments. For real deployments, a Docker setup adds PostgreSQL for persistence and checkpoints, a FastAPI server with interactive docs, MLflow for experiment tracking and an S3-compatible store for large outputs.
Pros and cons
Pros
- Free and open source, so you can read, fork and extend the whole framework instead of trusting a closed black box
- Recursive task tree handles long multi-step jobs where a single prompt would break down
- Full stage tracing makes debugging and context engineering fast, since every node's input and output is visible
- Mix models, providers and tools per node, with built-in support for MCP servers and DSPy strategies
- Independent subtasks run in parallel, keeping large jobs with hundreds of nodes responsive
- Ready-made toolkits cover search, files, code execution and crypto data without extra wiring
Cons
- Still beta (v0.1, then v0.2.0-beta), so APIs can change and break your code between releases
- Developer-focused: building an agent means writing Python, which rules out non-coders
- You supply and pay for your own model API keys, so costs scale with how much you run
- No official single price or hosted plan, and the repo does not list a standard license file, so check terms before commercial use
Frequently asked questions
ROMA is short for Recursive Open Meta-Agent. The name points at the two ideas behind it: a recursive structure that keeps breaking tasks into subtasks, and an open, extensible design anyone can build on.
Related content
Explore related tools, skills, and articles for ROMA.
ROMA Alternatives
Base Code
Base44 (Wix) · Coding · ProductivityBase Code is a shared cloud development environment from Base44. Teammates describe changes to an existing GitHub codebase in chat, preview them live and send them back as pull requests.
Google EmbeddingGemma 2
Google DeepMind · Writing · Image · CodingGoogle EmbeddingGemma 2 is a 740M-parameter open model that turns text, code, images, audio, and video frames into vectors in one 768-dimension space, running on phones and laptops.
GitGlow
GitGlow · Coding · ProductivityGitGlow is a local-first desktop Git client that lets independent developers review their own code and their AI agents' changes in one place before shipping.