Tech

Your agent burns 100,000 tokens before you type a word

June 17, 2026 · Wu Jun, The Beauty of Mathematics~5 min read

Open a fresh chat with your AI coding agent. Connect it to the tools your team actually uses — GitHub, Jira, Slack, a database. Now, before you have typed a single character, look at the context meter. On a typical enterprise setup it has already spent somewhere between 100,000 and 200,000 tokens. Not on your problem. On reading the instruction manuals for tools it may never touch. This is the quiet scandal underneath the loudest infrastructure fight of 2026 — and it has a shape you can measure.

The receipt nobody reads

When an agent connects to an MCP server — the Model Context Protocol, the standard way to plug tools into a model — every tool definition that server exposes is loaded into the context window. All of them. A single GitHub MCP server with 93 tools costs roughly 55,000 tokens just to say hello; Jira adds another 17,000. One developer's real stack — Linear, Notion, Slack, Postgres — burned 21,000 tokens before any work began, which is 10.5% of Claude's 200K window gone to overhead. And the benchmark that made people gasp: Scalekit asked one trivial question — "what language is this repo?" — and clocked 1,365 tokens through a command-line tool versus 44,026 through MCP. Same answer. Thirty-two times the price.

MCP isn't the villain. Scarcity is.

It would be easy to read all this as "MCP bad, CLI good," and a loud corner of Hacker News did exactly that. But the more careful consensus is subtler, and it isn't about the protocol at all — it's about context. A context window is finite. Every token you spend describing a tool you won't use is a token you can't spend reasoning about the tool you will. MCP buys you real things: authentication, governance, an audit trail, access for non-technical teammates. For an enterprise, that overhead is the price of admission. For a solo developer wiring up a coding agent, it's mostly dead weight. The fight isn't good-versus-evil; it's a budget problem wearing a protocol costume.

Wu Jun: you're not paying in tokens. You're paying in bits.

Decades ago, in The Beauty of Mathematics, Wu Jun walked readers through the one idea that quietly runs all of modern computing: information theory. Claude Shannon's insight was that information can be measured — in bits — and that any channel, from a copper wire to a conversation, has a finite capacity. You cannot push more meaning through it than its capacity allows; try, and the surplus is just noise. Wu Jun's gift is the translation: a communication channel is a pipe, and what flows through it isn't words, it's the reduction of uncertainty. The width of the pipe is fixed. What you choose to send through it is not.

Hold that next to an AI agent and the whole debate snaps into focus. The context window is the channel. Its capacity is fixed — 200,000 tokens, say. Tool definitions are traffic in that pipe. When you preload 150,000 tokens of tool manuals, you haven't made the agent smarter; you've stuffed the channel with low-information cargo and left almost no room for the signal that actually matters — your question, the code, the reasoning. The agent gets dumber not because the model shrank, but because the pipe is full of packing peanuts.

When an agent connects to an MCP server, every tool definition it exposes is loaded into context — all of them, before you ask anything. One real stack hit 21,000 tokens (10.5% of Claude's 200K window); Scalekit benchmarked one repo query at 1,365 tokens via CLI versus 44,026 via MCP — a 32x gap; a 93-tool GitHub server alone costs ~55,000 tokens at startup, and a typical enterprise stack burns 100,000–200,000 before a single character is typed. Wu Jun's The Beauty of Mathematics frames it cleanly: a context window is a finite channel, and the true currency isn't tokens but information per token. Load the signal you need, not the whole inventory. The 2026 consensus: CLI for most coding work; MCP's overhead is the price of enterprise governance.

Information per token, not tokens

Here is the metric Wu Jun's lens hands you, and it's the one the token-counting headlines miss. The currency of an LLM was never tokens. It's information per token — how much uncertainty each token in the window actually removes. By that measure, a 600-token definition for a tool the agent never calls has an information value of roughly zero. It's pure noise occupying premium space. The same instinct drives one of the book's favorite examples, TF-IDF: a word that shows up everywhere carries almost no information; the rare, on-point word carries a lot. Loading all tools, always, is the all-words-are-equal mistake. Loading only the tools this task needs — on demand, the way a command-line agent does — is the search engine's instinct: weight by relevance, and spend attention where the information density is highest.

What this means for what you ship

So you don't have to pick a tribe. You have to budget a channel. Audit what your agent loads before it does anything — if a stack eats six figures of context at hello, that's not a feature, it's a leak. Prefer load-on-demand: tools fetched when the task calls for them, not dumped in at startup. Reserve MCP's overhead for where its governance actually earns its keep, and reach for lean CLI tools for the 90% of coding work that needs no audit trail. And the next time a vendor brags about how many tools their server exposes, remember Wu Jun's quiet rule: a longer menu is not more information. It's usually just more noise in a pipe that was never going to get any wider. Spend the channel on signal.

A bigger toolbox isn't more information.

It's usually just more noise in a pipe that can't get any wider — and the currency of an agent was never tokens, but how much each token actually tells it.

Framework drawn from Wu Jun's The Beauty of Mathematics (吴军《数学之美》) — information theory, channel capacity, and TF-IDF. Token figures from the 2026 MCP-vs-CLI debate: one real stack at 21,000 tokens (10.5% of Claude's 200K window); Scalekit's benchmark of 1,365 (CLI) vs 44,026 (MCP) tokens, a 32× gap; a 93-tool GitHub server at ~55,000 tokens and a typical enterprise stack at 100,000–200,000 on initialization. Popular tech commentary; figures per the original reports.

