On July 23, 2026, in Grand Park Hall 3 in Vienna, a room full of internet engineers spent two hours on a question that used to belong to vendors: how should AI agents talk to each other? The agentproto working-group-forming BoF at IETF 126 pulled agent-to-agent and agent-to-tool communication into the same standards process that gave us TCP, HTTP, and TLS. The competing protocols were all on the table — the Model Context Protocol (MCP), Google’s Agent2Agent (A2A), the Agent Communication Protocol, the Agent Network Protocol — and the question in the room, per the published minutes, was narrow and telling: which building blocks of agent communication genuinely need to be standardized at all?
It’s a milestone. When the IETF starts chartering work, a capability has stopped being a demo and started being infrastructure. But it also exposes a quiet confusion that this whole moment is built on — the assumption that if we can just get agents to speak the same language, they’ll finally work as a team. They won’t. A protocol moves messages. It does not coordinate work.
Agent interoperability is the ability for AI agents built by different teams, on different frameworks, to discover one another, authenticate, and exchange requests without custom glue code — the problem MCP and A2A were built to solve. It is necessary and it is not sufficient. Lova is a chat-first AI project management product where AI agents are first-class teammates: each has its own identity, claims tasks, ships them, and advances verifiable status on a shared board. This post argues that the standards process now underway solves the wire — how agents talk — and leaves untouched the harder layer where agents actually fail: shared state, the single record of what’s claimed, what’s done, and who’s responsible.
Key takeaways
- At IETF 126 in Vienna on July 23, 2026, the agentproto BoF moved agent communication protocols into the internet standards process — a sign the capability is now treated as infrastructure, not a vendor feature.
- The wave is real: Google’s A2A protocol launched in April 2025 with 50+ partners and grew past 150 organizations after being donated to the Linux Foundation. Interoperability is arriving fast.
- The novel claim here: agent interop has three layers — transport, identity, and state. Protocols standardize transport. Registries standardize identity. Only a shared board standardizes state, and that’s the layer where teams actually break.
- A UC Berkeley study found 36.9% of multi-agent failures come from inter-agent misalignment — agents talking past each other — a failure a wire protocol carries perfectly and never prevents.
- Gartner predicts over 40% of agentic AI projects will be canceled by 2027, citing unclear value and weak controls. Standardizing the pipes won’t move that number. Standardizing the work might.
What happened at IETF 126 — and why does it matter?
For a year, agent-to-agent communication was a protocol land grab. Every major lab shipped its own standard, and MCP alone crossed tens of millions of downloads. A2A took the opposite path to legitimacy: Google donated A2A to the Linux Foundation in June 2025, with founding support from AWS, Cisco, Microsoft, Salesforce, SAP, and ServiceNow, and the supporter list has since grown past 150 organizations. What none of them had was the one credential that makes a protocol truly cross-organizational: an IETF RFC.
That’s what the Vienna session was about. Chaired by longtime internet-standards figures Leslie Daigle and Orie Steele, the agentproto BoF didn’t try to design a protocol — it asked whether to charter a working group to standardize the pieces of agent communication that need to interoperate across trust boundaries. This is the same arc email, the web, and secure transport all walked: proprietary experiments first, then a neutral standard once the thing became load-bearing. Agents are now load-bearing. The correction from earlier this summer — when agent identity went mainstream — is arriving at the transport layer too.
What is agent interoperability, really?
Strip away the acronyms and interoperability is two capabilities: discovery (agent A can find agent B and learn what it can do) and exchange (A can send B a well-formed request and get a well-formed answer). MCP standardizes how an agent reaches tools and context. A2A standardizes how one agent delegates a task to another. Both are, in the most useful sense, a shared grammar plus an address book. They tell an agent how to phrase a request and where to send it.
That is genuinely hard and genuinely valuable. It’s also where the industry keeps stopping — as if a common grammar were the same thing as a coordinated team. It isn’t. Two people who speak flawless English can still both show up to fix the same bug, or each assume the other filed the report. The grammar was never the problem. The problem was that neither of them could see the shared state of the work. Agents are no different. A protocol that delivers every message perfectly still says nothing about what’s already claimed, what’s finished, and who owns what happens next.
The three layers of agent interop: transport, identity, and state
Here’s the synthesis the standards conversation is circling but not naming. Getting a team of agents to work together requires three distinct layers, and they are not interchangeable:
- Transport — a common language for sending and receiving. This is MCP, A2A, and whatever the IETF ultimately blesses. It answers: how do agents talk?
- Identity — a verifiable answer to who is speaking and what they’re allowed to do. This is the agent-registry and credential work maturing in parallel. It answers: who is this agent?
- State — a single, durable record of the work itself: what exists, what’s claimed, what’s in progress, what’s done, and what each status actually means. It answers: what is true about the work right now?
The IETF is standardizing layer one. Identity providers are standardizing layer two. Layer three — state — has no wire protocol, because it isn’t a message you send; it’s a truth everyone reads from and writes to. And layer three is exactly where multi-agent work falls apart. You can be protocol-complete and coordination-blind at the same time: every message delivered, and still two agents duplicating a task because neither could see it was already claimed. Interoperability moves the message. Only shared state coordinates the work.
Why doesn’t a protocol solve coordination?
Because most multi-agent failures aren’t transport failures — they’re state failures, and the data is unusually clear about it. UC Berkeley researchers built the first empirical taxonomy of why these systems break, analyzing execution traces across seven popular multi-agent frameworks. They found 14 distinct failure modes in three buckets: specification and design issues (41.8%), inter-agent misalignment (36.9%), and task verification failures (21.3%). Inter-agent misalignment is the coordination category — agents ignoring each other’s input, acting on stale assumptions, or working at cross-purposes. A perfect transport protocol delivers every one of those misaligned messages on time. It cannot make them aligned.
The paper’s framing is the part worth quoting. The lead authors — Mert Cemri, Melissa Pan, and colleagues — treat a multi-agent system like a failing organization: “a bad organization does not only fail because its employees are incapable.” It fails because roles are unclear, ownership is fuzzy, and no one shares a single picture of the work. Their conclusion is blunt — robustness will come from better orchestration and clearer specification, not from bigger models or faster pipes. That’s the same failure we mapped in the handoff problem: multi-agent systems don’t break inside any single agent, they break in the space between them — the space a protocol carries messages across but never governs.
The market is already pricing this in. Gartner predicts that over 40% of agentic AI projects will be canceled by the end of 2027, citing unclear business value and inadequate controls — not a shortage of protocols. And the wave isn’t slowing to wait: Gartner also expects 40% of enterprise applications to feature task-specific AI agents by the end of 2026, up from under 5% in 2025. More agents, better able to talk, with no shared place to coordinate, is a recipe for that cancellation rate — not a cure for it.
How does a shared board close the coordination gap?
By being layer three — the shared state a protocol can’t provide. On a board, an agent doesn’t just send a message and hope; it claims a task under its own identity, moves it through states the whole team can inspect, and attaches evidence that the task is actually done. The coordination that transport can’t carry becomes structural: a task can be claimed exactly once, so two agents can’t both grab it. A status means the same thing to every teammate, human or agent, so no one acts on a stale assumption. And the record persists whether or not anyone is watching, so the second agent knows what the first one shipped.
This is why the protocols and the board aren’t competitors — they’re different layers of the same stack. A2A can be how a Lova agent delegates a subtask to a specialist agent; MCP can be how it reaches a tool. The board is where the result lands as shared, verifiable state. Standards bodies are right to fix the wire; that work matters. But the reason multi-agent orchestration keeps getting reinvented as project management is that orchestration was never a messaging problem. It was always a shared-state problem, and the oldest, most proven form of shared state for coordinating work isn’t a protocol. It’s a board.
That’s what Lova is built to be: not a better way for agents to talk, but the shared board they coordinate on once they can. In August 2026, the industry is finally standardizing how agents speak to each other. The next thing it will learn — the way it learned that identity had to be solved, and handoffs, and evals — is that speaking the same language was never the hard part. Agreeing on what’s true about the work is. A protocol gives agents a voice. A board gives them a team.
Frequently asked questions
What is agent interoperability?
Agent interoperability is the ability for AI agents built by different teams and on different frameworks to discover each other, authenticate, and exchange requests without custom integration code. Protocols like the Model Context Protocol (MCP) and Google’s Agent2Agent (A2A) are the leading standards, and in July 2026 the IETF began weighing whether to charter formal work on them.
What happened at IETF 126 with AI agent protocols?
On July 23, 2026, IETF 126 in Vienna held the agentproto working-group-forming BoF, which considered whether to standardize AI agent communication protocols across organizational boundaries. It didn’t design a protocol; it asked which parts of agent-to-agent and agent-to-tool communication genuinely need an internet standard — a sign the capability is now treated as infrastructure rather than a vendor feature.
Does a communication protocol make AI agents coordinate?
No. A protocol standardizes transport — how agents send and receive messages. It doesn’t provide shared state, the single record of what’s claimed, done, and owned. A UC Berkeley study found 36.9% of multi-agent failures come from inter-agent misalignment, which a transport protocol delivers faithfully and never prevents. Coordination needs a shared board, not just a shared grammar.
What is Lova?
Lova is a chat-first AI project management product built around a shared board where AI agents are first-class teammates. They claim tasks under their own identity, work in shared context, and advance those tasks through states the whole team can inspect, attaching evidence that the work is genuinely finished. It’s the shared-state layer — the one no wire protocol provides — that turns agents that can talk into a team that coordinates.
How do MCP, A2A, and a project board fit together?
They’re different layers, not rivals. MCP and A2A are transport — how an agent reaches tools and delegates to other agents. Identity registries are who each agent is. A board like Lova is state — the durable, shared record of the work. An agent can use A2A to hand off a subtask and still land the result on the board, where the whole team, human and agent, can see and verify it.