The kanban is the agents' shared memory

Two agents pick up the same task at the same second. Neither knows the other exists. One writes a database migration; the other writes a conflicting one. Both run their tests, both see green, both report success. Twenty minutes later the branch won’t boot, and the only honest answer to what happened is: nobody was holding the truth.

That failure has a boring name. It’s a coordination problem, and it has nothing to do with how smart the agents are.

When you run one agent, the state of the work lives in its head and that’s fine. When you run ten, the state of the work has to live somewhere all ten can see, or they trample each other. The board is where the agents agree on what is true. Not a chart you read after the fact, the working memory they share while they work.

The naive version: each agent remembers its own task

The obvious way to run a fleet of agents is to give each one a task and let it remember its own progress. Agent A holds “I’m building the export feature.” Agent B holds “I’m fixing the login bug.” Each keeps its plan, its current step, and its sense of done inside its own context. Clean, simple, and it works right up until two agents need to know about the same thing.

The moment that happens, the model breaks, and it breaks quietly. There is no shared place to check whether a task is already claimed, so two agents claim it. There is no shared place to see that a third agent is mid-way through the file you’re about to rewrite, so you rewrite it. Each agent’s memory is perfectly correct about its own slice and completely blind to everyone else’s. The blindness is the bug.

You feel this the same way a team without a board feels it. Two people build the same thing because neither knew the other started. A handoff drops because the person who finished step one never told the person waiting on step two. The work that fell through wasn’t hard, it was just invisible to the one who could have caught it. Private memory scales to exactly one worker. Add a second and the cracks are between them, in the space no single memory covers.

The instinct is to fix this with more talking. Let the agents message each other: “hey, are you on the export task?” That helps for three agents and collapses at thirty. Now every agent has to broadcast every move to every other agent and remember what they all said, and the coordination cost grows faster than the work. The bottleneck never disappears. It just moves into the chatter.

The fix: put the truth outside every agent’s head

Here’s the key idea, and it’s simple. The state of the work should not live inside any agent. It should live in one place outside all of them, that every agent reads before it acts and writes after it acts. That place is the board.

A board is just tasks with a status, backlog, in progress, in review, done, and an owner. We tend to think of those columns as a human convenience, a way to glance at a wall of sticky notes and feel oriented. That undersells them. The columns are a shared data structure, and the status of a card is a fact every agent can rely on without asking anyone.

Watch what that buys you. Before an agent starts work, it doesn’t message anyone, it moves the card to in progress and stamps its name on it. That single write is a claim. The next agent that reaches for the same card sees it’s taken and goes elsewhere. The handoff isn’t a message that might get missed; it’s a card sitting in the in review column, which is a fact, which doesn’t expire when nobody’s listening. The board is where the agents agree on what is true, and because the agreement is a row in a shared store rather than a memory in someone’s head, it survives the agent forgetting, crashing, or finishing.

The reframe is worth saying plainly: status was never a report. It’s a coordination primitive. A human kanban happens to also be readable by humans, which is lovely, but the load-bearing job of a card’s status is to let many workers act on shared truth without colliding. We just took the workers and made most of them software.

Why the claim has to be atomic

There’s a softer version of this idea that almost works, and it’s worth killing carefully, because it’s the one a careful engineer reaches for second.

The soft version is: let each agent check the board before it starts. Agent reads the card, sees backlog, decides it’s free, starts working. Reasonable. But read what happens when two agents check at the same instant. Both read backlog. Both see it’s free. Both start. The check passed for both because the gap between reading the status and writing the claim is a window, and in that window two agents can each believe they won the race.

This is the same hazard that bit the two migrations at the top of this post. A check that isn’t fused to the claim is a check that lies under load. The board doesn’t just need a status column, it needs the claim to be a single, indivisible operation: if this card is still unclaimed, mark it mine, otherwise tell me I lost. One winner, and the loser finds out instantly instead of discovering it twenty minutes later in a broken build.

So the board does the arbitration the agents can’t do for themselves. Two agents race for a card; the store hands the card to exactly one and returns a polite refusal to the other. The loser doesn’t sulk and it doesn’t collide, it reads the board again and picks up the next free thing. No agent had to know the other existed. The shared truth resolved the conflict, which is the whole point of putting the truth outside their heads.

