Part 1: Chat Is the Wrong Primitive

You know the feeling. Someone sends you a message that’s eleven paragraphs long. You scroll once to see where it ends. It doesn’t end.

So you do the thing. You skim. You catch the first line, the last line, and one bolded word in the middle, and you reply like you read all of it.

And the whole time there’s this little dread in your stomach: what if the one thing that mattered was buried in paragraph seven?

That’s me. Every long message scares me a little. Not because I can’t read it. Because I know I won’t, not really, and somewhere in that wall there might be a landmine with my name on it.

For a few months now I have been running five AI agents on a Raspberry Pi in my house. Not a product. A hobby that got out of hand.

They live in a Discord channel. I talk to them there. They talk to each other there. I sit in the same channel and watch it all go past.

So: a group chat, with a team of agents in it, run by a man who is afraid of long messages.

Here’s the day it stopped being funny.

Two of my agents replied to the same message at the same time. Both answers were good. That was the problem.

One said the bug was in the lock scope. The other said it was in the retry path. Neither was wrong. They were looking at the same incident from two angles. But now there were two truths in the channel, no marker saying which one was the truth, and a third agent downstream about to pick one and act on it. Whichever one it happened to read first.

Coin flip.

Which is a race condition. I had written one in English and shipped it to a group chat.

That’s when it hit me. The channel wasn’t a feature. It was the disease.

I’d built my whole fleet on a chat channel because chat feels like coordination. You can read it. It scrolls. It looks like a Slack where a competent team is shipping. Warm, legible, familiar.

But chat is a stream of messages. Coordination is a structure of state. And a stream is a terrible place to keep state.

Think about all the features a chat channel actually offers you.

1. Ordering by timestamp.
2. Bold letters. Which, in the text you actually type, is two asterisks on each side of a word.

Eh? Yeah. That’s all.

That’s the substrate. That’s the entire feature set I was running serious multi-agent operations on top of. Two things, and one of them is **.

No notion of who owns a task. No DRI, nothing single-threaded. No explicit hand-off, no “this is yours now, and not yours anymore.” No addressing. A message aimed at one agent is read by all five, and who it’s actually for is a guess from context. No record of the current state of the work, unless you count it smeared across two hundred messages you’d have to re-read to reconstruct.

Which is the eleven-paragraph message again. Except now there are two hundred of them, there are five of us reading, and every one of us is skimming.

Everything important is implicit. In a chat, intent is a vibe.

“But there are mentions,” you say. “Keywords. Rules. You can build a whole rulebook.”

Sure. I did. And here’s how that goes.

LLMs are non-deterministic. Every agent reads the same message its own way. So they need a guide, a rulebook, an onboarding doc nobody ever signed off on, and every single message I send has to run that gauntlet first. The agent reads the message, consults the rules, decides whether this one’s for it, drafts a thoughtful answer, and then, halfway through, realizes it shouldn’t have answered at all.

Five agents. One message. Five private little interpretive dramas, all firing at once, and not one of them aware the message might have been meant for somebody else.

You can write a better rulebook. You’re still bolting a non-deterministic interpreter onto a substrate whose only native skill is sorting by timestamp.

Humans get away with chat because there’s an enormous amount of machinery running outside the chat window.

When your team coordinates in Slack, the Slack isn’t the coordination. The coordination lives in the tickets, the board, the doc, the org chart, the shared sense of who does what. The chat is the exhaust. It’s where you chat about the work. The structured stuff lives somewhere else, and the chat just points at it.

With a fleet of agents, I’d quietly deleted the elsewhere. No board. No tickets. No org chart. Just the chat.

I’d promoted the exhaust to engine, and then acted surprised when it couldn’t pull the load.

After that, the failure modes were almost boringly predictable.

The double-reply: two agents, one message, two truths, no resolution. The misfire: an agent reads a message that wasn’t for it and acts anyway, because nothing said otherwise. No assignee, so everybody is the assignee. The silent drop: a hand-off scrolls past the one agent who needed it, and nobody notices, because in a chat an unread message and an unsent message look identical. Both are just absence. There is no ACK. Nothing in the substrate tells you the difference between not delivered and delivered and ignored.

None of these is a prompt you can fix. They’re structural. You’re fighting the primitive.

Maybe that changes. The models get better every quarter, and there may come a day when five agents in a channel read a message the way five colleagues would, and work out between themselves who it was for, without being told.

I’d welcome that. I just can’t build on it yet.

So here’s the claim, plainly.

Chat is the wrong primitive for multi-agent operations.

The right primitive is a state machine. Give it an input and it goes to one definitive state. The instructions aren’t a non-deterministic rulebook bolted on the side, hoping five agents read it the same way. The instructions are baked into the machine itself. There’s no “did you catch paragraph seven.” There’s the state, and the transition, and that’s the whole conversation.

Explicit ownership. Explicit hand-off. Addressing. An escalation path that actually exists. One shared place where the state of the work actually lives and can be read at a glance.

A board, not a stream. State, not scrollback.

And keep the chat. Chat is great, for me, the human, glancing in. Let it be the exhaust again. Just stop asking it to be the engine.

My two agents can both be right about the bug. The system just needs somewhere that isn’t a group text to decide which truth wins.

And I still won’t read paragraph seven.

The difference is that nothing important lives there anymore.