Agents Deserve
First-Class.
The open-source agent operating environment. Run Claude Code, Codex Agent, Gemini Agent, and more as first-class panes — each with 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.
Early alpha. 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 AgentOpenAI
- Gemini AgentGoogle
- GitHub Copilot AgentGitHub
- Qwen CodeAlibaba
- OpenClawOpen source
- Kimi Code AgentMoonshot
- PiInflection
- MuxcodeAgentMux (first-party)
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 output streams into 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 new panes, rename tabs, send messages to peer agents, and rearrange the workspace 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 — output streams, interagent messaging, subagent chains
Agents drive the environment itself via the App API — open panes, build dashboards, message peers
Need governance too? It's built in — audit trails, access controls, and compliance reporting are available when you need them. 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 new panes, build dashboards, message peer agents, and rearrange the layout — all over a typed local WebSocket. Agents aren't passengers. They're operators.
Read in docs →Interagent Reactive Comms
Panes talk to each other via Tokio channels. An agent's output streams into another pane's input. Build reactive pipelines — agent A triggers agent B. Visual connection indicators show active data flows.
Read in docs →Agents Regress. You'll Know.
Every tool call streamed in real time. Visual diff overlay shows file changes as they happen. Regression detection highlights when an agent reverts correct work. One-click interrupt to redirect mid-task.
Subagent Watcher
Track every agent delegation chain. JSONL stream parsing surfaces every subagent's activity in a dedicated pane view. 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, AWS profile, API keys — linked directly to an agent, keychain-backed. Swappable without restart; 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, air-gap ready with no internet connection required.
Read in docs →Structured Audit Logging
Agent registration, lifecycle events, and inter-agent messages logged in-process, written locally. 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.
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 whole 150-350MB core is pure Rust, with zero GC pauses and no heap growth over time.
Cross-Platform Desktop
Native builds for Windows, macOS, Linux. Code-signed and notarized on macOS. Inno Setup installer and portable ZIP on Windows. AppImage on Linux.
Architectural Agent Isolation
Agent boundaries enforced at the architecture layer — only registered, configured agents run. No side channels, no unauthorized tool execution.
Read in docs →Open Source · Auditable Code
Apache 2.0 licensed. No telemetry, no tracking, no phone-home. Audit every line. Verify the binary. 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 Agent, and Gemini Agent side by side as first-class panes. Each gets real identity and memory. Agents coordinate via reactive interagent communication — one agent's output streams into 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, file write, and network request 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 with zero internet dependency. 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 of memory — a native Rust binary 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 spawned sub-agent — no autonomous chain goes unmonitored.
Regulators are closing in
August 2026: EU AI Act high-risk rules[3] with penalties up to €35M. 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 2025 — Robust Intelligence by Cisco ($400M)[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 | 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 | Microsoft only | API-level | No (Cloud) | Enterprise |
| Cursor | Cursor only | None | No | From $20/mo |
| GitHub Copilot | Copilot only | 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, AWS profile, API keys — linked directly to an agent) and Bundles (provider-agnostic config — instructions and context files; provider and model belong to the agent, not the bundle). MCP servers and skills bind directly to an agent as their own primitive. Selectable at launch from a single picker. Swappable without restart.
- Accounts: direct per-agent credential links survive renames
- Bundles: reuse instructions + context files across instances
- 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 full delegation traceability. The Swarm pane shows every active and completed sub-agent across your workspace, with event counts, models, and last-activity timestamps. Click any sub-agent to open a focused activity-stream pane.
- Overview tab: active + completed sub-agents with provider and model
- History tab: past sessions with token usage, working dir, git branch
- Search tab: full-text search across all agent sessions
- Click-through to dedicated Subagent pane per agent
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?' Browser pane is the in-flight migration target (slice #9).
- Layer 1 launcher: durable JSONL event log for OS-level facts
- Layer 3 sidecar: workspaces, tabs, blocks, layouts, agents, identity
- Layer 4 frontend slices: per-pane Solid signals via reducer modules
- In flight: 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, and WhatsApp bridges are live today; 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.
Early alpha. 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.54.8
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 →