SPEAKER_1: Alright, last time we established that agentic infrastructure is essentially a workforce you architect, not a tool you prompt. So now I'm thinking — if you've got dozens of agents running in parallel, how do they actually talk to each other? SPEAKER_2: That's exactly the right next question. And the short answer is: very carefully, with standardized protocols — because without them, you don't have a workforce, you have a Tower of Babel. SPEAKER_1: The Babel problem. I like that framing. So what does that actually look like when it breaks down? SPEAKER_2: Imagine a compliance agent that outputs a JSON blob, a scheduling agent expecting Protobuf, and a reporting agent that only reads natural language summaries. None of them can reliably parse each other's outputs. You get dropped context, misrouted tasks, silent failures. In a hundred-agent swarm, that cascades fast. SPEAKER_1: So why can't agents just use natural language between themselves? They're language models — that's their native medium. SPEAKER_2: Natural language is expressive but deeply ambiguous. When an agent says 'handle this request,' does that mean execute, queue, delegate, or escalate? Structured protocols enforce intent through what are called message performatives — explicit labels like request, inform, or propose — so the receiving agent knows not just the content but the expected action. Ambiguity at that layer is a reliability tax you pay on every single message. SPEAKER_1: So schema enforcement is doing real work here, not just being pedantic about formatting. SPEAKER_2: Exactly. JSON contracts with enforced schemas give you clarity, interoperability, and a security surface you can audit. When every message conforms to a known structure, you can validate, log, and trace it. That's how you build trust in a system where no single human is watching every handoff. SPEAKER_1: Okay, so MCP was the first big move here — Anthropic open-sourced it in 2024. But what does it actually do at the protocol level? SPEAKER_2: MCP handles agent-tool integration and inter-agent communication. It uses Streamable HTTP, which means it supports both stateless request-response patterns and stateful sessions with persistent IDs. Agents declare their capabilities as tools with typed parameters, and there's a notification system so agents can dynamically discover new skills at runtime. Anthropic's February 2026 update — MCP 2.0 — added zero-knowledge capability proofs, so agents can negotiate what they can do without exposing sensitive implementation details. SPEAKER_1: AWS joined the MCP steering committee in early 2026. What does that signal? SPEAKER_2: It signals that MCP is becoming infrastructure, not just a framework choice. When a cloud hyperscaler joins the governance body, they're betting that this standard will underpin enterprise deployments at scale. AWS even ran a collision experiment — a hundred-agent swarm coordinating a simulated disaster response — and hit a ninety-five percent task success rate. That's a proof point, not a demo. SPEAKER_1: Then Google introduced A2A. How is that different from MCP — are they competing or complementary? SPEAKER_2: Complementary, by design. MCP connects agents to tools. A2A connects agents to agents — specifically across organizational boundaries. It's built on HTTP, SSE, and JSON-RPC, so it integrates cleanly with existing IT stacks. It supports shared task management and what Google calls user experience negotiation, where agents agree on how to present results. In March 2026, Google added native WebSocket support to A2A, cutting latency by forty percent in multi-agent simulations. SPEAKER_1: There's also something in A2A's metadata about emotion tagging — I wasn't sure if that was serious. SPEAKER_2: It's real, and it's subtle. Piloted in December 2025, it embeds sentiment signals in message metadata so agents in negotiation workflows can calibrate tone — less adversarial framing, more cooperative framing. Early results showed a twenty-seven percent improvement in negotiation outcomes. It sounds soft, but in multi-agent procurement or contract workflows, that matters. SPEAKER_1: And then there's ACP — the Agent Communication Protocol. Where does that fit? SPEAKER_2: ACP is the open standard under Linux Foundation governance, originally from IBM's BeeAI project. It uses a three-role architecture — agent client, agent server, and registry — and it's built for asynchronous interactions and offline discovery. The ACP registry hit ten thousand registered agents by January 2026, making it the largest open agent network in existence. Critically, ACP doesn't manage workflows or deployments — it standardizes discovery, invocation, and interaction. Think of it as the directory layer. SPEAKER_1: So how does someone actually sequence these? MCP, ACP, A2A — that's a lot of acronyms for one architecture. SPEAKER_2: There's a phased roadmap that's emerged. Start with MCP for tool access — that's your foundation. Layer in ACP for multimodal agent-to-agent communication and discovery. Add A2A when you need cross-organizational collaboration. And for decentralized agent marketplaces, there's ANP — the Agent Network Protocol — as the most advanced interoperability layer. Akka specifically recommends wrapping A2A and ACP calls inside workflow orchestration to handle retries and sequencing reliably. SPEAKER_1: What about security across all of this? If agents are talking to agents across org boundaries, that's a significant attack surface. SPEAKER_2: Every major protocol addresses this differently but consistently. MCP 2.0 has zero-knowledge proofs. ACP has permission controls, sandboxing, and message tracing. A2A inherits enterprise security from its HTTP/JSON-RPC foundation. The principle is the same across all of them: every message should be attributable, every capability should be declared, and every interaction should be auditable. Security isn't bolted on — it's in the protocol spec. SPEAKER_1: So for Suri and everyone working through this course, what's the one thing to hold onto from this lecture? SPEAKER_2: Effective collaboration between agents doesn't happen because the models are smart — it happens because the infrastructure enforces a shared language. Standardized protocols for message passing, intent signaling, and structured data exchange are what transform a collection of capable agents into a system that actually works. Without that layer, every integration is a custom negotiation, and custom negotiations don't scale.