●In development — local-first, written in Rust
Your AI coding sessions should outlive your terminal.
supermu is a persistent workspace for humans and AI coding agents. Run Claude Code, Codex, shells, and development processes as durable sessions — close your terminal, reconnect later, and everything is still there, still working, still yours.
$ supermu session list
NAME KIND STATE ATTENTION
claude agent running ● approval
tests shell running
dev-server process running
codex agent paused
$ supermu attach acme-api claude
» reattached — 2h 14m of history, nothing lost▍
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.
Terminals were built around interactive processes — you type, it responds, you watch. AI coding agents increasingly run for minutes or hours without you, and that work needs a durable identity, state, and a place — not a window. Even multiplexers like tmux, which keep processes alive, know nothing about what runs inside them: they can't tell you an agent is waiting on an approval.
supermu gives that work a home: persistent, named sessions in a workspace — organised, observable, and ready to resume.
A workspace, not a window
Never lose the session
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.
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.
Know when an agent needs you
Working, waiting, blocked, approval required, finished — session states you can see at a glance instead of terminals you have to reread. Triage the ones that need you; ignore the rest.
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.
Local-first by design. Honest about authority.
Everything lives on your machine in SQLite — no cloud account, no telemetry. supermu runs the real Claude Code, Codex, or Gemini CLI with the login you already have, rather than proxying model calls through a supermu API. And where actual containment matters, it uses OS-level sandboxing — not security theatre. Read the security model →
Stop watching agents work. supermu tells you when one actually needs you.
Agents can run for hours. You shouldn't have to watch their terminals for hours. Waiting for input, blocked on an approval, asking a question, failed, finished — supermu tracks those states per session and raises the moments that need a human as attention items, instead of leaving them buried in scrollback.
And it's deliberate about when it interrupts: an approval prompt only becomes an attention item if nobody is watching that session, and it's withdrawn the moment you attach. Work stays running, and you triage a short queue instead of patrolling terminal tabs wondering which agent stalled forty minutes ago.
Attention doesn't just notify — it gates. A risky agent action can block until you approve or deny it, with everything else intact. That's why native clients are next on the roadmap: the decision already works remotely, and the apps put it in your pocket.
● approval required
Run the database migration on staging?
claude · acme-api · 4m ago
● question
Keep the existing auth flow, or replace it?
codex · website · 11m ago
3 other sessions running quietly — nothing needs you
For developers with more AI sessions than they can comfortably keep track of.
If Claude Code stays open all day, you run several agents in parallel, or your terminal windows have quietly become a makeshift agent dashboard — supermu is for you. The same workspace scales from one developer's repos and dev servers to a team's first experiments with agent-driven development.
Why sessions survive
Persistence is architecture, not session restore. Every session is owned by a tiny, independent holder process that holds the real terminal. The coordinator — the daemon that keeps the map — can restart at any moment. Clients can disappear. The terminal stays alive through all of it, because nothing that can die owns it.
clients — stateless windows, safe to close
coordinator — restartable brain, all state in SQLite
holders — own the terminals, outlive everything above
live — every agent session gets its own scoped gateway
Terminals give agents a screen. supermu gives them an API.
An agent shouldn't have to read another terminal the way a human stares at a screen. Everything in supermu is an addressable session behind one control API, and the workspace is exposed to agents as structured capabilities: inspect a session, read test results, hand off work, raise a question.
Those capabilities arrive through the Model Context Protocol, which Claude Code and other agent CLIs already speak — each agent session gets its own gateway, wired in automatically. MCP is the plumbing, though; the idea is the structured workspace behind it, and it opens ways of working no terminal offers:
- →An agent tails the test session and starts fixing failures — no copy-pasting output between windows.
- →A manager agent hands work to another and gets back a completion with evidence — verified by an agent that didn't do the work.
- →An agent with a question raises it as an attention item that reaches you, rather than burying it in scrollback.
Every call passes the same default-deny permission engine humans do, authenticated with a per-session identity the agent cannot forge. What it observes is framed as untrusted; delegation and messaging need an explicitly granted capability; no agent can verify its own work; and runaway loops between agents are detected and broken. New power, same rules.
tools: session_inspect · session_tail · attention_create · task_verify · message_send · …
→ session_tail("acme-api/tests")
← untrusted ▸ FAIL auth.test.ts — 3 of 214
→ message_send("acme-api/codex", "fix the 3 auth failures")
← delivered · sender: claude
→ attention_create(question, "token TTL: 15m or 30m?")
← raised · waiting on you▍
Work doesn't have to start when you open a terminal
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. Sessions are persistent and recorded, so “finished” doesn't mean “gone”: the transcript is kept, budgets bound what unattended work can spend, and anything that needs a human becomes an attention item waiting for you.
$ supermu schedule create acme-api triage --cron "0 0 7 * * *" \
--session triage -- claude "triage overnight CI"
A scheduled check-in can leave a task for another agent as easily as it raises one for you — the night shift queueing up work for the day shift.
Persistent and cooperative today. Portable next. 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
Your sessions survive
Shells, agents, and processes that survive disconnects and runtime restarts, organised into workspaces, with schedules, budgets, and a first-class attention queue — driven from the reference CLI.
NOW
Your agents work together
Manager agents delegate to workers with full provenance, work is verified by an agent that didn't do it, each agent can run in its own git worktree, and loop-breakers stop runaway back-and-forth — all through the live agent API.
NEXT
Your workspace follows you
Native Mac and iPhone apps over secure device pairing. The runtime's remote approval gate already works — the apps put triage and approval in your pocket, not just at your desk.
LATER
One workspace across machines
Sessions living on the machines where they belong — your Mac, a devbox, a build server — appearing in a single workspace, without every host becoming another SSH window to manage.
Your agents can keep working. You don't have to keep watching.
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.