技术

你还没开口，智能体已经烧掉十万 token

2026 年 6 月 17 日 · 吴军《数学之美》约 4 分钟

打开一个全新的对话窗口，连上你团队真正在用的工具——GitHub、Jira、Slack、一个数据库。此刻，在你敲下第一个字符之前，看一眼上下文的余量表：在一套典型的企业配置里，它已经花掉了十万到二十万个 token。不是花在你的问题上，而是花在阅读一堆它也许永远不会碰的工具说明书上。这就是 2026 年最吵的那场基础设施之争背后、那桩没人声张的丑闻——而它有一个你能量出来的形状。

没人看的那张账单

当一个智能体连上 MCP 服务器——Model Context Protocol，把工具插进模型的那套标准——这台服务器暴露的每一条工具定义都会被塞进上下文窗口。一条不落。光一个有 93 个工具的 GitHub MCP 服务器，打声招呼就要约 55000 个 token；Jira 再加 17000。某位开发者真实的技术栈——Linear、Notion、Slack、Postgres——在干任何活之前先烧掉 21000 个，相当于把 Claude 那 20 万窗口的 10.5% 直接交了「手续费」。而真正让人倒吸一口凉气的基准是：Scalekit 问了一个再简单不过的问题——「这个仓库是什么语言？」——走命令行工具用了 1365 个 token，走 MCP 却用掉 44026。同一个答案，三十二倍的价钱。

MCP 不是反派，稀缺才是

把这些都读成「MCP 坏、CLI 好」很容易，Hacker News 上确实有很大一群人就这么喊。但更审慎的共识要微妙得多，而且根本不在协议身上——在上下文。上下文窗口是有限的。你每花一个 token 去描述一件用不上的工具，就少一个 token 留给你真正要用的那件工具去推理。MCP 确实给了你实在的东西：身份认证、治理、一条审计轨迹、让不懂技术的同事也能接入。对一家企业来说，这点开销是入场费；对一个独自搭编程智能体的开发者来说，它多半是死重。这场架不是正邪之分，而是一道预算题，套了件协议的外衣。

吴军：你付的不是 token，是比特

几十年前，在《数学之美》里，吴军带读者走过那个悄悄驱动整个现代计算的念头：信息论。香农的洞见是，信息可以被度量——以「比特」为单位——而任何信道，从一根铜线到一场对话，都有一个有限的容量。你没法往里推超过容量的意义；硬推，多出来的就只是噪声。吴军的本事在于翻译：一条通信信道就是一根管子，里头流的不是字词，而是「不确定性的减少」。管子的粗细是定死的，你选择往里塞什么，则不是。

把这个念头摆到一个 AI 智能体旁边，整场争论瞬间对上了焦。上下文窗口就是那条信道，容量是定死的——比如 20 万 token。工具定义是这根管子里的车流。当你预先塞进 15 万 token 的工具说明书，你并没有让智能体更聪明；你只是用低信息量的货把信道填满，几乎没给真正要紧的信号——你的问题、代码、推理——留下空间。智能体变笨，不是因为模型缩水了，而是因为管子里塞满了泡沫填充物。

当一个智能体连上 MCP 服务器，它暴露的每一条工具定义都会被加载进上下文——全部，在你开口之前。一个真实技术栈一上来就吃掉 21000 个 token（占 Claude 20 万窗口的 10.5%）；Scalekit 的基准里，同一个查仓库语言的问题，走 CLI 用 1365 个 token，走 MCP 却烧掉 44026——相差 32 倍；光一个 93 个工具的 GitHub 服务器，启动就要约 55000 个 token，一套典型企业栈在你敲下第一个字符前已烧掉 10 万到 20 万。吴军《数学之美》一语点破：上下文窗口是一条有限信道，真正的货币不是 token，而是每个 token 承载的信息。只加载你需要的信号，别加载整份清单。2026 年的共识是：多数编程活儿走 CLI，MCP 的开销是企业级治理的入场费。

