Build1 publisher2 min readPublished
A dev.to walkthrough prints both JSON blocks side by side and they match field for field, which puts MCP's real cost in the process you have to keep alive and the schemas loaded before anyone asks for them.
The Engineer · Build desk
Compiled by The EngineerSomething wrong?How this is made
The dispatch loop is where the equivalence gets concrete. You hand the model a tool name, a description and an input_schema. If it decides mid-run that it needs that tool, the response content carries a tool_use object with the name and the arguments it chose, and stop_reason comes back as tool_use [6]. Your code branches on that and calls the real function [6]. Registering the same weather tool through MCP produces the same tools entry, field for field, according to the dev.to post [5].
So MCP moves the plumbing behind that boundary rather than the boundary itself. The tool list now arrives from a process you keep running, and every tool the server exposes contributes its schema up front, whether this conversation needs it or not [7].
Treat "large context overhead" as a claim about somebody else's tool list. For it to hurt, the server has to expose many tools with long descriptions, and your sessions have to run long enough, or your window sit tight enough, that a fixed prefix on every request matters. The post publishes no token counts and no CPU or memory measurements [10], so the size of that tax is yours to measure before you argue about it.
The operational column is the part I would weigh at review: restarting a crashed server, sequencing startup order across several of them, and maintaining internal state over time [8]. A direct function call has none of those failure modes, though it inherits whatever your own process does when it falls over. If you own both sides and there is one client, the unified socket has one thing plugged into it.
What buys the overhead back is the case the post also names. Before MCP, every AI application wrote its own integration code for every external service it wanted to reach [9], and the post puts MCP's biggest strength in unifying that interface across a project's resources [11]. That is arithmetic about distribution. Ten applications against ten services is a hundred integrations the old way and twenty against one shared protocol [12]. One agent against three services you already own is three functions.
The CLI shortcut carries a different bill. Expose exactly one bash tool and you skip describing what bash can do, because the model has already read enough to write commands on its own [13]. The post is blunt that permission control here is hard to get right [14]. You have swapped schema maintenance for an authorization problem, which is the trade I would want stated out loud in a design doc rather than discovered in an incident.
Ranked by verification strength, evidence, and original report placement.
MCP (Model Context Protocol) is described as an open protocol launched by Anthropic that lets AI applications such as Claude Code, Claude Desktop and OpenClaw discover and call external tools, and read external resources, in a unified way.
The post prints the tools entry a model sees for a get_weather tool registered via MCP and via function calling, and states there is no difference between the two JSON blocks.
In function calling, you pass a function signature to the LLM; if it decides during execution that it needs the tool, the response content includes a tool_use object with the tool name and input, stop_reason is set to tool_use, and you write the code that branches on stop_reason and performs the call.
Once you connect to an MCP server, the full schema (name, parameters, description) for every tool that server exposes is placed into the model's context window up front, whether or not the conversation ever needs it.
An MCP server runs continuously as a separate process, consuming CPU and memory, and leaves you responsible for restarting it when it crashes, sequencing startup order across multiple servers, and maintaining internal state over time.
Before MCP existed, every AI application had to write its own integration code for every external service such as Google Drive, GitHub or Slack.
Follow any of these and your For You feed starts watching them — no settings page required.
Evidence-backed comparisons of source perspectives and observed adoption signals. Read the methodology
Which Builder, Operator, and Investor concerns the observed source mix emphasized—not a truth score.
Evidence, demonstrated adoption, hype gap, incentives, and confidence are assessed independently, each on its own current evidence. How these are measured.
Self-demonstrating on one point, asserted on the rest
The central comparison needs no trust: the get_weather tool entry is printed twice, once registered through MCP and once through function calling, and a reader can reproduce the match against any API. The costs the recommendation actually turns on — preloaded schemas, a resident process, restart and ordering duties — are described accurately as mechanisms but never sized, and dev.to is the only account we hold.
No deployment signal in this reporting
Two sentences gesture at uptake — job listings that keep mentioning MCP, companies that keep using it anyway — and neither names a listing, a company or a count. There is no server tally, no download figure and no named deployment to reason from, so a hiring anecdote is not going to be converted into an adoption reading.
Costs asserted louder than they are shown
Where the post can prove its point it proves it, and where it cannot it reaches for adjectives. 'Large context overhead' and servers that 'eat' CPU and memory are doing the persuasive work in a piece whose title is a recommendation, with no token or byte figure behind either. The overstatement runs against MCP rather than for it, which is unusual, and it is small: the mechanisms are real even where the magnitudes are unstated.
Audience-building, no vendor stake
CodePlato writes under a pseudonym and signs off with an X handle, which is the entire visible interest: a contrarian title in a market saturated with MCP tutorials draws readers. No employer, client or tooling vendor appears anywhere in the post, and the protocol under discussion belongs to Anthropic, whom the author neither sells for nor competes against.
One author, checkable in an afternoon
Two things hold this up. The schema comparison can be reproduced by anyone with an API key, and the tool_use and stop_reason mechanics are specific enough that a working developer would notice if they were wrong. Everything about cost and uptake is a single practitioner's recollection, with no second publisher in our coverage to test it against.
build
OpenClaw makes the channel the architecture, and the reasoning loop a lodger1 publisher
product
A 2x LLM bill is not a bug report: token spend is an observability problem1 publisher
product
ChatGPT Work's real ask is your Slack, and somebody has to say yes on everyone's behalf1 publisher
build
When the changelog reaches for your README's word: MCP memory and the price of filling a gap1 publisher
Publishers with included, body-backed reporting in this cluster.
1 article · September 7, 2026