Sentient AI Releases ROMA: An Open-Source and AGI Focused Meta-Agent Framework for Building AI Agents with Hierarchical Task Execution

Understanding the Target Audience

The target audience for ROMA includes AI developers, data scientists, and business managers interested in building advanced AI systems. Their pain points often revolve around the complexity of managing multi-agent systems, the need for transparency in AI workflows, and the challenge of debugging and refining AI models. Their goals include creating efficient, scalable AI solutions that can handle complex tasks while maintaining clear oversight and control. They are particularly interested in open-source tools that allow for customization and integration with existing systems. Communication preferences lean towards technical documentation, tutorials, and community engagement through platforms like GitHub and forums.

Overview of ROMA

Sentient AI has introduced ROMA (Recursive Open Meta-Agent), an open-source meta-agent framework designed for constructing high-performance multi-agent systems. ROMA organizes agent workflows into a hierarchical, recursive task tree, where parent nodes decompose complex goals into subtasks, which are then passed down to child nodes. This structure allows for transparent and traceable context flow across node transitions.

Architecture

ROMA operates on a minimal, recursive control loop structured as follows:

• Atomize
• Plan
• Execute
• Aggregate

A node first atomizes a request. If the request is non-atomic, a planner decomposes it into subtasks; otherwise, an executor runs the task using a large language model (LLM), a tool/API, or a nested agent. An aggregator then merges the outputs from child nodes into the parent’s response. This decision loop is repeated for each subtask, creating a dependency-aware tree that executes independent branches in parallel while enforcing left-to-right ordering for dependent subtasks.

Key Features

Information flows top-down as tasks are broken down and bottom-up as results are aggregated. ROMA allows for human checkpoints at any node, enabling users to confirm plans or fact-check critical transitions. It also provides stage tracing, which records inputs and outputs per node, allowing developers to debug and refine prompts, tools, and routing policies with visibility into every transition. This feature addresses the common observability gap in agent frameworks.

Developer Surface and Stack

ROMA offers a quick start setup using Docker or native installation, with flags for E2B sandbox integration. The technology stack includes:

• Backend: Python 3.12+ with FastAPI/Flask
• Frontend: React + TypeScript with real-time WebSocket
• LLM Support: Any provider via LiteLLM
• Code Execution: E2B sandboxes

Data paths support enterprise S3 mounting with goofys FUSE, path-injection checks, and secure AWS credential handling, ensuring that leaf skills remain swappable while the meta-architecture manages the task graph and dependencies.

Importance of Recursion

ROMA’s recursive structure confines context to what each node requires, reducing prompt sprawl. The stage-level tracing with structured Pydantic I/O enhances transparency, making failures diagnosable rather than opaque. Independent companions can run in parallel, and dependency edges impose sequencing, transforming model, prompt, and tool choices into controlled, observable components within the plan-execute-aggregate loop.

Benchmarks: ROMA Search

To validate its architecture, Sentient developed ROMA Search, an internet search agent implemented on the ROMA framework. On SEALQA (Seal-0), which is designed to stress multi-source reasoning, ROMA Search achieved 45.6% accuracy, outperforming Kimi Researcher (36%) and Gemini 2.5 Pro (19.8%). ROMA also reported state-of-the-art performance on FRAMES (multi-step reasoning) and near-state-of-the-art on SimpleQA (factual retrieval). These results should be treated as directional until independently verified, but they indicate that the architecture is competitive in reasoning-heavy and fact-centric tasks.

Where ROMA Fits

ROMA serves as a foundational framework for open-source meta-agents, providing a hierarchical, recursive task tree that allows for effective decomposition of goals into subtasks. Its design emphasizes transparency through stage tracing and supports human-in-the-loop checkpoints. The modular nodes enable developers to integrate any model, tool, or agent, facilitating parallelization for independent branches. This makes it easier to engineer multi-step workloads, from financial analysis to creative generation, with explicit context flow and observable execution.

Conclusion

ROMA is not merely another agent wrapper; it represents a disciplined recursive scaffold: Atomizer → Planner → Executor → Aggregator, with tracing at every step, parallel execution where feasible, and sequential execution where necessary. The initial results from ROMA Search are promising and align with the framework’s objectives, but the most significant outcome is the enhanced control for developers—clear task graphs, typed interfaces, and transparent context flow—allowing teams to iterate quickly and verify each stage. With Apache-2.0 licensing and an implementation that includes FastAPI/React tooling, LiteLLM integration, and sandboxed execution paths, ROMA is a practical foundation for building long-horizon agent systems with measurable, inspectable behavior.

Additional Resources

For more information, check out the Codes and Technical Details. You can also visit our GitHub Page for tutorials, codes, and notebooks. Follow us on Twitter, join our 100k+ ML SubReddit, and subscribe to our newsletter. Additionally, connect with us on Telegram.