看每个 token 的信息量，别看 token 数

这就是吴军那副眼镜递给你的度量，也正是那些「数 token」的标题漏掉的。大模型的货币从来不是 token，而是「每个 token 的信息量」——窗口里每一个 token 究竟消除了多少不确定性。按这把尺子，一条 600 token、智能体却从不调用的工具定义，信息价值约等于零。它是纯噪声，占着黄金地段。书里最爱举的一个例子——TF-IDF——背后是同一种直觉：一个到处都出现的词，几乎不携带信息；那个稀有又正中要害的词，信息量才大。永远把所有工具全加载，犯的正是「所有词一样重」的错。只加载这一个任务需要的工具——用到才取，就像命令行智能体那样——则是搜索引擎的直觉：按相关性加权，把注意力花在信息密度最高的地方。

这对你要做的东西意味着什么

所以你不必选边站队，你要做的是给一条信道做预算。审一审你的智能体在动手之前都加载了什么——如果一套栈刚打招呼就吃掉六位数的上下文，那不是功能，是漏。优先「用到才取」：工具在任务需要时再拉进来，而不是开机就一股脑倒进去。把 MCP 的开销留给它的治理真正值回票价的地方，而那 90% 不需要审计轨迹的编程活，就用精简的命令行工具。下一次有厂商炫耀他们的服务器暴露了多少工具时，请记起吴军那条安静的规矩：更长的菜单不等于更多信息，多半只是更多噪声，塞进一根本来就粗不了的管子里。把这条信道，花在信号上。

更大的工具箱不等于更多信息。

多半只是更多噪声，塞进一根粗不了的管子——而智能体的货币从来不是 token，是每个 token 到底告诉了它多少。

框架取自吴军《数学之美》——信息论、信道容量与 TF-IDF。token 数据来自 2026 年的 MCP 对 CLI 之争：某真实技术栈 21000 个 token（占 Claude 20 万窗口的 10.5%）；Scalekit 基准的 1365（CLI）对 44026（MCP），相差 32 倍；一个 93 工具的 GitHub 服务器约 55000 个 token、一套典型企业栈初始化即 10 万到 20 万。大众科技评论；数据以原报道为准。

テクノロジー

あなたが一文字打つ前に、エージェントは十万トークンを焼いている

2026年6月17日 · 呉軍『数学の美しさ』約 6 分

AIコーディングエージェントの新しいチャットを開く。チームが実際に使うツール——GitHub、Jira、Slack、データベース——を接続する。さあ、まだ一文字も打っていないのに、文脈のメーターを見てほしい。典型的な企業構成なら、もう10万から20万トークンを使い切っている。あなたの問題にではない。一度も触れないかもしれないツールの取扱説明書を読むことに、だ。これが2026年で最も騒がしいインフラ論争の裏にある、誰も声を上げない不祥事——しかもそれは、測れる形をしている。

誰も読まない領収書

エージェントが MCP サーバー——Model Context Protocol、ツールをモデルに差し込む標準——に接続すると、そのサーバーが公開する全ツール定義が文脈窓に読み込まれる。一つ残らず。93ツールを持つ GitHub MCP サーバーは、挨拶するだけで約55,000トークン。Jira がさらに17,000を足す。ある開発者の実際のスタック——Linear、Notion、Slack、Postgres——は、何か作業を始める前に21,000を焼いた。Claude の20万窓の10.5%が「手数料」に消えた計算だ。そして人々が息をのんだベンチマーク——Scalekit はこの上なく単純な問いを投げた。「このリポジトリは何の言語か？」。コマンドライン経由で1,365トークン、MCP 経由で44,026。同じ答え、32倍の値段だ。

MCP は悪役ではない。希少性が悪役だ。

これを全部「MCP は悪、CLI は善」と読むのはたやすく、Hacker News の声の大きい一角はまさにそう叫んだ。だが、より慎重な合意はもっと繊細で、しかもプロトコルの話ですらない——文脈の話だ。文脈窓は有限である。使わないツールを説明するために費やす1トークンは、使うツールについて推論するために使えない1トークンだ。MCP は確かなものをくれる——認証、ガバナンス、監査証跡、技術者でない同僚のアクセス。企業にとって、そのオーバーヘッドは入場料だ。一人でコーディングエージェントを組む開発者にとっては、ほぼ死荷重だ。この争いは善悪ではなく、プロトコルの衣装をまとった予算の問題である。

