What it is
Manus is a general-purpose autonomous agent from Monica, the team known for browser-side AI tooling. Its tagline is “less structure, more intelligence” — the idea being that you give it a goal in plain English (“build me a slide deck about Israel’s solar industry,” “research and book a 3-day Tokyo trip”), and it figures out the rest: spinning up a browser, running code, generating files, and reporting back. Manus made noise in 2025 by winning the GAIA general-assistant benchmark and is now part of Meta’s broader enterprise AI stack.
Manus itself is closed-source SaaS. OpenManus — specifically the henryalps/OpenManus repo (UNLICENSE / public domain, 901 stars at time of writing) — is an independently built open replica of the same architecture: a multi-agent system that plans, browses, codes, researches, and reports, all packaged as a Docker compose stack you can run locally.
Architecture
Both Manus and OpenManus are built on the CodeAct pattern. Instead of the agent picking from a fixed menu of JSON-shaped tool calls, every action is emitted as a Python (or shell) snippet that gets executed in a sandbox. Code is the action language. That gives the agent loops, conditionals, error handling and arbitrary composition for free — far more expressive than rigid tool schemas.
+-------------------------------+
| Coordinator agent |
| (plan, delegate, supervise) |
+----+--------+--------+---------+
| | |
v v v
+-------+---+ +--+-----+ +-+--------+
| Research | | Coder | | Browser |
| agent | | agent | | agent |
+-----+-----+ +---+----+ +----+-----+
| | |
v v v
+---+-----------+-----------+----+
| CodeAct sandbox (Docker) |
| - python exec |
| - shell |
| - headless browser |
| - file system |
+-------------+-------------------+
|
v
+-------+--------+
| Reporter agent |
| (writes final |
| artifact) |
+----------------+
The agent loop is the classic Plan → Act → Observe → Reflect cycle:
- Plan — the coordinator turns the user’s goal into an ordered plan with explicit subgoals.
- Act — a specialist agent (Research / Coder / Browser) emits a code snippet.
- Observe — the sandbox runs the code and returns stdout / stderr / file outputs.
- Reflect — the coordinator decides “done,” “retry,” or “replan,” and the cycle repeats until the Reporter agent emits the final artifact.
Install
System requirements for OpenManus:
- Docker 20.10+
- Docker Compose 1.29+
- Node.js 20.18+ (for local dev outside Docker)
- Python 3.9+ (for local dev outside Docker)
- Git
Recommended path — Docker Compose, three commands:
git clone https://github.com/henryalps/OpenManus.git
cd OpenManus
docker-compose up --build
That spins up the coordinator, the specialist agents, and the sandbox container, exposing the web UI on the port defined in docker-compose.yml. For local Python development without Docker:
git clone https://github.com/henryalps/OpenManus.git
cd OpenManus
python -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt
python client.py --task "Plan a 3-day trip to Tokyo"
Configuration
Configuration is split between an .env file (secrets) and config.yaml (agent behavior). Example:
# .env
OPENAI_API_KEY=sk-...
ANTHROPIC_API_KEY=sk-ant-...
SERPER_API_KEY=...
BROWSER_HEADLESS=true
SANDBOX_TIMEOUT_S=180
# config.yaml
model:
primary: anthropic/claude-opus-4-7
cheap: openai/gpt-5-mini
vision: openai/gpt-5
agents:
coordinator:
max_steps: 25
reflect_every: 3
research:
search_provider: serper
max_pages_per_query: 8
coder:
sandbox: docker
languages: [python, bash, javascript]
browser:
engine: playwright
user_agent: "OpenManus/0.x"
reporter:
output_dir: ./out
formats: [md, html, pdf]
safety:
network_egress: allowlist
allowed_hosts:
- "*.github.com"
- "*.wikipedia.org"
- "*.arxiv.org"
Usage examples
1) Trip planner.
$ python client.py --task "Plan a 3-day trip to Tokyo
for a vegetarian, mid-budget, late May."
[coordinator] plan:
1. research neighborhoods (research agent)
2. shortlist 6 vegetarian-friendly restaurants
3. build day-by-day itinerary
4. estimate cost in USD
5. write report.md
[research] browsing 8 sources...
[coder] writing itinerary.py to score options
[reporter] wrote out/tokyo-trip.md (1,842 words)
2) Code research agent.
$ python client.py --task "Compare the top 3 Python
web frameworks for async APIs in 2026. Output
a markdown table with stars, license, and a
one-line verdict."
[research] querying GitHub API for: fastapi, litestar, robyn
[coder] fetching repo metadata...
[reporter] wrote out/async-frameworks.md
3) Browser automation.
$ python client.py --task "Open my GitHub
notifications, summarize anything mentioning
me, and save to inbox.md."
[browser] launching playwright (headless)
[browser] login via stored session...
[coder] parsing 23 notifications
[reporter] wrote out/inbox.md (5 mentions)
What’s new / version
OpenManus (henryalps/OpenManus): 901 stars, 209 forks, 34 watchers, 94.2% Python / 4.1% JavaScript, UNLICENSE. Active iteration on the multi-agent split (Coordinator / Research / Coder / Browser / Reporter) and on the Docker sandbox.
Manus (the closed product): currently part of Meta, with a freemium web app, paid tiers, team / enterprise plans with SSO, an API for developers, and a startup program. Recent product surface includes slide generation, website building, desktop app generation, design tools, browser automation, research, image and music generation, and direct Email / Slack integrations.
Why it matters / where I use it
CodeAct is the most underrated idea in agent design right now. Tool-calling-via-JSON is fine for narrow tasks, but the moment your agent needs a loop, a conditional, or to chain three actions together, structured tool calls get clumsy. CodeAct collapses “reason” and “act” into one substrate — the Python interpreter — and the agent gets composability for free.
Manus showed that this pattern scales to a real GAIA-beating product. OpenManus proves that the same pattern, in 900-ish stars of open Python, will run on your laptop tonight. For my own work on the agent layer (Bot-UI’s SKILL_REGISTRY, the ADK-driven Agents Hub), OpenManus is the cleanest end-to-end reference for the Plan→Act→Observe→Reflect loop with a sandboxed code-as-action interface. If you want to learn how a multi-agent system actually behaves under load, fork it and watch the logs.
Source
OpenManus: github.com/henryalps/OpenManus (UNLICENSE) · Manus: manus.im (closed SaaS, now part of Meta).