ROOK

Agentic coding tools can work for hours, but the moment one hits a real decision it stops and waits at a terminal — which pins you to the desk for the whole run. ROOK splits that into two loops: a work loop that runs without you, and a decision loop that reaches you as a tappable card wherever you are, with plain-language options and a recommendation. The authoritative record lives on the machine doing the work; the desktop and phone apps are windows onto it, never a second copy.

ROOK is in active development. There is no installer and no signed distributable yet, so ROOK cannot currently be handed to another person, and pricing is not decided yet. macOS and iPhone are built and run. Windows has never been built.

How it works

The work loop runs without you: a non-thinking driver starts a fresh coding session, the session works a queued task, records what it did, and the driver starts the next one. The decision loop is the only thing that needs you.

When the coding agent hits a real decision it does not stop and wait at a prompt. It emits a card: a short, plain-language write-up of the situation, two or three concrete options with the consequence of each, and a recommendation. The card lands on your desktop dashboard and your phone. You tap an option, and the agent acts on it.

A blocking card parks that one thread. The driver pulls the next queued task and keeps going. The machine only goes idle when the queue is empty and every thread is parked. Roughly 95% of the loop runs without the operator.

Every card, answer, event, task and file reference is recorded on the device that does the work, in an append-only warehouse. The phone and the desktop are windows onto that record. They are never a second copy of it.

One brain

Exactly one component in the system is allowed to think: the coding CLI itself. The session driver, the comms layer, the server and every screen are non-thinking by construction. They drive, persist, render or converse — they never interpret, rank or re-summarize.

One generated contract

Every message shape in the system is declared once in JSON Schema and compiled into decoders for every surface. No screen and no server hand-parses a payload. Add a field, regenerate, and every surface either updates or fails loud. Wire-schema drift fails loudly at every decoded boundary: a surface running ahead breaks against an old decoder and a surface running behind breaks against a new one — both immediately, both at the boundary.

Proof-of-record

ROOK is designed around the rule that a state advances only when the warehouse records it — never because a command exited zero. If the write did not happen, the state did not change.

Who it's for

For solo developers and small teams who already run agentic coding sessions and are tired of babysitting a terminal. One operator per device; the phone aggregates a personal fleet.

Not for teams sharing a deployment, not multi-user, and not for anything holding production credentials.

What ROOK is not

• Not a second brain. No component other than the coding CLI interprets anything.
• Not a ROOK cloud. The authoritative ROOK warehouse stays on the device doing the work, and surfaces read it directly over your private mesh. There is no ROOK server holding your project state. Two external dependencies are real: the coding CLI calls a model provider over the internet, and device identity and connectivity depend on Tailscale's coordination service.
• Not an offline-write system. Writes go online-only to the origin device. Disconnected means honest read-only, not a queue that will conflict later.
• Not a chat wrapper. The decision card — a bounded, tappable, consequence-labelled unit — is the interaction primitive, not a free-text conversation.
• Not spoken output. Voice is input-only dictation.
• Not a team product. Single operator per device, by design. Multi-user is not deferred work; it is out of scope.

Where it is today

In active development.

The contract, the on-device server and warehouse, the work loop, the desktop dashboard, the phone app, the fleet model, the workspace selector and on-device voice dictation are built and running. ROOK's own work loop builds ROOK.

macOS and iPhone are built and run. Windows has never been built. It has run on a real iPhone: a signed development build, live off a real server over a private mesh, on 2026-08-02. Not a distributed app.

Watching and answering are built. The conversational layer is designed and locked, but not yet built — today the chat pane is a one-way project channel.

Voice is on-device dictation. Audio never touches disk, the warehouse, or the contract.

There is no installer and no signed distributable yet. ROOK cannot currently be handed to another person. Pricing is not decided yet.