If a protocol forgets everything between messages, who ends up keeping track of what's been asked and finished?

This explores why protocols that keep no memory between messages leave the bookkeeping of coordination to whoever builds on top of them. The corpus's clearest answer is a direct comparison: MCP supports most coordination needs with a lightweight design, but it hands conversational state and task lifecycle to application code, while A2A builds explicit support for those stateful interactions into the protocol itself (Does MCP handle multi-turn agent coordination without application code?). Coordination needs memory: who asked for what, what's still pending, what already finished. If the protocol doesn't hold that memory, something else has to.

The cost doesn't vanish, and the corpus suggests the shift is a trade. Agent protocols face a trilemma in which rigid-schema designs like MCP buy efficiency and portability but give up versatility, and no protocol gets all three (Can agent protocols be efficient, versatile, and portable simultaneously?). My reading is that leaving state out is part of what keeps such a protocol simple and portable, though the note doesn't say this outright. Simplicity at the protocol layer moves the hard part upward. Statelessness can be a real virtue elsewhere: Atom of Thoughts makes each reasoning step depend only on the current problem, not on prior steps, and loses nothing (Can reasoning systems forget history without losing coherence?). That works because the problem is decomposed so nothing needed is left behind. Coordination between agents rarely has that property.

The corpus shows this cost in two places. Per-action checks structurally cannot state a rule that depends on history, so preventing individually fine actions from adding up to a system-level violation needs a stateful monitor that someone has to build (Can stateless checks ever catch sequence-level constraint violations?). In production, one team found that MCP integration caused non-deterministic failures through ambiguous tool selection and parameter inference. They replaced it with explicit direct function calls, and a survey of 306 practitioners found 85% of production teams build custom agents rather than use frameworks (Why do protocol-based tool integrations fail in production workflows?). That failure is about ambiguity rather than state, but the pattern is similar: when the protocol leaves things open, teams close them in their own code.

When nobody builds the missing state, it can appear anyway. Short-lived agents turned a shared package repository into persistent memory by writing findings there for later agents to read, and a public wiki served the same purpose in a second case (Can ordinary infrastructure become unplanned agent memory?, Can agents repurpose ordinary infrastructure for unintended communication?). Where agents share a KV cache, reasoning models coordinate spontaneously by planning and spotting redundancy (Can multiple LLMs coordinate without explicit collaboration rules?). Without shared state, coordination at scale degrades in predictable ways. Agents agree too late, or adopt a strategy without telling their neighbors, or accept neighbors' information without checking it (Why do multi-agent systems fail to coordinate at scale?).

The practical response in the corpus is to add a coordination layer rather than fix the base protocol. Coordination standards gain adoption by wrapping and bridging existing protocols like MCP, so the state-holding part lives in a shared substrate above them (Should coordination protocols wrap existing systems or replace them?). The corpus doesn't offer a general theory of statelessness. Its direct evidence is the MCP-versus-A2A contrast, and the broader pattern comes from combining the notes above.