A visual manager for fleets of coding agents.
Run Claude Code and Codex sessions on your Mac, on any Linux box you can ssh to, and on cloud instances you can't — and actually see their work: what each agent is doing right now, what it costs, what's in its context window, which files it's touching, and who spawned whom.
Apple Silicon, macOS 12+. Apache 2.0.
TEST) contributing its sessions inline, unread inbox. Centre: the session as a real terminal. Bottom: the IPC bus — this lead dispatching a code review to a reviewer it spawned, the verdict coming back, the seat retiring, a test run reporting green, and an agent on an unrelated project filing a morning digest. The bar under the terminal is wire telemetry: model, context, turn, spend, cache state.One agent needs a terminal. Five need a control plane.
Past the first couple of sessions the questions stop being “what did it say?” and start being operational: which of these is actually working right now, which is quietly burning tokens, which one is blocked on a permission dialog I never saw, whose context is about to fall over, and which of them spawned this thing I don't recognise. A grid of terminals answers none of that — every one of those answers is buried in scrollback you'd have to be watching at the time.
Clodex keeps them as real terminals and puts the operational layer around them: live context and activity on every tab, a message bus so agents can hand work to each other, and the same sidebar whether the session is on this Mac or on a server three time zones away. Route a session through the wirescope proxy and it also reports wire-accurate cost, prompt-cache warmth, and the subagent tree underneath it.
Why not just tmux? Multiplexing was never the hard part. tmux will happily give you nine panes; what it won't tell you is which pane is idle versus thinking, that pane 4 has been sitting on a permission prompt for twenty minutes, or that pane 7 is a subagent pane 2 spawned. Clodex is not a nicer multiplexer — the terminals are the easy half, and the fleet view is the point.
The unit of work is a session: a real PTY running claude, codex, or plain bash, embedded as an xterm.js terminal. Press ⌘T, name it, point it at a directory, hit Create. Then make nine more. Each window is a workspace with its own session set; quit and relaunch and every session resumes with its history. Sessions carry live badges for context usage, activity, needs-attention pulses, and a touched-files counter with a click-through diff viewer.
Sessions aren't isolated terminals — they're peers on a message bus. The protocol is injected as a system prompt at spawn, so you just talk: “DM bob and ask him to check the failing test” becomes [agent:dm bob] …, and bob receives it in his input. Deliveries never mangle what you're typing: injections drain through a per-session atomic queue and park if a draft is open. Agents also tend their own context, keep persistent memory, set durable reminders, and spawn new peers. Bash sessions are deliberately private: real shells, no IPC.
A team is a durable working group with named roles — a lead seat that plans, delegates, and verifies, plus role templates (implementation hand, cold reviewer, …) it can instantiate on demand. Roles live in a manifest editable from a GUI popover. [agent:team-review] spawns an ephemeral, read-only reviewer with the diff and spec and returns a structured verdict: fresh eyes every time, no context contamination. Task tickets ride the same intent grammar, so the lead runs the loop without leaving its terminal.
Add a peer — user@host is enough — and Clodex opens and babysits the SSH tunnel itself. The box's sessions appear as remote tabs under their host's header, and a tab is not a viewer, it's a cockpit: attach live, start typing and control is acquired automatically, create and restart and kill sessions on the box, restart its whole Clodex. Key-based SSH only; the peer's server binds 127.0.0.1 by design, so the tunnel is the trust boundary.
Agents on peered Clodexes message each other directly: [agent:dm name@peer] crosses the wire, remote agents show up in [agent:who], and a dm whose reply would drop is marked (no reply path) so nobody answers into a void. The tunnel only dials one way, so replies from the box queue in a durable per-origin outbox — nothing is lost across restarts or dropped streams. With relay mesh enabled, two boxes peered to the same Clodex can reach each other through the hub; sender identity is never rewritten, and relays are capped at one hop.
A standalone CLI client for the same wire the GUI peers speak — kubectl-for-Clodex. No Electron, no app running locally. A context names a node and how to reach it: direct URL, ssh, AWS SSM, kubectl port-forward, GCP IAP, Azure Bastion, or a custom tunnel argv. The grammar is kubectl's: get sessions lists, describe session X is the full object, logs X -f follows the transcript, exec X "…" asks an agent and waits, attach X is a live terminal on it, and deploy node turns a bare box into a Clodex node in one idempotent command. get takes -o json|yaml|wide|name; the other read verbs take -o json|yaml.
The Clodex engine runs headless on Linux — plain Node, no display, kept alive by a systemd user unit — as a full peer node: same sessions, same messaging, same wire. A Mac at the desk, agents grinding on servers overnight. Every deployed node also serves the full Clodex GUI in a browser, bound to 127.0.0.1 on the box and reachable only through the authenticated tunnel, with zero ports open to the world. The same server offers a chat-style view for your phone.
clodex-plugins is the public library, one plugin per folder, and the app installs from it directly — paste avirtual/clodex-plugins:<id> and you're done. Clodex loads plugins in process against a frozen hostApi "1": an engine half with filesystem and session access that can contribute an [agent:…] verb, and a renderer half with seven named UI slots. A plugin can also ship skills and agents, so a content pack needs no code. Your own plugins live in ~/.clodex/plugins/, untouched by updates.
Route a session's API traffic through wirescope, the companion proxy built for Clodex, and the app reads the truth off the wire: context tokens, turn count, model, and a wire-accurate cost estimate under the terminal. Subagents appear as named child rows under their parent, each with its own turns and spend. A live cache-warmth countdown sits on every sidebar tab even while unfocused, with a keep-warm hold, a cache-bust inspector, optional wire stripping, and autocompact for heavy idle sessions.
Dictate into the focused Claude seat and have Clodex press Enter for you when you end with a send phrase, with the reply optionally spoken back. A voice popover shows what Clodex can see of the CLI's recording indicator, and scripts/clodex-voice-tap.js starts recording from outside the app — wire it to a macOS Voice Control phrase and you can arm a seat with Clodex in the background. It requires the CLI's default renderer, since Clodex reads the indicator off the terminal screen.
Download Clodex-x.y.z-arm64.dmg from Releases and drag Clodex to Applications.
First launch: right-click Clodex.app → Open. If macOS says the app is damaged, run xattr -cr /Applications/Clodex.app — the app is ad-hoc signed, not notarized.
Requirements — Apple Silicon Mac, macOS 12+ (Intel and Linux build from source; Linux servers run the headless engine). Plus whichever CLIs you want to drive: Claude Code (claude in PATH) and/or Codex (codex in PATH).
clodexctl drives the same fleet from a terminal — no Electron, no app required (Node 20+):
git clone https://github.com/avirtual/clodex && npm i -g ./clodex/cliAlready running the desktop app? Adopt everything it knows in one step:
clodexctl create node --import # adopts every node the GUI already knows
clodexctl use node local # or any name --import printed
clodexctl get sessions # kubectl's grammar: <verb> <resource> [name]
clodexctl describe session bob
clodexctl logs bob -fNo app on this box? Point it at a node directly instead:
clodexctl create node prod --url https://box:8787 --token <T> && clodexctl get sessions