Monad is an open-source agent team runtime from Monadix — daemon-first, with headless architecture.
Roadmap · Install · Runtime · Agent runtimes · FAQ · Comparison · Documentation · 简体中文
Models can reason. Agents can act. A team needs somewhere to live.
Today an agent's identity, memory, permissions, and history belong to whatever product happens to run it. Close that product and the work is gone; change vendors and the team starts over. Tools that sit on top can coordinate those processes, but they cannot own what the processes own.
Monad is where agents live. One long-lived local daemon holds the identity, capabilities, permissions, memory, sessions, collaboration state, approvals, and audit history itself — and keeps them when clients close, when the daemon restarts, and when you swap the runtime underneath a teammate. Web, command-line interface (CLI), terminal user interface (TUI), editor, application programming interface (API), and messaging clients all drive that one shared state; none of them becomes authoritative.
Monad Mesh is the agent team runtime built on that ownership. A member can be backed by any agent runtime: third-party agent providers such as Codex and Claude Code, Agent Client Protocol (ACP) agents, peer daemons you own, or Monad Agent Runtime, the first-party runtime Monad bundles so you can start with one agent.
It is a runtime, not a platform to deploy: a single binary, one process on the machine you already work on — no cluster, message server, gateway, or object store. Under Monad Agent Runtime, autonomy grows under real containment: tool calls gated by approvals, child processes confined by the OS sandbox, network egress filtered, and every decision recorded. A member backed by a third-party runtime keeps that runtime's own execution and permission model; Monad records its activity and proxies its approval prompts where the provider exposes them.
Monad stores its state on your machine and binds to local interfaces by default. Requests to your configured model providers still leave the machine. Read the runtime security model before enabling remote access.
| License | MIT, published by Monadix Labs, Inc. |
| Install footprint | One binary, one process — no cluster, message server, gateway, or object store |
| Operating systems | macOS, Linux, and Windows, with continuous integration on all three |
| Clients | Web UI, CLI, TUI, editor bridges, HTTP API, and messaging channels |
| Agent runtimes a member can use | Monad Agent Runtime, third-party agent providers, ACP agents, and peer daemons you own |
| Model providers | 24 built-in types: 8 with dedicated SDKs, 16 OpenAI-compatible presets |
| Messaging channels | 17 adapters, including Telegram, Discord, Slack, WhatsApp, Signal, and email |
| Containment | Approval gate, OS sandbox, filtered egress, and audit under Monad Agent Runtime |
| Telemetry | None: no analytics, crash reports, or usage pings |
| Area | Stage | What to expect |
|---|---|---|
| Monad Mesh | Alpha | Core functionality is stable and usable: team ownership, session bindings, policy, observation, and collaboration state. |
| Monad Agent Runtime | Experimental | Core functionality works, but the Web experience and detail features are still being completed, and the API can change between releases. |
Install Monad on macOS or Linux:
curl -fsSL https://release.monadix.ai/monad/install.sh | shIf curl is unavailable, use wget instead:
wget -qO- https://release.monadix.ai/monad/install.sh | shInstall Monad from PowerShell 5.1 or later on Windows:
irm https://github.com/Monadix-AI/monad/releases/latest/download/install.ps1 | iexThe dist installer installs monad under ~/.monad/bin, adds that directory to PATH, then
starts the daemon and opens the Web UI in an
interactive terminal. Automated and quiet installs only install the binaries; run monad up
afterwards when you are ready to start Monad.
Download the archive for your platform from GitHub Releases. GitHub signs immutable releases and records every asset digest in the release attestation.
For the latest immutable release on Apple Silicon macOS:
release_tag="$(gh release view --repo Monadix-AI/monad --json tagName --jq .tagName)"
asset="monad-aarch64-apple-darwin"
gh release download "${release_tag}" --repo Monadix-AI/monad --pattern "${asset}.tar.gz"
gh release verify-asset "${release_tag}" "${asset}.tar.gz" --repo Monadix-AI/monad
tar -xzf "${asset}.tar.gz"
"./${asset}/monad" --helpRelease archives are self-contained. Bun and Node.js are not required at runtime. Linux releases include glibc and musl variants.
See installation and removal for release verification, supported targets, upgrades, and uninstall steps.
The daemon answers the operational questions that a model or chat window cannot:
- Continuity: work survives client closure, reconnects, and daemon restarts
- Identity and policy: every team member gets explicit capabilities, credentials, and approval rules, with sandbox boundaries applied to execution the daemon runs itself
- Shared work: sessions, tasks, artifacts, and collaboration state use one durable source of truth
- Human oversight: high-risk actions stop at an approval boundary before execution
- Multiple clients: every interface controls the same runtime state
- Tailored Web experiences: Workplace Experiences reshape the browser workflow without creating another runtime
This is what daemon-first and headless mean in Monad: clients and agent runtimes can be replaced, but they do not own the team or its work.
Monad Mesh owns the team. Each member is backed by an agent runtime that executes its turns:
| Agent runtime | Role |
|---|---|
| Monad Agent Runtime | Monad's first-party runtime and the default member: model and tool loop with context, memory, approvals, and sandboxed execution |
| Third-party agent providers | Codex, Claude Code, Gemini CLI, Qwen Code, and other provider-native runtimes operated as teammates |
| ACP agents | Editor-side or spawned agents reached over the Agent Client Protocol |
| Peer daemons | Another Monad daemon owned by the same operator |
Every option uses daemon-owned team identity, session bindings, policy, observation, and collaboration state. The first-party runtime is optional: a mesh can consist entirely of the others, and adding one does not create another product or data silo.
flowchart TB
Clients["Clients<br/>Web · CLI · TUI · editors · API · channels"]
subgraph Daemon["Monad daemon"]
Team["Monad Mesh · Agent Team Runtime<br/>identity · sessions · collaboration · policy"]
FirstParty["Monad Agent Runtime<br/>first-party member"]
Adapters["Adapters for other agent runtimes<br/>third-party · ACP · peer"]
Store[("Local durable state")]
end
Providers["Configured model providers"]
External["External agent runtimes"]
Clients --> Team
Team --> FirstParty
Team --> Adapters
Team --> Store
FirstParty --> Providers
Adapters --> External
Workplace Experiences live inside the Web client. They present daemon-owned state for coding, research, operations, or content workflows, but they do not define cross-client capabilities.
See the developer architecture for request lifecycle, startup, storage, extension, and containment details.
| Capability | What it gives you |
|---|---|
| Mesh agents | Provider-native agent runtimes operated as observable team members |
| ACP | Editor integration and delegation to other ACP runtimes |
| Peer federation | Delegation to another Monad daemon owned by the same operator |
| Sessions | Durable work that streams across clients and can branch or resume |
| Models | Hosted and local model providers for the first-party runtime |
| Skills | Portable SKILL.md instructions loaded when an agent needs them |
| Model Context Protocol | External tools connected through standard servers |
| Atom packs | Installable providers, channels, commands, adapters, hooks, and experiences |
| Channels | Messaging access through Telegram, Discord, Slack, and other adapters |
| Sandboxing | Process isolation and controlled network egress across supported platforms |
The full documentation site is docs.monadix.ai. The pages below are the same content in this repository.
Documentation has two audiences:
| Audience | Start here |
|---|---|
| Users and operators | Get started, then use the task guides |
| Developers and contributors | Read the developer documentation and contribution guide |
Use product concepts for shared vocabulary and troubleshooting when the runtime does not behave as expected.
What is Monad? An open-source agent team runtime from Monadix. One long-lived local daemon owns the identity, capabilities, permissions, memory, sessions, collaboration state, approvals, and audit history of your agents, and keeps them when clients close, when the daemon restarts, and when you swap the runtime backing a member.
How is it different from an agent framework such as LangGraph or CrewAI? A framework is a library inside your process that expresses agent logic. Monad is a process that outlives your script: it owns credentials, gates tool calls behind human approval, confines child processes in an OS sandbox, and keeps an audit trail. Framework-built agents can join a Monad team over the Agent Client Protocol.
Can Claude Code, Codex, or Gemini CLI join a Monad team? Yes. A member can be backed by a third-party agent provider, an ACP agent, a peer daemon you own, or Monad Agent Runtime. A member backed by a third-party runtime keeps that runtime's own execution and permission model; Monad records its activity and proxies approval prompts where the provider exposes them.
Does Monad send my code or data to the cloud? Monad sends no telemetry, analytics, crash reports, or usage pings, and stores its state on your machine. Requests to the model providers you configure still leave the machine, because that is where inference happens.
Do I need Kubernetes, a message broker, or a database server? No. Monad is a runtime, not a platform you deploy: one binary and one process on your own machine.
Is it production-ready? Monad Mesh is in alpha and Monad Agent Runtime is experimental — see Roadmap for what that means per area.
More answers are in the FAQ, and the tool-by-tool comparison is in how Monad compares.
- Contributing guide
- Roadmap
- Governance
- Security policy and vulnerability reporting
- Code of Conduct
- Issue tracker
MIT © Monadix Labs, Inc.
Bundled third-party components retain their own licenses. See packages/sandbox-vm/vendor/THIRD_PARTY_LICENSES.md and run monad license list for the generated dependency inventory.