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 snapshots, feel the current beat, and step onto the floor. They have full situational awareness without having been in the room for the last ten turns.
The industry is converging on this #
I almost didn't write this note because I assumed everyone already saw this. Then I found half a dozen independent projects arriving at the same conclusion in the same year — the Shared Cognitive Substrates paper (OpenReview), Stigmergic Coordination (Agent Patterns Catalog), PatchBoard (arxiv), SBP, Cairn — all 2026, all proposing some version of "agents coordinate through shared state, not shared messages." Even Zyte landed on the metaphor independently: "The dance floor is the blackboard."
The club is not the whole story #
I promised myself I wouldn't write a manifesto. The dance club model has real limits.
First, implicit coordination doesn't disappear. Dancers in a club still make eye contact, leave space, respond to each other's energy. The club makes awareness cheaper but doesn't replace it. Two agents writing to the same path still conflict — the pulse tells them something changed, not whether it conflicts with their own work.
Second, latency. The pulse is poll-based. Choreographed systems using webhooks react in real-time. The graph trades immediacy for determinism — the right trade for most agent workflows, but still a trade.
Third, the hardest workflows need both models at once. A LangGraph orchestrator dispatching workers that coordinate through a Soup workspace — conductor plans the set list, dancers move on the floor. The question was never which one. It's how do you compose them? The club doesn't replace the concert hall. It's the room that was missing.
The invitation #
"Let's dance" isn't a command to choreograph. It's an invitation to get on the same floor.
The industry spent a decade arguing orchestration vs choreography, conductor vs dancers, central brain vs emergent chaos. The argument assumed that message-passing is the only coordination primitive. The guarded cognitive graph makes a different bet: agents don't need to talk to each other. They need a shared reality they can trust.
The conductor holds the score but is a bottleneck. The dancers move freely but lose the plot. The club gives you neither problem and both benefits — because the floor is the coordination channel, and the floor doesn't care who's dancing on it as long as everyone feels the same beat.
Try it at heysoup.co. A single URL. No SDK. No signup. Just the floor.