The Hidden Cost of Images in AI Agent Context Windows

675,000 dead images. 573 billion wasted tokens. 2.3 terabytes of redundant data — every single day.

By Joe Loves Tech · March 29, 2026

The Problem Nobody Talks About

Every AI agent framework that supports images — OpenClaw, LangChain, CrewAI, AutoGen — stores them as raw base64 in session history. When an image enters a conversation, it stays there. Forever. Getting re-sent to the API on every single turn.

That screenshot your agent received 40 turns ago? Still in context. Still costing tokens. Still eating your context window. And every compression tool on the market explicitly skips images.

OpenClaw's built-in /compact command? Skips images. Context Gateway? Skips images. Agno CompressionManager? Skips images. The pruning system literally says in the documentation: "Tool results containing image blocks are skipped (never trimmed/cleared)."

Everyone compresses text. Nobody touches the images.

The Math (Show Your Work)

Start with the OpenClaw ecosystem

OpenClaw crossed 250,000 GitHub stars in March 2026, surpassing React. With a conservative 5–10% active install rate for a daily-driver tool, that's 12,500–25,000 active instances.

Using moderate estimates:

• 12,500 active OpenClaw installations
• Average 3 agents per instance
• 37,500 total agent sessions
• Average 18 images per active session (from our production fleet of 10 agents)

Each image stored as base64 costs approximately 17,000 tokens. That's 60–100KB of raw encoded data per image.

But here's the part that hurts: images don't cost you once. They cost you every turn.

Every time the agent processes a message, the entire session history — including every image — gets sent to the API. A single conversation with 5 images costs 75,000+ extra tokens on every API call.

Scale that up

For context: 2.3 TB is equivalent to streaming about 750 hours of HD Netflix. Every day. Except nobody's watching — it's just screenshots from last Tuesday being re-tokenized by GPUs that have better things to do.

Where the Waste Goes

That 2.3 TB/day doesn't just vanish. Every redundant image re-send triggers a cascade:

1. Network transfer — base64 data uploaded from the user's machine to the API endpoint
2. API server parsing — the JSON payload gets deserialized, the base64 gets decoded
3. Image processing — the vision encoder (CLIP/ViT) tiles the image into patches and converts to token embeddings
4. Attention computation — every image token attends to every other token in the context window (O(n²) complexity)
5. GPU memory — VRAM allocated to store and process image representations that will be immediately irrelevant
6. Electricity — actual watts powering inference on pixels from a conversation that moved on 30 turns ago
7. Carbon emissions — real CO₂ for literally nothing

And this happens on every turn, for every agent, for every image, all day long.

The API provider (Anthropic, OpenAI, Google) bears the compute cost. The user bears the token cost. The planet bears the carbon cost. Nobody benefits.

Why Can't Agents Just… Forget Images?

The current architecture makes this surprisingly hard:

Session history is append-only. When an image enters the conversation, it becomes part of the immutable session log. The model needs the full conversation history to maintain coherence, so you can't just drop messages.

Compaction summarizes text, not images. When OpenClaw's /compact command runs, it summarizes the text conversation into a shorter form. But images are binary blobs — you can't "summarize" raw base64. So compaction skips them entirely.

Pruning is too conservative. OpenClaw's session pruning system trims old tool results to save space. But it explicitly exempts image blocks, likely because removing an image the model might still reference could cause hallucination or confusion.

The result: Images are the one content type that enters the context window and never leaves. They're the cockroaches of the token economy.

The Fix — Three-Tier Extraction

What if instead of carrying the raw image, you carried a complete text description of everything in it?

That's what Shrink does. It's the first multimodal context optimizer for AI agents. For each image in session history, Shrink:

1. Reads the surrounding conversation to understand why the image was shared
2. Sends the image to a vision model with a context-aware prompt
3. Extracts three tiers of information:
   • CONTEXT — why the image matters in the conversation
   • DATA — every readable value (text, numbers, IDs, dates, amounts)
   • VISUAL — design details (colors, layout, spacing, typography)
4. Replaces the base64 blob with the structured text description

Before: ~17,000 tokens of opaque base64
After: ~500 tokens of searchable, referenceable, structured text

Six months from now, when someone asks "what was the exact PIN number on that property tax case?", the answer is right there in the DATA tier. With the raw image, the model would have to re-interpret pixels. With Shrink, it's just reading text.

Real Numbers from a Production Fleet

We built Shrink and tested it on a production 10-agent OpenClaw fleet on the same day:

$0.08 to free 3.3 million tokens. The dedup detection caught 50 duplicate images (28% of total) and reused descriptions — those cost zero additional API calls.

ROI breakeven: 0.11 turns. The tool pays for itself before the first response completes.

The Scale of What's Possible

If every OpenClaw instance ran Shrink once:

And that's just OpenClaw. The broader agent ecosystem — LangChain, CrewAI, AutoGen, custom frameworks — multiplies these numbers by 10–50×.

What Needs to Happen

Short term (now)

Use Shrink. It's open source, takes 30 seconds to install, and works today.

clawhub install shrink

Medium term

Agent frameworks should build image lifecycle management into their context engines. Images should have a TTL — after N turns without reference, automatically extract and replace.

Long term

API providers should offer server-side image deflation. If Anthropic's API knows an image hasn't been referenced in 20 turns, it could automatically serve a cached description instead of re-processing the raw pixels. The inference savings alone would justify the engineering investment.

The current state — where every image persists at full fidelity forever — is a design artifact from when multimodal models were new and images were rare. In 2026, with agents receiving dozens of screenshots per session, it's unsustainable.

clawhub install shrink