MCP vs Tool Calling
Tool calling and MCP solve different problems, so choose by ownership.

Tool calling lets a model request an action, while MCP standardizes how tools are discovered and shared across clients. The useful decision is therefore not which one wins, but whether the integration and ownership problems in a system justify adding MCP.
Why the MCP-vs-tool-calling framing is wrong before the conversation starts
Should a team use MCP or function calling? The question conflates two layers of the stack. Tool calling is a model API feature that lets an application submit tool definitions and receive a structured request to invoke one. MCP is a client-server protocol that standardizes how those definitions are published, discovered, and routed to their implementations.
That distinction changes what a comparison can establish. A team can use tool calling without MCP, and when it adds MCP, tool calling still works underneath it. The relevant comparison is between application-specific integration code and a shared protocol for connecting that code to clients. Which arrangement earns its complexity depends on the system around the model.
What tool calling actually is and what your code is responsible for
A tool definition contains a name, a natural-language description, and a JSON Schema for its parameters. The application passes that definition to the model, which can return the tool name and JSON arguments. The description is effectively prompt text. It influences when the model chooses the tool, so it is part of the tool’s behavior as well as an explanation for developers.
Execution belongs to the application. An executor matches the structured output to a real function, handles authentication, retries, and rate limits, and returns the result to the model. Tools may seem to run on their own inside Claude or ChatGPT because those applications have an executor. A team building an agent into its own product owns that responsibility.
Schema adherence narrows one part of this problem. OpenAI shipped structured outputs on August 6, 2024, guaranteeing that arguments match the declared schema, and Anthropic offers the same with strict: true. But a schema-valid request is not necessarily the right request. Even when the arguments match the declared shape, the model may have chosen the wrong tool or asked for an action that should not be allowed.
What MCP adds on top through discovery, portability, and the N×M problem
Function calling gives an application access to tools, but it does not standardize access across applications. If several agents need the same external systems, each pairing can require bespoke integration work. This is the N×M problem. Different stacks need their own tool definitions and connections unless a common interface separates the clients from the systems they use.
MCP supplies that interface through a client-server architecture. Anthropic released it as an open protocol on November 25, 2024, and governance transferred to the Linux Foundation in December 2025. ToolBench’s evaluation covered tools across 43,467 Model Context Protocol servers, illustrating the scale of the ecosystem in which discovery and reuse now operate. A server can serve any MCP-capable host across model providers.
The practical additions are discovery, portability, and credential isolation. A host calls tools/list to get the current schemas, so new tools can appear without changes to the client-side code. The server handles authentication and execution, so the agent does not need direct access to API keys. That same server can work with hosts such as Claude Code, Cursor, or a custom agent.
The host then passes the schemas to the model as ordinary tool definitions. When the model returns a tool call, the host forwards it through tools/call. MCP changes how tools reach the application and where execution is routed. The model’s side of the interaction remains the same.
The state of the MCP specification as of mid-2026 and what changed for builders
The stateless redesign removes a major objection to hosting MCP servers at scale. The MCP specification revision 2026-07-28 removes the initialize handshake and the Mcp-Session-Id header, so each request is self-describing. Any request can go to any instance behind a plain round-robin load balancer. This makes remote servers easier to run on serverless hosting than they were under the earlier session-based architecture.
Clients can make an optional discovery call when they want capabilities up front, while Streamable HTTP replaces the deprecated HTTP+SSE transport. Tasks have moved from the protocol core into an official extension. These changes distinguish the current architecture from the 2025 protocol still described in many tutorials.
The revision also makes routing and caching more explicit. Method and tool names travel in the Mcp-Method and Mcp-Name HTTP headers, allowing gateways to route and authorize requests without parsing their bodies. Servers should return tools/list in deterministic order, and the list results should have hints for ttlMs and cacheScope. Order has a direct cost consequence because tool definitions sit at the front of model requests, where reshuffling them breaks prompt-cache hits.
The real cost of adding MCP through context, tool selection, and operations
Tool definitions take up context before the agent starts its task, and Anthropic found that five MCP servers could produce tens of thousands of tokens of definitions. A larger catalog also degrades tool-selection accuracy. The model has more possible actions to distinguish, and schema-valid arguments do not prevent it from choosing the wrong one.
The specification uses deferred loading and tool search to cut the number of tokens. Instead of receiving every definition up front, the model searches at inference time for tools marked for deferred loading. This changes how the catalog enters context. It does not remove the need to operate the servers that publish and execute those tools.
Credential isolation also depends on who controls the boundary. Keeping API keys behind a server helps when the environment is under control, but with an unknown third-party server, authentication and security also depend on a server outside the application’s control. Every server also needs monitoring and maintenance. A plain function call is still code in the same repository.
Nango’s fall 2025 survey of several hundred teams building agent integrations found that fewer than 10 kept MCP in production. That finding is specific to the surveyed teams, not a universal adoption rate. It nevertheless cautions against treating protocol support as a reason to adopt it. Most production agents end up with mostly function calling and, at most, a couple of MCP servers.
A practical decision framework based on integration count and team structure
For one to five integrations, plain function calling usually has fewer moving parts, gives the team direct control over identity and tenancy, and is easier to debug without extra infrastructure. At twenty or more integrations, the N×M problem increases the need for MCP servers and a governance gateway. These are pragmatic thresholds. Count is useful because it approximates repeated integration work, but it cannot describe who does that work.
Ownership can therefore change the decision at either scale. If another team or a vendor already maintains an MCP server for a needed system, building a separate function-calling integration may cost more than operating the MCP connection. If the tools implement the product’s own logic, keeping execution in application code preserves direct control. The preferred arrangement reduces duplicated work without obscuring responsibility.
OpenAI, Anthropic, and Google use different function-calling formats, so direct integrations require manual maintenance across providers. MCP servers are model-agnostic, though the host still handles the calls to and from the model. A shared server is consequently more useful when several clients need the same tools than when one application owns both ends.
Custom tool implementations can be written once, served through an MCP server, and consumed through either REST or MCP depending on the client. Prototypes and internal developer tools also benefit from MCP’s setup speed. Engineering oversight can compensate for trade-offs that are harder to accept in customer-facing production agents.
Where A2A fits — and why it belongs in this conversation without competing in it
A2A addresses delegation between autonomous agents. An MCP tool call is conceptually immediate, with an invocation followed by a result or stream. A2A instead describes discoverable, long-lived tasks that can outlast one request.
A multi-agent system can therefore use all three layers. Function calling handles the model’s structured action requests, MCP provides tool discovery and execution, and A2A coordinates delegated work between agents. Adding A2A does not resolve the integration costs discussed above because it serves a different boundary. The practical signal is work that must outlive a single HTTP request, persist state across turns, or be tracked as a distinct task with its own lifecycle.
Enterprise governance at the gateway layer — where policy enforcement actually lives
In a production MCP deployment, the gateway between agents and servers is the control plane. It is where shared access becomes enforceable policy. The protocol provides hooks for authorization and routing, but those hooks do not decide which agent may use which tool. That decision belongs to the deployment.
An audience-bound token ties access to the server being called, while an allow list limits each agent’s access to specified servers and tools. Writes and payments wait for a human to approve them before they run. Every call is recorded with the agent identity attached so that logs and traces preserve who requested the action.
Enterprise-Managed Authorization, or EMA, was promoted to stable in June 2026. It brings MCP authorization inside an organization’s existing IAM perimeter by using its identity provider as the control plane for access. Okta is the first identity provider supported, and others, including Microsoft Entra ID, are expected to follow. The implementation gap is therefore not an absence of protocol support, but whether the organization connects and enforces these controls.
Discovery must also reflect that organizational boundary. The official MCP Registry has been in preview since September 8, 2025, and lists no private servers. For an enterprise deployment, the recommended approach is a private registry treated as the organization’s allow list. Discoverability alone is not permission to execute.
What this architecture means for documentation — and why docs are now part of the tool layer
Documentation becomes part of how agents work when they use it to choose tools or write code. Descriptions guide selection, while supporting documentation supplies the context in which that selection occurs. Accurate schemas cannot make up for instructions around them that describe the wrong product version.
A documentation MCP server can make that context more selective. An agent can query for a product, a version, or changes since a particular date and receive MCP-formatted responses without downloading a flat file and parsing links. Structured files offer another route. Jeremy Howard proposed llms.txt in September 2024 as a Markdown file at a site’s root containing a curated index of important pages with one-line descriptions. Its companion, llms-full.txt, concatenates full Markdown content for agents that need deeper context.
IDE agents can fetch these files when manually directed to a documentation site. The standard workflow identifies which dependency owns a feature, fetches that library’s llms.txt, retrieves the relevant linked pages, and then writes code. Selection is the essential step. More available text is not automatically better context, just as more available tools do not automatically improve tool selection.
HubSpot’s failure mode shows the consequence of mixing incompatible sources. Models answering developer questions drew simultaneously from legacy V1 API docs, the current V3 API, private app examples, public app tutorials, and serverless functions, producing conflicting advice through context overload. Stale indexed documentation likewise frustrates individual readers and propagates into outdated generated code and autocompletions.
Tool calling defines the action boundary, while MCP can make tools and their supporting context reusable across clients. Whether that reuse improves a system depends on the quality of the definitions, the authority behind execution, and the ownership of the shared integration.


