Choreography is a coordination pattern in which there is no central controller. Instead of a single orchestrator directing work, autonomous agents independently observe events, decide how to respond based on their own instructions, and publish the results of their actions as new events that other agents can react to in turn. Coordination emerges from the collective behavior of independent agents responding to a shared event stream—not from any single entity telling them what to do.
The analogy that gives choreography its name is instructive. In an orchestrated performance, a conductor tells each musician when and what to play. In a choreographed performance, each dancer knows their part and responds to the music and to each other—no conductor required. The result can be just as coordinated, but the coordination mechanism is fundamentally different. Each participant follows their own rules and reacts to what’s happening around them, and coherent behavior emerges from the interaction.
In agentic systems, choreography is the coordination pattern that enables truly distributed, event-driven architectures. When a new order triggers an inventory agent to check stock, a shipping agent to prepare logistics, and a notification agent to alert the customer—all independently, all reacting to the same event, none directed by a central coordinator—that’s choreography. When a research agent publishes findings that trigger a writing agent, whose draft triggers an editing agent, whose edits trigger a publishing agent—all through events, with no supervisor managing the handoffs—that’s choreography too.
How Choreography Works
Choreography depends on two things: a shared event infrastructure and agents that know how to react to specific events.
The event infrastructure—an event bus, a message broker, a streaming platform—provides the communication medium through which events flow. When any agent completes an action, produces a result, or detects a state change, it publishes a notification event to the shared infrastructure. The infrastructure delivers that event to any agent that has subscribed to events of that type.
Each agent in a choreographed system has its own instructions that define which events it cares about and how it should respond to them. An inventory agent subscribes to “OrderPlaced” events and responds by checking stock availability. A fraud detection agent subscribes to “PaymentInitiated” events and responds by running risk analysis. A compliance agent subscribes to “ContractSigned” events and responds by verifying regulatory requirements. Each agent operates independently—it doesn’t know or care what other agents are doing with the same events.
When an agent completes its work, it publishes its own events. The inventory agent that finds an item is in stock publishes “InventoryConfirmed.” The fraud detection agent that clears a payment publishes “PaymentCleared.” These new events trigger further reactions from other agents, creating chains of activity that propagate through the system without any central coordination.
The key insight is that no single entity has a complete picture of the process. Each agent sees only the events it subscribes to and knows only what it’s supposed to do in response. The overall process exists only as the emergent result of all these independent reactions. This is fundamentally different from both workflow orchestration (where the process is explicitly defined) and agentic orchestration (where the orchestrator holds the plan in its head).
The Power of Decentralization
Choreography offers architectural properties that centralized coordination patterns cannot match.
Resilience is the most immediate benefit. In orchestrated systems, the orchestrator is a single point of failure—if it goes down, coordination stops. In choreographed systems, there is no single point of failure. If one agent goes down, the others continue operating. Events intended for the failed agent accumulate in the event infrastructure (assuming queued connections) and get processed when the agent recovers. The rest of the system doesn’t stall.
Independent scalability means that each agent can scale based on its own load, independent of every other agent. If the notification agent is overwhelmed by a marketing campaign, you scale the notification agent. The inventory agent, the shipping agent, and the fraud detection agent are unaffected. In orchestrated systems, scaling often requires scaling the orchestrator too, because it mediates all communication.
Independent deployment means that teams can build, test, and deploy their agents without coordinating with other teams. A team that owns the fraud detection agent can update its detection logic, deploy the new version, and start processing events—all without touching any other agent or any central process definition. This organizational decoupling is as valuable as the technical decoupling, particularly in large enterprises where coordination between teams is one of the biggest bottlenecks to delivery speed.
Extensibility without modification is perhaps the most strategically valuable property. When a new capability needs to be added to the system—a new compliance check, a new analytics agent, a new customer engagement workflow—it simply subscribes to the relevant events and starts operating. No existing agent needs to be modified. No process definition needs to be updated. No orchestrator needs to learn about the new capability. The new agent plugs into the event stream and starts contributing immediately.
The Challenges of Emergence
The same properties that make choreography powerful also make it challenging to design, debug, and govern.
Process visibility is the most frequently cited concern. When no single entity owns the overall process, understanding what the process actually is requires tracing events across multiple agents—reconstructing the sequence of reactions that produced a particular outcome. In orchestrated systems, the process is visible in the process definition. In choreographed systems, the process is implicit in the event subscriptions and agent behaviors, which can be difficult to piece together without specialized observability tooling.
Debugging complexity compounds the visibility problem. When something goes wrong in a choreographed system—an order is fulfilled incorrectly, a notification is sent prematurely, a compliance check is skipped—the root cause might be in any agent along the event chain. A missing event, a misconfigured subscription, a subtle ordering issue, or an unexpected interaction between agents that were designed independently can all produce failures that are difficult to trace and reproduce.
Emergent behavior can be both a strength and a risk. When agents interact through events, they can produce system-level behaviors that no individual agent was designed to exhibit—and that no designer anticipated. Most of the time this emergent behavior is benign or beneficial. Occasionally it produces pathological patterns: feedback loops where agents trigger each other in endless cycles, race conditions where the order of event processing produces different outcomes, or cascading failures where one agent’s error propagates through the entire event chain.
Consistency management is inherently harder in decentralized systems. In orchestrated systems, the orchestrator can enforce ordering—step B always happens after step A. In choreographed systems, two agents reacting to the same event might complete at different times, in different orders, on different runs. If the business logic requires a specific ordering, that ordering must be enforced through careful event design rather than central control—a subtlety that is easy to get wrong.
Governance and accountability present unique challenges. When a regulatory auditor asks “who decided to approve this transaction?”, the answer in an orchestrated system is clear—the orchestrator made the decision at a specific step. In a choreographed system, the answer might be “multiple agents each made independent assessments based on different events, and the transaction proceeded because no agent raised an objection.” This diffuse accountability can be uncomfortable in regulated environments.
Choreography and the Notification Pattern
Choreography has a deep, natural relationship with the notification interaction pattern. In fact, choreography is essentially coordination built entirely on notifications. Every event that flows through a choreographed system is a notification—an announcement that something happened, published without expectation of a specific directed response.
This means that designing effective choreography requires designing effective notification events. The three shapes of notification discussed in the notification primitive post—event notifications (minimal detail), event-carried state transfer (full detail), and domain events (business-meaningful detail)—are the building blocks from which choreographed coordination is constructed.
The choice of notification shape directly impacts choreography design. Lean event notifications keep the event infrastructure lightweight but force receiving agents to perform retrieval interactions to get the details they need—creating coupling to the source system. Rich event-carried state transfers give receiving agents everything they need but create larger messages and potential data staleness. Domain events strike a balance by encoding business meaning that helps agents make better independent decisions.
When to Use Choreography
Choreography is the right choice when the system needs to be resilient, scalable, and extensible—and when the trade-offs around visibility and debugging are acceptable.
Event-driven business domains where processes are naturally reactive rather than sequential are strong candidates. Order fulfillment, supply chain management, and IoT monitoring all involve multiple independent systems reacting to streams of events. These domains map naturally to choreography because the work is already distributed and event-driven.
Monitoring and alerting systems where multiple agents need to independently assess signals and react are well-suited to choreography. Anomaly detection agents, security monitoring agents, and performance tracking agents can all subscribe to the same operational events and respond based on their own specialized logic—without a central coordinator bottlenecking the response.
Cross-team integration where different teams own different agents and need to collaborate without tight coordination benefits from choreography’s organizational decoupling. Each team maintains its own agents and event contracts, and integration happens through the shared event infrastructure rather than through shared process definitions that require cross-team coordination to change.
Systems that need to grow incrementally benefit from choreography’s extensibility. Each new agent plugs into the event stream independently, so the system’s capabilities can expand without redesigning the coordination architecture. This is particularly valuable for platform teams building infrastructure that other teams will extend over time.
The general principle: use choreography when you need resilience and extensibility, when the domain is naturally event-driven, and when you’re willing to invest in the observability and event design discipline that makes decentralized coordination governable.
Choreography vs. Other Coordination Patterns
The three coordination primitives form a spectrum from maximum control to maximum autonomy.
Workflow orchestration is centralized and deterministic. Maximum predictability, maximum auditability, maximum control—but rigid and brittle when facing ambiguity or novel situations.
Agentic orchestration is centralized and dynamic. Flexible and adaptive, capable of handling complexity—but expensive, harder to audit, and still dependent on a single coordinating entity.
Choreography is decentralized and reactive. Maximum resilience, maximum scalability, maximum extensibility—but harder to reason about, debug, and govern.
Choreography differs from both orchestration patterns in a fundamental way: it has no single entity that holds a view of the overall process. In workflow orchestration, the process definition is the view. In agentic orchestration, the orchestrator agent holds the view in its reasoning. In choreography, the view exists only as an emergent property of independent agents reacting to events. This makes choreography the most autonomous coordination pattern—and the one that requires the most discipline in event design, agent behavior specification, and observability infrastructure to operate effectively.
In practice, choreography often coexists with orchestration. Individual business processes might be workflow-orchestrated internally (deterministic sequences within a bounded context), while the broader system coordinates across boundaries through choreography (events flowing between independently operated subsystems). This hybrid approach is common in enterprise architectures and maps well to how large organizations actually operate—teams working autonomously within their domains while coordinating through well-defined interfaces.
Also Known As
Choreography appears under various names depending on the platform and architectural tradition. You’ll encounter it as event-driven coordination (emphasizing the mechanism), decentralized orchestration (though some purists object to the contradiction in terms), reactive coordination (emphasizing the response pattern), pub/sub coordination (when implemented through publish-subscribe infrastructure), or emergent coordination (emphasizing the bottom-up nature). In microservices architecture, choreography is one of two recognized coordination patterns alongside orchestration. In domain-driven design, it maps to the concept of domain events flowing between bounded contexts. The defining characteristic across all terminology is the same: coordination achieved through independent agents reacting to shared events, without a central controller.
Key Takeaways
Choreography is the decentralized, event-driven coordination pattern where independent agents react to events and coordinate without a central controller. It provides resilience, scalability, independent deployment, and extensibility that centralized patterns cannot match—but at the cost of process visibility, debugging simplicity, and the governance clarity that comes with having a single coordinating entity. In the agentic primitives framework, choreography sits alongside workflow orchestration and agentic orchestration as the three coordination patterns, and it is the pattern most directly tied to building agentic systems that operate as truly distributed, event-driven ecosystems where coordination emerges from the interactions of autonomous participants.