Tools vs. Agents: Drawing the Right Boundary on Google Cloud

GCP Study Hub
November 15, 2026

Not every capability in an agentic system should be built as an agent. When an operation involves no reasoning and no multi-step conversation, it belongs as a tool rather than an agent. Wrapping a plain operation inside an agent adds a reasoning layer, latency, and network hops while gaining nothing. A capability warrants an agent when it needs its own reasoning, owns its own models and tools, or belongs to another organization that will not share how it works. On the Professional Agentic Architect exam, scenarios frequently test this boundary because several protocols and platform options overlap on the surface while solving different problems.

A practical rule of thumb separates the three patterns:

  • Tools are exposed through MCP or an API specification.
  • Independent agents are reached through the A2A protocol.
  • Agents owned by the same team that work closely together belong in one application as local sub-agents.

When a capability belongs in a tool and MCP

MCP is the protocol for connecting agents to tools and data. Plain operations, such as reading records from an internal database or performing writes through an internal REST API, involve no reasoning or multi-step conversation. When several agents need those same capabilities, exposing them through a single MCP server lets every agent connect to the same tools. We would lean toward a shared MCP server in that situation because credentials stay in one place and any change to the underlying database or API happens in one place. Copying client code and credentials into each agent spreads secrets across many deployments and multiplies maintenance.

Wrapping each plain lookup or write in its own ADK agent inserts a reasoning layer and extra network hops into work that requires no reasoning. Other options also fit different problems:

  • A2A is meant for agents collaborating on tasks, not for simple lookups and writes.
  • Gemini Enterprise makes agents available to an organization's own employees, so publishing capabilities there does not give other agents a way to invoke them as tools.

When to integrate with an independent agent over A2A

When a capability requires its own reasoning, manages its own models and tools, or runs on another organization's infrastructure without revealing its internals, it should be reached through the A2A protocol. A2A is designed for collaboration between independent agents that may keep their internal design private. It models work as tasks that can run for hours while the client tracks status and receives the final result later, without needing to know how the remote agent produces its output.

Other integration patterns break down across an organizational boundary. MCP connects an agent to its own tools and data, so using MCP with an external party would require that party to expose tools it keeps private, and listing MCP tools treats the remote system as a set of tools rather than a peer agent that takes on tasks. Running an external party's agent as a local sub-agent requires its code, which external organizations do not share. Calling a remote model endpoint directly skips the remote agent's logic entirely and assumes access to models that are not offered. Gemini Enterprise is also the wrong boundary here, because it makes agents available to an organization's own employees rather than to another company's agents.

Agent discovery with Agent Cards

Before one A2A agent sends a task to another, the client needs a standard way to discover what the remote agent can do. An A2A agent describes itself by publishing an Agent Card, which is A2A's discovery document, at the /.well-known/agent-card.json path on the agent's domain.

The Agent Card gives clients the details they need before sending any task:

  • How to reach the agent and the interfaces it supports, including protocol bindings.
  • The skills and capabilities the agent offers.
  • The security schemes that specify how clients must authenticate.

Because the Agent Card follows the A2A specification, any compliant client can read it without custom integration work. An OpenAPI specification does not replace an Agent Card here, because OpenAPI describes REST operations rather than A2A skills, task behavior, or protocol bindings.

When owned agents belong together as local sub-agents

Even when both sides are genuine agents, A2A is not always the right boundary between them. A2A earns its network boundary when another team owns the remote agent or other applications need to call it. When one team owns both agents, they are tightly coupled, and nothing else calls the second agent, that boundary adds cost without serving any shared consumer.

Combining such agents into a single ADK application, with one running as a local sub-agent of the other, removes the boundary entirely. Local sub-agents run in the same process, so one agent can hand work to another without a network call. The ADK documentation notes that for tightly coupled agents that share state, A2A's network overhead and serialization are counterproductive.

The reason is structural. Every A2A call crosses the network and serializes whatever state travels with it, whichever protocol binding carries the message. A more compact binding such as gRPC can make each message cheaper to encode, but the network hop and the copied state remain, so the overhead grows with how often coupled agents talk and how much context they pass. Running both agents in one process is what removes it.

Keeping the distinction clear comes down to reasoning, ownership, and coupling: plain operations belong in MCP tools or an API specification, independent or external agents belong behind A2A with a published Agent Card, and tightly coupled ADK agents owned by the same team belong in one application as local sub-agents.

Our Professional Agentic Architect practice exams test the boundary between tools and agents alongside A2A discovery with Agent Cards and ADK multi-agent design, with detailed explanations that drill these distinctions.

Get tips and updates from GCP Study Hub

arrow