The Big Picture
A single, recursive control loop that splits a large task into clear subtasks, runs local workers, and compresses their outputs makes multi-agent AI systems more accurate, transparent, and scalable.
ON THIS PAGE
The Evidence
A four-role, recursive framework (decide if a task is atomic, plan subtasks, run executors, and aggregate results) produces a hierarchical execution trace that’s easy to inspect and debug. Localized executors work with small, relevant context while aggregators compress and verify outputs before passing them up, preventing context overload. A prompt-optimization routine tailored to this setup (GEPA+) further improves performance while cutting the number of evaluations needed to tune prompts.
Not sure where to start?Get personalized recommendations
Data Highlights
1ROMA instantiated with GLM-4.6 improved accuracy on the SEAL-0 benchmark by 9.9% versus a strong baseline (Kimi-Researcher).
2GEPA+ produced 2–6 percentage-point absolute accuracy gains on long-form writing while requiring about 3–4 fewer metric evaluations than standard prompt evolution.
3ROMA plus DeepSeek-V3 matched the performance of a leading closed-source model (Claude Sonnet 4.5) on the EQ-Bench long-form writing test.
What This Means
Engineers building multi-step AI workflows and orchestration layers can reuse the same decomposition-and-aggregate pattern instead of reengineering control flow for every task. Technical leaders evaluating agent platforms will benefit from the clearer execution traces for debugging, auditing, and compliance. Researchers can use the framework to compare orchestration strategies fairly and to explore mixing models per role.
Key Figures
Fig 1: Figure 1: Overview of ROMA’s recursive architecture. An Atomizer determines whether a task is atomic. Atomic tasks are executed directly, while non-atomic tasks are decomposed into subtasks by a Planner . Each subtask is executed recursively by Executors , after which an Aggregator merges the outputs of all descendants to produce the final result.
Fig 2: Figure 2: ROMA’s hierarchical execution flow. Non-atomic tasks are decomposed top-down through planning, with left-to-right dependencies guiding execution, while results are combined bottom-up through aggregation. Executors operate on atomic subtasks, producing intermediate outputs that are aggregated into higher-level artifacts; the inset shows a zoomed-in executor node with tool interaction.
Ready to evaluate your AI agents?
Learn how ReputAgent helps teams build trustworthy AI through systematic evaluation.
Learn MoreConsiderations
Experiments mainly used a single base model per task, so benefits from mixing different models across roles were not fully explored. Some evaluations rely on closed-source judge models and search interfaces, which may affect reproducibility. GEPA+ was applied only to long-form writing in these experiments, so its effectiveness on other task families needs further study.
Methodology & More
Solve big tasks by repeating a simple loop: decide if the task is already atomic, break non-atomic tasks into mutually exclusive and collectively exhaustive subtasks, run small local workers on atomic pieces, and then synthesize and compress the child outputs back into a parent result. The four roles—Atomizer (decides if a task is atomic), Planner (creates a dependency-aware subtask graph), Executors (handle atomic work, possibly in parallel), and Aggregator (verifies and compresses child outputs)—are applied recursively. That creates a hierarchical trace of every planning, execution, and aggregation step, which makes it straightforward to find where failures happen and limits how much intermediate detail must be kept in context.
Tailored prompt tuning (GEPA+) speeds adaptation by proposing multiple prompt edits in parallel, judging them with lightweight evaluators, and merging the best changes into safe updates; this gave consistent gains while using fewer evaluations. In benchmarks, the framework improved reasoning accuracy (9.9% on SEAL-0 with GLM-4.6), matched top closed-source long-form writing models when paired with a strong generator, and produced measurable gains from prompt optimization. The approach is model-agnostic, supports parallel execution of independent branches, and intentionally limits context growth by passing up compressed, verified summaries rather than raw transcripts. Future work should test heterogeneous model assignments per role, broaden GEPA+’s application, and increase reproducibility with open evaluation stacks.
- Links: hierarchical trace, parallel execution
Avoid common pitfallsLearn what failures to watch for
Credibility Assessment:
Mostly low h-indices and no known affiliations; small citation count but still an arXiv paper — limited signals.