Every AI session you have open. One governed fleet.
cait turns terminals, subscriptions, and workstations you run today into one system — handoffs, capacity, recovery, receipts.
the tap opens once you’re invited · v0.3 · macos + iterm2 · headless verbs on linux
Five dashboards. One terminal.
The fleet, the account math, and the advisory brain that catches duplicated work before it costs a day — every value rendered from receipts the CLI emits today.
Every session on every workstation — attributed to its account and working state, live and read-only. Looking never touches a session.
A bounded prompt lands only in an idle tab, and comes back as a receipt. After a stall, reattach the exact session — same tab, same context.
Capacity across every subscription you own, probed live — with the trajectory that tells you what would reset unused.
Where the work actually runs: usage per workstation and account, so the next launch goes to headroom instead of a wall.
Duplicated work and out-of-order foundations, caught before they cost a day — advisory only, every claim traced to a receipt.
live sessions across three workstations, in a single attributed view.
sessions spawned, wrapped, or proxied. cait drives the terminals you already run.
one versioned receipt per action — an audit trail you can grep.
Work moves between machines. You don’t.
Three workstations, one registered mesh, one origin — and exactly one writer per clone. Observation is read-only. Handoffs land only in idle sessions. Steering addresses the current task, never a bypass. Every arrow that mutates anything comes back as a receipt.
Every row is a live terminal tab — one AI coding session running in iTerm2, on the machine that owns it. Each session is attributed to the account driving it, and no clone ever has two writers.
Observation is a read path. Asking the Mac Studio what it’s doing cannot alter it — no keystroke is sent, no session is touched, and nothing needs your permission because nothing changes.
A handoff carries a bounded prompt to a named session on another machine. It lands only in an idle tab with a proven-empty editor; a busy target queues in the inbox instead of being interrupted.
The delivery returns a versioned receipt for that one session — schema, target, delivery state, reason code, next action. The difference between an agent that acted and an agent you can audit.
Steering addresses the task a session is already on — this one, not its machine. It cannot redirect a session mid-write, and it is never a way around the busy guard: the guard has no override.
auth-service sits at its weekly limit on codex-alt. Rotation points its next launch at codex-team — headroom you already paid for — then resume reattaches the exact session, same tab, same context.
Edges
Session state · terminal tab
Provider · account text
Six subscriptions. One ledger.
Nobody buys one AI plan. You accumulate a portfolio — different providers, different weekly windows, each resetting on its own clock. None of it rolls over, and none of it is visible from inside a single terminal.
Windows, not pools
Every plan resets on its own schedule. Capacity you didn’t spend this week isn’t banked — it’s gone, and you bought it anyway.
Imbalance is the default
One account stalls at 2% in the same week another sits at 88%. Same desk, same work — one terminal can’t see either number.
Routing, not evasion
cait points the next launch at headroom you already paid for. Never past a limit, never pooled, never proxied — when everything you own is empty, you wait.
Session coordination ships for Codex and Claude today; more providers arrive with the terminal-adapter contract. The live version of this ledger is Watch every limit ↑
Governed by receipts.
Agents that touch your terminals raise two questions: where your code goes, and what the tool refuses to do. Both are answered in code rather than in a policy page — and every answer leaves a receipt on your disk.
Where your code goes
What it refuses to do
There is nothing to send to.
cait is a local binary that talks only to the CLIs already installed on your workstations. No service, no account, no sync — so there is no path by which your code could leave the machine it is on.
Nothing is collected.
Not prompts, not code, not session names, not counts, not timing. There is no analytics build and no opt-out to hunt for, because there is nothing to opt out of.
Even your own output is careful.
Accounts, provider-home paths, and full working directories are masked in every view — on screen, in JSON, and in receipts — until you explicitly ask for them.
The audit trail is yours.
Every action writes its versioned receipt to your disk. Readable, diffable, and replayable months later without asking us for anything, because we never had it.
Nothing mutates until you say so.
Mutating commands print the plan they would carry out and stop. You see the target, the authority, and the consequence before anything is touched.
It will not type into a busy session.
A prompt lands only in an idle tab with a proven-empty editor, confirmed across stable samples. A busy target queues in the inbox instead, TTL-bounded. There is no force flag.
Ambiguity stops the action.
Ambiguous names, duplicate tabs, lost ownership — delivery blocks and returns a stable reason code rather than guessing which session you meant.
Looking never touches anything.
Summaries, inventory, capacity, and the dashboards above are strictly read paths. Watching your fleet cannot alter it, so observation is always safe to run.
Every switch can be undone.
Auth changes back up the previous state before touching anything, and no token value is ever printed — not in output, not in logs, not in receipts.
Two agents never share a working copy.
Write authority over a clone is held by exactly one session. Parallel tracks get parallel clones, which is what makes many sessions at once safe rather than reckless.
The receipt is the contract
Versioned and structured, with a stable reason code and a next action — verifiable by you or by your agents. Schema names are promises: a field means the same thing in the next release.
$ cait … --json"schema": "cait.handoff.v1","target": "billing-e2e · 019ebe1e…","delivery_state": "delivered" ,"reason_code": "handoff_delivered_to_idle_tab","next_action": "observe_target"
Operated by agents. Compared honestly.
One view model, two renderers. Anything you can see, your agents can query — same masks, same receipts, same governance.
GET /llms.txtVerb inventory, safety contract, and receipt schemas — served where agents look first.
$ cait … --jsonVersioned receipts with stable reason codes and next-action fields. Contracts, not log noise.
skills/Drop-in skills teach Claude Code and Codex when to coordinate — and when to stop.
| TOOL | EXISTING SESSIONS |
FAIL-CLOSED HANDOFF |
CAPACITY + ROTATE |
EXACT RECOVERY |
MULTI- HOST |
|---|---|---|---|---|---|
| collaborait | ● | ● | ● | ● | ● |
| claudexor | ○ | ○ | ● | ◐ | ○ |
| agent-deck | ◐ | ○ | ◐ | ○ | ○ |
| claude-squad | ○ | ○ | ○ | ○ | ○ |
| openclaw | ○ | ○ | ○ | ◐ | ○ |
| claude-swap | ○ | ○ | ● | ○ | ○ |
Good tools, adjacent problems: openclaw is a messaging-first gateway, the tmux tools spawn fresh agents, the switchers isolate sessions. cait exists for the intersection. As of Aug 2026 — tell us if we have you wrong.
The questions worth asking.
Is multi-account rotation OK with provider terms?+
cait manages accounts you own and pay for separately, on your own machines. It never pools or shares credentials, never proxies requests, and never evades a limit — when every account you bought is empty, you wait like everyone else. Rotation is capacity planning across what you already purchased. Read your plan's terms; cait's job is to make what you do explicit: every switch is logged, receipted, and reversible.
Will it ever type into a busy session?+
No. Prompts land only in an idle tab with a proven-empty editor; anything else queues in the inbox or fails closed with a reason code. There is no force flag.
Where's tmux? Linux? Windows?+
macOS + iTerm2 first, because that's the fleet we actually run. Auth, usage, and headless verbs already work on Linux; WSL2 should run those the same way, though we haven't certified it. Full coordination elsewhere waits on the terminal-adapter contract — the seam that lets tmux and other terminals be supported without re-deriving the safety model. It is on the roadmap, not shipped.
Is there a team version?+
cait is single-operator by design — your fleet, your accounts, your receipts. The team version of these ideas — humans and AI teammates sharing context, authority, and memory — is Sociail, the team-scale platform we build alongside it.
What does it cost?+
cait is in invitation-only early access, at no charge for invited operators. Pricing isn't set. If a paid plan lands later it will be announced before it applies, it will be priced against the capacity it recovers, and it will never meter the provider subscriptions you already pay for.
How do I audit what it did?+
Every mutating action returns a versioned receipt with a stable reason code, written locally. Mutating commands are dry-run until you pass --execute, and auth switches back up the previous state first. The receipts are the audit trail — you can replay any action's story from them, and so can your agents.
Are the dashboards on this page real?+
The verbs are shipped. The five-screen TUI is a v0.4 design preview rendered from the same receipt schemas the CLI emits today — labeled as such wherever it appears. When it ships, this answer changes.
Run your fleet like one machine.
invitation-only early access · built on our own fleet — 3 workstations · 6 subscriptions · dozens of sessions daily · case studies →