A board, not a queue of commands
Your projects, your cards and your agents fit on a single screen. You drag a card from one column to the next; the work follows.
Features
What HaikoDev can do
Twelve capabilities, written without jargon. They all exist for the same reason: to let you hand work to a machine without losing sight of what it is doing.
The detail
Twelve features, one per real need
Each one was born from a concrete problem met while handing a real project to agents.
An orchestrator that writes the cards
You describe the need in plain language. The orchestrator reads back through the conversation, cuts it into short cards and picks the thinking level of each agent.
A plan mode before a single line is written
On delicate topics, the agent proposes a plan first, which you refine back and forth. Nothing starts until the plan suits you.
One branch and one folder per card
Every agent works in its own copy of the project, on its own branch. Two cards started together never tread on each other.
Three engines, your pick
Claude, Codex and Cursor all run on the command line behind the same interface. Work is sent to whichever account has the most room left.
A project memory that actually earns its place
Lasting rules and facts are filed by topic. When a card starts, only the passages that answer the request are sent — not the whole folder.
Quota tracking, account by account
You see what is left on each subscription and when the window resets. A run cut short by a limit does not count as a failure: it starts again.
Publishing in one gesture
The “To deploy” batch is merged, committed and released following the project’s written procedure. Every step carries its own log, readable in a drawer.
GitHub open to every agent
Reading a repository, opening a pull request, pushing a branch, handling issues: all available right away, with nothing to configure.
An interface that fits anywhere
Twelve palettes, five interface languages, installable on your phone, notifications: you follow the board from your desk or from the sofa.
Estimates and invoices
Every card reports its machine time, its developer hours and its cost. Enough to turn delivered work into a quote or an invoice, with nothing retyped.
One improvement proposed every night
Around 3 a.m., an analysis agent looks for what could be improved in the project. It only PROPOSES: when you wake up, you choose.
The report names the failures tooA sleeping card costs nothingA question stops the agentAn interrupted run picks up againThe report names the failures tooA sleeping card costs nothingA question stops the agentAn interrupted run picks up again
The columns
The board, column by column
The characters are the ones from the tool. They serve as landmarks: one glance shows where a card stands, and who is allowed to move it along.
Planned
Every card is born here. It carries a short request, a thinking level and, if you want, a start date. Nothing has gone to the engine yet: while the card sleeps, it costs nothing.
Running
An agent has taken the card. It has its own branch and its own copy of the project; it reads, edits, tests and shows you its task list ticking off live. A question from the agent stops everything until you answer.
Done
The agent has handed in its report: what it understood, what it did, the consequences, and the outcome of the checks — failures included. The card lands here on its own; nobody pushes it.
To deploy
You have read it over and you approve. Cards pile up here as one batch, ready to go out together. No agent walks through this door: publishing is a human gesture, always.
Archived
What is settled leaves the board without disappearing. The history, the branches, the reports and the estimates stay readable — and only reopen on your gesture.
The benefits
What changes once it is installed
The safeguards sit in the engine, not in a checkbox.
You keep control of publishing
No agent ever publishes on its own initiative. Code gets written, committed and pushed by itself, but it waits in “To deploy” until you click. It is the hardest rule in the tool, and there is no way around it.
You follow the work without reading code
Every agent announces its task list and ticks it off in front of you, then hands back a report in plain language: what it understood, what it did, what it changes. Failed tests are written there too — a failed check is never hushed up.
You do not pay for nothing
A sleeping card burns no tokens. Memory only sends the useful passages, the orchestrator does not pay for a heavy model just to sort, and what goes to the engine is measured, not assumed.
Nothing gets stuck
A run that ends closes its card, a passing outage is retried, a run cut short by an account limit starts again, and a sweep catches forgotten cards. A card in “Running” always says what is still going on.
Your rules outlive the agents
Whatever an agent learns that is useful goes into the project memory, filed by topic. The next agent finds it again, without you repeating yourself. A delivery log is kept separately, and never clutters the engine.
You stay at home
HaikoDev runs on your server, with your accounts and your repositories. Your project code does not leave your machine other than through the engines you chose.
Fancy a try?
Installing takes an evening. The guide says it all: what the machine needs, the commands, and the service that keeps it alive.