ROMA: Recursive Open Meta-Agent Framework for Long-Horizon Multi-Agent Systems
ROMA plus GEPA+ lifts SEAL-0 accuracy by 9.9% over Kimi-Researcher.
Key Findings
Methodology
ROMA standardizes long-horizon agentic work into four roles: Atomizer, Planner, Executors, and Aggregator. Atomizer decides whether a task is atomic; non-atomic tasks are split by the Planner into a MECE, dependency-aware DAG; Executors handle atomic leaves with type-specialized strategies; Aggregator compresses, validates, and merges child outputs bottom-up. The framework is built in DSPy with typed I/O, supports task types such as search, think, write, and code, and uses sandboxed execution plus MCP-style tool access.
Key Results
- On SEAL-0, ROMA instantiated with GLM-4.6 improves accuracy by 9.9% over Kimi-Researcher, showing that recursive decomposition and structured aggregation materially help reasoning over conflicting web evidence.
- On EQ-Bench, ROMA enables DeepSeek-V3 to match leading closed-source systems such as Claude Sonnet 4.5, demonstrating that an open model can reach top-tier long-form writing performance when paired with the right orchestration layer.
- GEPA+ typically delivers 2–6 absolute-point gains over standard GEPA under the same budget, while requiring roughly 3–4× fewer metric evaluations; this supports the paper’s claim that parallel proposal generation plus contract-preserving merging is a more sample-efficient optimizer.
Significance
The paper addresses three persistent failures of current agentic systems: brittle sequential orchestration, context-window blowup, and opaque execution traces that are hard to debug. ROMA reframes multi-agent design around a reusable meta-agent protocol rather than an ad hoc prompt chain. That matters academically because it gives researchers a common abstraction for comparing, composing, and auditing agents; it matters operationally because it allows teams to mix models and tools without redesigning the control flow each time. In short, ROMA aims to make long-horizon agent behavior both scalable and inspectable.
Technical Contribution
ROMA’s technical contribution is a recursive execution semantics with explicit contracts: is_atomic(t) decides whether to stop recursion, plan(t) emits a dependency-aware DAG, execute(t) runs localized leaf computation, and aggregate(·) returns a parent-scoped artifact rather than a raw transcript. Unlike linear planners, ROMA allows parallel branches and left-to-right dependencies in the same graph. Unlike naive summarization, the Aggregator performs relevance-preserving compression and validation. GEPA+ extends DSPy’s GEPA by moving from single-proposer prompt edits to K-way diverse proposals, judge/verifier reranking, and structured merging across multiple modules, which opens a practical path to no-finetuning adaptation.
Novelty
The novelty is twofold. First, ROMA elevates recursive task decomposition from a heuristic into a domain-agnostic meta-agent framework with fixed roles and transparent hierarchical traces. Second, GEPA+ optimizes prompts inside that hierarchy while preserving module contracts, rather than treating the system as one monolithic prompt. Compared with most prior agent frameworks, the key jump is from ad hoc orchestration to a standardized recursive protocol with explicit dependency graphs and structured aggregation.
Limitations
- The evaluation set is still relatively benchmark-centric: SEAL-0, FRAMES, SimpleQA, EQ-Bench, and AbGen cover important capabilities, but they do not fully capture messy real-world tool ecosystems, extremely long contexts, or safety-critical deployment settings. Some gains may also depend on strong search results and strong judge models.
- Although ROMA supports heterogeneous model assignment, the experiments mostly use a single base model per task, so the paper does not yet quantify the best cost-latency-quality trade-off for different roles. In practice, optimal routing across Atomizer, Planner, Executors, and Aggregator remains an open systems question.
Future Work
Future work should study learned decomposition policies, role-specific model routing, stronger aggregation verification, and more robust tool-chain safety. The paper itself leaves heterogeneous role assignment as a direction for further exploration. A natural next step is to combine ROMA with longer memory, online adaptation, and formal checks so that deep reasoning remains both efficient and auditable under real deployment constraints.
AI Executive Summary
ROMA responds to a familiar failure mode in modern agent systems: once a task stops being a single prompt and becomes a long-horizon workflow spanning search, reasoning, writing, and code, ad hoc orchestration starts to crack. The context grows, errors propagate, and the system’s internal decisions become difficult to inspect. Instead of adding yet another monolithic planner, ROMA proposes a reusable meta-agent structure that treats decomposition, execution, and aggregation as first-class, recursive operations.
At the center is a four-role protocol. An Atomizer first asks whether the current task is atomic. If not, a Planner decomposes it into a dependency-aware DAG of mutually exclusive and collectively exhaustive subtasks. Executors then solve atomic leaves, with task types routing to specialized strategies such as ReAct for search, CoT for reasoning, drafting for writing, and CodeAct for programmatic manipulation. Once children finish, an Aggregator compresses and validates their outputs into a parent-scoped artifact. This top-down planning and bottom-up aggregation loop repeats at every node, producing a hierarchical trace that is far easier to debug than a flat transcript.
ROMA’s second contribution, GEPA+, extends DSPy’s prompt optimization into the same modular hierarchy. Rather than editing one prompt at a time, GEPA+ generates K diverse candidate edits in parallel, ranks them with judge and verifier signals using a composite score J(π|D)=α Judge + β Verifier − γ ContractViolations, and merges the best ideas while preserving interface contracts. In the authors’ experiments, this design yields 2–6 absolute-point gains and roughly 3–4× fewer metric evaluations than standard GEPA, which makes task-specific adaptation more efficient without fine-tuning.
Empirically, ROMA delivers strong system-level results. On SEAL-0, which tests reasoning over conflicting web evidence, ROMA with GLM-4.6 improves accuracy by 9.9% over Kimi-Researcher. On EQ-Bench, a long-form writing benchmark, ROMA enables DeepSeek-V3 to match closed-source leaders such as Claude Sonnet 4.5. The paper also evaluates on FRAMES, SimpleQA, and AbGen, and uses GPT-4o-mini as judge for several tasks, with Claude Sonnet 4 serving as the official-style evaluator on EQ-Bench. These results suggest that the main gains are not merely from stronger base models, but from better system design.
The broader message is that multi-agent systems need an architecture, not just a prompt recipe. ROMA’s value lies in making long-horizon computation legible: who planned what, which branch depended on which result, and how intermediate evidence was condensed. That kind of trace is useful both for research and for deployment, especially when different models, tools, and budgets must coexist. In that sense, ROMA is less a single agent and more a blueprint for building agent ecosystems.
The remaining challenge is to prove this blueprint at scale. The paper still relies on benchmark-heavy evaluation and mostly single-model instantiations, so the optimal routing of heterogeneous models across roles is unresolved. Future work will need to test whether ROMA’s recursive structure remains stable in messier real-world settings, with longer contexts, noisier tools, and stronger safety constraints. If it does, ROMA could become a foundation for interpretable, modular, and adaptable agent platforms.
Deep Analysis
Background
LLM agents have evolved from simple chat wrappers into multi-step systems that retrieve information, reason over evidence, call tools, and generate structured outputs. Prior work such as ReAct, CoT, CodeAct, and various research agents showed that decomposition helps, but many systems remain hand-wired, linear, and brittle. They often hard-code control flow, hide intermediate states, and accumulate transcripts until the context window becomes the bottleneck. ROMA builds on the idea of recursive writing assistants and generalizes it into a domain-agnostic architecture with typed modules, explicit dependencies, and structured aggregation.
Core Problem
The core problem is how to scale agent reasoning depth without sacrificing robustness or interpretability. Sequential orchestration is brittle because one bad step can poison the entire run. Flat context accumulation is also expensive and unstable: each new retrieval, note, or tool output enlarges the prompt until earlier evidence is diluted or truncated. A third issue is observability: when a long task fails, most systems cannot localize whether the fault came from decomposition, retrieval, execution, or merging. ROMA is designed to solve all three at once.
Innovation
ROMA’s first innovation is a fixed four-role contract that separates concerns cleanly. Atomizer decides whether to recurse; Planner decides how to recurse; Executors do local work; Aggregator composes results. Second, the Planner emits a dependency-aware DAG, not a simple list, so parallelizable branches can run concurrently while precedence constraints are preserved. Third, the Aggregator is a semantic compressor: it returns a concise, verified parent artifact rather than raw child traces, which directly addresses context growth. Fourth, GEPA+ turns prompt optimization into a multi-module search problem with diverse proposals, judge/verifier reranking, and contract-preserving merging.
Methodology
- �� Task input: a textual goal with optional constraints and output expectations.
- �� Atomizer: compute is_atomic(t); if True, bypass planning and call execute(t) directly.
- �� Planner: if the task is non-atomic, call plan(t) to produce S(t), a dependency-aware DAG whose nodes are subtasks and whose edges encode precedence.
- �� Executors: solve atomic subtasks with type-specialized implementations. ROMA names four task types—search, think, write, code—and maps them to strategies such as ReAct, CoT, drafting, and CodeAct.
- �� Aggregator: collect child outputs and call aggregate({ys}) to synthesize a parent-level answer, table, paragraph, JSON object, or other target artifact.
- �� Parallelism: independent branches at the same level can execute in parallel; dependent branches unblock as soon as predecessors finish.
- �� Safety and tools: code tasks run in a sandbox and can access external APIs or MCP servers through standard interfaces; artifacts are stored externally rather than embedded into prompts.
- �� Optimization: GEPA+ samples k prompt edits in parallel, scores them with judge and verifier terms, penalizes contract violations, keeps the top-n candidates, and merges them into a single interface-safe update.
Experiments
The evaluation suite spans SEAL-0, FRAMES, SimpleQA, EQ-Bench, and AbGen. SEAL-0 measures reasoning over conflicting web evidence; FRAMES and SimpleQA probe multi-hop factual reasoning and QA; EQ-Bench stresses long-form writing; AbGen checks whether the model can design rigorous ablations. For search-intensive tasks, ROMA uses the GPT-5-mini search interface to gather evidence. GLM is used on the reasoning/search side, while DeepSeek-V3 is used for generation-heavy tasks. The paper also reports that GPT-4o-mini serves as the LLM judge on SEAL-0, FRAMES, and SimpleQA, and Claude Sonnet 4 evaluates EQ-Bench in line with the benchmark protocol. GEPA+ is applied mainly to EQ-Bench, where prompt quality has the largest visible effect.
Results
The headline finding is the SEAL-0 result: ROMA instantiated with GLM-4.6 improves accuracy by 9.9% over Kimi-Researcher. That is important because SEAL-0 specifically tests reasoning over conflicting web evidence, a setting where brittle evidence ordering and poor aggregation often hurt agent performance. A second highlight is EQ-Bench: with GEPA+, ROMA enables DeepSeek-V3 to match top closed-source writing systems such as Claude Sonnet 4.5, indicating that orchestration quality can close much of the gap between open and closed models. A third result is optimization efficiency: GEPA+ typically achieves 2–6 absolute-point gains while using about 3–4× fewer metric evaluations than standard GEPA.
Applications
ROMA is directly relevant to deep research assistants, long-form report generation, evidence-grounded QA, and code-enabled analytic workflows. Teams can assign cheaper models to local execution, stronger models to planning or aggregation, and tools to sandboxed code or search nodes. Because the control loop is explicit, product teams can inspect plans, child outputs, and final merges, which is useful for debugging and compliance. The framework is also well suited to modular benchmarking and ablation studies in research labs.
Limitations & Outlook
ROMA’s current evidence is strongest on benchmarked tasks, not on open-ended production environments with many tool types, noisy retrieval, or high-stakes safety constraints. The paper also does not fully explore when recursion should stop, how deep the task tree should be, or how best to allocate heterogeneous models across roles. Finally, performance depends on the quality of judges, verifiers, and external search results, so weak auxiliary signals could limit gains. More work is needed on automatic role routing, stronger verification, and robustness under distribution shift.
Plain Language Accessible to non-experts
Think of ROMA like a well-run restaurant kitchen that handles giant banquet orders. The head chef does not cook everything alone. First, the chef checks whether a dish is simple enough to make directly. If it is a big order, the chef splits it into smaller jobs: one person prepares ingredients, another cooks, another plates, and someone else checks whether the final dish matches the order. Each worker only sees the part they need, so they do not get overwhelmed by the entire banquet menu.
Now imagine the kitchen also keeps its notes tidy. Instead of passing around every scribbled draft and every half-finished plate, the final checker gives each station a short, clean summary of what matters. That keeps the kitchen from drowning in paperwork and prevents confusion when the order is huge. ROMA does the same thing with information: it breaks big tasks into small ones, lets them run in parallel when possible, and then condenses the results before moving upward.
GEPA+ is like a smart improvement meeting for the kitchen. Several consultants suggest recipe changes at the same time, the manager checks which ideas actually help and which would break the workflow, and then the best changes are merged into one updated playbook. The result is a kitchen that can handle bigger banquet orders, make fewer mistakes, and still keep a clear record of how each dish was prepared.
ELI14 Explained like you're 14
Imagine you’re leading a raid in a game where the mission is huge: find clues, beat bosses, craft items, and write a perfect strategy guide all at once. ROMA is like giving you a team with clear jobs. First, one teammate asks, “Can I do this right away, or is this quest too big?” If it’s big, another teammate breaks it into smaller quests. Then different teammates do their parts at the same time: one searches, one thinks, one writes, and one handles code-like stuff.
The coolest part? They don’t all keep dumping every tiny detail into one giant chat. That would be chaos! Instead, after each mini-quest is done, someone summarizes the important stuff and passes only that upward. So the team doesn’t get stuck reading endless logs or replaying the whole match history. It’s like clearing a level and keeping only the useful loot.
GEPA+ is basically the team’s “upgrade patch” system. Instead of asking one person for one idea, it asks several people for several ideas, checks which ones are actually good, and then mixes the best parts into one cleaner plan. Pretty smart, right? That’s how ROMA helps big tasks feel less like a messy boss fight and more like a well-coordinated squad mission.
Glossary
Atomizer
A module that decides whether a task is small enough to execute directly. Technically, it computes is_atomic(t) and controls whether recursion stops at the current node.
Used at every node before planning or execution.
Planner
The module that breaks a non-atomic task into subtasks and attaches dependency edges. In this paper it produces a MECE, dependency-aware DAG rather than a flat list.
Used to implement plan(t).
Executor
The local worker that solves atomic subtasks. In practice it can be specialized by task type, such as search, think, write, or code.
Used to implement execute(t) for leaf nodes.
Aggregator
The module that merges child outputs into a concise parent artifact. It does validation and compression, not just concatenation.
Used to implement aggregate({ys}).
GEPA+
A multi-proposer prompt optimizer that generates several candidate edits in parallel, reranks them with judge/verifier signals, and merges the best ideas while preserving module contracts.
Used to tune ROMA components without fine-tuning model weights.
Open Questions Unanswered questions from this research
- 1 The paper does not yet answer how ROMA behaves under truly heterogeneous tool ecosystems with many external APIs, adversarial or noisy evidence, and much longer histories. Strong benchmark gains may not translate directly to those settings, so broader evaluation is still needed.
- 2 GEPA+ improves efficiency, but the best strategy for balancing judge cost, verifier strength, and proposal diversity is still open. More principled search over k, n, and module-specific edit operators could make the optimizer more reliable and cheaper.
Applications
Immediate Applications
Deep research assistant
Research teams can use ROMA to separate evidence gathering, reasoning, and synthesis into explicit stages. With a search interface and verifiers, it can produce better-traceable reports and make late-stage errors easier to locate.
Long-form writing system
Editorial or content teams can assign planning, drafting, and polishing to different roles, then let the Aggregator enforce the final structure. This is useful when a project needs consistent style, citations, and a clean final output.
Long-term Vision
General agent operating system
In the long run, ROMA could become a base layer for enterprise agents that mix models, tools, memory, and safety checks. The main obstacles are automatic decomposition, robust routing, and verified aggregation at scale.
Abstract
Current agentic frameworks underperform on long-horizon tasks. As reasoning depth increases, sequential orchestration becomes brittle, context windows impose hard limits that degrade performance, and opaque execution traces make failures difficult to localize or debug. We introduce ROMA (Recursive Open Meta-Agents), a domain-agnostic framework that addresses these limitations through recursive task decomposition and structured aggregation. ROMA decomposes goals into dependency-aware subtask trees that can be executed in parallel, while aggregation compresses and validates intermediate results to control context growth. Our framework standardizes agent construction around four modular roles --Atomizer (which decides whether a task should be decomposed), Planner, Executor, and Aggregator -- which cleanly separate orchestration from model selection and enable transparent, hierarchical execution traces. This design supports heterogeneous multi-agent systems that mix models and tools according to cost, latency, and capability. To adapt ROMA to specific tasks without fine-tuning, we further introduce GEPA$+$, an improved Genetic-Pareto prompt proposer that searches over prompts within ROMA's component hierarchy while preserving interface contracts. We show that ROMA, combined with GEPA+, delivers leading system-level performance on reasoning and long-form generation benchmarks. On SEAL-0, which evaluates reasoning over conflicting web evidence, ROMA instantiated with GLM-4.6 improves accuracy by 9.9\% over Kimi-Researcher. On EQ-Bench, a long-form writing benchmark, ROMA enables DeepSeek-V3 to match the performance of leading closed-source models such as Claude Sonnet 4.5. Our results demonstrate that recursive, modular agent architectures can scale reasoning depth while remaining interpretable, flexible, and model-agnostic.