Why do LLM agents struggle with protocol discipline in distributed settings?
This explores why LLM agents have trouble reliably following the rules of structured interaction — turn-taking, message formats, role boundaries, agreement procedures — once they're spread across multiple agents and a network, rather than running as a single model.
This explores why LLM agents have trouble reliably following the rules of structured interaction — turn-taking, message formats, role boundaries, agreement procedures — once they're spread across multiple agents and a network. The short version the corpus keeps circling back to: protocol discipline isn't a thing models *have*, it's a thing that has to be built *around* them. Left to maintain it themselves, agents drift.
The most concrete diagnosis is that the failures aren't about agents being wrong, they're about agents being late or losing the thread. When LLM groups try to reach agreement, they mostly fail through *liveness loss* — timeouts and conversations that never converge — rather than through corrupting the actual value being agreed on Can LLM agent groups reliably reach consensus together?. The same pattern shows up at the coordination level: agents fail either by agreeing too late or by quietly adopting a strategy without telling their neighbors, and these breakdowns get predictably worse as the network grows Why do multi-agent systems fail to coordinate at scale?. Distribution doesn't introduce a new failure so much as it stretches the gaps where an agent's discipline was already thin.
Why is the discipline thin in the first place? Because LLMs don't hold a stable sense of *who they are* or *what they're doing* across many turns. One study names four recurring breakdowns — role flipping, flaky replies, infinite loops, and conversation deviation — and ties them directly to the lack of persistent goal representation and stable role identity Why do autonomous LLM agents fail in predictable ways?. A protocol is exactly a promise to keep playing a fixed role under fixed rules over time, which is the thing these models are worst at sustaining unaided. There's a quieter version of the same problem too: agents tend to *accept neighbors' information without verifying it* Why do multi-agent systems fail to coordinate at scale?, and they skip the grounding work of reasoning about what other agents *don't* know — which is invisible when one model puppets everyone but breaks badly the moment information is genuinely private Why do LLMs fail when simulating agents with private information?.
The interesting turn is what fixes it. Reliability, it turns out, doesn't come from a bigger model — it comes from *externalizing* the cognitive burdens of memory, skills, and protocols into a harness layer so the model doesn't have to re-solve them on every call Where does agent reliability actually come from?. Protocol discipline is explicitly one of the three things that should live in the harness, not the head. You can see practitioners arriving at the same conclusion from the production side: protocol-mediated tool access (MCP) caused non-deterministic failures through ambiguous selection and parameter guessing, and teams restored reliability by replacing it with explicit direct function calls and one-tool-per-agent designs Why do protocol-based tool integrations fail in production workflows?. The deeper principle is that an explicit algorithm wrapped around the LLM — hiding irrelevant context and managing control flow — turns fragile open-ended interaction into debuggable, step-scoped calls Can algorithms control LLM reasoning better than LLMs alone?.
So the surprise for a curious reader is this: the answer to "why can't agents follow protocols" is partly "stop asking them to." The winning move isn't training models to be more disciplined negotiators — it's building scaffolding that *carries* the protocol, and even composing existing protocols under a shared substrate rather than asking each agent to reinvent coordination from scratch Should coordination protocols wrap existing systems or replace them?. Discipline becomes a property of the system, not a virtue of the model.
Sources 8 notes
Across hundreds of simulations, LLM-agent groups frequently fail to reach valid agreement due to timeouts and stalled convergence rather than subtle value corruption. Agreement degrades with group size even without Byzantine agents present.
AgentsNet benchmark shows agents fail to coordinate strategies either by agreeing too late or adopting strategies without informing neighbors. Agents accept neighbor information without verification, enabling error propagation while remaining capable of detecting direct conflicts.
Research identifies role flipping, flake replies, infinite loops, and conversation deviation as LLM-specific failures in multi-agent cooperation. These occur because LLMs lack persistent goal representation and stable role identity.
Research shows LLMs perform well when one model controls all interlocutors but fail systematically when agents possess private information. This reveals that apparent social competence relies on grounding work that models skip in omniscient settings.
Research shows reliable LLM agents externalize three cognitive burdens—memory (state persistence), skills (procedural components), and protocols (structured interaction)—into a harness layer rather than relying on model scale alone. The harness unifies these externalities and eliminates the need for the model to solve the same problems repeatedly.
MCP integration caused non-deterministic failures through ambiguous tool selection and parameter inference. Replacing it with explicit direct function calls and single-tool-per-agent design restored determinism. A 306-practitioner survey confirms 85% of production teams build custom agents, forgoing frameworks.
LLM Programs embed LLMs within explicit algorithms that manage control flow and state, presenting only step-specific context to each LLM call. This information hiding addresses capability and context window limits while treating complex reasoning as modular, debuggable sub-tasks.
Research shows that agent coordination standards achieve adoption by composing existing protocols like MCP and DIDComm under a shared substrate, rather than competing to replace them. Bridging lets value accrue incrementally without forcing ecosystem-wide rewrites.