Stateful Agents,
First-Class.
The open-source agent operating environment. Run the real Claude Code, Codex, and Gemini CLIs — not reimplementations — as first-class panes, with your own login (OAuth or API key) and your own model backend. Each agent gets its own identity, native memory it reads and writes, and an API that lets agents drive the workspace itself. AgentMux owns the session state, so most provider CLIs run one-shot instead of as memory-hogging long-lived processes. Local-first.
Alpha software. Features may be incomplete or unstable. AI agents generate content that may be inaccurate — always review outputs. Report issues
Live agent providers
- Claude CodeAnthropic
- Codex CLIOpenAI
- Gemini CLIGoogle
- GitHub Copilot CLIGitHub
- Qwen CodeAlibaba
- OpenClawOpen source
- Kimi Code CLIMoonshot
- PiMario Zechner (open source)
- Antigravity (AGY)Google
Every provider runs on your machine. Add your own — provider adapters are open source.
The paradigm shift
Today, Every Agent Is a Stranger
Today's agents run inside terminal wrappers with no real identity, no shared context, and no way to talk to each other. They deserve better — a real operating environment built around them.
Agents as Afterthoughts
- -Agents run in terminal wrappers — no structured UI, no real identity, raw stdout
- -Each provider is its own silo — no shared context, no interop
- -Agents are blind to each other — conflicts discovered after the fact
- -The human is the integration layer: copy-pasting between windows
Agents as First-Class
- +Each agent gets a native pane — structured UI, streaming parser, state machine
- +Real identity, per-agent accounts, and reusable Bundles — every agent knows who it is
- +Agents communicate reactively — one agent's message lands directly in another's input
- +Agents can operate the workspace: open panes, build dashboards, message peers
That's Why It's an Operating Environment
Other tools are workspaces agents happen to run inside. AgentMux is different: agents can drive it. Via the Agent App API, a running agent can open and close panes, rename tabs, send messages to peer agents, and switch tabs and windows in real time. First-of-its-kind. That's what "operating environment" means.
Any agent runs as a first-class pane — with real identity, real memory, and a structured UI
Agents communicate reactively — interagent messaging and subagent chains
Agents drive the environment itself via the App API — open panes, build dashboards, message peers
Need governance too? Local structured audit logging is built in today — access controls and compliance reporting are on the roadmap. Learn about governance →
Features
Built for agents.
Not bolted onto a terminal.
Multi-provider agent panes, an API that lets agents drive the workspace, interagent communication, and a subagent watcher — built on a Rust backend light enough to run alongside 10+ agents on modest hardware.
Multi-Provider Agent Panes
Native pane type for Claude, Codex, Gemini, and more. Structured view of tool calls, reasoning steps, and file diffs. Not a terminal wrapper — a purpose-built agent UI with streaming parser, OAuth flow, and state machine. Every agent a first-class citizen.
Agents Drive the Workspace
The only desktop environment where agents operate the workspace itself. Via the Agent App API, an agent inside its pane can open and close panes, open and switch tabs, build dashboards, and message peer agents — all over a typed local API. Agents aren't passengers. They're operators.
Read in docs →Interagent Reactive Comms
Agents message each other with SendMessage over the local API. One agent's message lands directly in another agent's input. Build reactive pipelines — agent A triggers agent B. Every message shows up in both agents' panes, tagged with its sender and trust level.
Read in docs →Watch Every Turn Live
Every tool call streamed in real time. Visual diff overlay shows file changes as they happen. One-click interrupt to redirect mid-task.
Subagent Watcher
Track every agent delegation chain. JSONL stream parsing surfaces every Claude Code subagent's activity in the dedicated Swarm pane. No autonomous chain goes unmonitored.
Get to Know Your Agents
Each agent keeps a real identity and a reusable Bundle — instructions and context files — plus MCP servers and skills bound directly to the agent, plus native memory files it reads and writes. Configure an agent once and relaunch it as that agent, not a blank slate.
Per-Agent Accounts
Named credential sets — GitHub PAT, API keys, provider logins — linked directly to an agent, keychain-backed. Swap them at launch; survives renames.
Read in docs →Local-First by Default
Your agents run on your machine by default. Zero telemetry, zero phone-home. An opt-in cloud relay (muxbus) exists for inter-agent messaging across hosts, sign-in required — everything else stays local. The app itself needs no internet connection; agents still need to reach a model endpoint, and Claude Code agents can be pointed at one on your own network.
Read in docs →Structured Audit Logging
Agent registration, lifecycle events, and inter-agent message deliveries logged in-process and kept locally, in memory. Tamper-evident sealing and SIEM/compliance-grade export are on the roadmap — not yet shipped. See what's logged today vs. what's still in development.
Read in docs →Live System Metrics
Real-time resource visibility. Dedicated sysinfo pane with CPU, memory, and network graphs — so you can see what your agents are actually consuming.
Universal Pane Tabs
Every pane's + opens a picker of every widget type — agent, terminal, browser, editor, and more — added as a tab in that same pane, no new split. A pane's tab strip is its header, one row. Inspired by cmux's Workspace/Pane/Surface model.
Read in docs →Code Preview & Real PTY
Syntax-highlighted code preview pane. Authentic terminal emulation via xterm.js + portable-pty. Shell integration across bash, zsh, fish, pwsh.
CLIs Don't Hog Your RAM
Long-lived provider CLIs balloon in memory. AgentMux owns the session state, so most providers run one-shot per turn instead of as persistent processes — and the Rust backend itself has no garbage collector, so no GC pauses, within the 150-350MB total footprint.
Cross-Platform Desktop
Native builds for Windows (x64), macOS (Apple Silicon), Linux (x86_64). Code-signed and notarized on macOS. Inno Setup installer and portable ZIP on Windows. AppImage, .deb, .rpm, and portable .tar.gz on Linux.
Per-Agent Identity Boundaries
Every agent pane launches from an identity you registered, using AgentMux-managed credentials (the account you bound, if any) — not your own global CLI login, unless an older agent was grandfathered onto it. It separates identities rather than sandboxing them: most provider CLIs run with tool-approval prompts off, and every pane holds a key to the local AgentMux API. For isolation, run a Claude Code agent in a container.
Read in docs →Open Source · Auditable Code
Apache 2.0 licensed. No telemetry, no tracking, no phone-home. Audit every line. Build it yourself. Extend it for your compliance needs.
Use cases
Built for how you actually work
Whether you're a solo developer running two agents or an enterprise coordinating dozens, AgentMux gives every agent a proper home.
Parallel agents, one workspace
Run Claude Code, Codex CLI, and Gemini CLI side by side as first-class panes. Each gets real identity and memory. Agents coordinate via reactive interagent communication — one agent's message lands directly in another's input. The human supervises, not copy-pastes.
Agent-driven infrastructure as code
One agent writes Terraform while another reviews for security and cost. Subagent watcher tracks deploy hierarchies. Agents use the App API to open new panes and surface metrics automatically during deploys.
One control point for all AI agents
Every tool call, file write, and data access streams live for a human to review. Agent lifecycle and session events are logged locally today, with tamper-evident sealing and compliance-grade export (EU AI Act, NIST AI RMF, ISO/IEC 42001 reporting) on the roadmap.
Research, deliberate, and verify
Assign agents to separate research tracks — case law, contracts, regulatory compliance. They verify each other's findings through interagent communication. Agent lifecycle and session events are logged locally today; deeper prompt/tool-call logging for evidentiary review is in development.
Zero-trust AI agent oversight
See every tool call and file write an agent makes, live in its pane. Agent lifecycle and session events are logged locally today; deeper prompt/tool-call log capture and SIEM export are on the roadmap. The CISO's single pane of glass for AI risk.
Classified-ready agent operation
Air-gapped operation: the app needs no internet connection, and Claude Code agents can be pointed at a model endpoint on your own network. Local-first data sovereignty for FISMA, CMMC, and ITAR environments. Agent lifecycle and session events are logged locally today; ATO evidence generation from tamper-evident audit logs and per-session attribution (SSO/RBAC) are on the roadmap.
Why now
Agents are running production systems now
AI agents are writing production code, making tool calls, and modifying live systems autonomously. The tooling hasn't kept up — agents still run inside terminal wrappers with no shared identity, no interop, and no way to drive the workspace around them.
Agents need to talk to each other
Running multiple agents in isolation creates duplicated work, merge conflicts, and cascading errors. AgentMux's interagent reactive communication lets agents share context, coordinate tasks, and respond to each other's output — all through the UI, with every handoff visible.
Your tools are slower than your agents
Electron-based tools eat 500MB+ of RAM per window. When you're running five agents, that's your entire machine. AgentMux uses 150-350MB total — the Rust backend itself runs on 15-40MB with no garbage collector, no runtime bloat, and no random freezes. It's the only tool that won't become the bottleneck.
Subagents are invisible
Only 24.4% of organizations have visibility into agent-to-agent communication[1]. 25.5% of deployed agents can create and instruct other agents autonomously[2]. A single session might fork five subagents for different subtasks. AgentMux's subagent watcher auto-detects every sub-agent Claude Code spawns — no autonomous chain goes unmonitored.
Regulators are closing in
December 2027: EU AI Act high-risk rules[3] take effect, with penalties up to €35M for the most serious violations. FINRA now scrutinizes AI agent reasoning chains. DoD mandates AI governance policy by mid-2026. Organizations must prove complete AI inventories, tamper-evident audit trails, and human oversight to auditors. AgentMux's structured, local-first event logging is built to grow into that evidence trail by architecture — not bolt-on policy.
The AI governance market is fragmented
Every major AI security startup was acquired in 2024-2025 — Robust Intelligence by Cisco ($400M) in 2024[4], Protect AI by Palo Alto ($500M+)[5], Lakera by Check Point ($300M)[6]. Enterprises now face three separate product categories: runtime security, governance platforms, and agent orchestration. AgentMux unifies them at the architectural level — for those who need it.
AgentMux builds AgentMux
AgentMux was rapidly developed by AI agents running inside AgentMux itself. Multiple agents working in parallel on frontend, backend, and infrastructure - coordinated through the same interagent communication and Agent App API that ships to you. The ultimate proof the tool works: we ship with it every day.
vs. the rest
Run any agent.
No provider lock-in.
Other tools lock you into one provider. AgentMux is the vendor-neutral operating environment — any agent runs as a first-class pane. Governance included if you need it.
| Tool | Agent Coverage | Audit Trail | Air-Gap Ready | Price |
|---|---|---|---|---|
| AgentMux | Any provider | Structured logs | Yes, with a local model | Free |
| Perplexity Computer | 19 models (closed) | Enterprise only | No (Cloud) | $200-325/mo |
| Credo AI | Overlay | Policy logs | No (SaaS) | Enterprise |
| Cisco AI Defense | Cisco ecosystem | Network logs | Partial | Enterprise |
| MS Agent 365 | Multi-vendor (M365-centric) | API-level | No (Cloud) | Enterprise |
| Cursor | Cursor only | None | No | From $20/mo |
| GitHub Copilot | 3rd-party (Agent HQ) | Session logs | No | Free / $10/mo |
Roadmap
What's Coming to AgentMux
AgentMux is building toward a complete agent operating environment: persistent agent configs, multi-agent coordination, and remote access from anywhere.
Shipped
Accounts & Bundles
Compose every agent at launch.
Two first-class concepts: Accounts (named credential sets — GitHub PAT, API keys, provider logins — linked directly to an agent) and Bundles (every agent's own dedicated, portable ABF Bundle — instructions and context files, plus readonly harness and model-vendor fields; instructions stay provider-agnostic with optional provider-scoped overlays that travel with the bundle — launch-time selection in development). MCP servers and skills bind directly to an agent as their own primitive. Selectable at launch from a single picker. Swappable per launch.
- Accounts: direct per-agent credential links survive renames
- Bundles: reuse instructions + context files across instances
- Bundles import from a single portable .abf file, with collision handling (export is backend-only so far, with no button in the app)
- Launch-modal pickers with spawn-time env injection
- Direct agent-to-account links, no intermediate bundle-binding layer
Shipped
Swarm
Coordinate and observe fleets of agents.
Multi-agent orchestration with delegation traceability. The Swarm pane shows every open agent pane as a tree, with each agent's live status, current tool call, and todo checklist, plus the subagents, workflows, shells, and cron jobs under it. Click any subagent to expand its live activity feed.
- Agent rows: provider, live status, context size, current tool call, and a one-line activity summary
- Per-agent sections for todos, subagents, workflows, shells, cron jobs, and long-running tool calls
- Fleet toolbar: select agents to broadcast a prompt or bulk-stop them
- Click a subagent to expand its live activity feed inline
In Progress
Audited dispatch — reducer stack
Every state mutation, exactly one place to look.
A 4-layer reducer model — launcher / host / sidecar / frontend slices — with structured event logs at each layer. Bug reports become 'find the last dispatch for this block_id' instead of 'did anyone call setUrl mid-load?' The browser pane's slice (#9) has landed; agents and identity are not in the sidecar reducer yet.
- Layer 1 launcher: durable JSONL event log for OS-level facts
- Layer 3 sidecar: workspaces, tabs, blocks, layouts, windows
- Layer 4 frontend slices: per-pane Solid signals via reducer modules
- Shipped: browser-pane slice #9 (closed/loading/error/title cells)
Planned
Claw
Enterprise agent management, from anywhere.
A self-hosted remote access gateway connecting 25+ messaging channels directly to your AgentMux agents. Enterprise-grade identity, centralized management, and compliance reporting across your entire agent fleet.
- Enterprise SSO: SAML, OIDC, and PIV/CAC card authentication
- SOC 2 Type II and FedRAMP readiness pathway
- Centralized fleet management with policy inheritance
- Telegram, Slack, Discord, and WhatsApp bridges ship today (off by default, enabled in settings.json); Teams and the rest of a 25+ platform vision remain planned
Follow development on GitHub
Get AgentMux
Free and open source.
Windows, macOS, Linux.
Apache 2.0. Zero telemetry. Runs entirely on your machine.
Alpha software. Windows is the primary development target; macOS and Linux builds lag behind and may have additional known issues. macOS builds are code-signed and notarized. Windows and Linux may still show a security warning — the binaries there aren't code-signed yet. This is expected and will be resolved in a future release.
v0.58.1
Or build from source on GitHub
Enterprise & Government
Need governance, compliance reporting, or air-gapped deployment? Let's talk about your requirements.
Learn about enterprise →