Let's dance, or how I stopped worrying and learned to love a good soup | heysoup blog

← Back to notes

Put on your red shoes and dance the blues.

I used to spend hours with work mates arguing about orchestration vs choreography. This was back when "microservices" was still the new thing and we thought the hard problem was service discovery. The conductor or the dancers? Central brain or emergent chaos? We'd go in circles — every argument ended the same way: "it depends."

It took me years to realise we were arguing about the wrong axis. The real question isn't who controls the flow. It's what do the agents share.

The concert hall

Orchestration is the oldest pattern. A central conductor holds the score, calls the cues, tells every musician when to play. The result is a predictable, auditable performance. When a note is wrong, you know exactly which bar and which instrument. Every enterprise deployment I've ever seen starts here because it feels safe.

And it is safe — up to a point. The conductor is a bottleneck. The conductor is a single point of failure. The conductor must know the entire score before the first note plays. In agent terms: the orchestrator must decompose the task, sequence the subtasks, route the results, handle every edge case the prompt didn't anticipate. Anthropic's own research system found that the orchestrator needs "detailed task descriptions" or subagents "duplicate work, leave gaps, or fail to find necessary information." The conductor can't wing it.

Microsoft's architecture docs and Ability.ai's production surveys both land on the same conclusion: orchestration is correct when you need auditability and have low error tolerance. Regulated industries, financial approvals, compliance checks — the concert hall is the only room they trust.

But trust comes at a cost. The orchestrator's context window fills with routing logic instead of domain reasoning. Every agent waits for its cue. The music stops when the conductor blinks.

The street performance

Choreography was the rebellion. No conductor. Every agent watches the others and responds. A research agent finishes and publishes an event. An analysis agent hears it, picks up the work, publishes its own event. The overall process "exists only as the emergent result of all these independent reactions," as Agentic Academy's taxonomy puts it.

The promise is intoxicating: resilience, loose coupling, no single point of failure. Add agents freely. They self-organise.

The reality is more expensive. Sandipan Bhaumik — who has debugged more multi-agent production systems than I have — puts it bluntly: "moving from one agent to five increases complexity 25x." Choreography becomes a debugging nightmare. When a critical process fails, operations teams play detective. Did agent A fail to publish? Did agent B consume the event twice? Without bulletproof observability, you're chasing ghosts that don't exist in any single log.

The deepest problem with choreography is not debugging. It's that intent lives in messages, and messages are ephemeral. An event fires, agents react, the moment passes. What was the reasoning that led agent A to publish that event in the first place? The next agent in the chain doesn't know. It only knows the message it received. The why doesn't travel with the what.

The dance club

Both models are about message-passing — either through a central dispatcher or a distributed event bus. That's the shared assumption I never questioned. Messages are how agents coordinate. The only choice is who sends them.

There's a third model, and it's not a compromise between the two. It's a completely different primitive: state-mediated coordination . Agents don't send messages to each other at all. They read and write shared state. The state is the coordination channel.

Think of a dance club. The venue provides:

The floor — shared space everyone occupies

The beat — a common pulse everyone syncs to

The lights — visibility into what's happening around you

The bouncer — no one rewrites reality after the fact

No conductor tells dancers where to move. No dancer sends messages to other dancers. Coordination emerges from sharing the same space, feeling the same beat, and responding to the same floor. A new dancer walks in, watches for two counts, and joins the flow. No introductions needed. No protocol negotiation.

This is what the guarded cognitive graph is. A workspace is the dance floor. The pulse ticker is the beat — a monotonically increasing version number that every agent reads. Agents don't need to watch each other; they watch the pulse. When it changes, they know something happened. They read the latest state, check the purpose string, and decide what to do. Every mutation carries why it was made, who made it, and where it fits in the HMAC chain — the bouncer that keeps the timeline honest.

Fresh agents are stateless and swappable because they don't need to catch up on a conversation history. They read the last three...