[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"project-72113":3},{"id":4,"name":5,"fullName":6,"owner":7,"repo":5,"description":8,"homepage":9,"htmlUrl":10,"language":11,"languages":10,"totalLinesOfCode":10,"stars":12,"forks":13,"watchers":14,"openIssues":15,"contributorsCount":16,"subscribersCount":16,"size":16,"stars1d":16,"stars7d":17,"stars30d":18,"stars90d":16,"forks30d":16,"starsTrendScore":16,"compositeScore":19,"rankGlobal":10,"rankLanguage":10,"license":10,"archived":20,"fork":20,"defaultBranch":21,"hasWiki":20,"hasPages":20,"topics":22,"createdAt":10,"pushedAt":10,"updatedAt":23,"readmeContent":24,"aiSummary":25,"trendingCount":16,"starSnapshotCount":16,"syncStatus":26,"lastSyncTime":27,"discoverSource":28},72113,"ROMA","sentient-agi\u002FROMA","sentient-agi","Recursive-Open-Meta-Agent v0.1 (Beta). A meta-agent framework to build high-performance multi-agent systems.","",null,"Python",5072,772,143,15,0,5,25,39.66,false,"main",[],"2026-06-12 02:02:58","\u003Cdiv align=\"center\">\n    \u003Cimg src=\".\u002Fassets\u002Fsentient-logo-new-M.png\" alt=\"alt text\" width=\"60%\"\u002F>\n    \u003Ch1>ROMA: Recursive Open Meta-Agents\u003C\u002Fh1>\n\u003C\u002Fdiv>\n\n\u003Cp align=\"center\">\n  \u003Cstrong>Building hierarchical high-performance multi-agent systems made easy! (Beta) \u003C\u002Fstrong>\n\u003C\u002Fp>\n\n\u003Cp align=\"center\">\n\u003Ca href=\"https:\u002F\u002Ftrendshift.io\u002Frepositories\u002F14848\" target=\"_blank\">\u003Cimg src=\"https:\u002F\u002Ftrendshift.io\u002Fapi\u002Fbadge\u002Frepositories\u002F14848\" alt=\"sentient-agi%2FROMA | Trendshift\" style=\"width: 250px; height: 55px;\" width=\"250\" height=\"55\"\u002F>\u003C\u002Fa>\n\u003C\u002Fp>\n\n\u003Cp align=\"center\">\n  \u003Ca href=\"https:\u002F\u002Fsentient.xyz\u002F\" target=\"_blank\" style=\"margin: 2px;\">\n    \u003Cimg alt=\"Homepage\" src=\"https:\u002F\u002Fimg.shields.io\u002Fbadge\u002FSentient-Homepage-%23EAEAEA?logo=data%3Aimage%2Fsvg%2Bxml%3Bbase64%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%2BPC9zdmc%2B&link=https%3A%2F%2Fhuggingface.co%2FSentientagi\" style=\"display: inline-block; vertical-align: middle;\"\u002F>\n  \u003C\u002Fa>\n  \u003Ca href=\"https:\u002F\u002Fgithub.com\u002Fsentient-agi\" target=\"_blank\" style=\"margin: 2px;\">\n    \u003Cimg alt=\"GitHub\" src=\"https:\u002F\u002Fimg.shields.io\u002Fbadge\u002FGithub-sentient_agi-181717?logo=github\" style=\"display: inline-block; vertical-align: middle;\"\u002F>\n  \u003C\u002Fa>\n  \u003Ca href=\"https:\u002F\u002Fhuggingface.co\u002FSentientagi\" target=\"_blank\" style=\"margin: 2px;\">\n    \u003Cimg alt=\"Hugging Face\" src=\"https:\u002F\u002Fimg.shields.io\u002Fbadge\u002F%F0%9F%A4%97%20Hugging%20Face-SentientAGI-ffc107?color=ffc107&logoColor=white\" style=\"display: inline-block; vertical-align: middle;\"\u002F>\n  \u003C\u002Fa>\n\u003C\u002Fdiv>\n\n\u003Cdiv align=\"center\" style=\"line-height: 1;\">\n  \u003Ca href=\"https:\u002F\u002Fdiscord.gg\u002Fsentientfoundation\" target=\"_blank\" style=\"margin: 2px;\">\n    \u003Cimg alt=\"Discord\" src=\"https:\u002F\u002Fimg.shields.io\u002Fbadge\u002FDiscord-SentientAGI-7289da?logo=discord&logoColor=white&color=7289da\" style=\"display: inline-block; vertical-align: middle;\"\u002F>\n  \u003C\u002Fa>\n  \u003Ca href=\"https:\u002F\u002Fx.com\u002FSentientAGI\" target=\"_blank\" style=\"margin: 2px;\">\n    \u003Cimg alt=\"Twitter Follow\" src=\"https:\u002F\u002Fimg.shields.io\u002Fbadge\u002F-SentientAGI-grey?logo=x&link=https%3A%2F%2Fx.com%2FSentientAGI%2F\" style=\"display: inline-block; vertical-align: middle;\"\u002F>\n  \u003C\u002Fa>\n\u003C\u002Fp>\n\u003Cp align=\"center\">\n  \u003Ca href=\"https:\u002F\u002Fwww.sentient.xyz\u002Fblog\u002Frecursive-open-meta-agent\">Technical Blog\u003C\u002Fa> •\n  \u003Ca href=\"https:\u002F\u002Farxiv.org\u002Fabs\u002F2602.01848\">Paper\u003C\u002Fa> •\n  \u003Ca href=\"https:\u002F\u002Fwww.sentient.xyz\u002F\">Build Agents for $$$\u003C\u002Fa>\n\u003C\u002Fp>\n\n\n\n\u003C\u002Fdiv>\n\n## 📑 Table of Contents\n- [🧠 Conceptual Overview](#-conceptual-overview)\n- [📦 Installation & Setup](#-installation--setup)\n- [⚡ Quickstart: End-to-End Workflow](#-quickstart-end-to-end-workflow)\n- [⚙️ Configuration & Storage](#-configuration--storage)\n- [🧰 Toolkits](#-toolkits)\n- [🌐 REST API & CLI](#-rest-api--cli)\n- [🏗️ Core Building Block: `BaseModule`](#-core-building-block-basemodule)\n- [📚 Module Reference](#-module-reference)\n  - [⚛️ Atomizer](#-atomizer)\n  - [📋 Planner](#-planner)\n  - [⚙️ Executor](#-executor)\n  - [🔀 Aggregator](#-aggregator)\n  - [✅ Verifier](#-verifier)\n- [🎯 Advanced Patterns](#-advanced-patterns)\n- [🧪 Testing](#-testing)\n- [💡 Troubleshooting & Tips](#-troubleshooting--tips)\n- [📖 Glossary](#-glossary)\n\n---\n\n## 🎯 What is ROMA?\n\n\u003Cdiv align=\"center\">\n    \u003Cimg src=\".\u002Fassets\u002Froma_run.gif\" alt=\"alt text\" width=\"80%\"\u002F>\n\u003C\u002Fdiv>\n\u003Cbr>\n\n**ROMA** is a **meta-agent framework** that uses recursive hierarchical structures to solve complex problems. By breaking down tasks into parallelizable components, ROMA enables agents to tackle sophisticated reasoning challenges while maintaining transparency that makes context-engineering and iteration straightforward. The framework offers **parallel problem solving** where agents work simultaneously on different parts of complex tasks, **transparent development** with a clear structure for easy debugging, and **proven performance** demonstrated through our search agent's strong benchmark results. We've shown the framework's effectiveness, but this is just the beginning. As an **open-source and extensible** platform, ROMA is designed for community-driven development, allowing you to build and customize agents for your specific needs while benefiting from the collective improvements of the community.\n\n## 🏗️ How It Works\n\n\n**ROMA** framework processes tasks through a recursive **plan–execute loop**:\n\n```python\ndef solve(task):\n    if is_atomic(task):                 # Step 1: Atomizer\n        return execute(task)            # Step 2: Executor\n    else:\n        subtasks = plan(task)           # Step 2: Planner\n        results = []\n        for subtask in subtasks:\n            results.append(solve(subtask))  # Recursive call\n        return aggregate(results)       # Step 3: Aggregator\n\n# Entry point:\nanswer = solve(initial_request)\n```\n1. **Atomizer** – Decides whether a request is **atomic** (directly executable) or requires **planning**.  \n2. **Planner** – If planning is needed, the task is broken into smaller **subtasks**. Each subtask is fed back into the **Atomizer**, making the process recursive.  \n3. **Executors** – Handle atomic tasks. Executors can be **LLMs, APIs, or even other agents** — as long as they implement an `agent.execute()` interface.  \n4. **Aggregator** – Collects and integrates results from subtasks. Importantly, the Aggregator produces the **answer to the original parent task**, not just raw child outputs.  \n\n\n\n#### 📐 Information Flow  \n- **Top-down:** Tasks are decomposed into subtasks recursively.  \n- **Bottom-up:** Subtask results are aggregated upwards into solutions for parent tasks.  \n- **Left-to-right:** If a subtask depends on the output of a previous one, it waits until that subtask completes before execution.  \n\nThis structure makes the system flexible, recursive, and dependency-aware — capable of decomposing complex problems into smaller steps while ensuring results are integrated coherently. \n\n\u003Cdetails>\n\u003Csummary>Click to view the system flow diagram\u003C\u002Fsummary>\n\n```mermaid\nflowchart TB\n    A[Your Request] --> B{Atomizer}\n    B -->|Plan Needed| C[Planner]\n    B -->|Atomic Task| D[Executor]\n\n    %% Planner spawns subtasks\n    C --> E[Subtasks]\n    E --> G[Aggregator]\n\n    %% Recursion\n    E -.-> B  \n\n    %% Execution + Aggregation\n    D --> F[Final Result]\n    G --> F\n\n    style A fill:#e1f5fe\n    style F fill:#c8e6c9\n    style B fill:#fff3e0\n    style C fill:#ffe0b2\n    style D fill:#d1c4e9\n    style G fill:#c5cae9\n\n```\n\n\u003C\u002Fdetails>\u003Cbr>\n\n## 🚀 Quick Start\n\n### Fastest Way: Minimal Installation (Recommended for Evaluation)\n\nGet started in **under 30 seconds** with no infrastructure required:\n\n```bash\n# Install with uv (10-100x faster)\nuv pip install roma-dspy\n\n# Or with pip\npip install roma-dspy\n\n# Set your OpenRouter API key (default uses Claude Sonnet 4.5 + Gemini 2.5 Flash)\nexport OPENROUTER_API_KEY=\"sk-or-v1-...\"\n\n# Start solving tasks immediately\npython -c \"from roma_dspy.core.engine.solve import solve; print(solve('What is 2+2?'))\"\n```\n\n> **Note**: The default configuration uses OpenRouter with Claude Sonnet 4.5 (executor) and Gemini 2.5 Flash (other agents). You can also use OpenAI directly by setting `OPENAI_API_KEY` and customizing the config.\n\n**What you get:**\n- ✅ Core agent framework (Atomizer, Planner, Executor, Aggregator, Verifier)\n- ✅ All DSPy prediction strategies (CoT, ReAct, CodeAct, etc.)\n- ✅ File storage (no database required)\n- ✅ Built-in toolkits (Calculator, File operations)\n- ✅ Works with any LLM provider (OpenRouter, OpenAI, Anthropic, etc.)\n\n**No Docker, no database, no setup - just install and go!**\n\n### Production Setup: Full Features with Docker\n\nFor production use with persistence, observability, and API server:\n\n```bash\n# One-command setup (builds Docker, starts services)\njust setup\n\n# Or with specific profile\njust setup crypto_agent\n\n# Verify services running\ncurl http:\u002F\u002Flocalhost:8000\u002Fhealth\n\n# Solve tasks via API\njust solve \"What is the capital of France?\"\n```\n\n**Additional features with Docker:**\n- 📊 PostgreSQL persistence (execution history, checkpoints)\n- 📈 MLflow observability (experiment tracking, visualization)\n- 🌐 REST API server (FastAPI with interactive docs)\n- 📦 S3-compatible storage (MinIO)\n- 🔧 E2B code execution sandboxes\n- 🎨 Interactive TUI visualization\n\n**Services Available:**\n- 🚀 **REST API**: http:\u002F\u002Flocalhost:8000\u002Fdocs\n- 🗄️ **PostgreSQL**: Automatic persistence\n- 📦 **MinIO**: S3-compatible storage (http:\u002F\u002Flocalhost:9001)\n- 📊 **MLflow**: http:\u002F\u002Flocalhost:5000 (with `docker-up-full`)\n\nSee [Quick Start Guide](docs\u002FQUICKSTART.md) and [Deployment Guide](docs\u002FDEPLOYMENT.md) for details.\n\n---\n\n## 🧠 Conceptual Overview\nROMA's module layer wraps canonical DSPy patterns into purpose-built components that reflect the lifecycle of complex task execution:\n\n1. **Atomizer** decides whether a request can be handled directly or needs decomposition.\n2. **Planner** breaks non-atomic goals into an ordered graph of subtasks.\n3. **Executor** resolves individual subtasks, optionally routing through function\u002Ftool calls.\n4. **Aggregator** synthesizes subtask outputs back into a coherent answer.\n5. **Verifier** (optional) inspects the aggregate output against the original goal before delivering.\n\nEvery module shares the same ergonomics: instantiate it with a language model (LM) or provider string, choose a prediction strategy, then call `.forward()` (or `.aforward()` for async) with the task-specific fields.\n\nAll modules ultimately delegate to DSPy signatures defined in `roma_dspy.core.signatures`. This keeps interfaces stable even as the internals evolve.\n\n## 📦 Installation & Setup\n\n### Option 1: Minimal Installation (Fastest - Recommended for Evaluation)\n\n**Perfect for:** Evaluating ROMA, development, testing, quick prototyping\n\n**Install in under 30 seconds:**\n\n```bash\n# With uv (recommended - 10-100x faster)\nuv pip install roma-dspy\n\n# Or with pip\npip install roma-dspy\n```\n\n**Set your API key:**\n```bash\nexport OPENROUTER_API_KEY=\"sk-or-v1-...\"  # Recommended\n# OR\nexport OPENAI_API_KEY=\"sk-...\"\nexport ANTHROPIC_API_KEY=\"sk-ant-...\"\n```\n\n**Start using immediately:**\n```python\nfrom roma_dspy.core.engine.solve import solve\n\n# Solve any task\nresult = solve(\"What is the capital of France?\")\nprint(result)\n```\n\n**What's included:**\n- ✅ All core modules (Atomizer, Planner, Executor, Aggregator, Verifier)\n- ✅ All DSPy prediction strategies\n- ✅ File-based storage (no database needed)\n- ✅ Core toolkits (Calculator, File operations)\n- ✅ Works with any LLM provider\n\n**What's NOT included (install separately if needed):**\n- PostgreSQL persistence → `uv pip install roma-dspy[persistence]`\n- MLflow observability → `uv pip install roma-dspy[observability]`\n- E2B code execution → `uv pip install roma-dspy[e2b]`\n- REST API server → `uv pip install roma-dspy[api]`\n- S3 storage → `uv pip install roma-dspy[s3]`\n- All features → `uv pip install roma-dspy[all]`\n\n---\n\n### Option 2: Full Installation with Docker (Production)\n\n**Perfect for:** Production deployment, teams, full observability\n\n**Prerequisites:**\n- Docker & Docker Compose\n- Python 3.12+ (for local development)\n- [Just](https:\u002F\u002Fgithub.com\u002Fcasey\u002Fjust) command runner (optional, recommended)\n\n**One-command setup:**\n```bash\n# Interactive setup (prompts for E2B, S3, etc.)\njust setup\n\n# Or with specific profile\njust setup crypto_agent\n```\n\n**Manual Docker start:**\n```bash\njust docker-up       # Basic (PostgreSQL + MinIO + API)\njust docker-up-full  # With MLflow observability\n```\n\n**Environment variables** (auto-configured by `just setup`):\n```bash\n# LLM Provider (required)\nOPENROUTER_API_KEY=...     # Recommended\n# OR\nOPENAI_API_KEY=...\nANTHROPIC_API_KEY=...\n\n# Optional: Advanced features\nE2B_API_KEY=...           # Code execution\nCOINGECKO_API_KEY=...     # Crypto toolkit\n```\n\n**Additional Docker features:**\n- 📊 PostgreSQL (execution history, checkpoints)\n- 📈 MLflow (experiment tracking, metrics)\n- 🌐 REST API (FastAPI with docs)\n- 📦 MinIO (S3-compatible storage)\n- 🎨 TUI visualization\n\n---\n\n### Option 3: Development Installation\n\n**For contributing or extending ROMA:**\n\n```bash\n# Clone repository\ngit clone https:\u002F\u002Fgithub.com\u002Fsentient-agi\u002Froma.git\ncd roma\n\n# Install with dev tools (includes pytest, ruff, mypy)\nuv pip install -e \".[dev]\"\n\n# Run tests\njust test\n\n# Format code\njust format\n\n# Type check\njust typecheck\n```\n\n---\n\n### Comparison: Which Installation is Right for You?\n\n| Feature | Minimal (`pip install roma-dspy`) | Docker (`just setup`) |\n|---------|----------------------------------|----------------------|\n| Installation time | **\u003C 30 seconds** | ~5-10 minutes |\n| Infrastructure required | **None** | Docker |\n| Core agent framework | ✅ | ✅ |\n| File storage | ✅ | ✅ |\n| PostgreSQL persistence | ❌ (install `[persistence]`) | ✅ |\n| MLflow observability | ❌ (install `[observability]`) | ✅ |\n| REST API | ❌ (install `[api]`) | ✅ |\n| Best for | Evaluation, development | Production, teams |\n\n## ⚡ Quickstart: End-to-End Workflow\nThe following example mirrors a typical orchestration loop. It uses three different providers to showcase how easily each module can work with distinct models and strategies.\n\n```python\nimport dspy\nfrom roma_dspy import Aggregator, Atomizer, Executor, Planner, Verifier, SubTask\nfrom roma_dspy.types import TaskType\n\n# Optional tool that the Executor may call\ndef get_weather(city: str) -> str:\n    \"\"\"Return a canned weather report for the city.\"\"\"\n    return f\"The weather in {city} is sunny.\"\n\n# Executor geared toward ReAct with a Fireworks model\nexecutor_lm = dspy.LM(\n    \"fireworks_ai\u002Faccounts\u002Ffireworks\u002Fmodels\u002Fkimi-k2-instruct-0905\",\n    temperature=0.7,\n    cache=True,\n)\nexecutor = Executor(\n    lm=executor_lm,\n    prediction_strategy=\"react\",\n    tools=[get_weather],\n    context_defaults={\"track_usage\": True},\n)\n\n# Atomizer decides when to branch into planning\natomizer = Atomizer(\n    lm=dspy.LM(\"openrouter\u002Fgoogle\u002Fgemini-2.5-flash\", temperature=0.6, cache=False),\n    prediction_strategy=\"cot\",\n    context_defaults={\"track_usage\": True},\n)\n\n# Planner produces executable subtasks for non-atomic goals\nplanner = Planner(\n    lm=dspy.LM(\"openrouter\u002Fopenai\u002Fgpt-4o-mini\", temperature=0.85, cache=True),\n    prediction_strategy=\"cot\",\n    context_defaults={\"track_usage\": True},\n)\n\naggregator = Aggregator(\n    lm=dspy.LM(\"openrouter\u002Fopenai\u002Fgpt-4o-mini\", temperature=0.65),\n    prediction_strategy=\"cot\",\n)\n\nverifier = Verifier(\n    lm=dspy.LM(\"openrouter\u002Fopenai\u002Fgpt-4o-mini\", temperature=0.0),\n)\n\ndef run_pipeline(goal: str) -> str:\n    atomized = atomizer.forward(goal)\n    if atomized.is_atomic or atomized.node_type.is_execute:\n        execution = executor.forward(goal)\n        candidate = execution.output\n    else:\n        plan = planner.forward(goal)\n        results = []\n        for idx, subtask in enumerate(plan.subtasks, start=1):\n            execution = executor.forward(subtask.goal)\n            results.append(\n                SubTask(\n                    goal=subtask.goal,\n                    task_type=subtask.task_type,\n                    dependencies=subtask.dependencies,\n                )\n            )\n        aggregated = aggregator.forward(goal, results)\n        candidate = aggregated.synthesized_result\n\n    verdict = verifier.forward(goal, candidate)\n    if verdict.verdict:\n        return candidate\n    return f\"Verifier flagged the output: {verdict.feedback or 'no feedback returned'}\"\n\nprint(run_pipeline(\"Plan a weekend in Barcelona and include a packing list.\"))\n```\n\nHighlights:\n- Different modules can run on different LMs and temperatures.\n- Tools are provided either at construction or per-call.\n- `context_defaults` ensures each `.forward()` call enters a proper `dspy.context()` with the module's LM.\n\n---\n\n## ⚙️ Configuration & Storage\n\nROMA-DSPy uses **OmegaConf** for layered configuration with **Pydantic** validation, and provides **execution-scoped storage** for complete task isolation.\n\n### Quick Configuration Example\n\n```python\nfrom roma_dspy.config import load_config\n\n# Load with profile and overrides\nconfig = load_config(\n    profile=\"crypto_agent\",\n    overrides=[\"agents.executor.llm.temperature=0.3\"]\n)\n```\n\n**Available Profiles**: `general`, `crypto_agent` (list with `just list-profiles`)\n\n**See**: [Configuration Guide](docs\u002FCONFIGURATION.md) for complete documentation on profiles, agent configuration, LLM settings, toolkit configuration, and task-aware agent mapping.\n\n### Storage\n\nStorage is automatic and execution-scoped - each task gets an isolated directory. Large toolkit responses (>100KB) are automatically stored as Parquet files.\n\n```python\nfrom roma_dspy.core.engine.solve import solve\n\n# Storage created automatically at: {base_path}\u002Fexecutions\u002F{execution_id}\u002F\nresult = solve(\"Analyze blockchain transactions\")\n```\n\n**Features**: Execution isolation, S3-compatible, automatic Parquet storage, Docker-managed\n\n**See**: [Deployment Guide](docs\u002FDEPLOYMENT.md) for production storage configuration including S3 integration.\n\n---\n\n## 🧰 Toolkits\n\nROMA-DSPy includes 9 built-in toolkits that extend agent capabilities:\n\n**Core**: FileToolkit, CalculatorToolkit, E2BToolkit (code execution)\n**Crypto**: CoinGeckoToolkit, BinanceToolkit, DefiLlamaToolkit, ArkhamToolkit\n**Search**: SerperToolkit (web search)\n**Universal**: MCPToolkit (connect to any [MCP server](https:\u002F\u002Fgithub.com\u002Fwong2\u002Fawesome-mcp-servers))\n\n### Quick Configuration\n\n```yaml\nagents:\n  executor:\n    toolkits:\n      - class_name: \"FileToolkit\"\n        enabled: true\n      - class_name: \"E2BToolkit\"\n        enabled: true\n        toolkit_config:\n          timeout: 600\n```\n\n**See**: [Toolkits Reference](docs\u002FTOOLKITS.md) for complete toolkit documentation including all tools, configuration options, MCP integration, and custom toolkit development.\n\n---\n\n## 🌐 REST API & CLI\n\nROMA-DSPy provides both a REST API and CLI for production use.\n\n### REST API\n\nFastAPI server with interactive documentation:\n\n```bash\n# Starts automatically with Docker\njust docker-up\n\n# API Documentation: http:\u002F\u002Flocalhost:8000\u002Fdocs\n# Health check: http:\u002F\u002Flocalhost:8000\u002Fhealth\n```\n\n**Endpoints**: Execution management, checkpoints, visualization, metrics\n\n### CLI\n\n```bash\n# Local task execution\nroma-dspy solve \"Your task\" --profile general\n\n# Server management\nroma-dspy server start\nroma-dspy server health\n\n# Execution management\nroma-dspy exec create \"Task\"\nroma-dspy exec status \u003Cid> --watch\n\n# Interactive TUI visualization (requires MLflow for best results)\njust viz \u003Cexecution_id>\n\n# Full help\nroma-dspy --help\n```\n\n**See**: API documentation at `\u002Fdocs` endpoint for complete OpenAPI specification and interactive testing.\n\n---\n\n## 🏗️ Core Building Block: `BaseModule`\nAll modules inherit from `BaseModule`, located at `roma_dspy\u002Fcore\u002Fmodules\u002Fbase_module.py`. It standardizes:\n- signature binding via DSPy prediction strategies,\n- LM instantiation and context management,\n- tool normalization and merging,\n- sync\u002Fasync entrypoints with safe keyword filtering.\n\n### Context & LM Management\nWhen you instantiate a module, you can either provide an existing `dspy.LM` or let the module build one from a provider string (`model`) and optional keyword arguments (`model_config`).\n\n```python\nfrom roma_dspy import Executor\n\nexecutor = Executor(\n    model=\"openrouter\u002Fopenai\u002Fgpt-4o-mini\",\n    model_config={\"temperature\": 0.5, \"cache\": True},\n)\n```\n\nInternally, `BaseModule` ensures that every `.forward()` call wraps the predictor invocation in:\n\n```python\nwith dspy.context(lm=self._lm, **context_defaults):\n    ...\n```\n\nYou can inspect the effective LM configuration via `get_model_config()` to confirm provider, cache settings, or sanitized kwargs.\n\n### Working with Tools\nTools can be supplied as a list, tuple, or mapping of callables accepted by DSPy’s ReAct\u002FCodeAct strategies.\n\n```python\nexecutor = Executor(tools=[get_weather])\nexecutor.forward(\"What is the weather in Amman?\", tools=[another_function])\n```\n\n`BaseModule` automatically deduplicates tools based on object identity and merges constructor defaults with per-call overrides.\n\n### Prediction Strategies\nROMA exposes DSPy's strategies through the `PredictionStrategy` enum (`roma_dspy\u002Ftypes\u002Fprediction_strategy.py`). Use either the enum or a case-insensitive string alias:\n\n```python\nfrom roma_dspy.types import PredictionStrategy\n\nplanner = Planner(prediction_strategy=PredictionStrategy.CHAIN_OF_THOUGHT)\nexecutor = Executor(prediction_strategy=\"react\")\n```\n\nAvailable options include `Predict`, `ChainOfThought`, `ReAct`, `CodeAct`, `BestOfN`, `Refine`, `Parallel`, `majority`, and more. Strategies that require tools (`ReAct`, `CodeAct`) automatically receive any tools you pass to the module.\n\n### Async Execution\nEvery module offers an `aforward()` method. When the underlying DSPy predictor supports async (`acall`\u002F`aforward`), ROMA dispatches asynchronously; otherwise, it gracefully falls back to the sync implementation while preserving awaitability.\n\n```python\nresult = await executor.aforward(\"Download the latest sales report\")\n```\n\n## 📚 Module Reference\n\n### ⚛️ Atomizer\n**Location**: `roma_dspy\u002Fcore\u002Fmodules\u002Fatomizer.py`\n\n**Purpose**: Decide whether a goal is atomic or needs planning.\n\n**Constructor**:\n```python\nAtomizer(\n    prediction_strategy: Union[PredictionStrategy, str] = \"ChainOfThought\",\n    *,\n    lm: Optional[dspy.LM] = None,\n    model: Optional[str] = None,\n    model_config: Optional[Mapping[str, Any]] = None,\n    tools: Optional[Sequence|Mapping] = None,\n    **strategy_kwargs,\n)\n```\n\n**Inputs** (`AtomizerSignature`):\n- `goal: str`\n\n**Outputs** (`AtomizerResponse`):\n- `is_atomic: bool` — whether the task can run directly.\n- `node_type: NodeType` — `PLAN` or `EXECUTE` hint for downstream routing.\n\n**Usage**:\n```python\natomized = atomizer.forward(\"Curate a 5-day Tokyo itinerary with restaurant reservations\")\nif atomized.is_atomic:\n    ...  # send directly to Executor\nelse:\n    ...  # hand off to Planner\n```\n\nThe Atomizer is strategy-agnostic but typically uses `ChainOfThought` or `Predict`. You can pass hints (e.g., `max_tokens`) via `call_params`:\n\n```python\natomizer.forward(\n    \"Summarize this PDF\",\n    call_params={\"max_tokens\": 200},\n)\n```\n\n### 📋 Planner\n**Location**: `roma_dspy\u002Fcore\u002Fmodules\u002Fplanner.py`\n\n**Purpose**: Break a goal into ordered subtasks with optional dependency graph.\n\n**Constructor**: identical pattern as the Atomizer.\n\n**Inputs** (`PlannerSignature`):\n- `goal: str`\n\n**Outputs** (`PlannerResult`):\n- `subtasks: List[SubTask]` — each has `goal`, `task_type`, and `dependencies`.\n- `dependencies_graph: Optional[Dict[str, List[str]]]` — explicit adjacency mapping when returned by the LM.\n\n**Usage**:\n```python\nplan = planner.forward(\"Launch a B2B webinar in 6 weeks\")\nfor subtask in plan.subtasks:\n    print(subtask.goal, subtask.task_type)\n```\n\n`SubTask.task_type` is a `TaskType` enum that follows the ROMA MECE framework (Retrieve, Write, Think, Code Interpret, Image Generation).\n\n### ⚙️ Executor\n**Location**: `roma_dspy\u002Fcore\u002Fmodules\u002Fexecutor.py`\n\n**Purpose**: Resolve atomic goals, optionally calling tools\u002Ffunctions through DSPy's ReAct, CodeAct, or similar strategies.\n\n**Constructor**: same pattern; the most common strategies are `ReAct`, `CodeAct`, or `ChainOfThought`.\n\n**Inputs** (`ExecutorSignature`):\n- `goal: str`\n\n**Outputs** (`ExecutorResult`):\n- `output: str | Any`\n- `sources: Optional[List[str]]` — provenance or citations.\n\n**Usage**:\n```python\nexecution = executor.forward(\n    \"Compile a packing list for a 3-day ski trip\",\n    config={\"temperature\": 0.4},  # per-call LM override\n)\nprint(execution.output)\n```\n\nTo expose tools only for certain calls:\n\n```python\nexecution = executor.forward(\n    \"What is the weather in Paris?\",\n    tools=[get_weather],\n)\n```\n\n### 🔀 Aggregator\n**Location**: `roma_dspy\u002Fcore\u002Fmodules\u002Faggregator.py`\n\n**Purpose**: Combine multiple subtask results into a final narrative or decision.\n\n**Constructor**: identical pattern.\n\n**Inputs** (`AggregatorResult` signature):\n- `original_goal: str`\n- `subtasks_results: List[SubTask]` — usually the planner’s proposals augmented with execution outputs.\n\n**Outputs** (`AggregatorResult` base model):\n- `synthesized_result: str`\n\n**Usage**:\n```python\naggregated = aggregator.forward(\n    original_goal=\"Plan a data migration\",\n    subtasks_results=[\n        SubTask(goal=\"Inventory current databases\", task_type=TaskType.RETRIEVE),\n        SubTask(goal=\"Draft migration timeline\", task_type=TaskType.WRITE),\n    ],\n)\nprint(aggregated.synthesized_result)\n```\n\nBecause it inherits `BaseModule`, you can still attach tools (e.g., a knowledge-base retrieval function) if your aggregation strategy requires external calls.\n\n### ✅ Verifier\n**Location**: `roma_dspy\u002Fcore\u002Fmodules\u002Fverifier.py`\n\n**Purpose**: Validate that the synthesized output satisfies the original goal.\n\n**Inputs** (`VerifierSignature`):\n- `goal: str`\n- `candidate_output: str`\n\n**Outputs**:\n- `verdict: bool`\n- `feedback: Optional[str]`\n\n**Usage**:\n```python\nverdict = verifier.forward(\n    goal=\"Draft a GDPR-compliant privacy policy\",\n    candidate_output=aggregated.synthesized_result,\n)\nif not verdict.verdict:\n    print(\"Needs revision:\", verdict.feedback)\n```\n\n## 🎯 Advanced Patterns\n\n### Swapping Models at Runtime\nUse `replace_lm()` to reuse the same module with a different LM (useful for A\u002FB testing or fallbacks).\n\n```python\nfast_executor = executor.replace_lm(dspy.LM(\"openrouter\u002Fanthropic\u002Fclaude-3-haiku\"))\n```\n\n### Per-Call Overrides\nYou can alter LM behavior or provide extra parameters without rebuilding the module.\n\n```python\nexecutor.forward(\n    \"Summarize the meeting notes\",\n    config={\"temperature\": 0.1, \"max_tokens\": 300},\n    context={\"stop\": [\"Observation:\"]},\n)\n```\n\n`call_params` (or keyword arguments) are filtered to match the DSPy predictor’s accepted kwargs, preventing accidental errors.\n\n### Tool-Only Execution\nIf you want deterministic tool routing, you can set a dummy LM (or a very low-temperature model) and pass pure Python callables.\n\n```python\nfrom roma_dspy import Executor\n\nexecutor = Executor(\n    prediction_strategy=\"code_act\",\n    lm=dspy.LM(\"openrouter\u002Fopenai\u002Fgpt-4o-mini\", temperature=0.0),\n    tools={\"get_weather\": get_weather, \"lookup_user\": lookup_user},\n)\n```\n\nROMA will ensure both constructor and per-call tools are available to the strategy.\n\n## 🧪 Testing\n\n```bash\n# Run all tests\njust test\n\n# Run specific tests\npytest tests\u002Funit\u002F -v\npytest tests\u002Fintegration\u002F -v\n```\n\n**See**: `justfile` for all available test commands.\n\n## 💡 Troubleshooting & Tips\n- **`ValueError: Either provide an existing lm`** — supply `lm=` or `model=` when constructing the module.\n- **`Invalid prediction strategy`** — check spelling; strings are case-insensitive but must match a known alias.\n- **Caching** — pass `cache=True` on your LM or set it in `model_config` to reutilize previous completions.\n- **Async contexts** — when mixing sync and async calls, ensure your event loop is running (e.g., use `asyncio.run`).\n- **Tool duplicates** — tools are deduplicated by identity; create distinct functions if you need variations.\n\n## 📖 Glossary\n\n### Core Concepts\n- **DSPy**: Stanford's declarative framework for prompting, planning, and tool integration.\n- **Prediction Strategy**: The DSPy class\u002Ffunction that powers reasoning (CoT, ReAct, etc.).\n- **SubTask**: Pydantic model describing a decomposed unit of work (`goal`, `task_type`, `dependencies`).\n- **NodeType**: Whether the Atomizer chose to `PLAN` or `EXECUTE`.\n- **TaskType**: MECE classification for subtasks (`RETRIEVE`, `WRITE`, `THINK`, `CODE_INTERPRET`, `IMAGE_GENERATION`).\n- **Context Defaults**: Keyword arguments provided to `dspy.context(...)` on every call.\n\n### Configuration & Storage\n- **FileStorage**: Execution-scoped storage manager providing isolated directories per task execution.\n- **DataStorage**: Automatic Parquet storage system for large toolkit responses (threshold-based).\n- **Execution ID**: Unique identifier for each task execution, used for storage isolation.\n- **Base Path**: Root directory for all storage operations (local path or S3 bucket).\n- **Profile**: Named configuration preset (e.g., `general`, `crypto_agent`).\n- **Configuration Override**: Runtime value that supersedes profile\u002Fdefault settings.\n\n### Toolkits\n- **BaseToolkit**: Abstract base class for all toolkits providing storage integration and tool registration.\n- **REQUIRES_FILE_STORAGE**: Metadata flag indicating a toolkit requires FileStorage (e.g., FileToolkit).\n- **Toolkit Config**: Toolkit-specific settings like API keys, timeouts, and thresholds.\n- **Tool Selection**: Include\u002Fexclude lists to filter which tools from a toolkit are available.\n- **Storage Threshold**: Size limit (KB) above which responses are stored in Parquet format.\n\n### Architecture\n- **Execution-Scoped Isolation**: Pattern where each execution gets unique storage directory.\n- **Parquet Integration**: Automatic columnar storage for large structured data.\n- **S3 Compatibility**: Ability to use S3-compatible storage via Docker volume mounts.\n- **Tool Registration**: Automatic discovery and registration of toolkit methods as callable tools.\n\n---\n\nHappy building! If you extend or customize a module, keep the signatures aligned so your higher-level orchestration remains stable.\n\n**Additional Resources:**\n- [Quick Start Guide](docs\u002FQUICKSTART.md) - Get started in under 10 minutes\n- [Configuration Guide](docs\u002FCONFIGURATION.md) - Complete configuration reference\n- [Toolkits Reference](docs\u002FTOOLKITS.md) - All built-in and custom toolkits\n- [Deployment Guide](docs\u002FDEPLOYMENT.md) - Production deployment with Docker\n- [E2B Setup](docs\u002FE2B_SETUP.md) - Code execution toolkit setup\n- [Observability](docs\u002FOBSERVABILITY.md) - MLflow tracking and monitoring\n- [Configuration System](config\u002FREADME.md) - Configuration profiles and examples\n\n\n## 📊 Benchmarks\n\nWe evaluate our simple implementation of a search system using ROMA, called ROMA-Search across three benchmarks: **SEAL-0**, **FRAMES**, and **SimpleQA**.  \nBelow are the performance graphs for each benchmark.\n\n### [SEAL-0](https:\u002F\u002Fhuggingface.co\u002Fdatasets\u002Fvtllms\u002Fsealqa)\nSealQA is a new challenging benchmark for evaluating Search-Augmented Language models on fact-seeking questions where web search yields conflicting, noisy, or unhelpful results.  \n\n![SEAL-0 Results](assets\u002Fseal-0-full.001.jpeg)\n\n---\n\n### [FRAMES](https:\u002F\u002Fhuggingface.co\u002Fdatasets\u002Fgoogle\u002Fframes-benchmark)\n\u003Cdetails>\n\u003Csummary>View full results\u003C\u002Fsummary>\n\nA comprehensive evaluation dataset designed to test the capabilities of Retrieval-Augmented Generation (RAG) systems across factuality, retrieval accuracy, and reasoning.  \n\n![FRAMES Results](assets\u002FFRAMES-full.001.jpeg)\n\n\u003C\u002Fdetails>\n\n---\n\n### [SimpleQA](https:\u002F\u002Fopenai.com\u002Findex\u002Fintroducing-simpleqa\u002F)\n\u003Cdetails>\n\u003Csummary>View full results\u003C\u002Fsummary>\n\nFactuality benchmark that measures the ability for language models to answer short, fact-seeking questions.  \n\n![SimpleQA Results](assets\u002FsimpleQAFull.001.jpeg)\n\n\u003C\u002Fdetails>\n\n## 🧩 Foundations & Lineage\n\nWhile ROMA introduces a practical, open-source framework for hierarchical task execution, it is directly built upon two foundational research contributions introduced in [WriteHERE](https:\u002F\u002Farxiv.org\u002Fabs\u002F2503.08275):\n\n- **Heterogeneous Recursive Planning** — The overall architecture of ROMA follows the framework first introduced in prior work on *heterogeneous recursive planning*, where complex tasks are recursively decomposed into a graph of subtasks, each assigned a distinct cognitive type.  \n\n- **Type Specification in Decomposition** — ROMA’s “Three Universal Operations” (THINK 🤔, WRITE ✍️, SEARCH 🔍) generalize the *type specification in decomposition* hypothesis, which identified reasoning, composition, and retrieval as the three fundamental cognitive types.  \n\nThese contributions are described in detail in the WriteHERE repository and paper. By explicitly adopting and extending this foundation, ROMA provides a **generalizable scaffold, agent system, versatility, and extensibility** that builds upon these insights and makes them usable for builders across domains. \n\n## 🙏 Acknowledgments\n\nThis framework would not have been possible if it wasn't for these amazing open-source contributions!\n- Inspired by the hierarchical planning approach described in [\"Beyond Outlining: Heterogeneous Recursive Planning\"](https:\u002F\u002Farxiv.org\u002Fabs\u002F2503.08275) by Xiong et al.\n- [Pydantic](https:\u002F\u002Fgithub.com\u002Fpydantic\u002Fpydantic) - Data validation using Python type annotations\n- [DSPy]([https:\u002F\u002Fdspy.ai\u002F)) - Framework for programming AI agents\n- [E2B](https:\u002F\u002Fgithub.com\u002Fe2b-dev\u002Fe2b) - Cloud runtime for AI agents\n\n## 📚 Citation\n\nIf you use the ROMA repo in your research, please cite:\n\n```bibtex\n@misc{alzubi2026romarecursiveopenmetaagent,\n      title={ROMA: Recursive Open Meta-Agent Framework for Long-Horizon Multi-Agent Systems}, \n      author={Salaheddin Alzu'bi and Baran Nama and Arda Kaz and Anushri Eswaran and Weiyuan Chen and Sarvesh Khetan and Rishab Bala and Tu Vu and Sewoong Oh},\n      year={2026},\n      eprint={2602.01848},\n      archivePrefix={arXiv},\n      primaryClass={cs.AI},\n      url={https:\u002F\u002Farxiv.org\u002Fabs\u002F2602.01848}, \n}\n```\n\n## 🌟 Star History\n\n\u003Cdiv align=\"center\">\n\n[![Star History Chart](https:\u002F\u002Fapi.star-history.com\u002Fsvg?repos=sentient-agi\u002Froma&type=Date)](https:\u002F\u002Fwww.star-history.com\u002F#sentient-agi\u002Froma&Date)\n\n\u003C\u002Fdiv>\n\n## 📄 License\n\nThis project is licensed under the Apache 2.0 License - see the [LICENSE](LICENSE) file for details.\n","ROMA 是一个用于构建高性能多智能体系统的元智能体框架。它采用递归开放的架构设计，允许开发者轻松创建具有层次结构的多智能体系统，从而实现更复杂的任务分配与协作。项目基于 Python 语言开发，具备良好的扩展性和灵活性。适合于需要多个自主决策单元协同工作的场景，如复杂环境下的模拟仿真、自动化控制以及游戏AI等。",2,"2026-06-11 03:40:24","high_star"]