Build with your agents.Keep control of the work.

Every CLI, as a peer.

Eleven agent CLIs are built in, and DeckSpace detects whichever are already on your PATH. You sign in to each with your own account, and the work moves between them: hand a task from one to another when it runs out of context, and have one vendor’s model review a diff another vendor’s model wrote.

Independence is what makes the rest of it work. A task can move between CLIs because none of them is the house model, and a review means something because the reviewer was not the author. You are never choosing a vendor when you choose the deck.

• Claude Code, Codex, Antigravity, OpenCode, Cursor Agent, Droid, Copilot CLI, Grok, Amp, Qwen Code, Aider
• Register any other CLI yourself — same flags, same panes, same review
• The author and the reviewer are different models on purpose
• Your accounts, your keys, your rate limits — we never sit in the middle

Three attempts at the same task. One diff you keep.

Run the same job several times over — different models, different prompts, different approaches — each on its own git worktree, and read the results next to each other before anything touches your branch. Not old-versus-new. Old versus every new.

Generating code is no longer the slow part. Deciding which version to trust is — and that is the part this is built for.

• Each attempt isolated on its own worktree — none of them can see the others
• Read the diffs side by side, with the tests each one passes or fails
• Keep one, merge it, and the rest are thrown away rather than unpicked
• Ask a different vendor’s model which one it would ship, and why

The seat price is not the bill.

Agents bill by the token, so the number that matters is the one that arrives with the invoice. DeckSpace picks a model to match the job rather than sending everything to the most expensive one, tells you which it picked and why, and stops at a ceiling you set.

We never meter you and never mark anything up. You are on your own accounts, at your own rates — we are the thing that stops those rates surprising you.

• A spend ceiling you set, enforced at dispatch — refusing after the request has gone out is a display, not a cap
• Cheap models for the cheap work — most of a task is not the hard part
• “Why this model” on every routed task, in a sentence
• $0 metering, $0 markup, forever — our price is our price

Work that starts without you.

Hand a job to the deck and give it a time. It runs in a fresh git worktree, on its own branch, and leaves you a diff to read rather than a change already made. Nightly, on an interval, once at a set time — or right now, if you would rather watch it.

Good for the work that is worth doing and never worth interrupting yourself for: the flaky test that needs bisecting, the dependency bump nobody wants, the audit you keep meaning to run.

• Nightly, every N minutes, or once at a time you pick
• Each run isolated on its own worktree — a bad one is discarded, not unpicked
• Run one immediately, cancel one mid-flight, delete one that has served its purpose
• Confine writes to the working directory, per job

Sixteen agents. Zero collisions.

Every parallel task runs on its own branch and git worktree, so agents never trip over each other's files. Fill the whole deck, watch it move at once, and merge each result when it's ready — one at a time, on your terms.

• A dedicated git worktree per agent — real isolation, not a sandbox toy
• Mix models across panes — the CLIs you already have on your PATH
• Background & scheduled agents that keep working while you don't
• Checkpoints + snapshot-before-action, so anything is undoable