Multi-Agent Systems Coordinate. They Don't Execute.

Two agents agreed on the plan. Nothing happened.

This failure shows up constantly in multi-agent setups. A planner agent decides what to do and hands off to an executor agent. The handoff is clean. The messages validate against the schema. Every log reads green. Then the write never lands in the system of record.

The reason usually isn’t the model. It’s the seam between deciding and doing. The executor had the wrong scope, or a stale token, or the action half-completed and no one noticed.

The failures cluster at the seams

When researchers looked at more than 1,600 production agent traces, the single largest category of failure wasn’t reasoning. It was inter-agent coordination and handoffs: 37% of all failures. The model picked the right action. The system around it dropped the ball moving that action from one agent to the next and out into a real tool.

Zoom out and the picture holds. Studies of multi-agent systems in production put the failure rate somewhere between 41% and 87%, depending on the task and how you count.

Part of this is arithmetic. Chain ten steps together, each 95% reliable on its own, and you land around 60% end to end. Errors compound down a chain. They don’t cancel out.

Add more agents and the chain gets longer, not shorter. Every new step is another chance for the number to drop.

Coordination is getting standardized. Execution isn’t.

The industry is moving fast on the coordination problem. A2A, the agent-to-agent protocol Google donated to the Linux Foundation, crossed 150 organizations at its one-year mark, with Microsoft, AWS, Salesforce, Workday, ServiceNow, and SAP all backing it. We built StackOne’s own agent on that A2A, ADK, and Gemini stack, and a maturing coordination layer is a real step forward.

A shared protocol for how agents talk to each other is real progress. But a coordination standard says nothing about whether the final action is allowed, correctly scoped, and logged. Two agents can negotiate a flawless plan over A2A and still fail the moment one of them tries to write to Workday.

That gap on the right side of the diagram is where the 37% lives. The talking part worked. The acting part didn’t.

The last mile is where governance actually lives

Every one of those silent failures is a governance problem wearing a reliability costume.

Wrong scope means an agent could touch records it should never see, or act under an identity that isn’t really its own. A stale token means the action fails, or retries against the wrong account. A half-completed write means your system of record and your agent’s memory now disagree, and nothing flagged it.

“Every log looks green” is the trap. Approval prompts and other human-in-the-loop checks give the same false comfort: they look like control without being control. A reviewer clicking approve on the fortieth routine request isn’t governing anything, and neither is a green log line that only confirms the message was well-formed.

Real control sits at the point of action: is this specific agent allowed to run this specific write, right now, against this specific account, and did it complete?

More agents multiply the surface

Adding agents doesn’t shrink this problem. It multiplies it. Every agent in the mesh is another identity that needs the right scope, another token that can go stale, another handoff that can drop an action on the floor. The coordination graph grows, and so does the number of places a real write can quietly fail.

This is why “we standardized how our agents communicate” and “our agents reliably do things in production” are two different sentences. The first is close to solved. The second is the work.

Where StackOne fits

That second sentence is the layer we spend our time on at StackOne. Not the conversation between agents, the governed action at the end of it.

When an agent decides to update a record in Salesforce, ServiceNow, or Workday, that action runs through one place. It’s scoped to that single agent, permission-checked in under a millisecond, and logged for whoever owns the rollout. The same rules apply across 430+ connectors and 26,000+ actions, so a decision made in an A2A conversation actually lands in the system of record, with an audit trail your security team will accept.

Coordination matters. But a coordination standard and an execution guarantee are different things, and most teams only have the first one.

What this means if you run agents in production

An agent chain is only as reliable as its worst handoff into a real system. If you own an agent rollout, the coordination between agents is the part the whole industry is standardizing for you. The action at the end is the part you still have to answer for: who is allowed to do what, whether it happened, and how you’d prove it later.

If you want to see what governed execution looks like in practice, the StackOne docs walk through how each action is scoped, checked, and logged per agent.