Published: 2026-07-07
Summary

The Fable 5 "Context as Image" Hack: Cut Input Tokens ~30–60%

Chapters / key moments (click to jump — plays here on the page)

Nick Saraev demos a token-cost hack for Claude Code / Fable 5: render bulky context (system prompt, tool docs, history, long knowledge files) as a single tiny-but-legible image instead of text. Because image billing is fixed by pixel dimensions — not by how much text is inside — a 1928×1928 image can carry far more characters per token than plain text, cutting input-token cost roughly 30% on general prompts and up to about 59% on large "needle-in-a-haystack" retrieval queries, with no measured loss in recall. He's candid that it exploits current image-vs-token pricing and will likely be patched.

Source video

"NEW Fable 5 API Usage Exploit (Reduce Costs Immediately)" by Nick Saraev — Watch on YouTube →

Why it works

An image's token cost is fixed by its pixel dimensions, not by the amount of text rendered inside it. Shrink legible text into a fixed-size image and you pay a flat vision-token cost no matter how many characters it holds — and Fable's OCR is strong enough to read very small text, so legibility (not size) is the only real limit.

Key Takeaways

Image billing is fixed by pixel dimensions, not text volume. That's the whole arbitrage: the same context costs less when it arrives as a compact image than as tokens of text.
Measured result on a general prompt: $1.03 as text dropped to $0.69 as an image — about 33% off (59,822 → 38,142 cached tokens) with zero difference in the model's ability to recall the text.
Measured result on a large retrieval task: input tokens fell 68.7% and cost fell ~59%. The bigger and more retrieval-heavy the prompt, the larger the saving.
The math: a 1928×1928 image costs a fixed number of vision tokens and holds a set character count; compare that against Claude Code's average characters-per-token to see when the image wins.
Best for massive, long-lived, frequently-recycled prompts (hundreds of thousands of tokens powering a business function) — not worth it for short everyday queries.
Legibility is the only constraint. You can optimize the layout further (e.g. justifying text) for more savings, as long as the OCR can still read it.
Caveat: this arbitrages current image-vs-token pricing and will probably be patched; it also assumes you're on API pricing. Treat it as a temporary optimization, not a permanent architecture.

How He Built It

Rather than feeding prompts directly, he had Fable build a small pipeline (a script he calls pxpipe.py): store your prompts in a file, run the script to render them into a fixed-size image, then feed the image to Fable. He described the goal to Fable by voice using Hex (a free local voice-to-text tool running on Parakeet) inside a Ghostty terminal, then pasted in the reference repo for the technique. The pipeline is the reusable part — a skill that one-shots any long prompt file into an image before it hits the model.

Tools & Scripts Mentioned

pxpipe.py   — generated pipeline: prompts file -> rendered image -> Fable
Hex         — free, fully-local voice-to-text (runs on Parakeet)
Ghostty     — terminal used for the demo (any Claude Code terminal works)

What you can actually set up from this

Extracted from the video's own transcript — the specifics the original summary left out.

Configuration shown

Image size example from the video

A 1928 by 1928 pixel image: the script computes its approximate vision-token cost against how many characters fit in it, versus the average characters per token of real Claude Code traffic. That ratio is where the saving comes from.

Template shown in the video. Adapt to your project — do not copy verbatim without reviewing each line.

Reproducible steps

The idea
Render a bulky prompt (system prompt, tool docs, history, a long knowledge file) as a small-text image and send the image instead. The speaker's claim is that image billing is set by pixel dimensions, not by how much text is inside, so a dense image costs fewer tokens than the same text. He says Fable reads tiny text accurately enough that recall did not change.
How he built it
He dictated a request into Claude Code, pointed it at a GitHub repo called pxpipe, and had Fable build a small script (pxpipe.py) that takes a prompt stored in a file, renders it to an image, and sends that. He used a free local voice-to-text app called Hex (Parakeet model) to dictate.
Test 1: same prompt as text vs as image
Text version cost $1.03; image version cost $0.69, a little over 30% lower. Cached-rate tokens fell from 59,822 to 38,142.
Test 2: needle-in-a-haystack questions over a very long knowledge file
He stored every video he has uploaded, with performance data, in one large text file and asked specific retrieval questions through the API at Fable 5 pricing. Input tokens fell 68.7% and cost fell 59%.

Gotchas

The speaker says this arbitrages how image tokens are billed and expects it to be patched "pretty quick"; treat the saving as temporary.
He would not use it on every query. It pays off for very large prompts (hundreds of thousands of tokens) that are reused heavily, and most for retrieval-style questions over long text.
The text must stay legible; the demo images were a compressed layout and he says justified text could do better.
Promotional: the video ends in a pitch for his paid programme. The figures come from one run each, and the pxpipe repo is a third-party lead, not something verified here.