Use Cases
AgentMux fits wherever several agents work in parallel, hand findings to each other, and stay under a human's eye - from code to contracts to compliance reviews.
Split the research, cross-check the findings
Put each agent on its own track in its own pane - one on case law, one on contract terms, one on regulatory questions. They run side by side, and a research agent can hand a finding to a reviewer agent the moment it surfaces something.
- +One agent works precedent while another argues the other side, both panes open at once
- +A reviewer agent re-checks citations another agent pulled and flags what does not line up
- +Drop case files straight into a pane to start the agent on them
- +Use the Agent App API to lay out the panes you want - event timeline, clause comparison, risk grid
- +Every pane keeps a running session log of what the agent did and read
- +SendMessage lets a research agent trigger the reviewer agent as soon as it hits something material
Run several lines of inquiry at once
Open one agent per approach and let them run in parallel. Each can pass findings to the others through SendMessage, and a reviewer agent can read across all of them to catch where conclusions disagree.
- +Give competing hypotheses to separate agents and read their reasoning side by side
- +SendMessage lets agents pass findings to each other and pick apart the logic
- +Point a reviewer agent at the others to surface contradictions as they come up
- +Drop datasets, papers, or source documents straight into agent panes
- +Use the Agent App API to have an agent build the layout that fits the work
- +Each agent keeps a session log, so you can read back how a conclusion was reached
Watch what the agent actually does
Every agent runs in a native pane where you read its tool calls and edits as they happen. Nothing runs hidden in a background process, and a second agent can review the first agent's work before anything ships.
- +Read each agent's tool calls and file edits live in its own pane
- +One agent hunts for vulnerabilities while a second reviews what the first reports
- +SendMessage can hand a critical finding straight to a human-review pane
- +Drop your security guidelines into a pane so the agent works against them
- +Give each agent its own identity bundle, so credentials stay scoped per agent
- +Each session keeps a log you can read back for post-incident review
Prototype your multi-agent product
Your product runs on agents, so you need to see them interact before you ship. AgentMux gives you a place to wire agents together, read their messages, and work out why Agent #4 keeps reverting Agent #2.
- +Watch agents message and react to each other across panes in real time
- +Use the Agent App API so an agent can open panes and lay out its own view
- +SendMessage models the handoffs your production agents will do later
- +Try out coordination patterns locally before you build the real pipeline
- +Light Rust core (roughly 150-350MB) runs next to your full dev stack
- +Open source, so you can read it, fork it, or build on top of it
Take the grind out of the backlog
Point agents at your issues. Watch them triage, reproduce, and draft fixes in separate panes, then review the result before any PR goes out.
- +One agent triages new issues while another tries to reproduce the bugs
- +Drop issue links into a pane to put an agent on the investigation
- +A reviewer agent reads a proposed fix before the PR gets written
- +SendMessage lets the triage agent flag a duplicate to the fix agent
- +You keep the review, the agents take the legwork
- +Reading the agent's work in its pane means you decide what ships
Check several frameworks in parallel
Put one agent on each framework and run them at the same time. Each works from its own preset and instructions, and a reviewer agent reads their findings before anything goes into a report.
- +Give SOC 2, GDPR, and HIPAA each their own agent, running side by side
- +Agents flag findings and a separate reviewer agent re-checks each one
- +Drop policy documents into a pane to point an agent at the current baseline
- +Use the Agent App API to lay out a pass/fail view across the running agents
- +SendMessage lets a finding in one domain kick off checks in a related one
- +Each agent keeps a session log of what it checked and what it found
Keep autonomous agents under human eyes
80% of companies running AI agents have seen them act outside intended boundaries. AgentMux keeps each agent in its own pane on your own hardware, where a human reads what it does and decides whether it continues.
- +Read each agent's tool calls, file edits, and reasoning live in its pane
- +Each agent runs from a preset with its own provider, model, instructions, and MCP setup
- +Identity bundles give each agent its own credentials, so access stays scoped per agent (39% of organizations report AI agents reaching systems they should not - SailPoint, 2025)
- +A human stays in the loop on every pane and can stop an agent at any point
- +Session logs record what each agent did, for your own review and incident follow-up
- +Runs locally with no telemetry, so nothing about your agents leaves your machines
- +Air-gap friendly: the whole thing runs offline on a light Rust core
- +Open source, so your security team can read exactly what it does
A reviewer on every infra change
Agents writing Terraform, CDK, and Kubernetes manifests need someone watching. Read the diff as it forms, put a second agent on the review, and catch a risky change before apply.
- +One agent writes the IaC while a second reads the diff for security and cost
- +Swarm shows the subagent tree live, so you see when a deploy agent spawns a task per service
- +Keep a system-info pane open to watch CPU and memory during agent-driven load tests
- +SendMessage feeds deploy status back to the agent so it can confirm its change worked
- +Session logs keep a record of what was proposed, reviewed, and applied
- +Presets let you set up one agent per environment - dev, staging, prod
One agent per pipeline stage
Data pipelines split cleanly across agents - one builds the ETL, one validates the output, one writes the tests. Watch all three at once and catch a data-quality problem before it moves downstream.
- +Put separate agents on ingestion, transformation, validation, and testing
- +Use the Agent App API to have an agent render row counts, schema drift, and anomalies
- +SendMessage lets the validation agent hand an issue back to the ETL agent to fix
- +Drop sample datasets into a pane to run the pipeline logic against real data
- +Keep a code pane open to read the SQL, dbt, or Spark next to the agent's reasoning
- +Swarm shows the worker tree when an agent splits across partitions
Close the gap between code and docs
Point agents at your codebase and your docs. One finds where they have drifted apart, one drafts the updates, one checks the draft against the code. Run the chain whenever the code moves.
- +A research agent scans code changes since the last docs update and lists undocumented features
- +A writing agent drafts the updates with examples pulled from the actual codebase
- +A reviewer agent reads the draft against the code to catch where it is wrong
- +SendMessage chains the flow: find the gap, draft the update, check it
- +Drop API specs or changelogs into a pane for targeted doc work
- +Session logs keep a record of what was found, drafted, and checked for editorial review
Hit it from every angle at once
When production is down you need several answers at the same time. Put agents on logs, metrics, recent deploys, and config changes, and read their findings in parallel as they point at a root cause.
- +One agent reads error logs while another checks recent deploy diffs, both panes open
- +Keep a system-info pane open for live metrics next to the agents' output
- +SendMessage lets the log agent pass a finding to the deploy agent to correlate
- +Use the Agent App API to build an incident timeline as agents turn up events
- +Swarm shows when the lead agent spins up its own sub-investigations
- +The session log doubles as your post-incident write-up - the steps are already there
Show the reasoning, not just the answer
Use AgentMux in the classroom to make agent reasoning visible. Students follow the tool calls and decisions step by step, and side-by-side panes let them compare how different prompts or models tackle the same problem.
- +Run different providers side by side as native panes - Claude Code, Codex, Gemini, Copilot
- +Students read every tool call and reasoning step, not just the final output
- +Open several agents at once to compare approaches to the same problem live
- +Presets let you hand students a ready-made agent setup to start from
- +Light Rust core (roughly 150-350MB) runs on student laptops without bogging them down
- +Open source and free, with no per-seat licensing for classroom use
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