Kanban for AI coding agents: why a board beats the chat box

Every prompt you hand an AI coding agent is a task. It has a scope, a definition of done, and a result somebody should check before it counts. The chat box knows none of that. It renders your task as a line of scrollback, runs it, and forgets it ever existed.

With one agent, you can carry the missing structure in your head. But agents got good enough to run several at once, and the moment you do, the head runs out. Which pane is on the payments bug? Did the refactor finish? What did you ask the third one to do an hour ago? The model isn't the bottleneck anymore. Your task tracking is.

A chat box is a queue of one

Look at what a prompt-driven workflow actually gives you:

• No queue. Work starts when you remember to type it, not when an agent frees up. Ideas you had at lunch are gone by four.
• No status. The state of every task lives in scrollback, and scrollback is where state goes to die.
• No gate. The moment an agent stops, its work is de facto accepted unless you go digging for the diff.
• No memory. Next week's version of the same job starts from a blank prompt, minus everything you learned this week.

None of this is the agent's fault. It's the interface. A conversation is a fine way to do one piece of work and a terrible way to manage twenty.

Kanban was invented for machines that work without you

Kanban didn't start as a software ritual. Toyota built it to run factory floors: cards that signal what to produce next, pulled only when capacity frees up, with every piece of in-flight work visible at a glance. The insight was never the sticky notes. It was three rules: make work visible, limit work in progress, and pull rather than push.

For years, software teams borrowed that system to coordinate people. Coding agents quietly recreated the original problem: you are now the operator of several machines that produce without supervision. That is exactly the shape of work Kanban was designed to run, which is why a board fits a fleet of agents better than it ever fit a standup.

The card is the brief

A card is not admin overhead on top of the prompt. Done right, the card is the prompt: a title, notes with the constraints that matter, and acceptance criteria you could check in a minute. Writing it forces the two decisions that decide whether agent work succeeds, long before a model sees it: is this one task or three, and how will you know it worked?

Cards also compound. A prompt you type is spent the moment you hit enter. A card you wrote survives: redeploy it when the first attempt misses, refine the notes instead of re-explaining from scratch, and point next month's agent at the same brief. If a job repeats on a schedule, the card graduates into automation entirely.

In Review is the point of the whole board

Columns look like decoration until you treat them as a contract. In Progress means an agent owns the task. In Review means a human does. Nothing an agent produced counts as done until it has crossed that line, with a "what changed, how to test it" note attached and a person on the other side actually reading the diff.

That single gate changes the economics of trusting agents. You can hand out bolder work when you know every result parks itself in a column and waits, instead of dissolving into a terminal you stopped watching. And when a result isn't right, the card takes a follow-up note and goes back through, carrying its full history with it.

Your real WIP limit is your review bandwidth

Classic Kanban limits work in progress to stop half-finished work from piling up. With agents, the scarce resource isn't their capacity to start. It's yours to finish. Every deployed card comes back as a diff someone has to read.

So set the limit where the constraint actually is: run only as much In Progress as you can move out of In Review the same day. A board makes the violation visible early, as a swelling review column, rather than late, as a merge day you dread. If the review pile keeps growing, adding more agents is adding risk, not speed.

Where agent boards go wrong

An honest word, because a board can absolutely make things worse:

• The board becomes a second job. If you move every card by hand, the board and reality drift apart by Thursday, and a board that lies is worse than no board. The transitions have to be automated by the tool: cards should advance because agents started and finished, not because you remembered.
• Untracked work stays invisible. The quick prompt you typed straight into a terminal is still a task. If it never becomes a card, your board is a partial record pretending to be a whole one.
• Ceremony swallows small fixes. A two-minute typo fix doesn't need acceptance criteria. Card the work you'll want to find, review, or repeat.

What this looks like in SanuDesk

SanuDesk is a desktop app built around exactly this loop. Every project gets a Kanban board that sits next to a tiled grid of your Claude Code, Codex and Gemini sessions, and the board does the moving on its own:

• Deploy, don't paste. A card's brief launches a fresh agent session with one click. The card moves to In Progress when the agent starts and lands in In Review the moment it stops, carrying the agent's own "what changed / how to test" note.
• Nothing escapes the board. Prompts typed directly into any terminal auto-create and advance their own cards, so the board stays honest even on the days nobody thinks about it.
• Follow-ups keep the thread. Reject a result with a note and redeploy: the next session gets the card's whole history, not your reconstruction of it.
• Loops feed the board. Recurring chores fire on a schedule and drop their results into the same review lane as everything else.

The board and the grid are in the free plan (see pricing), and SanuDesk drives the agent accounts you already pay for, so there's no second meter running while your fleet works.

Run this experiment

Take the next five things you would have pasted into a chat box and write each one as a card first: a title, two sentences of notes, one acceptance check. Deploy them one by one. At the end of the day, look at the board and ask what it told you that scrollback never would have: what's still running, what's waiting on you, and what shipped.

That's the quiet shift. The chat box made agents feel like a clever tool. A board makes them feel like a team you're running.

Download SanuDesk free and put your next five tasks on a board, or see how the board, the grid and Loops fit together on the features page.