Building AI agents that speak to each other

Key Concepts

• Agent-to-Agent Protocol (ATA): A standardization method for AI agent communication, enabling interoperability regardless of underlying implementation language.
• agent.json: A standardized “ID card” file served by each ATA agent, defining its input and output schemas.
• Orchestrator Agent: A central agent responsible for managing workflow and maintaining state in a multi-agent system.
• State Management: The practice of the orchestrator agent holding all critical data (the “clipboard”) to ensure resilience against worker agent failures.
• ADK Patterns (Sequential, Loop): Predefined workflows within the ADK framework for organizing agent tasks.

The Problem of AI Agent Integration

The video begins by highlighting the difficulties inherent in integrating AI agents built using different technologies. The analogy of incompatible travel plugs illustrates the core issue: agents developed in Python and Node.js, for example, often possess differing API schemas and communication mechanisms. This necessitates significant “glue code” – code solely dedicated to translation and interoperability – diverting development effort from core AI logic. The speaker emphasizes that this situation is inefficient and creates a messy, complex system.

Introducing the Agent-to-Agent Protocol (ATA)

To address this integration challenge, the video introduces the Agent-to-Agent Protocol (ATA). ATA is presented not as a complex technology, but as a simple standardization method. The core principle is that each agent exposes a standardized “ID card” located at a well-known endpoint: /.well-known/agent.json. This file functions as a “dating profile” for the agent, detailing its capabilities.

The agent.json file is crucial as it defines a contract between agents. Specifically, it outlines the input schema – the arguments the agent accepts – and the output schema – the data the agent guarantees to return. This is explicitly compared to the OpenAPI specification (Swagger), but tailored specifically for agentic interactions. The speaker stresses that this decoupling allows for independent development and deployment of agents.

Decoupling and Microservices for AI

The benefits of ATA are framed in terms of decoupling. An orchestrator agent, responsible for coordinating tasks, no longer needs to directly import or understand the internal code of individual worker agents (like a researcher or content builder). It only requires the agent’s URL. This enables a flexible architecture where different agents can utilize varying levels of computational resources – a fast, cheap model for research and a powerful, expensive model for reasoning – without impacting the overall system.

Furthermore, the speaker points out that an agent’s underlying implementation can be changed (e.g., rewriting a Python agent in Go) without disrupting the rest of the system, as long as the agent.json interface remains consistent. This is described as “true microservice architecture but for AI.”

Orchestration and State Management

Having established a common communication language (ATA), the video shifts focus to orchestration – the process of directing agents to perform tasks. The orchestrator agent is presented as a “project manager” with a “master clipboard” representing the system’s state.

Crucially, the worker agents (e.g., researcher, judge) are described as “forgetful” – they do not retain state. They simply execute instructions from the orchestrator based on the current state presented on the clipboard and then relinquish control. This design is intentional: if a worker agent crashes, it doesn’t lose critical data because it never possessed it in the first place. The orchestrator maintains the authoritative record of the workflow.

Utilizing ADK Patterns

The video highlights that the ADK (Agent Development Kit) provides tools to manage this clipboard effectively. Specifically, it mentions two standard patterns:

• Sequential: Executes tasks in a linear order (step A, then step B).
• Loop: Repeatedly executes a task until a specified condition is met.

The speaker emphasizes the importance of defining the “clipboard” – the data that needs to be tracked – before writing any code. In the example presented, the clipboard contains research findings and judge feedback.

Recap and Future Steps

The video concludes with a recap of the key takeaways: the orchestrator must hold the state, ADK patterns facilitate workflow organization, and careful definition of the clipboard data is essential. The speaker announces that the next video will focus on building the orchestrator agent itself, laying the foundation for a functional multi-agent system.

Notable Quote:

“It's not magic. It's just a standard.” – Regarding the Agent-to-Agent Protocol (ATA).