Orchestration, Coordination, Choreography.

Three words I wish we’d stop using interchangeably. Cloud architecture treats them as one.

An Agentix-Native System (aka Agentic AI) cannot.

I’ve had this conversation more times than I can count. Someone from a cloud-native background sits down with me, we start talking about Agentix-Native Systems running across distributed devices, and within ten minutes they ask the same question: “Okay, but what orchestrates all of it?”

I get it. If you’ve spent a decade with Kubernetes, Step Functions, or Airflow, orchestration is distributed systems. You don’t have a separate word for it because you never needed one. Everything is orchestrated. The orchestrator is the air you breathe.

In an Agentix system, that assumption falls apart. Not philosophically. Physically. The control plane is too far away, the network is too unreliable, and the thing you’re trying to react to is happening in fifty milliseconds. So I find myself, over and over, having to untangle three words that the cloud world treats as one: orchestration, coordination, and choreography.

Let me make it concrete with a scenario I’ve used a lot lately.

Picture a city that deploys physical AI boxes at five hundred traffic intersections. Each box has cameras, a small NPU, and runs detection models: pedestrians stepping off curbs, cars veering into bike lanes, stalled vehicles, near-misses. Now follow what actually has to happen across that fleet.

The first thing

Rolling out a new model.

The city’s data team trains a better pedestrian detector. You want it on every box, but staged: ten percent first, watch the metrics, ramp up. That’s a workflow with a predefined shape, a central authority that owns the decision, and tolerable latency to that authority. Nobody’s life depends on the rollout finishing in fifty milliseconds.

That’s orchestration. It’s the right tool. Use it.

I want to be clear about that, because the temptation when you’re pushing back on cloud assumptions is to throw orchestration out entirely. Don’t. Orchestrate where orchestration earns its keep: deployments, lifecycle, the steps inside a single agent’s plan. That’s the conductor’s stand, and it has a job.

The second thing

Trust.

Box 247 at Main and Elm comes online after a hardware swap. Before any other box trusts what it says (“I just detected a near-miss”), every other box needs to know box 247 is who it claims to be, that its model is the approved version, that it’s authorized to publish incident events.

You can register it centrally, sure. But the agreement across the mesh (who’s online, what they’re running, who can be trusted) has to keep working when the central piece is unreachable. The boxes share that picture among themselves. They gossip identities. They check each other’s signed credentials directly.

That’s coordination. It’s the layer almost everyone overlooks, and it’s the one I find myself spending the most time defending in design reviews.

Coordination doesn’t drive behavior. It makes correct behavior possible.

Without it, your peers can’t act safely on their own. With it, they can.

The third thing

Actually reacting.

It’s Tuesday, 5:47 PM. Box 247 sees a delivery van veer into the bike lane. The detection fires.

If you tell me the box reports to a controller, the controller decides what to do, then sends commands downstream. I’ll tell you the cyclist is already in the intersection. Two to four hundred milliseconds of round trip is too slow. That path doesn’t exist for this kind of event.

What happens instead: box 247 publishes an event. “Incident, type X, location Y, confidence 0.92.” The two upstream boxes are subscribed to incidents in their geographic neighborhood. They receive it, run their own local logic, extend their red phase by four seconds to slow traffic into the area. The box at the next intersection downstream sees the same event and pulls forward its yellow. Nobody asked permission. Nobody waited for a controller.

That’s choreography. Event-driven, peer-to-peer, no conductor on the floor. The system-level behavior (a whole neighborhood reacting coherently to a near-miss) emerges from each box knowing its own part and reacting to cues.

This is the part that’s hardest to get cloud-native engineers to internalize. There is no central plan being executed here. There’s no one watching from above. And it still works. It works better, in fact, because there’s no controller to be a bottleneck, no controller to be a single point of failure, no controller to be unreachable when the network partitions.

The analogy

Strategy, operational art, tactics.

If you’ve ever read military doctrine, you’ve seen this pattern under different names. The three classical levels of war are strategy, operations, and tactics.

Strategy is theater-level. The general staff sets objectives, allocates resources, commits to a campaign. Centralized, deliberate, top-down. That’s orchestration.

Tactics is what a squad does when they round a corner and meet contact. No time to call the general. Each soldier knows their drill, reacts to what the soldier next to them does, and the firefight unfolds from the bottom up. That’s choreography.

Operational art sits in between: the level where logistics, intelligence, communications, and command-and-control are coordinated across the theater so that tactical actions add up to strategic objectives. Nobody on the operational staff fires a weapon. They make it possible for the units that do fire to act coherently. That’s coordination.

Strategy, operational art, tactics. Orchestration, coordination, choreography. Same shape, different vocabulary. And the same lesson:

The general cannot issue orders fast enough to win the firefight.

The recursion

Three modes, three layers.

Step inside a single box. It runs an inference loop: perception, decision, action. But that’s only the inner ring. Wrapped around it, the box is acting at three layers at once. There’s the infrastructure that hosts it on the device. There’s the agent or composed solution it’s executing. There’s the business outcome it ultimately serves. The three modes show up at each one.

Down at the infrastructure, the runtime that turns each device into a node, all three are already in play. Orchestration is the staged rollout of agents and model updates across nodes. Coordination is node identity, discovery, the signed credentials that keep the mesh’s picture consistent when the center is unreachable. Choreography is context driven communication between nodes, peer-to-peer reactions at machine speed, no controller in the loop.

One layer up, where agents compose into actual solutions, the same three show up again wearing different clothes. Orchestration is a single agent’s plan: deterministic, step by step. Coordination is agents discovering each other’s capabilities, agreeing on identity, agreeing on who is authorized to do what. Choreography is event-driven multi-agent behavior where no single agent is in charge and the outcome emerges from each agent reacting to its peers.

One layer up again, at the business outcome the operator actually cares about, the same three again. Orchestration is the supply chain step, the regulatory workflow, the customer journey. Coordination is cross-domain agreement, audit chain integrity, shared state across organizations. Choreography is ecosystem-level behavior where independent businesses react to each other’s events without anyone in the middle conducting.

And the pattern doesn’t stop at one node. Scale out to the fleet and the same three modes run across boxes. Scale further and you have a system of systems, the same three modes at every boundary you cross.

Cloud-native platforms ship orchestration well at every layer and pretend the other two modes don’t exist. An Agentix system has to ship all three, at every layer.

Closing

Three rooms.

The orchestrator’s stand for things with a predefined workflow and a central owner. The council chamber for things peers need to agree on. The dance floor for things that have to happen in real time across a mesh that may never have a stable center.

Every Agentix platform I’ve worked on (and every one I’m building now) needs all three. The mistake isn’t picking one. The mistake is letting cloud habits convince you the orchestrator is the only room in the building.

That’s why mimOE is built the way it is. We don’t pick one of the three. We give you a way to live in all three at once.