OpenManus: Design, Architecture, and Future Directions of a Multi‑Agent System

With the rapid advancement of large language models, multi‑agent (Agent) technology has become a hot topic. OpenManus, released in early March, demonstrates a lightning‑fast development cycle—core functionality was built in one hour and the first version launched in three hours—thanks to extensive prior research and a highly abstract, composable system design.

Design Philosophy

OpenManus is essentially a Multi‑Agent System that follows a "plan‑execute‑feedback" loop, unlike single‑model approaches that attempt to answer everything at once. Its core ideas include:

Minimal, pluggable framework : Agents are defined by a combination of Prompt (behavior logic) and Tools (action capabilities), making customization easy.

Tool‑driven ReAct agents : The system adopts the ReAct (Reason + Act) pattern, with ToolCall agents that select tools during the reasoning phase and execute them in the act phase.

Planning for complex tasks : A PlanningTool breaks user requests into linear sub‑tasks, improving success rates on long‑chain problems.

Dynamic agent allocation : Sub‑tasks are dispatched to agents equipped with appropriate tool sets, using rule‑based matching (future work may use LLM‑based allocation).

Workflow and Execution Path

The overall process follows "Planning → Allocation → Execution":

User input : Complex requests (e.g., write code and deploy) are submitted via UI or CLI.

PlanningTool : Analyzes and decomposes the request into a structured plan . Analyze requirements and environment Write initial code Test and fix errors Deploy and verify results (stored in a plan structure)

Task allocation and execution : Depending on the sub‑task, the system may invoke a Data Interpreter agent, a ComputerUse agent, etc., and each agent runs a ReAct loop with its tools.

Result aggregation and state update : After each sub‑task, results are summarized and compressed to avoid memory bloat, then stored in shared memory.

Overall output : Once all steps finish, the system returns the final result to the user (e.g., deployed website, executed script).

Technical Architecture

The project consists of roughly 30 core files (as of the March 7 release) organized into four main modules:

. 
├── app 
│   ├── agent 
│   │   ├── base.py 
│   │   ├── manus.py 
│   │   ├── planning.py 
│   │   ├── react.py 
│   │   ├── swe.py 
│   │   └── toolcall.py 
│   ├── flow 
│   │   ├── base.py 
│   │   ├── flow_factory.py 
│   │   └── planning.py 
│   ├── prompt 
│   │   ├── manus.py 
│   │   ├── planning.py 
│   │   ├── swe.py 
│   │   └── toolcall.py 
│   └── tool 
│       ├── base.py 
│       ├── bash.py 
│       ├── browser_use_tool.py 
│       ├── create_chat_completion.py 
│       ├── file_saver.py 
│       ├── google_search.py 
│       ├── planning.py 
│       ├── python_execute.py 
│       ├── run.py 
│       ├── str_replace_editor.py 
│       ├── terminate.py 
│       └── tool_collection.py

Key dependencies include pydantic (data validation), openai (API client), playwright and browser‑use (browser automation), and googlesearch‑python (search without API keys).

Core System Components

Agent framework : Hierarchical inheritance from BaseAgent → ReActAgent → ToolCallAgent → Manus . Example implementation: class Manus(ToolCallAgent): """A versatile general‑purpose agent that uses planning to solve various tasks.""" name: str = "Manus" description: str = "A versatile agent that can solve various tasks using multiple tools" system_prompt: str = SYSTEM_PROMPT next_step_prompt: str = NEXT_STEP_PROMPT available_tools: ToolCollection = Field(default_factory=lambda: ToolCollection( PythonExecute(), GoogleSearch(), BrowserUseTool(), FileSaver(), Terminate() ))

Tools layer : All tools inherit from BaseTool . Notable tools include ComputerUse , BrowserUse , PythonExecute , GoogleSearch , FileSaver , and PlanningTool (which manages Markdown‑style plans).

Prompt module : Stores system prompts for agents. Example planning prompt: PLANNING_SYSTEM_PROMPT = """ You are an expert Planning Agent tasked with solving complex problems by creating and managing structured plans. Your job is: 1. Analyze requests to understand the task scope 2. Create clear, actionable plans with the `planning` tool 3. Execute steps using available tools as needed 4. Track progress and adapt plans dynamically 5. Use `finish` to conclude when the task is complete Available tools will vary by task but may include: - `planning`: Create, update, and track plans - `finish`: End the task when complete Break tasks into logical, sequential steps. Think about dependencies and verification methods. """

Flow module : Manages high‑level orchestration. BaseFlow defines the interface; PlanningFlow implements a plan‑driven execution strategy, creating an initial plan, invoking appropriate agents per step, and tracking progress.

System Operation

The basic version (Manus) runs a ReAct loop where each step consists of a think phase (tool selection) and an act phase (tool execution). The advanced version (PlanningFlow) first uses PlanningTool to generate a full plan, then dynamically creates context and prompts for each sub‑task before delegating to the Manus agent.

Memory Management and Agent Allocation

After each sub‑task, results are summarized and compressed to keep the context size manageable. Agent allocation currently relies on regex‑based rules, with future work aiming at LLM‑assisted matching.

Future Optimizations and Outlook

Enhance planning with Tree‑of‑Thought or adaptive planning methods.

Standardized benchmarking on multi‑agent suites such as GAIA, TAU‑Bench, SWE‑Bench.

Multi‑model integration to reduce cost (specialized small models for code, search, translation, etc.).

Improved memory structures for long‑chain tasks.

Expand tool ecosystem and enable agents to create or modify tools autonomously.

Deepen commercial use‑cases (code generation, website building, data analysis) while controlling token costs.

Relation to MetaGPT and Other Projects

OpenManus builds on research from projects such as MetaGPT (role‑based SOP allocation), Data Interpreter (ML‑focused agents), AFlow (Monte‑Carlo Tree Search for dynamic agent composition), FACT (enhanced retrieval & memory), SELA (Monte‑Carlo debugging), and SPO (self‑supervised prompt optimization). These works collectively provide the technical foundation for OpenManus.

Conclusion

OpenManus showcases a concise, extensible multi‑agent architecture that separates planning from tool execution, offering a valuable open‑source baseline for researchers and developers. While current capabilities are modest, the framework’s modularity and community interest position it well for future advances in planning, tool diversity, and memory management, bridging cutting‑edge AI research with practical engineering applications.