The Hidden Token Tax: What Real AI Agents Actually Cost Per Turn

The thesis

An AI agent re-sends its entire system prompt plus every tool/function schema on every single turn. That fixed payload is billed as input tokens on each request — invisibly — until the bill arrives. We measured it across 13 real open-source projects (79 tools total).

Top findings

Six things the data makes hard to argue with.

The dataset

13 real open-source agents, 79 tools. Overhead / turn is the fixed payload re-sent on every request; $/1k turns projects that across 1,000 turns plus a modeled 150-token reply. See the per-server MCP token cost reference for each server's exact numbers.

Scroll the table sideways on mobile to see every column.

Methodology

Every number reproducible.

• Tokenizer: o200k_base (GPT-4o BPE) via gpt-tokenizer. An ESTIMATE for Claude (Anthropic's differs a few %), applied identically to every agent so cross-agent comparisons are fair. Cross-validated against Python tiktoken (o200k_base) — identical counts to the token.
• A "tool" = the object the model sees ({name, description, input_schema}) serialized to compact JSON, as the SDKs send the tools array.
• Schema fidelity: Pydantic models re-run through model_json_schema(); zod schemas through zod-to-json-schema; literal-JSON schemas extracted verbatim.
• Cost model: per-turn input = fixed overhead; per-turn output = a modeled 150-token reply. Sonnet $3/M in, $15/M out; Haiku $1/M in, $5/M out. Projected over 1,000 turns.
• Pinned sources: modelcontextprotocol/servers @ f5054df1fb86; servers-archived @ 9be4674d1ddf; anthropics/anthropic-quickstarts @ f37f1685e256; stackblitz/bolt.new @ eda10b121221.

Caveats

Stated honestly — the credibility lives here.

• Tokenizer is a Claude estimate (o200k_base is GPT's); absolute dollar figures carry a few-percent error bar. Applied uniformly, so relative comparisons and structural conclusions are robust.
• Provider-side tool-block scaffolding not modeled; real bills will be marginally higher.
• zod/Pydantic schemas are reconstructed via the same converters the servers use, not byte-captured; a few tokens may differ. Literal-JSON schemas are verbatim/exact.
• Schema-derived tools only — agents whose schemas are generated at runtime from code we couldn't reproduce exactly (e.g. Cline, gpt-researcher, OpenAI Swarm, Codex) were excluded rather than guessed. Cline in particular likely exceeds bolt.new but requires running its build to measure.

Cited repositories

Every agent measured, linked to the exact source.

• GitHub MCP github.com/modelcontextprotocol/servers-archived/tree/main/src/github
• GitLab MCP github.com/modelcontextprotocol/servers-archived/tree/main/src/gitlab
• Git MCP github.com/modelcontextprotocol/servers/tree/main/src/git
• Sequential Thinking MCP github.com/modelcontextprotocol/servers/tree/main/src/sequentialthinking
• Slack MCP github.com/modelcontextprotocol/servers-archived/tree/main/src/slack
• Google Maps MCP github.com/modelcontextprotocol/servers-archived/tree/main/src/google-maps
• Puppeteer MCP github.com/modelcontextprotocol/servers-archived/tree/main/src/puppeteer
• Brave Search MCP github.com/modelcontextprotocol/servers-archived/tree/main/src/brave-search
• AWS KB Retrieval MCP github.com/modelcontextprotocol/servers-archived/tree/main/src/aws-kb-retrieval-server
• Fetch MCP github.com/modelcontextprotocol/servers/tree/main/src/fetch
• Time MCP github.com/modelcontextprotocol/servers/tree/main/src/time
• Anthropic quickstarts agent github.com/anthropics/anthropic-quickstarts/tree/main/agents
• bolt.new github.com/stackblitz/bolt.new

These are estimates. Token counts are computed with a GPT BPE tokenizer (o200k_base); Anthropic's tokenizer differs by a few percent, so absolute dollar figures carry a few-percent error bar. Applied uniformly across every agent, so the relative comparisons and structural conclusions are robust — but verify against your provider's real pricing and tokenizer before budgeting on any single figure.

Fix it: slim your tool schemas

The cruft — $schema, additionalProperties, and Pydantic's auto-added title — carries no tool-selection signal, so you can strip it with zero accuracy cost and send compact JSON. Drop this in before you pass tools to the API:

Node / TypeScript

const strip = (o) => Array.isArray(o) ? o.map(strip)
  : (o && typeof o === "object")
    ? Object.fromEntries(Object.entries(o)
        .filter(([k]) => !["$schema", "additionalProperties", "title"].includes(k))
        .map(([k, v]) => [k, strip(v)]))
    : o;

// compact, cruft-free — send this to the model
const tools_slim = JSON.stringify(strip(tools));

Python

import json

def strip(o):
    if isinstance(o, list):  return [strip(x) for x in o]
    if isinstance(o, dict):  return {k: strip(v) for k, v in o.items()
                                     if k not in ("$schema", "additionalProperties", "title")}
    return o

tools_slim = json.dumps(strip(tools), separators=(",", ":"))  # compact, cruft-free

One caveat: additionalProperties: false is occasionally intentional (strict validation) — drop it from the strip list if you rely on it. Measure before/after with the free profiler, which now flags this cruft for you automatically.