Amux
Open-source control plane for running 5–50 parallel AI coding agents from one dashboard and your phone.
If you already pay for Claude Code or Codex and you're drowning in tmux panes, amux solves a problem those vendors don't: coordination across a fleet. Atomic claiming, origin-stamped messaging, and the watchdog-with-replay are the parts that matter at 3am. The free self-hosted tier is genuinely feature-complete — Cloud ($20/mo, or $200/yr billed annually at $16.67/mo) only adds managed hosting, persistence, and shareable session links. Skip it if you run a single agent, need SSO and RBAC today, or want a vendor to sell you the model too. Compare against running bare tmux or an editor-integrated tool like Cursor if your workflow never leaves the IDE.
Verified 5d ago · liveness 82/100 · cite: rightaichoice.com/tools/amux
- Developers running 5–50 parallel AI coding agents and losing track of them in tmux
- Teams that want unattended overnight runs with self-healing recovery and a morning review
- Builders who want to keep model choice open per task
- Solo devs and small teams comfortable self-hosting a Rust binary and bringing their own API key
- Developers running a single agent session — you gain nothing over a plain terminal
- Teams that require enterprise SSO, RBAC, or granular permissioning today
- Buyers who want an all-in-one tool that bundles model inference rather than BYO API key
We scan live Reddit threads, YouTube comments, X posts, G2 reviews and other communities — and hand you an honest verdict in under a minute.
- Honest verdict, not marketing
- Real pros & cons from real users
- Attributed quotes with receipts
3 free scans · no card needed
Skip amux if you run a single agent session, need SSO and RBAC today, want a vendor to bundle the model tokens, or won't adopt a tmux-shaped workflow.
amux Cloud at $20/mo covers the infrastructure only — you still supply your own Anthropic API key, so model token spend is billed separately by Anthropic.
The self-hosted tier is free forever under MIT + Commons Clause, which puts amux below every managed agent-platform competitor for solo devs and small teams. Cloud at $20/mo (or $200/yr, $16.67/mo billed annually) lands squarely in the indie-to-small-team band — cheaper than an enterprise orchestration contract, but on top of whatever you already pay for Claude Code or Codex plus your own API usage.
In short
Amux — Open-source control plane for running 5–50 parallel AI coding agents from one dashboard and your phone. Best for Developers running 5–50 parallel AI coding agents and losing track of them in tmux, Teams that want unattended overnight runs with self-healing recovery and a morning review, Builders who want to keep model choice open per task. Free to start; paid plans from $20/mo.
What's new in Amux
Checked 5 days agoAcross the latest 2 updates: 2 feature updates.
Review dashboard with Trends view and Fleet org chart
A review dashboard now groups fleet activity by theme, shows blockers first, and includes a fleet org chart so you can see what each agent is working on.
Plan strip in peek panel
The peek panel now shows the agent's live task list and next steps in real time, so you can see intent without attaching to the session.
What people actually say about Amux — is it worth it?
We ran a structured research pass across product reviews, community discussions, and post-purchase forum threads to surface the patterns vendors won't publish themselves. Below: the recurring strengths, the hidden costs people mention most, and the cohort that consistently regrets adopting this tool.
35 mentions across 4 sources (Hacker News, App Store, GitHub, Lemmy) · researched Jul 3, 2026.
Average across the 4 sources that answered — each source counts once, not each post.
- +Self-healing watchdog auto-compacts context and restarts crashed sessions reliably.
- +Manage agents from a mobile PWA or native iOS app anywhere.
- +Single-file architecture (amux-server.py) makes deployment trivial.
- +Kanban board with atomic task claiming via SQLite prevents collisions.
- +Agent-to-agent messaging via channels and @mentions enables coordination.
- −Auto-update feature downloads and runs code from GitHub—major security risk.
- −APIs exposed on 0.0.0.0 without authentication allow remote file access.
- −No CLI command to list registered sessions; dashboard required.
- −Limited enterprise integrations and third-party plugin ecosystem.
- −No explicit role-based access control for multi-user scenarios.
- • Self-hosting requires a server with tmux and network exposure
Viability Score
How well maintained and how widely used is Amux? Built from what the vendor actually publishes (docs, changelog, tutorials, integrations, pricing), whether the site is live, and how much real users discuss it. How we calculate this
Last calculated: October 2026
How we score →Key Features
- Run 5 to 50 named coding agents in parallel from one dashboard
- Kanban board with atomic task claiming via SQLite compare-and-swap
- done requires evidence of what ran; verified requires a peer check
- Self-healing watchdog: monitors context, auto-compacts, restarts, replays last message
- Peek panel with live terminal output and a plan strip of next steps
- Review dashboard with Trends view and fleet org chart grouped by theme
- Origin-stamped agent-to-agent messaging — server records the true sender
- Autonomous loops where agents schedule their own next wakeup
- Cron-style schedules in plain words (daily at 9am, every 15m, weekly on Monday)
- Groups/lanes sharing memory, environment, and gates across peers
- Scoped settings cascading card to worker to group to global
- Model switching on a running worker: Claude, Codex, Gemini, or local Ollama
- REST API on every session for agent discovery, tasking, peeking, and claiming
- Message ledger with fetchable ids for every prompt, reply, and delivery
- Steering: type into any running session from dashboard or phone
About Amux
amux is an open-source control plane for AI coding agents. Instead of juggling a dozen terminal windows, you register Claude Code, Codex CLI, Gemini CLI, OpenCode, or a local Ollama model as named workers that share one kanban board — the vendor advertises a range of 5 to 50 agents. Coordination is the product: task claiming is compare-and-swap in SQLite so two workers can't grab the same card, `done` requires evidence of what actually ran, and `verified` requires a peer check. Workers message each other directly through a REST API, with the server stamping the true origin on every message, so misattribution is impossible. Cron-style schedules accept plain words ("daily at 9am", "every 15m", "weekly on Monday") and autonomous loops let an agent schedule its own next wakeup, drain the ready queue, and go quiet when nothing needs it. A watchdog monitors context, auto-compacts, restarts crashed sessions, and replays the last message. Every prompt, reply, and delivery lands in a message ledger with a fetchable id. A 2026-07-31 changelog adds a plan strip showing the agent's live task list and next steps inside the peek panel, and a 2026-08-02 changelog adds a review dashboard with a Trends view and fleet org chart that groups activity by theme and surfaces blockers first. Control is mobile-first: steering, one-tap approvals, and owner alerts run on both the installable PWA and the native iOS app. Self-host the entire thing free as a single Rust binary under MIT + Commons Clause, or pay for managed cloud hosting at $20/mo (or $200/yr, $16.67/mo billed annually). Either way you bring your own Anthropic API key — amux sells the plane, not the tokens.
Behind the Verdict
amux's pitch is narrow and honest: it is infrastructure for people who already have an agent subscription and a terminal habit. The mental model is a fleet, not a chatbot. You register sessions (`amux register myproject --dir ~/Dev/myproject --yolo`), start them (`amux start myproject`), serve the dashboard (`amux serve` on port 8824), and steer from there. The pieces that justify the layer are the ones a single agent never needed. Claiming is compare-and-swap in SQLite, so two workers cannot take the same card. Closing a card as `done` requires evidence of what actually ran; `verified` requires a peer check. Dependencies are expressed as `blocked_on`, and `GET /api/board/ready` returns only tasks whose dependencies have cleared. Workers talk directly over a REST API and the server stamps the true origin on every message — the vendor's claim is that provenance is a fact, not a claim, which is the kind of thing that matters when you are reconstructing why an overnight run went sideways. Recovery is the second load-bearing piece. The watchdog monitors context, auto-compacts at a threshold, restarts crashed sessions, and replays the last message, so a 3am crash does not mean dead terminals and a lost task. The message ledger keeps every prompt, reply, and delivery as a fetchable row. Schedules accept plain English rather than cron syntax, and autonomous loops let an agent pace itself: schedule the next wakeup, drain the ready queue, go quiet when there is nothing to do. The vendor cites an overnight run of 7 cards closed with 0 interventions. The July/August 2026 changelog entries address the thing fleets actually break on — observability. The 2026-07-31 plan strip puts the agent's live task list and next steps inside the peek panel, so you can see intent without attaching. The 2026-08-02 review dashboard adds a Trends view and a fleet org chart that groups activity by theme and surfaces blockers first, which is the closest thing here to a morning standup. Where it doesn't fit: the self-hosted path wants Python 3.8+, tmux, and an installed and authenticated Claude Code CLI, and sessions literally run Claude Code inside tmux panes. If you run one agent, you gain nothing over a plain terminal. There is no SSO or RBAC in what we can see, which rules it out for teams with a compliance gate. And the workflow is tmux-shaped — teams standardized on editor-integrated agents will bounce off it. Cloud ($20/mo, or $200/yr billed annually) removes the server but not the BYO Anthropic API key, so your token spend stays separate.
Researching Amux? Get your full AI stack in 60 seconds.
Free, no signup — tell us your goal and get tools matched to your budget & existing stack.
Real-world workflow fit
Concrete scenarios for the personas Amux actually fits — and what changes day-one when you adopt it.
Registers four named workers (backend, frontend, tests, review) pointing at the same repo, posts a dozen board cards with blocked_on dependencies, and starts an autonomous loop on the backend worker before going to bed.
Outcome: Overnight the fleet claims cards atomically, the watchdog auto-compacts and replays after a crash, and the morning review dashboard shows closed cards with evidence attached and blockers listed first.
Opens the installable PWA on a phone, peeks into a worker's terminal to read the plan strip, and answers a blocked prompt with one tap.
Outcome: The run continues without a laptop, and the origin-stamped reply lands in the message ledger with a fetchable id for later reconstruction.
Installs the single Rust binary on a dev box, registers Claude Code, Codex CLI, and a local Ollama model as separate workers, and sets a group-level gate that every worker in the lane inherits.
Outcome: One dashboard shows live status and token usage across providers, with settings cascading card to worker to group to global instead of being re-specified per session.
Use Cases
- Run 30+ Claude Code agents overnight on a large monorepo with automatic task claiming and a morning review pass.
- Answer a blocked agent prompt with one tap from your phone instead of walking back to a laptop.
- Coordinate several agents working the same codebase through the kanban board, blocked_on dependencies, and groups.
- Schedule recurring work in plain words — daily at 9am, every 15m — with run history and an audit trail.
- Self-host a persistent agent control plane with a single Rust binary and zero cloud dependencies.
- Swap the model or provider on a running worker per task without losing the worker or its context.
Models Under the Hood
as of 2026-10-16
Limitations
- Self-hosting requires Python 3.8+, tmux, and an installed and authenticated Claude Code CLI, and sessions run Claude Code instances inside tmux panes. amux Cloud ($20/mo, or $200/yr billed annually at $16.67/mo) provides hosting plus persistent sessions, R2 backups, and shareable session links, but you still bring your own Anthropic API key.
- The self-hosted open-source version is fully feature-complete; Cloud adds managed hosting, persistence, and sharing.
- The Cloud Tunnel feature requires amux Cloud.
- No SSO or RBAC is documented in the material we reviewed.
as of 2026-10-03
Verification history
We have re-verified Amux 8 times since . Each pass re-reads the vendor's own pages and re-checks every listed field against that evidence; passes where nothing had changed are marked as such.
- — re-checked, vendor evidence unchanged
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-checked, vendor evidence unchanged
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
Showing the 6 most recent of 8 verification passes.
Free to cite with attribution — this page re-verifies continuously.
12-month cost
Project the real annual outlay, including the implied monthly cost when only an annual tier is published.
Vendor list price only. Add-on usage, seat overages, and contract minimums are surfaced under Hidden costs & gotchas.
Plans compared
For each published Amux tier: who it actually fits, and what it adds vs. the previous tier. Cross-reference the cost calculator above for projected annual outlay.
Open Source
$0
Ideal for
Solo devs and small teams who already pay for Claude Code and are comfortable running a single Rust binary on their own machine.
What this tier adds
Starting tier — free forever with unlimited agents and sessions, MIT + Commons Clause, but you host it and manage persistence yourself.
Cloud
$20/mo
Ideal for
Teams that want the same fleet features without running a server, and that need shareable session links and automatic backups.
What this tier adds
Adds persistent cloud sessions, no setup or server, automatic R2 backups, shareable session links, and file sync and workspace on top of Open Source.
Cloud Annual
$200/yr ($16.67/mo billed annually)
Ideal for
Teams committed to amux Cloud for a year that want priority support and early access to new features at a lower effective rate.
What this tier adds
Same as Cloud at $200/yr ($16.67/mo billed annually, 17% off monthly) plus priority support and early access to new features.
Where the pricing makes sense
The company stage and team size where Amux's pricing actually pencils out — and where peers do it cheaper.
The self-hosted tier is free forever under MIT + Commons Clause, which puts amux below every managed agent-platform competitor for solo devs and small teams. Cloud at $20/mo (or $200/yr, $16.67/mo billed annually) lands squarely in the indie-to-small-team band — cheaper than an enterprise orchestration contract, but on top of whatever you already pay for Claude Code or Codex plus your own API usage.
Setup time & first value
How long it actually takes to get something useful out of Amux — broken out by persona, not the marketing-page minute.
Self-hosted: the vendor advertises install in under 2 minutes via Homebrew or pipx, and the docs say you can run your first agent fleet in 5 minutes — realistically 10–20 minutes once you've installed tmux and authenticated the Claude Code CLI. Cloud: sign up, add your Anthropic API key in settings, and you're steering sessions in a few minutes with no server to manage.
Switching to or from Amux
How to bring data in from common predecessors and how to get it back out — written for the switcher, not the buyer.
- →From raw tmux: register each pane as a named amux session and let the board replace your shell scripts for task handoff.
- →From shell scripts and cron: move scheduled prompts into amux schedules using plain words like daily at 9am or every 15m.
- →From a single Claude Code session: register the project directory, then add workers as you need them rather than rewriting the workflow.
- ↗To raw tmux: each amux session is a tmux pane, so you can attach directly and keep working; you lose the board, watchdog, and message ledger.
- ↗To an editor-integrated agent like Cursor: move individual tasks into the IDE, but you lose fleet-level claiming and origin-stamped messaging.
- ↗To a managed orchestration platform: export board items and the message ledger over the REST API before you cancel Cloud.
Integrations
Resources & Guides
Tutorials & Learning
YouTube returned 6 videos for “Amux”, and we withheld 6: 6 could not be judged, because “Amux” is a single word that other videos use for other things. We are showing none, because we could not prove any of them are about Amux.
Official links
Featured Head-to-Head Comparisons
Amux vs Spider Cloud
If you need to feed web data into AI agents (RAG, LLMs), Spider Cloud is the clear choice — it's a purpose-built scraping API with a 99.9% success rate and low cost per page. For orchestrating multiple AI coding agents (e.g., Claude Code, Codex), Amux is a unique open-source control plane that handles parallel sessions, context compaction, and crash recovery. They solve entirely different problems: data ingestion vs. agent management.
Amux vs Temporal Ai
Choose Temporal AI if you need enterprise-grade durable execution with automatic retries and state persistence for AI agents or microservices – it's battle-tested at OpenAI and Replit. Pick Amux if you're a developer running many AI coding agents (Claude Code, Codex) and want a lightweight self-hosted dashboard with self-healing and mobile access. They solve different problems: reliability vs. parallelism.
Amux vs Voyage Ai
Voyage AI and Amux serve completely different needs: Voyage AI is an enterprise embedding API for high-accuracy RAG, while Amux is an open-source tool for orchestrating coding agents. Choose Voyage AI if you need domain-specific embeddings with long context; choose Amux if you manage multiple AI coding sessions and want a free, self-hosted dashboard.
Popular in Autonomous Coding Agents
Cognition AI
Cognition builds Devin, an autonomous AI software engineer that plans, codes, tests, and ships merge-ready pull requests inside your
Poolside AI
Poolside builds open-weight agentic coding models — Laguna XS 2.1 (33B) and Laguna S 2.1 (118B) — for code that stays inside your security
Frequently Asked Questions
Used Amux? Help shape our editorial sentiment research.