呉軍：あなたが払うのはトークンではなく、ビットだ

何十年も前、『数学の美しさ』で呉軍は、現代のコンピューティング全体を静かに動かす一つの考え——情報理論——を読者に手ほどきした。シャノンの洞察は、情報は「ビット」で測れること、そして銅線から会話まで、あらゆる通信路には有限の容量があることだった。容量を超える意味は押し込めない。無理に押し込めば、あふれた分はただのノイズだ。呉軍のうまさは翻訳にある——通信路とは一本のパイプであり、流れるのは言葉ではなく「不確かさの減少」だ。パイプの太さは決まっている。何を流すかは、決まっていない。

これを AI エージェントの隣に置くと、論争全体の焦点が一気に合う。文脈窓がその通信路だ。容量は固定——たとえば20万トークン。ツール定義はそのパイプの中の交通量だ。15万トークンのツール説明書を先読みしても、エージェントが賢くなるわけではない。低情報の貨物で通信路を埋め、本当に大事な信号——あなたの問い、コード、推論——にほとんど余地を残さなかっただけだ。エージェントが愚かになるのは、モデルが縮んだからではない。パイプが緩衝材で埋まっているからだ。

エージェントが MCP サーバーに接続すると、公開された全ツール定義が文脈に読み込まれる——あなたが何か尋ねる前に、すべて。ある実際のスタックは初手で21,000トークン（Claudeの20万窓の10.5%）を消費した。Scalekitのベンチマークでは、同じリポジトリ照会がCLIで1,365トークン、MCPで44,026——32倍の差。93ツールのGitHubサーバーだけで起動に約55,000トークン、典型的な企業スタックは最初の一文字を打つ前に10万〜20万を焼く。呉軍『数学の美しさ』が端的に言う——文脈窓は有限の通信路であり、本当の通貨はトークンではなく、トークンあたりの情報量だ。必要な信号だけを読み込め、在庫一覧ではなく。2026年の合意は、大半のコーディングはCLI、MCPのオーバーヘッドは企業統治の入場料、というものだ。

トークン数ではなく、トークンあたりの情報量

これこそ呉軍のレンズが手渡す尺度であり、「トークンを数える」見出しが見落とすものだ。LLM の通貨は、もともとトークンではなかった。トークンあたりの情報量——窓の中の各トークンが、実際にどれだけ不確かさを取り除くか——だ。その尺度では、エージェントが一度も呼ばない600トークンのツール定義は、情報価値がほぼゼロ。一等地を占める純然たるノイズである。本のお気に入りの例、TF-IDF も同じ直感に立つ——どこにでも現れる語はほとんど情報を運ばず、まれで的を射た語こそ情報量が大きい。全ツールを常に読み込むのは、「すべての語は等しく重い」という誤りだ。この作業が必要とするツールだけを——必要時に取る、コマンドラインのエージェントのように——読み込むのは、検索エンジンの直感だ。関連度で重みづけし、情報密度の最も高いところに注意を使う。

あなたが作るものにとっての意味

だから部族を選ぶ必要はない。一本の通信路に予算をつければいい。エージェントが動き出す前に何を読み込むかを点検せよ——スタックが挨拶だけで六桁の文脈を食うなら、それは機能ではなく漏れだ。必要時読込を優先せよ——ツールは作業が求めたときに取り込み、起動時に一気に流し込まない。MCP のオーバーヘッドは、そのガバナンスが本当に元を取る場所に取っておき、監査証跡の要らない9割のコーディングには、痩せたコマンドラインツールに手を伸ばせ。次にベンダーがサーバーの公開ツール数を自慢したら、呉軍の静かな規則を思い出してほしい——長いメニューは多くの情報ではない。たいていは、もともと太くなりようのないパイプに注ぎ込まれた、ただのノイズだ。通信路は、信号に使え。

大きな道具箱は、多くの情報ではない。

たいていは、太くなれないパイプに詰めたノイズだ——エージェントの通貨はトークンではなく、各トークンがどれだけ伝えるかだ。

枠組みは呉軍『数学の美しさ』より——情報理論、通信路容量、TF-IDF。トークンの数値は2026年の MCP 対 CLI 論争から：ある実在スタックで21,000トークン（Claude の20万窓の10.5%）、Scalekit のベンチマークで1,365（CLI）対44,026（MCP）の32倍差、93ツールの GitHub サーバーで約55,000トークン、典型的な企業スタックは初期化時に10万〜20万。大衆向けテック評論。数値は原報道を基準に。