ROMA by Sentient AI: A Recursive Meta-Agent Framework for Transparent, High-Performance Multi-Agent Systems

What ROMA does

ROMA (Recursive Open Meta-Agent) is an open-source meta-agent framework from Sentient AI that models agent workflows as a hierarchical, recursive task tree. Each parent node breaks down a complex goal into subtasks, passes context to child nodes, and aggregates their outputs as results flow back up. This makes context movement explicit and traceable across node transitions.

Core loop: Atomize → Plan → Execute → Aggregate

ROMA defines a concise recursive control loop. A node first atomizes a request to determine whether it is atomic. If the request is non-atomic, a planner decomposes it into subtasks. If it is atomic, an executor runs the task using an LLM, a tool or API, or a nested agent. Finally, an aggregator merges child outputs into the parent answer. That loop repeats recursively for each subtask, generating a dependency-aware tree that can execute independent branches in parallel and enforce left-to-right ordering when a subtask depends on a prior sibling.

Observability, tracing and human checkpoints

Information moves top-down as tasks are decomposed and bottom-up as results aggregate. ROMA surfaces stage-level tracing with structured inputs and outputs per node, which helps developers debug prompts, tool usage, and routing policies with visibility into every transition. Developers can also insert human checkpoints at any node to confirm plans or fact-check critical hops, addressing a common observability gap in agent frameworks.

Developer surface and integrations

ROMA ships with a quick start script and supports Docker or native setup, plus flags for sandbox integration. The stack targets Backend: Python 3.12+ with FastAPI or Flask; Frontend: React and TypeScript with real-time WebSocket; LLM support via LiteLLM; and code execution via sandboxed E2B environments. Data paths support enterprise S3 mounting, path-injection checks, and secure AWS credential handling. Leaf skills are swappable while the meta-architecture manages the task graph and dependencies.

You can wire ROMA to closed or open LLMs, local models, deterministic tools, or other agents without changing the meta-layer. Inputs and outputs are defined with Pydantic to provide structured, auditable I/O during runs and tracing.

Why recursion matters

The recursive decomposition confines context to what each node requires, reducing prompt sprawl. Stage-level tracing with typed I/O makes the flow transparent so failures are diagnosable rather than opaque. Independent sibling nodes can run in parallel while dependency edges impose sequencing when needed, turning model, prompt, and tool choices into controlled, observable components of the plan-execute-aggregate loop.

Benchmarks and validation

Sentient implemented ROMA Search on the ROMA scaffold to validate the architecture. On SEALQA (Seal-0), a subset aimed at multi-source reasoning, ROMA Search reports 45.6% accuracy, outperforming Kimi Researcher at 36% and Gemini 2.5 Pro at 19.8%. ROMA also reports state-of-the-art on FRAMES for multi-step reasoning and near-state-of-the-art on SimpleQA for factual retrieval. These vendor-published results are directional until independently reproduced, but they indicate the architecture is competitive across reasoning-heavy and fact-centric tasks.

Where ROMA fits and practical implications

ROMA positions itself as a backbone for open-source meta-agents. Its recursive, hierarchical task tree, stage tracing, and human-in-the-loop checkpoints let builders plug in any model, tool, or agent and exploit parallelization for independent branches. That design simplifies engineering of multi-step workloads from financial analysis to creative generation by providing explicit context flow, typed interfaces, and observable execution.

Open source and developer control

ROMA is released under an Apache-2.0 license and already provides tooling including FastAPI, a React frontend, LiteLLM integration, and sandboxed execution paths. The framework emphasizes developer control: clear task graphs, typed interfaces, and transparent context flow enable teams to iterate quickly and verify each stage in long-horizon agent systems.