●In development — local-first, written in Rust
Your AI coding sessions should outlive your terminal.
supermu is a persistent development workspace for Claude Code, Codex, shells, and long-running dev sessions. Start work, detach, reconnect, and keep going — without rebuilding your environment or losing track of what your agents are doing.
$ mux session list
NAME WORKSPACE KIND STATE ATTENTION
claude acme-api agent running ● approval required
tests acme-api shell running
dev-server acme-api process running
codex writing agent paused
$ mux attach acme-api claude
» reattached — 2h 14m of history, session never stopped▍
AI coding tools keep getting more capable. The terminal they live in is still temporary.
Close a window and the session is gone. Run three agents at once and your day becomes tab-checking: which one is thinking, which is stuck waiting for an answer, which died when the connection dropped. Move between machines and the whole workflow falls apart.
Terminal multiplexers keep processes alive, but they know nothing about what runs inside them. They can't tell you an agent needs an approval, and they were never designed for work that runs for hours without you.
supermu turns those sessions into persistent, named parts of a workspace — organised, observable, and ready to resume.
A workspace, not a window
Persistent sessions
Start Claude Code, Codex, a shell, tests, or a dev server and leave them running. Close the client, drop the connection, even restart the runtime — reconnect later and continue exactly where you left off.
AI agents are first-class
Coding agents aren't sidebars or disposable chats. They're named, persistent sessions with state, activity, and history — plus schedules, budgets, and pause-not-kill runaway control, so autonomy has limits you set.
One workspace for everything
Group shells, agents, builds, logs, and services around a project instead of juggling terminal windows and tmux sessions. The whole project's activity in one addressable place.
Take over any session
Every agent runs in a real terminal you can open. Step in, interact with Claude Code or any CLI directly, then step back out. Supervision and hands-on-keyboard are the same session.
Know what needs attention
See which agents are working, waiting, blocked, finished, or asking for a decision — instead of watching multiple terminals scroll. Triage the ones that need you; ignore the rest.
The real CLIs, not a wrapper
Use the normal Claude Code, Codex, or Gemini login and subscription you already have. supermu supervises the real CLI process rather than replacing it — no API keys, no per-token billing.
local-first · everything on your machine, in SQLite · no cloud account · no telemetry · read the security model →
For developers whose AI sessions became part of the working environment — not occasional chats.
Heavy agent users
Solo developers running Claude Code or Codex as a core part of every working day.
Multi-repo engineers
Engineers keeping several repositories, dev servers, and long-running environments alive at once.
Technical founders
People who want agents making progress while they're in meetings, on other tasks, or asleep.
Agent-led teams
Teams starting to experiment with agent-driven development and needing one place to see it all.
Why sessions survive
Persistence isn't a feature bolted on top — it's the process architecture. Three roles, each allowed to fail independently.
01 · the brain
Coordinator
One daemon keeps the map: workspaces, sessions, activity, budgets, schedules — all persisted to SQLite. It can be killed and restarted at any moment without a single session noticing.
02 · the muscle
Holders
Each session gets a deliberately boring little process that owns its terminal. Holders detach at spawn, survive the coordinator's death, and are re-adopted when it comes back.
03 · the windows
Clients
CLI today, native Mac and iPhone apps next — all stateless views over one versioned protocol. If closing a client could destroy work, the architecture would be wrong. It can't, so it isn't.
in design — ships with the agent-coordination phase
Terminals give agents a screen. supermu gives them an API.
Everything in supermu is an addressable session behind one control API — so agents don't have to scrape terminal output to know what's going on around them. Through the Model Context Protocol, which Claude Code and other agent CLIs already speak, an agent will see the runtime the way it sees an operating system: the workspace it's in, the sessions beside it, what needs attention, and the tasks that concern it.
That opens ways of working no terminal offers:
- →An agent tails the test session and starts fixing failures — no copy-pasting output between windows.
- →One agent hands a task to another and collects the result, instead of you replaying context between them.
- →An agent with a question raises it as an attention item that reaches you, rather than burying it in scrollback.
Every such call is a thin wrapper over the same control API humans use — it passes the same default-deny permission engine, authenticated with a per-session identity the agent cannot forge. New power, same rules.
tools: workspace_inspect · session_tail · task_send · attention_raise
→ session_tail("acme-api/tests")
← untrusted ▸ FAIL auth.test.ts — 3 of 214
→ task_send("acme-api/codex", "fix the 3 auth failures")
← accepted · task 018f…
→ attention_raise(question, "token TTL: 15m or 30m?")
← raised · owner will be notified▍
Work that runs on a clock, not on your attention
The schedule engine is already in the runtime: any session — including an agent — can spin up at a set time, do its job, and exit. Because sessions are persistent and recorded, “finished” doesn't mean “gone”: the full transcript is there to inspect, and anything that needs a human becomes an attention item waiting for you.
Morning CI triage, a nightly dependency check, a weekly tidy of a backlog — work that happens whether or not a terminal is open, on a budget you set.
And when the coordination phase lands, a scheduled check-in will be able to leave a task for another agent as easily as it raises one for you — the night shift queueing up work for the day shift.
$ mux schedule create acme-api triage --cron "0 0 7 * * *" \
--session triage -- claude "triage overnight CI"
— next morning —
07:00 triage started · agent
07:06 exited(0) · transcript kept
● attention — “2 flaky tests quarantined; PR #142 needs a decision”▍
Persistent first. AI-native second. Distributed later.
The core runtime works today. What's built on top of it arrives in order — and we'll only ever claim the part that ships.
NOW
Persistent sessions
Shells, agents, and processes that survive disconnects and restarts, organised into workspaces, with attention states and budgets — driven from the reference CLI.
NEXT
Native clients & remote
A native Mac cockpit for the whole workspace, then secure device pairing and push — reconnect and approve from your phone, not just your desk.
LATER
Agents working together
Controlled capabilities for agents to observe sessions, exchange tasks, and coordinate — and eventually one workspace spanning multiple machines.
Be there when it ships
Early access opens with the Mac app. Leave an email and you'll hear from us exactly once when there's something worth running — no newsletter, no drip campaign.