AIArticle
Developers are rendering code and system prompts as PNGs to exploit a massive loophole in LLM token pricing.
When Anthropic dropped Claude Fable 5 on June 9, 2026, it felt like a classic Faustian bargain. On one hand, the model is an absolute monster. It boasts a 1-million-token context window, always-on adaptive thinking, and enough raw reasoning power to pull off stunts like Stripe migrating a 50-million-line Ruby codebase in a single day. On the other hand, it costs $10 per million input tokens and $50 per million output tokens. That is exactly double the price of Claude Opus 4.8.
Worse, Fable 5 uses a new tokenizer that can consume up to 35% more tokens for the exact same text. It does not take long for agentic workflows to run up eye-watering bills. Developer Simon Willison famously blew through $110.42 in a single day during an active coding session.
Faced with these prices, developers are getting weird. The most creative, counterintuitive cost-saving hack to emerge is pxpipe, an open-source local proxy that intercepts your API requests, takes your dense text context (system prompts, tool documentation, older chat history), renders it into a PNG image, and feeds that image back to the model.
The result is a 60% to 70% reduction in end-to-end API costs. It sounds like a joke, but the math behind this token arbitrage is entirely real.
The Token Arbitrage Math #
To understand why converting text to images saves money, you have to look at how frontier models charge for multimodal inputs.
For text, you pay per token. Because of the way tokenizers split code, JSON, and system prompts, text density is highly inefficient. On typical developer workloads, you get roughly one character per text token.
For images, however, the token cost is fixed strictly by the pixel dimensions of the image, completely ignoring what is actually inside the frame. When you reflow and pack dense text (like code or API documentation) into a highly compact image, you can cram about 3.1 characters into the equivalent of a single image token.
This spatial compression creates a massive arbitrage opportunity. In one real-world benchmark run by pxpipe, a block of system prompts and tool documentation containing roughly 48,000 characters of text (which would normally cost 25,000 text tokens) was rendered into a single image. The model ingested that image for just 2,700 tokens.
That is a 9x reduction in input tokens for that block of context. Because input costs dominate long-horizon agentic sessions, this translates directly to a 59% to 70% drop in the end-to-end bill. On compressed requests, the savings can climb as high as 74%. In a side-by-side demo, a standard Claude Code session racked up $42.21 in costs and filled 96% of the context window, while the pxpipe-enabled session solved the same tasks for $6.06 with plenty of context to spare.
How the Proxy Hijacks Your Context #
You do not have to manually take screenshots of your IDE to use this. The pxpipe tool operates as a local proxy that sits between your development environment and the Anthropic API.
When you run Claude Code or any other agentic tool, you point its base URL to the local proxy:
npx pxpipe-proxy
export ANTHROPIC_BASE_URL=http://localhost:47821
claude
The proxy intercepts the outgoing request to the claude-fable-5
model. It leaves recent conversation turns as raw text so the model has immediate, byte-exact access to your latest instructions. However, it takes the bulky, static parts of the request (the system prompt, tool schemas, and older history), minifies the whitespace, reflows the text into full rows, and appends an OCR instruction banner on top.
It then renders this text block into a compact PNG and swaps the raw text out for the image before forwarding the payload to Anthropic. The proxy also serves a local dashboard at http://127.0.0.1:47821
where you can monitor token savings, view side-by-side text-to-image conversions, and toggle a global kill switch.
The Catch: Silent Confabulation and the Lossy Limit #
If this sounds too good to be true, that is because it comes with a major catch. This is a "gist tier" optimization, not a lossless database.
While Fable 5 is remarkably good at reading text from images (it scored 100/100 on pxpipe's clean reading evals and successfully completed complex multi-step ledger arithmetic from imaged data), older models like Opus 4.8 completely fall apart on this task. Even on Fable 5, there is a hard limit to what the vision encoder can reliably extract.
In a needle-in-a-haystack evaluation testing the recall of 12-character hexadecimal strings embedded deep within dense imaged content, Opus scored 0/15. Fable 5 managed a highly impressive 13/15, but those two missed strings highlight the real danger: silent confabulation.
When the model fails to read a pixelated string, it does not throw an error. Instead, it confidently invents a plausible but incorrect value.
Because of this, anything that requires byte-exact precision (API keys, secrets, commit hashes, database IDs, or exact floating-point numbers) must remain as text. If your agent needs to extract a specific hash to run a git checkout, sending that hash as an image is a recipe for broken pipelines.
There are also minor behavioral quirks. In testing, the image-fed version of Fable 5 occasionally struggled with single-reply formatting compliance, requiring an extra follow-up prompt to output data in the exact requested layout, whereas the text-fed version nailed it on the first try.
The New Era of Model Triage #
The existence of hacks like pxpipe underscores a broader shift in how developers are building with AI. As models grow more powerful and exponentially more expensive, "model triage" is becoming a core software engineering skill.
We are moving away from the naive approach of routing every single LLM call to the most powerful model available. Instead, developers are building multi-agent loops that treat Fable 5 as a high-priced architect and cheaper models as the construction crew. For example, some teams use Fable 5 strictly for high-level planning, hand off the code execution to OpenAI's Codex 5.5 (which costs a fraction of the price), and then bring Fable 5 back in for the final code review.
Using pxpipe is a variation of this triage. It acknowledges that while Fable 5's reasoning engine is incredibly overpowered, we do not need to pay a premium to feed it raw text instructions over and over again.
For now, this image-OCR trick is a brilliant, highly functional loophole. But it is likely a temporary one. Anthropic could easily close the gap by adjusting its vision token pricing or updating its tokenizer. Until they do, running a local proxy to turn your code into pictures is one of the smartest ways to keep your development budget from vaporizing.
Sources & further reading #
60% Fable cost cut by converting code to images and having the model OCR it— github.com - Utah Senator's Data Center Victory Lost as AI Boom Causes Voter Backlash - YOLCY— yolcy.com - Claude Mythos pricing in 2026: Fable 5 costs, Mythos 5 costs, and what every model actually runs— cloudzero.com - Claude Fable cost $9 in one coding test. GPT-5.5 cost $1.50. Model triage is the new AI skill. - The New Stack— thenewstack.io - How to Model Fable 5 Costs Before They Blow Up Your Budget - Developers Digest— developersdigest.tech
Rachel Goldstein· Dev Tools Editor
Rachel has been embedded in the developer tooling ecosystem for nearly eight years, covering everything from IDE wars and package-manager drama to the quiet rise of AI-assisted coding. She has a soft spot for open-source maintainers and an unhealthy number of terminal emulators installed on a single laptop.
Discussion 0 #
No comments yet
Be the first to weigh in.