One GitHub task, wired up three different ways, can produce bills more than an order of magnitude apart. On November 11, 2026, OpenRouter published a hands-on measurement that lays this out in a table you can check row by row: on Claude Sonnet 5.5, the default MCP server consumed 42 times the CLI's input tokens and cost 17 times as much. The instinctive reaction is to start trimming tool definitions. The official TL;DR says the opposite: what actually blows up the context is not the tool definitions, but the results those tools return. This piece is a single-task measurement readout and a self-check list, not an integration tutorial and not a unit-price comparison. As of November 12, 2026, every number below can be traced back to the OpenRouter measurement post and its companion quantization post. One angle note before we start: the site's August 31 token cost comparison and November 4 pricing comparison weigh unit prices and cross-model costs, while this piece tracks token consumption for one fixed task under different wiring, so the angles do not overlap.
What OpenRouter actually measured
Fix the setup first. The official task is a single English question asking for the latest release of the cli/cli repository, plus the three most recently opened open issues with the label bug in that repository:
What is the latest release of the GitHub repository cli/cli, and what are the three most recently opened open issues in that repository with the label bug?The wording looks plain, but it is the anchor of the whole experiment: the agent has to read a release object and then page through an issue list, which is exactly the kind of job where MCP tools love to return large JSON blobs. Four models took part: Claude Haiku 5.5, Claude Sonnet 5.5, GPT-6 Luna, and Gemini 3.8 Flash. The wiring came in three families: a command-line CLI, a Skill, and MCP, with MCP further split by tool count and by whether results were trimmed.
The post is deliberately modest about method. In its own words, We ran each combination three times on October 20, 2026, and show medians. Every combination ran three times on October 20, 2026, and the figures shown are medians, not a best single run and not a mean. More important is the stated boundary: We tested one server on one task, so run mcp_cost.py on yours before you decide. One server, one task, a narrow sample; the authors themselves warn you to run mcp_cost.py against your own server before drawing a conclusion. Carrying that sentence into your decision record matters more than memorizing any single number, because everything below is a product of this one task, this one server, and these four models; change the task and the ordering can change with it. That is also why this piece keeps returning to "check it yourself": the table belongs to someone else, while the conclusion has to be yours.
Reading 42 times and 17 times as the original words
Spread out the Sonnet 5.5 column and six rows are quotable verbatim. A plain CLI wiring: 1,421 tokens at $0.0075. A Skill: 3,315 tokens at $0.0118. MCP with just 2 tools: 23,228 tokens at $0.0552. The 46 default tools: 59,417 tokens at $0.1274. All 91 tools: 101,351 tokens at $0.2113. And 2 tools with results capped at 4,000 characters: 5,357 tokens at $0.0191. The number 46 recurs in the same table: the default tier is 46 tools, and the result comparison is 'more than all 46 definitions'.
One line in the post is worth quoting verbatim: On Sonnet 5.5, the default MCP server used 42 times the CLI's input tokens and cost 17 times as much, $127 against $7.50 per 1,000 tasks. In other words, the default MCP used 42 times the CLI's input tokens and 17 times the cost, or $127 against $7.50 per 1,000 tasks. Write 42 times / 17 times / $127 / $7.50 exactly as the original gives them; there is no need, and no basis in the source, to recompute them from the 59,417 and 1,421 cells, or to soften the integers into approximations. These two multiples are the official conclusion for this measurement, not an estimate someone else derived.
Tool definitions do carry a fixed cost. The post says 46 default tools add 19,436 tokens to every request on Claude Sonnet 5.5 - note Sonnet 5.5, not Haiku. That charge is paid on every request, an up-front cost you pay just to walk in the door. It should still be scoped, but it is not the main source of the spread across the later rows; something else is pushing token counts up there.
It is worth separating one easily confused idea here: a low unit price per token does not mean a low total cost for a single task. The CLI and MCP paths build completely different contexts for the same task. Tool definitions, tool results, and the number of retries all change the tokens actually consumed. Unit price is a number on the rate card; total cost is the rate card multiplied by usage, and usage is precisely the part that swings with wiring. Declaring one wiring cheaper just because its per-million-token quote is lower skips a variable that moves a lot with wiring.
The money actually goes into tool results
The official TL;DR names the root cause plainly: one tool result, GitHub's release object, cost about 20,400 tokens, more than all 46 definitions. A single tool result, GitHub's release object, cost about 20,400 tokens - more than all 46 definitions combined. Put differently, tool definitions are a fixed up-front charge paid on every request, but they are not the hidden bulk that blows up the context; the bulk is the payload a tool hands back after it runs.
Break it open. get_latest_release returned GitHub's full release object, 42,182 characters, and 87% of it described the 22 download files: asking for the latest release made the API dump the entire release object, 42,182 characters, of which 87% described the 22 download files. Yet the task only asks which release is newest, so that file list is almost pure noise. The post then runs a control: asking for only number, title, and creation date cut its result from 8,336 characters to 714. Ask for only number, title, and creation date, and the result drops from 8,336 characters to 714 - an order of magnitude smaller with no loss of meaning.
The other end is more extreme: In four of six runs with 46 or 91 tools loaded, GPT-6 Luna asked for 100 issues with their full text and got 281,963 characters back. In four of six runs with 46 or 91 tools loaded, GPT-6 Luna requested 100 issues with their full text and received 281,963 characters. The larger and less constrained the tool set, the more easily a model pulls back a whole page of results; at that point shaving a few definitions barely moves the bill. So assigning the main cost to tool definitions runs opposite to the official conclusion - definitions should still be scoped, but what sets the order of magnitude of the bill is how large the returned results are and whether they can be trimmed. That is also why scoping to 2 tools and then capping results at 4,000 characters show up as two separate gains in the table.
Why this is not a price comparison
It is tempting to read the table as another write-up on which API is cheaper. It is not. The site's August 31 token cost comparison and November 4 pricing comparison weigh unit prices; this piece holds the task fixed and varies only the wiring, so what moves is the token count, not the per-token price.
Five steps you can check yourself
The official conclusion is short: Use a CLI when one exists and your agent can run commands. When it can't, use MCP, scoped and with small results. Following that line, the decision breaks into five steps, each stated in dimensions you can verify on your own, with no buttons, menus, or console paths to hunt for.
Step one, CLI first. When a task has an existing command-line tool and your agent can actually run commands, take the CLI path. The 1,421 / $0.0075 row is the baseline, and both the Skill and MCP rows are built on top of it. The premise is that the agent can run commands; the site's Claude Code sandbox runtime SOP covers how to make that capability real, while this piece treats it as a checkable precondition and does not repeat environment setup.
Step two, scope the tool set. If the CLI is unavailable and MCP is required, do not load the full default set. The authors scoped 46 default tools down to 2, and the up-front definition cost narrowed with it; the gap between the 2 tools row (23,228 / $0.0552) and the 46 default row (59,417 / $0.1274) is the room this step buys. The checkable dimension is plain: expose only the few tools this task will actually call.
Step three, trim results. This step shows a direct, visible payoff in the measurement. Cutting the fields get_latest_release asks for, from the full object down to number, title, and creation date, moved the result from 8,336 characters to 714; capping result length then lands the 2 tools plus results capped at 4,000 characters row at 5,357 / $0.0191, well below the uncapped 23,228 / $0.0552. What you can verify: which fields in each tool's return the task truly needs to read, and what maximum character count a single result is allowed. The site's AI Agent tool calling SOP complements this on how calls and results are organized.
Step four, treat Tool Search as model-dependent, not as a guaranteed saving. With all 46 GitHub tools deferred, the cost before any search was 578 tokens on the Claude models, 144 on GPT-6 Luna, and 130 on Gemini 3.8 Flash, and It's in beta. The post also warns Tool Search doesn't shrink tool results: it compresses which definitions are loaded up front, not the payloads that come back, and Our docs suggest keeping your three to five most-used tools loaded. Across the full task the effect is mixed: Sonnet drops from 59,417 to 30,334, a real saving; but Haiku goes from 99,319 to 154,623 and Gemini from 35,409 to 37,568, both more expensive. So Tool Search is a model-dependent switch, not a blanket money-saver; measure it on your own model before turning it on. One related note from the companion quantization post: 1,455 provider endpoints ... across 470 models describes 1,455 endpoints measured across 470 models on October 20, 2026, not the platform's total endpoint count - do not read it as a platform-wide scale figure.
Step five, decide only after running mcp_cost.py yourself. Back to the stated boundary: one server, one task, four models, three runs with medians, a sample so narrow the authors will not draw the conclusion for you. Point mcp_cost.py at your own MCP server and your own task, produce your own table, and only then choose between CLI, Skill, and MCP. None of the five steps asks you to trust someone else's numbers; every one of them ends at "measure it again in your own environment". That is a concrete thing a single-task readout can hand you.
FAQ
Q1: Where do 42 times and 17 times come from?
A1: From the original line in the OpenRouter measurement post: on Sonnet 5.5 the default MCP server used 42 times the CLI's input tokens and cost 17 times as much, $127 against $7.50 per 1,000 tasks. These are the multiples the official post states directly. Quote them as written; there is no reason to back-derive them from the 59,417 and 1,421 cells, and no reason to rewrite the integers as approximations.
Q2: Are tool definitions the main cost?
A2: No. The official TL;DR says one tool result, GitHub's release object, cost about 20,400 tokens, more than all 46 definitions. Tool definitions are a fixed up-front charge (46 default tools add 19,436 tokens to every request on Claude Sonnet 5.5), and they should be scoped, but what fills the context is returned results: a 42,182-character release object, 281,963 characters of issue full text. Trimming results beats cutting definitions.
Q3: Does Tool Search always save money?
A3: No, it is model-dependent. Before any search the cost was 578 tokens on the Claude models, 144 on GPT-6 Luna, and 130 on Gemini 3.8 Flash; it is in beta, and it does not shrink tool results. Over the full task Sonnet fell from 59,417 to 30,334, a saving, but Haiku rose from 99,319 to 154,623 and Gemini from 35,409 to 37,568, both more expensive. Measure it on your own model first.
Q4: Can I copy these numbers straight into my own project?
A4: No. The stated boundary is one server, one task, four models, three runs with medians, and the authors explicitly wrote that they tested one server on one task and that you should run mcp_cost.py on yours before you decide. The figures hold for this task only; change the task, the server, or the model and they move. Run mcp_cost.py in your own environment to produce your own table.
Q5: Is 1,455 the platform's total endpoint count?
A5: No. The original is 1,455 provider endpoints ... across 470 models, meaning 1,455 endpoints measured across 470 models on October 20, 2026, not a platform-wide total. Do not treat it as a scale figure for the whole platform, and do not mix it with the per-task token counts in this piece.
Related reading