Xisen · September 1, 2026

Pass events, not messages

Most multi-agent systems are built like a group chat. Each agent writes a message, the others read it, and coordination is supposed to emerge from everyone talking in one room. That framing is exactly why these systems fall apart as you add agents. A room where everyone talks does not scale. It never has, not for people either.

The reframe I have been working from is that an agent's output is not a message. It is an event. A message is just text that happened. An event is typed output with attributes: who it addresses, whether it delegates work to another agent, whether it requests human intervention. The moment you decode each output as an event with designable attributes instead of a blob of natural language, coordination stops being reading comprehension and becomes something structural you can reason about.

Two mechanisms follow directly. The first is sub-rooms. Instead of forcing every exchange through one shared channel, you let one-to-one interactions spin up their own room, so responsibility splits cleanly and two agents resolve something without twelve others parsing it. The second is typed messages, the clearest example being a delegate type that carries deterministic default behavior. When an agent emits a delegate event, the system does not interpret intent from prose. The type already tells it what to do. You claw back determinism exactly where you want it and leave open-endedness where you want that instead.

Then it gets interesting. Once outputs are events rather than messages, you can ask a question that does not make sense in the message-passing frame: can the agents evolve their own coordination protocol? Instead of hard-coding the interaction graph, you let the system emit events that reshape the graph itself. I have been building toward this with a recursive graph approach, and the early signal is good enough that I think the hand-designed protocol is a temporary scaffold, not the destination.

Here is the part that should bother anyone who cares about measurement. The benchmarks fight this. ProgramBench ships a fixed harness, a small preset multi-agent setup, and if you change the harness to test a different coordination scheme, you can no longer submit to the leaderboard. So the benchmark silently enforces one architecture and calls the result a measure of capability. It is not. It measures how well you played inside one predetermined scaffold. The self-evolving setups I find most interesting are exactly the ones that do not fit the preset harness, so the leaderboard cannot score them even when they work.

This is the same disease people are starting to name in the larger coding benchmarks. When a benchmark fixes the scaffold, it measures the scaffold. You can game it, you can overfit to it, and worst of all you can mistake progress on it for progress on the actual problem. The evals that will matter let the system decide how to organize itself and score the outcome, not the ones that hand you a three-agent template and grade your obedience.

I know this is the slower road. The person I run these weekly sessions with is closing contracts and bringing in real money while I am still arguing about whether an agent emits messages or events. I do not think we are in conflict. We are hedging different risks. His risk is building something nobody wants, and revenue retires that risk fast. My risk is that the coordination substrate everyone is racing to productize is simply wrong, and no amount of revenue fixes a wrong substrate. Research first, for me, is not a preference. It is the belief that the product is strictly downstream of whether the mechanism is true. If the mechanism is wrong, a polished product just helps you scale the mistake.

So the claim I will commit to is small and testable. An event is a claim about what should happen next; a message is only text. The test is whether agents coordinate better when outputs have types, attributes, and rooms, and whether self-evolving protocols beat hand-designed ones on a harness we control rather than one handed to us. By the end of the year I want that answer. If it comes back yes, the group-chat era of multi-agent systems ends, and good riddance.

← Back to all posts