A board, not a chat window
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. Nothing to dig back out of an endless conversation.
Features
What HaikoDev adds
Twelve capabilities, written without jargon. They all answer the same question: what has to be added around a model that writes code before you can really hand it a project?
The detail
Twelve features, one per real need
Each one was born from a concrete problem met while handing a real project to agents.
One agent per card, writing the card rather than a wall of text
Every card is born with its own agent, on a low-cost model. You describe the need in plain language, it talks it over with you, then writes the card in a fixed format - title, goal, thinking level - and nothing starts until you press “Start the task”.
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.
As many cards running at once as you like
Every agent works in its own copy of the project, on its own branch. Five cards started together move together, and never tread on each other.
The AI tools already on your server
HaikoDev detects the AI tools installed on your VPS. From the settings, you can add more, then use them all through the same interface.
A memory that files itself
Every agent that finishes drops off what it learned; the memory sorts itself by topic and grows with the project. When a card starts, only the useful passages go to the engine - not the whole folder.
Tokens and quotas, account by account
You see what each card consumed, what is left on each subscription and when the window resets. A run cut short by a limit is not 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: the server does the work, and 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 - your computer off, the server awake. It only PROPOSES: when you wake up, you choose.
Templates, not free-form textThe memory grows with every cardA sleeping card costs nothingA question stops the agentTemplates, not free-form textThe memory grows with every cardA sleeping card costs nothingA question stops the agentTemplates, not free-form textThe memory grows with every cardA sleeping card costs nothingA question stops the agentTemplates, not free-form textThe memory grows with every cardA sleeping card costs nothingA question stops the agentTemplates, not free-form textThe memory grows with every cardA sleeping card costs nothingA question stops the agentTemplates, not free-form textThe memory grows with every cardA sleeping card costs nothingA question stops the agentTemplates, not free-form textThe memory grows with every cardA sleeping card costs nothingA question stops the agentTemplates, not free-form textThe memory grows with every cardA sleeping card costs nothingA question stops the agent
The columns
The board, column by column
The agents are the ones from the tool. They serve as landmarks: one glance shows where a card stands, and what role each stage gives it.
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.
Answers in a fixed format, not free-form text
A general-purpose assistant answers whatever it likes, however it likes. Here every step returns a shape decided in advance: a card has a title, a goal and a level; a report has its sections, its consequences and its estimate. You always read the same thing, and you see straight away what is missing.
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 burn your tokens
A sleeping card consumes nothing. The project memory structures itself with every finished card: the next agent gets the three useful passages instead of the whole folder. And what goes to the engine is measured, card by card, 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.
You stay at home, with the code
HaikoDev is open source and runs on your own server, with your accounts and your repositories. The whole project is handed to you: you read it, you change it, you keep it. Nothing depends on a service that could shut down tomorrow.
Fancy a try?
Installing takes an evening. Make a donation, and the whole project downloads, ready to put on your server - source included.