# I Asked My AI "Who Are You" — It Cost 42,000 Tokens to Answer > Source: > Published: 2026-07-24 09:43:22+00:00 I typed a 19-character question into Claude Code: who are you? Then I opened the network logs of what my machine actually sent over the wire. I recommend you never do this. It ruins something in you. My question was **19 bytes**. The request that carried it was **118,693 bytes**. That's a 6,200x amplification before the model reads a single word I wrote. My actual message was **0.016%** of the payload. If this were a letter, I'd be mailing a phone book with a Post-it note inside. Here's the pie, byte for byte: | What | Bytes | Share | |---|---|---| | 38 tool JSON schemas | 78,935 | 66.8% | | System prompt (behavior manual, safety rules, my git status) | 22,178 | 18.8% | A list of 60 more tools it could load, plus 25 skill descriptions | 16,844 | 14.3% | | My memory files, my email address, today's date | 1,126 | 1.0% | My question | 19 | 0.016% | And the tool schemas aren't even schemas, mostly. Of those 78,935 bytes, only 29,164 are machine-readable JSON schema. The other **44,392 bytes are English prose** — instruction manuals for the model, shipped on every single request. One tool alone, `Workflow` , carries a 19,012-byte description. That's a small essay. It rides along on every message I send, forever, whether I orchestrate a multi-agent workflow or just say "hi." Sixteen of the 38 tools are for driving a browser preview I never opened. There's an iOS Simulator controller in there. I was asking a chatbot its name. Every tool schema in that request, largest first. "Prose" is the English description; "schema" is the actual machine-readable part. Approximate tokens = bytes ÷ 4. | Tool | Bytes | Prose | Schema | ~Tokens | Did I need it? | |---|---|---|---|---|---| | Workflow (multi-agent orchestration) | 21,609 | 19,012 | 1,833 | ~5,400 | No | | Artifact (publish web pages) | 10,679 | 6,358 | 4,002 | ~2,670 | No | | AskUserQuestion | 4,371 | 1,097 | 3,149 | ~1,090 | No | | iOS Simulator control | 3,976 | 1,307 | 2,518 | ~990 | No | | ScheduleWakeup (self-pacing loops) | 3,942 | 2,685 | 1,068 | ~985 | No | | visualize show_widget | 3,038 | 648 | 2,259 | ~760 | No | | Agent (spawn subagents) | 3,037 | 1,574 | 1,342 | ~760 | No | | Bash | 2,860 | 1,290 | 1,456 | ~715 | No (but fair) | | ReportFindings (code review UI) | 2,314 | 574 | 1,646 | ~580 | No | | Browser computer (mouse/keyboard) | 2,141 | 193 | 1,837 | ~535 | No | | Skill | 1,699 | 1,244 | 345 | ~425 | No | | Read | 1,670 | 790 | 776 | ~420 | No | | Browser preview_start | 1,656 | 1,328 | 143 | ~415 | No | | spawn_task (background task chips) | 1,553 | 664 | 765 | ~390 | No | | ToolSearch (loads MORE tools) | 1,522 | 953 | 427 | ~380 | No | | mark_chapter (session table of contents) | 1,092 | 699 | 256 | ~275 | No | | Edit | 1,037 | 360 | 584 | ~260 | No | | dismiss_task | 918 | 560 | 234 | ~230 | No | | + 20 more (browser tabs, navigation, console readers, form filler, widget reader, Write…) | ~9,800 | — | — | ~2,450 | No | Total | 78,935 | 44,392 | 29,164 | ~19,700 | 0 of 38 used | Read that last column again. The model answered my question using **zero** of the 38 tools it was handed. Then notice `ToolSearch` : a tool whose only purpose is to fetch *even more tools* — there are ~60 additional ones (WebSearch, WebFetch, cron schedulers, task managers, notebook editors, a whole second browser that drives my real Chrome, password-manager integration) waiting behind it, listed by name in that 16.8KB deferred-tools block. The request contains a tool for requesting tools. We have achieved tool-calling recursion. The prose-to-schema ratio is the tell. `Workflow` 's description is 19KB of instruction manual — pipeline semantics, barrier vs. no-barrier philosophy, seven design patterns with code examples, a "smell test" for when you're using it wrong. It's genuinely well-written documentation. It is also transmitted to a datacenter every time I type "ok". I audited my own machine after this. Here's the honest control surface, verified against my actual config files — with guesses labeled as guesses. **Things I verified you CAN control:** `~/.claude/settings.json` ). Delete the hook block, it's gone.`~/.claude/projects//memory/` . Delete them, they stop being sent. (The app injecting my email address alongside them — that part has no knob.)`anthropic-skills` plugin. Uninstalling it removes ~25 skill descriptions from every request.`DISABLE_TELEMETRY=1` , `DISABLE_ERROR_REPORTING=1` , `CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1` are documented switches for the ~600KB `tengu_*` firehose. (Documented — I haven't packet-captured a session with them on yet. Trust, but HAR-verify.)`claude` doesn't load. Using the terminal is the single biggest schema diet available to a normal user.**Things you CANNOT control, period:** `tengu_workflows_enabled: true` , `tengu_report_findings_tool: true` , `tengu_chrome_auto_enable: true` ). There is a `--disallowedTools` launch flag on the CLI, but the desktop app exposes no such thing in its UI.`.claude.json` ) is a cache that re-syncs on their schedule. I found flags in mine for experiments I've never seen, promo banners, A/B copy tests, per-model "velvet hammer" variants (twenty-two of those, whatever they are), and two remote kill switches — `tengu-off-switch` and `tengu-fable-off-switch` — that Anthropic can flip and I cannot.`metadata` of every model call. OS, arch, node version, shell, package managers go in the telemetry. None of it optional.The asymmetry is the story. The user's levers — a hook, some markdown files, one plugin, an env var — govern maybe 3% of the payload. The other 97% is decided by people you've never met, toggled by flags with names like `tengu_amber_moleskin` , shipped to you on every keystroke, and cached with a straight face. The response to my question was **127 tokens** — 47 of them the model privately thinking "user's being blunt, keep it brief," and 80 tokens of actual answer. Generating those 127 tokens takes well under a second. The other ~8 seconds? The model had to ingest **42,270 tokens of context** first — and 13,445 of them weren't in the prompt cache yet, because this was the session's first message. I paid an eight-second cold-start tax so the model could re-read the operating manual for a browser I never launched. The economics in one line: **42,270 tokens in, 127 tokens out.** A 333:1 read-to-write ratio. To say hello. While answering me, the app quietly made a **second, parallel model call** — to a different, smaller model — whose entire job was to invent a title for the sidebar. Input: my rude question. Output: `"Clarify Claude agent identity"` . Five hundred twenty-one tokens of prompt to produce four polite words I never asked for. After the answer landed, the client fired **40 more API calls in one burst** — all to a token-counting endpoint. Why 40? It was measuring itself: one call per slice of its own system prompt, plus one call per tool sending the string `"foo"` next to a single schema, so it could subtract the baseline and learn each tool's exact token weight. The app literally runs a scientific experiment on its own bloat, every session, to render a little context meter. And the telemetry. Oh, the telemetry. In the same 15-second window: **~600KB across 184+ events**, every one namespaced `tengu_` — Anthropic's internal codename for Claude Code. `tengu_feature_ok` fired 72 times, once per remote feature-flag check. `tengu_skill_loaded` fired 48 times. The telemetry shipped to log my question *outweighed the question* by a factor of thirty thousand. (To be fair: I grepped every event — my actual words appear in none of them.) I went looking for the config file where I'd opted into all this. It doesn't exist. My settings contain a theme and one hook. My MCP server list is empty in every project. Every fat tool, every schema, every deferred-tool stub is switched on by **~370 server-side feature flags** with names like `tengu_velvet_hammer_opus_4_8` and `tengu_amber_moleskin` , cached to my disk and re-synced whenever the mothership pleases. There's even a complete 5KB onboarding-guide prompt template embedded *inside the flag cache*, sitting on my SSD in case a feature I've never used ever wants it. There are two kill switches in that file: `tengu-off-switch` and `tengu-fable-off-switch` . Neither is mine to flip. Here's the part that annoys me most: it's not even stupid. The 100KB of scaffolding is prompt-cached — I pay full prefill once per session, then it's cheap cache reads. The deferred-tool list I mocked exists precisely to *avoid* sending 60 more schemas. The 8.7 seconds is a one-time tax; turn two is fast. Every individual decision is defensible. The system is locally rational and globally deranged — a machine that ships a library with every postcard and has optimized the shipping. But step back. A human answering "who are you" needs zero context refresh, no tool manifest, no telemetry burst, no second brain generating a title. We've built agents that must be handed their entire identity, capabilities, safety rules, and worldview from scratch on every request, because the underlying model remembers nothing. Statelessness is the original sin; everything else — the caching, the deferral, the 40-call self-measurement — is increasingly elaborate penance. 19 bytes in. 118,693 bytes of context, 600KB of telemetry, 43 API calls, two models, and 8.7 seconds later: "I'm Claude Code." I know. I read the packet capture.