Why must image tokens be accounted for in the context budget separately from text tokens?

Multimodal models convert images into tokens before they can attend to them. Those **image tokens count against the same context window** as text tokens, they are not free. The number of tokens per image depends on **resolution and provider-specific tiling rules**. - A small thumbnail (under 512 pixels on each side) is typically 100-300 tokens. - A medium image (1024x1024) is typically 500-1000 tokens. - A high-resolution image (2048x2048 or larger) can be 1500-3000+ tokens. For reference, 1500 tokens is roughly equivalent to **2-3 pages of dense text**. One high-res image can equal several pages. If your budget calculator only counts text, it will **under-report the real prompt length**. The model receives a prompt longer than your calculator thinks, which leads to one of three bad outcomes: 1. The prompt overflows the hard window limit and the API returns an error. 2. The provider truncates silently (some APIs do this by default) and the model sees a clipped prompt without any indication. 3. The prompt fits but is far closer to the soft quality budget than expected, and answer quality degrades. The fix is straightforward. Treat images as a **separate accounting line** in the budget. For each image, compute its token cost using the provider's published formula (Anthropic, OpenAI, and Google all publish their image-token math). Add it to the running total. Apply the same eviction rules under budget pressure: drop the least-relevant image first. The rule of thumb: **assume an image is at least 1k tokens until you have measured otherwise**. That gives you a safe upper bound for budget planning.

**Images consume real tokens in the context window**, computed by provider-specific rules that depend on resolution and tiling. A text-only budget calculator silently under-reports prompt length and creates three failure modes: hard-limit overflow with an API error, silent truncation that drops content without notification, or soft-budget quality degradation that the engineer cannot explain. **The token math varies by provider.** **Anthropic's Claude Opus 4.7** computes image tokens as approximately `tokens = (width * height) / 750`, with a maximum of about 1600 tokens per image. A 1568x1568 image is roughly 1600 tokens; a 512x512 image is roughly 350 tokens. **OpenAI's GPT-5.5** uses a fixed cost per tile scheme: a baseline of about 85 tokens plus 170 tokens per 512x512 tile in detail-high mode. A 2048x2048 image is about 16 tiles plus baseline, around 2800 tokens. **Google's Gemini 3.1 Pro** uses approximately 258 tokens per image for typical resolutions, with adjustments for very large images. The exact numbers differ enough that **you cannot guess across providers**, you have to know the math for the model you are using. **Why this breaks a text-only budget.** If your calculator counts text tokens and assumes images are negligible, a prompt that the calculator says is 50k tokens may actually be 60k or 70k tokens depending on the images. When the hard limit is 200k, you might still fit. When the hard limit is 128k, you may overflow. When you are operating near a soft quality budget, you have shifted from comfortably-under to over-budget without realizing it. The failure modes: 1. **Hard overflow**: the API returns a context-length error. Easy to detect, hard to recover from in production. 2. **Silent truncation**: some APIs truncate the prompt to fit and proceed. The model produces an answer that ignores the truncated content. The engineer sees a confusing or wrong answer with no obvious cause. 3.