
Connecting agents to tools and to peer agents on Google Cloud involves three distinct mechanisms: MCP, A2A, and local sub-agents inside an ADK application. MCP connects an agent to its own tools and data. A2A connects independent agents that collaborate across team, application, or company boundaries. A local sub-agent runs inside the same ADK process as its caller when one team owns tightly coupled agents. Separating these three boundaries is a recurring theme on the Professional Agentic Architect exam, because putting a capability behind the wrong mechanism either cuts off shared callers or adds unnecessary network and serialization overhead.
The clearest way to choose among these options is to ask who owns the capability and who else needs to call it. Those two answers determine whether a network boundary is necessary or counterproductive. Turning a shared agent into a local sub-agent takes it away from its other callers and from the team that owns it. Keeping an agent behind A2A when no other application calls it adds latency without serving any shared consumer. Wrapping another team's agent as MCP tools changes its integration model and treats a peer agent as a toolbox.
MCP is the protocol for connecting agents to tools and data. It fits straightforward lookups and writes against databases or APIs where no reasoning or multi-step conversation occurs. When several agents need the same capabilities, building a single MCP server that each agent connects to lets every agent reuse the same tools. Credentials stay in one place, and updates to the underlying database or API happen in one place as well.
Other approaches create avoidable downsides for plain tool work. Copying client code and credentials directly into every agent spreads secrets across deployments and multiplies maintenance. Wrapping simple lookups or writes in separate ADK agents adds a reasoning layer and extra network hops to work that involves no reasoning, and A2A is meant for agents collaborating on tasks rather than basic tool calls. Gemini Enterprise solves a different need as well, because it makes agents available to an organization's employees rather than letting other agents call capabilities as tools.
A2A is designed for collaboration between independent agents that may not disclose their internal models, tools, or code. It models work as tasks that can run for hours while the calling agent tracks status and receives the final result. Other integration models break down across organizational boundaries: MCP would require the other party to expose private tools, a local sub-agent would require access to their code, and calling a model endpoint directly would skip their agent logic altogether.
To let other agents inspect what an A2A agent offers before sending a task, the agent serves an Agent Card at /.well-known/agent-card.json on its domain. The Agent Card is A2A's discovery document. It describes how to reach the agent, its skills and capabilities, the interfaces it supports with their protocol bindings, and the security schemes clients must use to authenticate. Because the card follows the A2A specification, any compliant client can read it without custom integration work.
Other discovery and publishing tools do not replace an Agent Card. An OpenAPI specification describes REST operations, not A2A skills, task behavior, or protocol bindings. Gemini Enterprise makes agents available to an organization's own employees rather than to another company's agents. Listing MCP tools treats the agent as a set of tools for another agent to call instead of a peer agent that takes on tasks.
Local sub-agents fit agents that one team owns and that are tightly coupled. A local sub-agent runs in the same process as the agent that calls it, so handing work between them needs no network call. As the ADK documentation notes, A2A's network overhead and serialization are counterproductive for tightly coupled agents that share state. The ownership question from earlier still applies, because the pattern works only when no other application or team needs to call the sub-agent on its own.
The overhead of A2A between coupled agents comes from the boundary itself rather than from how it is tuned. Each call crosses the network and serializes the state it carries, whichever protocol binding is used. A compact binding such as gRPC lowers the encoding cost of each message, but the network hop and the copied state remain. Removing the boundary is what removes that cost.
An agent that another team owns, or that several applications call, stays an independent A2A service, so latency work on it happens within that boundary. Traces show where each call spends its time, and each kind of delay has its own remedy:
Our Professional Agentic Architect practice exams test choosing between MCP, A2A, and local sub-agents alongside Agent Cards and A2A protocol bindings, with detailed explanations that drill these distinctions.