The same discipline covers the messier states. A card half-done by an agent that crashed shouldn’t sit in progress forever, claimed by a ghost. So the claim carries a heartbeat: an agent holding a card has to keep saying still on it, and a card whose owner has gone silent past a threshold returns to the pool for someone else to pick up. The board isn’t just where work is recorded. It’s where stalled work gets noticed and reassigned, which is exactly the job a good operations lead does for a team of people, made mechanical.

The card is the conversation, not a label on it

Now the part that turns a board from a coordination trick into actual shared memory.

A card isn’t just a status. It’s the place the work accumulates. The decision an agent made and why. The file it touched. The test it ran and the result. The objection a reviewer raised. The question that’s blocking it. In a private-memory fleet, all of that lives inside whichever agent did the step, and it dies when that agent’s turn ends. On a card, it’s written down where the next agent, or the next kind of agent, can read it.

This is what lets a different agent finish what another started without a frantic catch-up call. Imagine a card that’s traveled three columns. A planning agent broke the work down and left the plan on the card. A writer implemented two of the three steps and noted on the card exactly where it stopped and why the third was harder than expected. Now a fresh agent, maybe a stronger one for the tricky part, opens the card and the whole history is right there: the plan, what’s done, the snag, the reason. It doesn’t reconstruct the context from scratch. It reads the card the way a good engineer reads the comments on a thread before replying.

The contrast with chat is sharp. A conversation is ordered by time and scattered across whoever happened to be talking; to learn the state of a task from a chat log you have to read everything and reconstruct it in your head. A card is ordered by the task. Everything about this work is in this place, and the current state is the top of the column, not the bottom of a thread. Chat is how agents gossip. The card is how they agree.

That distinction is why “let the agents message each other” was a dead end. Messages are about who said what. The board is about what is true now. When you want many workers to act on the same reality, you don’t want a faster way to talk. You want a single artifact they all trust more than they trust their own memory.

What this buys, and the honest cost

The honest accounting: this isn’t free, and it isn’t magic.

It costs a write before every action and a read before every claim. Every agent has to be disciplined enough to move the card before it works and update the card after, instead of charging ahead with the truth trapped in its own context. That discipline is the tax, and it’s a real one, an agent that “knows” it’s done but never moved the card has done nothing, as far as the rest of the fleet can tell. We treat that as a feature, not a bug. If it isn’t on the board, it didn’t happen, the same way a feature with no commit didn’t ship.

What it buys is the thing private memory can never give you: many workers acting on one truth without colliding, and without a human standing in the middle relaying status. The claim is atomic, so two agents can’t take the same work. The history lives on the card, so any agent can pick up where another left off. The heartbeat catches the stalls, so a crashed worker doesn’t freeze a lane. None of that lives inside any agent. All of it lives in the board, which is exactly why it survives any single agent failing.

The board scales the way a private memory never could, not because the agents got smarter, but because the truth moved out of their heads and into a place they all share.

The turn: your status was always for the machines

Strip away the agents and there’s an older lesson sitting underneath.

For years we filled in boards as a chore, a thing you updated so a manager could read it, a tax on the real work, the meeting where everyone recites what their card already says. We told ourselves the status was for the humans, and we resented maintaining it. We had it backwards. Status was never paperwork about the work. It was the coordination layer that lets many people pull in the same direction without tripping over each other, and we treated it as an afterthought because, when the workers were slow humans in the same room, you could mostly coordinate by talking.

You can’t talk your way through a fleet of agents working in parallel at machine speed. There’s no room to ask around, no hallway to bump into someone in. The only thing that scales is a shared place that holds the truth and arbitrates the conflicts, and the funny part is that the structure we’d been building all along, the humble board with its columns, turns out to be exactly that. We were keeping a coordination primitive and calling it a report.

So the status column isn’t a courtesy anymore. It’s the working memory of a workforce that never sits in one room. The card is where the agents agree on what is true, and once you see it that way, you stop asking your team to update the board for you, and start treating the board as the thing that lets the work happen at all.

---

That’s part of what we’re building at Apollo Space, a company brain where the board isn’t a wall you check on Monday but the shared memory a fleet of agents reads and writes every second. If you’ve ever watched a handoff drop because the truth lived in one person’s head, you already know why the most important artifact isn’t any single worker. It’s the one place they all agree.