Why AgentMux, Why Now
AI agents already write production code, fire tool calls, and reshape live systems. Our tools still treat them like terminals. AgentMux is built for what agents actually do.
The agentic era arrived faster than its tools
At GTC 2026, Jensen Huang framed agentic AI as the operating reality, with NVIDIA projecting $1 trillion in infrastructure demand through 2027. Engineers get token budgets. SaaS companies become AaaS companies. But the workspace for driving fleets of agents still doesn't exist. AgentMux is that workspace.
- +Agents now read, write, compile, test, and iterate on their own - the loop runs without you in it
- +Agentic coding is already mainstream: Claude Code, Codex, and Cursor are standard issue at NVIDIA and beyond
- +Agents spawn sub-agents, work in teams, and run for hours - you need to watch all of it at once
- +Jensen: 'For the first time, you don't ask AI what, where, when, how. You ask it create, do, build.'
- +Inference demand is climbing fast - your tooling either keeps pace or becomes the bottleneck
Subagents run blind by default
Agents parallelize by spawning subagents. One Claude Code session can fork five of them across different subtasks. Without AgentMux's Swarm view, that whole tree is a black box - you can't see what each subagent is doing or when one goes wrong.
- +Swarm reads the JSONL stream, auto-detects spawned subagents, and opens a dedicated pane for each
- +See the full agent tree - parent agents, child agents, and how they relate
- +Watch bootstrap output as each subagent picks up its task and starts reasoning
- +Catch a subagent that regresses, corrupts data, or loops - instead of finding out after the fact
- +Real-time subagent observability that most tools simply don't offer
Your tools are slower than your agents
Cursor and Windsurf regularly hit 3-40GB RAM in multi-day sessions. AgentMux runs Chromium 148 over a pure Rust backend - no GC pauses, no heap growth, flat memory from hour 1 to hour 8.
- +Pure Rust backend: no Node.js, no V8 garbage collector, no stop-the-world freezes mid-agent-run
- +150-350MB at idle and sub-second startup, against 3-40GB RAM reported for Cursor and Windsurf in long sessions
- +CEF (Chromium 148) renders the same on Windows, macOS, and Linux - no WebView2 version mismatches
- +Tokio async runtime carries thousands of concurrent WebSocket connections without thread overhead
- +GPU-accelerated rendering with an RDP-compatible fallback - stays smooth even over remote desktop
- +Your CPU and RAM stay free for your agents, not your tooling
Agents regress silently
An agent fixes a bug, then quietly undoes the fix three steps later. With no view into each decision, you find the damage after it's merged. AgentMux streams every tool call as it lands, so you catch the turn when it happens.
- +Stream-JSON parser renders agent output live, not after the run completes
- +Visual diff overlay shows file changes as they happen, not at session end
- +Regression cues surface the moment an agent reverts work that was already correct
- +One interrupt redirects an agent mid-task, before the damage compounds
- +Searchable session history pinpoints exactly when and why an agent went off track
- +Document model captures hierarchical message blocks - diffs, terminal output, code - for replay
One workspace for every provider
Claude for reasoning, Codex for code, Gemini for analysis - today that means three terminals and three output formats. AgentMux runs them as native panes under one workspace, with identity bundles and reusable presets so any provider launches the same way.
- +Native panes for multiple providers - configure once, launch from a shared picker
- +Identity bundles carry an agent's name, role, and native memory files into every session
- +Reusable presets capture a provider setup so you spawn the same agent without re-wiring it
- +Built-in installer handles setup for supported providers straight from AgentMux
- +A structured presentation layer normalizes provider output into one consistent UI
- +Per-agent color, icons, and status indicators so you read the room at a glance
Agents need to talk to each other
Run agents in isolation and you get duplicated work, merge conflicts, and cascading errors. AgentMux gives agents interagent reactive comms - one agent sends a message, another reacts - plus auto-registration so panes find each other.
- +SendMessage routes one agent's output straight into another agent's context
- +Event-driven pane comms over Tokio channels - no polling, no shared scratch files, no hacks
- +Panes auto-register on the backend and advertise what they can do
- +An offline queue buffers messages for agents that are down and delivers on reconnect
- +Connection indicators show which panes are linked and what's flowing between them
- +Fewer merge conflicts, because agents stay aware of each other's work in real time
Agents should drive their own UI
Most tools treat an agent as a text stream and nothing more. AgentMux's Agent App API lets agents drive the workspace itself - spawn panes, render custom views, and reshape the layout - all over a typed IPC bridge to the Rust core.
- +Agents call the API to open new panes - terminals, editors, webviews, dashboards
- +Agents reshape their own pane: title, status, layout position, color
- +Build rich views from inside a run - progress bars, dependency graphs, deploy status
- +Reactive injection endpoints coordinate agents across hosts, with rate limiting
- +Injections are logged, the start of an audit trail that's still taking shape
- +The API bridges straight to the Rust backend over IPC for sub-millisecond response
Oversight is becoming the requirement
The EU AI Act mandates human oversight of high-risk systems, and the Colorado AI Act takes effect June 2026. With agents reported to exceed their permissions in the wild, the bar is moving from guardrails toward provable oversight. AgentMux is built local-first to put that visibility in your hands.
- +Watch every tool call, file write, and data access stream by, tagged with the agent's identity
- +See the reasoning at each handoff - the decision context, not just the result
- +Runs fully local with zero telemetry - your agent activity never leaves your machine
- +Native memory files keep an agent's context on disk, in your control, today
- +53% of organizations report AI agents exceeding intended permissions (CSA/Zenity, 2026) - visibility is the floor
- +Frameworks like NIST's agent work and ISO/IEC 42001 push runtime monitoring - AgentMux's audit trail is growing toward it
AgentMux builds AgentMux
AgentMux is built by AI agents running inside AgentMux. Agents work the frontend, backend, and infrastructure in parallel, coordinated through the same features that ship to you.
- +Agents work in parallel across the codebase - frontend, backend, infrastructure
- +Swarm tracked the agent tree throughout AgentMux's own development
- +Regression cues caught real bugs during development, before they shipped
- +The Agent App API was shaped by what our own agents needed while building the product
- +Identity bundles and presets manage the agent fleet that builds AgentMux every day
- +Dogfooding, literally - the tool exists because agents can build with it
Try AgentMux
Free and open source. ~160MB portable — no install needed.
Early alpha. Features may be incomplete or unstable. AI agents generate content that may be inaccurate — always review outputs. Report issues