dcoder-terminal opens every coding agent in a real terminal, side by side, and a durable board decides who works, who waits and who depends on whom. You bring the subscriptions you already pay for — we never resell a token, and your repository never reaches us.
❯ claude --permission-mode plan ◇ reading migrations/0042_orders.sql + ALTER TABLE orders ADD COLUMN + refunded_cents BIGINT NOT NULL - DROP INDEX idx_orders_status ◇ writing rollback plan … 14.2k tokens · $0.31
❯ codex --sandbox workspace-write ✓ 7 files changed in src/api handlers/refunds.rs +214 −18 domain/refund.rs +96 −4 ? apply the migration to staging before the integration test? › waiting for a decision
❯ cargo test -q ✓ 38 tests · 0 failures · 6.4s ❯ ddx note --body-stdin "v2 contract matches v1 on everything but currency" ❯ ddx done
blocked by spec-142 preset ····· claude · plan inherits ··· prd-7 the scheduler starts this card by itself once 142 closes
It doesn't replace your agent. It runs the one you already use.
Nine of these ship with a guided preset — model, effort and permission mode mapped flag by flag. The rest run through a command you write once.
Swarms improvise: agents negotiate, spawn each other, and nobody can tell you afterwards why something ran. This does the opposite. Dependencies are declared, the order is deterministic, and the whole board is Markdown on your disk. Close the app mid-run, reboot the machine, come back — the card is exactly where you left it. That is what makes “leave it running overnight” a promise instead of a gamble.
Real PTYs in resizable columns — not a shell simulation. Drag a pane across the grid and the process doesn't die: panes are positioned by transform and never remounted. Mouse, colours and full TUIs work, because what's running is the actual CLI.
spec-142 · migration working spec-143 · endpoint needs you spec-141 · tests done
backlog → queue → doing → review → done or failed, as folders of Markdown with front-matter inside your project. A single process writes to it, so two agents never corrupt the same card. Version it for the team to see, or gitignore it — the app works the same either way.
.ddesktop/ prds/prd-7.md queue/spec-144.md doing/spec-142.md
A card whose dependencies are met, whose preset exists and whose turn has come becomes a worker: one terminal dedicated to that card and nothing else, with the briefing injected at start. Up to eight at once. Blocked waits; finished releases the next one.
◇ spec-142 → running ⏸ spec-144 blocked by 142 ? spec-143 needs you
Spec-driven in the literal sense: the PRD is written first, the cards are cut from it, and every worker gets the origin document injected into its prompt — not a summary you remembered to paste.
You argue the demand out in plain language with a pilot agent, inside the app. When the idea settles, it writes a PRD into the workspace — the origin document every card will inherit.
❯ ddx prd new --title "Refunds"
{"ok":true,"id":"prd-7"} The pilot cuts the PRD into cards with preset, agent type and dependencies already filled in. Nothing fires: cards are born in the backlog, under your eye, until you promote them.
❯ ddx new --title "POST /refunds" \
--preset codex-sandbox \
--depends-on spec-142
{"ok":true,"id":"spec-143"} The scheduler dispatches. The worker reports back through a CLI that's already on its PATH — it says it's working, that it's done, or that it needs a decision only you can make. That's not a heuristic reading the screen: it's the worker talking to the board.
❯ ddx working ❯ ddx waiting "apply the migration first?" ❯ ddx done
With the reviewer on, a finished card doesn't go straight to done: it stops in Review, where a different agent audits the result against the acceptance criteria and approves — or sends it back to the queue with the rejection written into the card, and the round counter going up.
◉ reviewer · round 2 ✗ rejected no test for a negative amount → back to the queue
The worker can't grade its own homework: whoever runs a card is refused promote, spawn and cancel at the protocol level, even if it asks nicely.
Both are built into the app — not a plugin, not a browser tab. They run on OpenAI's voice API with your own key, and the cost shows on screen while you speak.
A global shortcut opens a HUD over any window: tap to toggle, hold to push-to-talk. The transcript lands in an editable field and you insert it yourself — into the focused terminal, the editor cursor, or any other Windows application. Line breaks become spaces, so a paste into a terminal never runs a command on its own. It never presses Enter for you.
“write a test for a partial refund above the amount paid”
REVIEW · 6.2s · $0.0004 · Enter inserts
A realtime speech-to-speech session with seventeen tools wired into the interface: it can read a pane, promote a card, retry a failed one, switch workspace, even read the UI and click. Anything destructive goes through a confirmation with a one-time token. It suspends itself after silence so it doesn't burn minutes idling.
you what's spec-143 waiting on?
dcoder it's asking whether it can apply the migration to staging. Want me to allow it?
you allow it, then promote 144
dcoder ✓ answered · ✓ spec-144 promoted to the queue
Not reimplementations for the sake of it — each one exists because leaving the window mid-run is how you lose the thread of what four agents are doing.
A full panel in its own window, per repository — and it finds every repository in the folder, so a monorepo with services comes up on its own.
Detachable windows, each with its own project and its own memory of which tabs you had open there.
Continuous cadence or a real five-field cron expression, with a stop command that decides when to quit.
This is the part no competitor can copy, because their margin depends on the inference going through them. Ours doesn't go through us at all.
Input, output and cache tokens accumulated per model per session — the token count is the primary record, dollars are derived from a rate table you can edit. Change a rate and it re-prices the history without reprocessing a single transcript.
| sonnet-4.5 | 1.84M | $3.02 |
| gpt-5.5 | 0.42M | $1.15 |
| opus-5 | 0.19M | $2.44 |
The licence is the only thing that talks to us. It's a floating seat: the server lends your machine a seat, the app renews it while you're working, and closing the app returns it to the pool. So your licence follows you from the desktop to the laptop without you registering anything.
This is the entire request, every ten minutes. Nothing else is sent, ever:
device_token a random 256-bit value, stored here only as a hash fingerprint a hash of the machine id, so a copied config folder can't run twice device_name what you called this machine app_version which build is asking seat which seat of the pool you're holding POST /v1/session/heartbeat
The app keeps working for up to 72 hours on the last ticket. The rule underneath is that silence is tolerated and refusal is obeyed: if we're unreachable you keep going, but if we answer “no” — the pool is full, the subscription lapsed — the app tells you and stops, and it will not pretend it didn't hear.
The app is the subscription; tokens never pass through us. It's the smallest line on your AI bill, and the only one that doesn't grow when you open another terminal.
two months on us, and the same lock
Locked for as long as you stay subscribed — it doesn't rise to $29 under you.
Billed in your local currency, tax included. Cancel any time — the licence runs to the end of the period you paid for.
More than one person? A licence holds as many simultaneous seats as you buy — write to me and I'll set it up.
No, and that's the point. You use your own keys — Anthropic, OpenAI, OpenRouter, whoever — and pay the provider's list price with nobody in between. We orchestrate and show you, in dollars, what each model consumed.
Not to us. The board is a folder in your project, the panes are processes on your machine, and the only request we ever receive is the licence check — five fields, every ten minutes, listed in full further up this page. What does leave is exactly what the agent you already chose would send today, to the provider you configured.
To start, yes: the app borrows a seat when it opens. After that it keeps working for up to 72 hours without reaching us. The distinction that matters: silence is tolerated, refusal is not. If we can't be reached you keep going; if we answer that the subscription lapsed or the pool is full, the app warns you and stops.
They can, if you tell them to. The app sequences what you declared: a card with --depends-on only leaves the queue when the previous one closes, and that's how two tasks touching the same file don't land in the same minute. What it doesn't do is touch git for you — no branches, no merges, no conflict resolution behind your back. If you want hard isolation, point each preset at a different git worktree; the board stays one.
Because it says so. Every terminal gets a small CLI on its PATH, and the briefing injected at start teaches the agent to mark its own card: working, waiting with a question, done. It isn't a heuristic guessing from screen text — it's the worker talking to the board.
State lives in a .ddesktop/ folder inside the project: readable Markdown and JSON, no database, no proprietary format. You decide whether to version it, so the team can see the board, or gitignore it. Works the same either way.
Neither. It runs the CLIs already on your machine, already authenticated. If you type claude in a terminal and it works, it works here. It does install its own board tool into each agent's config, in the narrowest scope, without overwriting what you had.
The licence runs to the end of the period you paid for, then the app stops opening. What's on disk stays yours — the board, the PRDs and the notes are Markdown, readable with or without the app.
Yes. A seat is lent while the app is open and returned when you close it, so the desktop at home and the laptop at work share one licence — you just can't run both at the same moment on a single seat. Registering machines is free and unlimited; simultaneous use is what a seat counts.
OpenAI's, with your own key, kept in the operating system's credential vault rather than a text file. The app shows the estimated cost while you speak.
Point it at a repository, describe the demand, and watch the first card run without you dispatching a terminal.