Build a Multi-Agent System with ADK, MCP, and Gemini

Key Concepts

• MCP (Model Context Protocol): A standard for decoupling tools from agents, allowing agents to discover and use external resources without hardcoding.
• ADK (Agent Development Kit): A framework for implementing specific agent architectures (Sequential, Parallel, Loop).
• A2A (Agent-to-Agent) Protocol: A communication standard that turns local agents into discoverable, network-addressable microservices.
• Interceptor Pattern: A governance mechanism using callbacks and plugins to enforce business rules (e.g., rate limits, cooldowns) without modifying core agent logic.
• Hierarchical Routing: A strategy where a "Summoner" (orchestrator) agent dynamically routes tasks to specialized "Familiar" agents.

1. Decoupled Tooling Ecosystem (MCP)

To avoid the "monolithic agent" trap, the system separates tools from agents using MCP servers.

• Imperative Pattern: Used for external APIs and complex logic. It involves wrapping functions in MCP decorators, allowing agents to list and call tools dynamically. This is ideal for legacy systems or third-party integrations.
• Declarative Pattern: Used for database connectivity (e.g., Cloud SQL). By using a YAML configuration file, developers define data sources and SQL queries without writing connection code.
• Benefits: Decoupling allows teams to update APIs or database schemas independently of the agent logic, promoting reusability and parallel development.

2. Specialized Agent Architectures (ADK)

Instead of one LLM handling all tasks, the system uses specialized "Familiars" with distinct workflows:

• Sequential Agent (Fire Familiar): Executes tasks in a linear dependency chain (Output of A becomes Input of B). Used for precision.
• Parallel Agent (Water Familiar): Uses a "fan-out/fan-in" pattern to execute multiple tasks simultaneously, followed by a "power merger" agent to synthesize results. Used for speed.
• Loop Agent (Earth Familiar): Iterates tasks until a specific condition is met or a maximum count is reached. Used for persistence.

3. Orchestration and Service Discovery (A2A)

The "Summoner" agent acts as a strategist, routing tasks to specialized agents.

• Agent Cards: Each agent acts as a microservice with an "Agent Card"—a metadata file describing its name, capabilities, and endpoint URL.
• Service Discovery: The Summoner performs an HTTP GET request to the agent’s URL to read the card. This allows the Summoner to register remote agents as available tools dynamically, meaning the Summoner does not need to be redeployed when a Familiar’s internal logic changes.

4. Governance as Code

To ensure system stability and cost-efficiency, the architecture enforces rules via the Interceptor Pattern:

• Callbacks: Function-level hooks attached to a single agent (e.g., a cooldown check before an agent executes).
• Plugins: Global classes attached to the ADK runtime that intercept requests across all agents. This is the preferred method for enforcing system-wide rules like rate limits or cooldowns (e.g., preventing an agent from being called twice within 60 seconds).

5. Memory and State Management

To prevent redundant actions, the Summoner agent is given "short-term state":

• Mechanism: An after_tool_callback updates a session state (a "sticky note") every time a tool is executed.
• Application: The Summoner’s system prompt is updated to reference this state, ensuring it does not summon the same familiar twice in a row, thereby optimizing resource usage and logic flow.

Synthesis and Conclusion

The transition from a single-agent chatbot to a distributed multi-agent ecosystem requires a shift in architectural thinking. By utilizing MCP for decoupled tools, ADK for specialized workflows, and the A2A protocol for service discovery, developers can build resilient, scalable systems. Governance is maintained not through manual oversight, but through interceptors (callbacks/plugins) and stateful orchestration, ensuring that the system remains performant, cost-effective, and maintainable in a production environment.

"As an architect, you take individual features and design ecosystems."