On November 22, 2026, the same 503 KB of AI agent context came out between 128,484 and 176,040 tokens across 55 open-weight models priced on OpenRouter. At an identical $0.30 per million input tokens, Inkling 2 Small bills 37% more than Command A Plus to read it.

Most AI agent cost comparisons multiply one token count by each model's price. That only works if every model turns your prompt into the same number of tokens. They don't. OpenRouter's API docs say that "credit usage and model pricing are based on these native token counts", meaning each model's own tokenizer. So I ran one agent context through every open-weight tokenizer I could download, to see how much that moves the bill.

What question does this answer?

Short answer: whether you can carry a per-task token count from one open-weight model to another without changing your AI agent cost estimate.

The research question: for the content an agent actually reads (instructions, tool schemas, code, JSON tool results, docs and shell output), how far do token counts differ across the tokenizers of open-weight models sold per token, and does that ever reverse the price order?

This matters for anyone using an AI agent cost calculator. You type in input tokens per task, and the tool multiplies them by a price. That token count belongs to the tokenizer that produced it.

How was the test run?

Short answer: six real public artifacts, 34 published tokenizer files and one price snapshot, all collected on one morning.

  • Corpus (503,269 bytes, 133,105 tokens in OpenAI's o200k_base). Six segments an agent typically holds in context:
    1. Instructions: the AGENTS.md from openai/openai-agents-python (16,627 bytes)
    2. Tool definitions: the 51 tools exposed by the Tavily, Exa, Firecrawl and Brave search MCP servers, serialized as compact JSON with name, description and input schema (130,061 bytes)
    3. Python: langgraph/graph/state.py from LangGraph main (76,500 bytes)
    4. A JSON tool result: the GitHub REST API response for 10 LangGraph issues (66,927 bytes)
    5. Docs: the README of the MCP filesystem server (38,372 bytes)
    6. Shell output: git log --stat -n 25 on LangGraph (174,782 bytes)
  • Models. Every model in OpenRouter's /api/v1/models list with a Hugging Face ID, a non-zero price, a creation date from late May 2026 onward and a downloadable tokenizer, plus gpt-oss and Gemma 4. That gave 55 models and 34 distinct tokenizer files. Kimi ships a tiktoken.model, which I loaded with the split regex from its own tokenization_kimi.py. Everything else loaded through tokenizers.
  • Counting. Raw text only, with no chat template and no special tokens. Ratios are measured against o200k_base, the tokenizer behind gpt-oss.
  • Prices. The OpenRouter list price (pricing.prompt, non-batch), captured at 8:31 AM ET on November 22, 2026.
  • Not covered. Claude, Gemini and GPT-6 tokenizers aren't published, and their counting endpoints need an API key. Those models aren't in this test.

The dataset has one row per model, with token counts per segment, ratios, prices and tokenizer hashes. It's saved as 2026-11-22-agent-context-tokenizer-cost-open-weight-models.csv.

How many tokens does the same agent context cost on each model?

Short answer: 45 of the 55 models land within ±10% of o200k_base. The heaviest tokenizer needs 37% more tokens than the lightest.

Model (OpenRouter ID) Tokens, whole corpus vs o200k Tool schemas Python JSON result Shell log List $/M input $/M per o200k-equivalent token
cohere/command-a-plus 128,484 0.965 0.969 0.988 0.980 0.951 0.3000 0.2896
moonshotai/kimi-k3.1-pro 131,435 0.988 0.994 0.994 0.994 0.980 0.2403 0.2373
minimax/minimax-m3 132,366 0.994 0.990 1.011 1.014 0.986 0.3000 0.2983
openai/gpt-oss-120b 133,105 1.000 1.000 1.000 1.000 1.000 0.0900 0.0900
z-ai/glm-5.3 133,860 1.006 0.988 0.992 1.025 1.014 0.0699 0.0703
mistralai/mistral-large-4-0 133,943 1.006 0.995 1.020 1.008 1.008 0.7000 0.7044
tencent/hy4 135,649 1.019 1.039 1.046 1.035 0.997 0.4170 0.4250
deepseek/deepseek-v4.1-flash 139,308 1.047 1.053 1.074 1.069 1.032 0.0498 0.0521
xiaomi/mimo-v2.6-pro 139,551 1.048 1.014 0.993 1.066 1.084 0.4350 0.4561
qwen/qwen3.8-27b 144,122 1.083 1.013 1.080 1.117 1.119 0.0350 0.0379
nvidia/nemotron-3-ultra-550b-a55b 145,074 1.090 1.074 1.042 1.106 1.120 0.5000 0.5450
google/gemma-4-26b-a4b-it 154,145 1.158 1.055 1.194 1.251 1.191 0.0675 0.0782
thinkingmachines/inkling-2-small 176,040 1.323 1.489 1.375 1.390 1.232 0.3000 0.3968

The median ratio across all 55 models is 1.047. Only 9 models need fewer tokens than o200k_base. The 34 tokenizer files collapse to 22 distinct counts, because labs often reuse a tokenizer across a family. The DeepSeek V4.1 Flash and V4 Pro rows match exactly, as do Qwen3.8 27B and its 2.4T sibling.

Which kind of agent content spreads the most?

Short answer: structured text. JSON tool results and tool schemas spread far more than prose.

The instructions file stays within 0.95 to 1.15x on every tokenizer. The JSON tool result runs from 0.980 (Command A Plus) to 1.390 (Inkling 2). Gemma 4 needs 25% more tokens than o200k_base for that one GitHub API response.

Inkling 2 is the outlier, and its published file shows why. It has the same 200,058-token vocabulary size and the same split regex as the first Inkling, whose counts matched o200k_base on every segment. But it lacks merges for runs of punctuation:

input: {"type":"string","description":"Search query"} inkling-2: ['{', '"', 'type', '"', ':', '"', 'string', '"', ',', '"', 'description', '"', ':', '"', 'Search', 'Ġquery', '"', '}'] -> 18 tokens o200k_base: -> 10 tokens 

Each ", : and , becomes its own token. On the 51 search-tool schemas that adds 49% more tokens. An agent resends its Model Context Protocol tool list on every turn, so that overhead repeats on every call.

Does a lower price per token always mean a cheaper agent?

Short answer: usually yes, but not always. 15 of the 1,485 price-ordered pairs flip.

Among models with different list prices, 15 pairs reverse: the cheaper model on paper costs more to read this corpus. The clearest case:

  • Gemma 4 26B A4B lists at $0.0675 per million input tokens, 3.4% below GLM-5.3 at $0.0699. Reading the corpus costs $0.010405 on Gemma and $0.009357 on GLM-5.3. The cheaper sticker comes out 11.2% more expensive.
  • Inkling 2 Mini ($0.075) costs more than gpt-oss-120b ($0.09) on the same text: $0.013203 against $0.011979.

The bigger effect shows up where prices tie. Four models list at $0.30 per million input tokens: Command A Plus (128,484 tokens), Motif 3 (131,334), MiniMax M3 (132,366) and Inkling 2 Small (176,040). They charge the same sticker and send bills 37% apart. At $0.15, six models range from 132,366 tokens (MiniMax M3.1 Flash) to 145,074 (Nemotron 3.5 Super VL).

Most of the time, price differences dwarf tokenizer differences. Prices in this sample span 133x, from $0.015 (Ling 3.0 Tiny) to $2.00 (Qwen3.8 2.4T) per million. Tokenizers span 1.37x. Tokenizers decide close calls, and close calls are where most model shortlists end up.

How does this change a 30-day agent bill?

Short answer: on a busy agent at the same list price, it can add about $160 a month. That figure is illustrative arithmetic, not a measured invoice.

Take the cost calculator's formula: 30 × tasks per day × tokens × price. Assume 1,000 tasks a day, each reading 50,000 o200k-equivalent input tokens of this mix. Scaled by the measured ratios, that comes to:

Model Input tokens per task 30-day input bill
Command A Plus ($0.30) 48,265 $434.38
MiniMax M3 ($0.30) 49,720 $447.48
Inkling 2 Small ($0.30) 66,130 $595.17
GLM-5.3 ($0.0699) 50,285 $105.45
Gemma 4 26B ($0.0675) 57,905 $117.26

Output tokens, cached-input discounts and chat-template overhead are left out on purpose. A real invoice will differ. The direction won't, because the same scaling applies to everything the model reads. Shrinking the context with context compaction cuts the bill on every tokenizer. Choosing the tokenizer changes how much each kilobyte costs.

How does this connect to what the lab has found in production?

Short answer: price per token was already a weak guide to cost per task. Tokenizers add a second, smaller layer of the same problem.

aiagentsinfo.com, an independent research lab and AI agent directory, found the same pattern one level up. Its report on AI agents in production in 2026 states: "Hold the harness at Codex and the accuracy at 58.18 percent and the listed run cost is still $3,267.18 for GPT-6 Astra against $634.24 for GPT-6.1 Sol, 5.2 times the money for the same printed score." There, the spread comes from how many tokens a model spends on a task. Here, it comes from how many tokens the model counts for the same text. Both mean the per-million price on a model card is only one input to cost per task.

The same report tells builders to log input and output tokens on the same span as successes and retries. If you do, log them from each model's own usage field, not from a count made with another model's tokenizer. For coding-benchmark runs, the benchmark cost per solved task calculator already works from listed run cost, which avoids the problem.

What are the limitations?

Short answer: one corpus, one price snapshot, raw text only, and no closed models.

  • One corpus. A Chinese-heavy or prose-heavy agent will see different ratios. Kimi's split regex, for example, handles Han characters as their own class.
  • Raw text only. Chat templates and tool-call wrappers add per-message tokens that vary by model. Those weren't counted.
  • List prices, not invoices. OpenRouter routes to providers. Batch, cached and provider-specific prices were excluded.
  • Published tokenizer files. I assume a provider bills with the tokenizer on the model's Hugging Face page. OpenRouter says it bills native counts, but I didn't send paid requests to confirm the totals.
  • Closed models are missing. Claude, Gemini and GPT-6 tokenizers can't be counted offline.

What should you do before comparing AI agent costs?

Short answer: measure tokens per model on your own context, then multiply by price.

  1. Save one real agent turn: system prompt, tool list and a typical tool result.
  2. Count it with each candidate's tokenizer, or send it once and read the usage field.
  3. Put those per-model counts into the AI agent cost calculator instead of one shared number.
  4. Check the size of your tool JSON with the prompt and tool checker. Tool schemas were the segment with the widest spread here.

For context on the tools behind those schemas, aiagentsinfo.com's directory lists 743 AI agent tools, each checked against a working site.

Data: 55 OpenRouter models, 34 tokenizer files from Hugging Face, and one 503,269-byte agent corpus, counted on November 22, 2026, 8:31 to 8:50 AM ET. Prices from openrouter.ai/api/v1/models at the same time.

Sarath is the founder of aiagentsinfo.com, the research lab and directory for AI agents.

This article was written with AI assistance and reviewed for accuracy.