Build a multi-agent system: A2A & Agent Registry

Key Concepts

• A2A (Agent-to-Agent) Protocol: A standardized communication protocol for AI agents, analogous to HTTP for web services, allowing agents to discover, hand off tasks, and stream results regardless of the underlying framework (e.g., ADK, LangChain, CrewAI).
• Agent Registry: A centralized management system for agents, MCP (Model Context Protocol) servers, and endpoints, designed to solve fragmentation and sprawl in multi-agent architectures.
• Agent Card: A JSON-based "business card" or profile for an agent that defines its identity, capabilities (skills), and connection URI.
• MCP (Model Context Protocol): A standard for connecting AI assistants to systems, data, and tools.
• Loose Coupling: An architectural benefit of A2A where agents can be updated or redeployed independently without requiring a full system rewrite.

---

1. The Problem: Fragmentation and Sprawl

In complex AI systems, agents are often scattered across cloud environments and on-premise servers. This leads to:

• Tight Coupling: Hardcoding URLs and custom authentication makes systems difficult to maintain or scale.
• Management Overhead: Difficulty in tracking agent ownership, capabilities, and discovery.
• Plumbing Complexity: Manual effort required to connect disparate agents and tools.

2. A2A Protocol: The "HTTP for AI"

A2A enables interoperability. Instead of custom glue code, agents use the A2A protocol to:

• Discover: Read an agent_card.json to understand another agent's skills and connection requirements.
• Communicate: Support both Synchronous (request-response) and Asynchronous (polling or Server-Sent Events/SSE) communication modes.
• Decouple: By using a standard protocol, developers can update a single agent without redeploying the entire multi-agent system.

3. Agent Registry: Centralized Governance

The Agent Registry acts as a "phone book" for an organization's AI assets.

• Reusability: Instead of nesting agents as sub-agents, they are registered once and can be invoked by any orchestrator.
• Standardization: It provides a unified way to connect to various resources (Agents, MCP servers, endpoints).
• Governance & Audit: Offers centralized logging, compliance monitoring, and risk management.
• Flexibility: Supports both first-party (ADK) and third-party agents (LangGraph, CrewAI) regardless of where they are hosted.

4. Step-by-Step Implementation Framework

1. Define the Agent: Create the agent logic (e.g., a "Dog Walker" agent using Gemini 1.5 Flash).
2. Wrap for A2A: Use the to_A2A library to expose the agent. If no custom card is provided, the system generates a default one.
3. Register: Use gcloud commands or the Cloud Console to add the agent to the Registry.
4. Discovery: The orchestrator agent uses the Registry’s MCP server to search for agents based on tags or skill descriptions.
5. Execution: The orchestrator retrieves the dynamic URI from the registry and invokes the remote agent via the A2A protocol.

5. Real-World Application: The Multi-Agent Trip Planner

The video demonstrates a "Trip Planner" agent that coordinates with a "Dog Walker" agent:

• Scenario: A user wants to plan a trip to Kyoto while ensuring their dog (Bobby) is cared for.
• Process:
  • The Trip Planner queries the Agent Registry to find the Dog Walker agent.
  • The Registry returns the Dog Walker's metadata.
  • The Trip Planner calls the Dog Walker agent via A2A to get a pet care routine.
  • The final output combines travel logistics with the pet care plan.

6. Notable Quotes

• "A2A is like HTTP, but for AI agents... it doesn't matter if you're building with Google ADK, LangChain, or CrewAI; if they speak A2A, they can discover each other." — Annie
• "Agent registry is like a yellow book or a phone book... it's a place that puts together all the necessary useful things." — Annie

7. Synthesis and Conclusion

Building production-ready multi-agent systems requires moving away from hardcoded, local dependencies toward a service-oriented architecture. By combining the A2A protocol for standardized communication and the Agent Registry for centralized discovery and governance, developers can create scalable, maintainable, and secure AI ecosystems. The transition from hardcoded URLs to dynamic registry lookups is the critical step in evolving from simple prototypes to robust, enterprise-grade multi-agent applications.