ROMA

ROMA: The Backbone for Open-Source Meta-Agents

ROMA (Recursive Open Meta-Agent) is an open-source framework designed to build high-performance multi-agent systems. It helps solve complex problems by breaking them down into smaller, manageable tasks. ROMA uses a structured, hierarchical, recursive task tree. Parent nodes can break down complex goals into subtasks, pass them to child nodes, and then combine the results as they flow back up. This makes it easier to build agents that can handle tasks requiring multiple steps.

For example, if you want an agent to write a report on the climate differences between Los Angeles and New York, a parent node could break this into subtasks: researching LA’s climate, researching NYC’s climate, and then creating a final comparison task that analyzes the differences and aggregates the results into a comprehensive report.

ROMA ensures transparency and traceability in the flow of context, making it straightforward to debug, refine prompts, and swap agents. Its modular design allows for the integration of any agent, tool, or model at the node level, including specialized LLM-based agents and human-in-the-loop checkpoints. The tree-based structure also encourages parallelization, delivering both flexibility and high performance for large, demanding problems.

To demonstrate its efficacy, ROMA Search, an internet search agent built using ROMA’s architecture, achieved state-of-the-art performance on the challenging SEALQA benchmark subset known as Seal-0, which tests complex, multi-source reasoning. ROMA Search achieved 45.6% accuracy, outperforming the previous best performer, Kimi Researcher, at 36% accuracy, and more than doubling Gemini 2.5 Pro’s performance at 19.8%. Among open-source models, ROMA Search significantly outperformed the next best system, Open Deep Search, which achieved 8.9% accuracy.

ROMA Search also demonstrated effectiveness across different types of search challenges, achieving state-of-the-art performance on FRAMES (multi-step reasoning) and near state-of-the-art results on SimpleQA (factual knowledge retrieval). Most importantly, ROMA is open-source and extensible by design, allowing anyone to plug in new agents, extend the framework with custom tools, or adapt it for various domains ranging from financial analysis to creative content generation.

Why Long-Horizon Tasks Break Agents

AI has made significant strides in single-step tasks but struggles with long-horizon tasks that require multiple steps or reasoning to reach a goal. The problem is that errors compound, and a single hallucination, misapplied instruction, or lost piece of context can derail the entire process. Addressing this fragility requires solving two tightly coupled challenges: the meta-challenge (architecture) and the task-specific challenge (instantiation).

Search is a great case study because it stresses both challenges. It is inherently multi-step and tightly bound to up-to-date, real-world knowledge. For example, answering the question, “How many movies with an estimated net budget of $350 million or more were not the highest-grossing film of their release year?” requires breaking the query into parts, gathering fresh data from multiple sources, reasoning about the results, and synthesizing a clean, final answer.

ROMA’s Architecture: From Goals to Results

ROMA addresses the long-horizon challenge by providing a recursive, hierarchical structure for agent systems. Every task is represented as a node, which can either execute directly, break itself down into subtasks, or aggregate the results of its children. This tree-like structure makes the flow of context explicit, traceable, and easy to refine.

The process begins with the main goal node, which determines whether the task is simple enough for a single agent to complete or whether it needs to be broken down. If the task is complex, the node becomes a Planner, splitting the goal into simpler pieces. Each subtask becomes a child Atomizer node, and siblings may be dependent or independent, giving a clear structure for context engineering while preserving flexibility.

Once the Atomizer decides a subtask is simple enough to execute directly, the node becomes an Executor. Executors call the appropriate tools/agents, then pass their outputs to the next dependent subtask. The final subtask returns its result to the parent, which becomes an Aggregator. The Aggregator collects child outputs, verifies consistency, and synthesizes the final answer.

At any node, a human can verify facts or add context, especially useful for very long-horizon tasks where hallucinations or gaps are likely. After planning, ROMA can also ask the user to confirm the subtasks, catching misunderstandings early. Even without human intervention, stage tracing (viewing inputs/outputs at every node) provides the transparency and control needed to diagnose errors and iterate quickly.

ROMA scales to many layers of recursion for complex goals, forming deep task trees. When sibling nodes are independent, ROMA executes them in parallel, so large jobs with hundreds or thousands of nodes remain fast.

Ready to build the future of AI agents?

ROMA Search is just the beginning. We’ve made it open-source and extensible so you can push the boundaries of what’s possible. For builders, start experimenting with building agents in ROMA. Swap in different agents, test multi-modal capabilities, or customize prompts to create agents that can generate anything from creative content like comics and podcasts to analytical work like research reports.

For researchers, advance the field by building on ROMA’s foundation. Our transparent stage tracing gives you insights into agent interactions and context flow, perfect for developing next-generation meta-agent architectures. While proprietary systems advance at the pace of a single company, ROMA evolves with the entire community’s collective efforts. Get started with ROMA today by visiting the GitHub repo or watching the video presentation.