A Fable 5 Cost-Saving Trick Goes Viral: Cut Bills by Up to 70% with Image-Based Context

IntroductionA surprisingly old-school trick has started getting attention in the Fable 5 community: turn long text context into dense images, then let the model read the images back through its vision capability.It sounds almost like making a tiny cheat sheet for an exam. But in this case, the “cheat sheet” is not for a person. It is for a multimodal model that can read screenshots. One developer found that by converting Claude Code context into tightly packed PNG images, the input token bill could drop by roughly 59% to 70% in tested workloads.The basic idea is simple: system prompts, tool documentation, command outputs, logs, and older conversation history are often extremely token-heavy. If those blocks are rendered into images, their image-token cost is mainly tied to image dimensions rather than the amount of text packed into the image.This article walks through what pxpipe does, why the method can save money, where it breaks down, and how it connects to earlier research such as CLIPPO and newer optical-context-compression work like DeepSeek-OCR.## Source NoteThis article is based on the original Chinese article published on BAAI Hub, which states that the source came from QbitAI on WeChat. The original reference links include the pxpipe GitHub repository and the CLIPPO paper. Images kept below are article-relevant screenshots, demos, diagrams, and social discussion screenshots. QR codes, promotional follow prompts, engagement CTAs, and unrelated platform decoration have been removed.## Turn Context into a “Cheat Sheet” and Cut the BillThe method that went viral is called pxpipe. It is an open-source local proxy that rewrites bulky Claude Code input context before the request leaves your machine.According to the project description, pxpipe reduces token usage by rendering large text blocks as images. The same system prompt, tool docs, tool outputs, and older history can be packed into a much smaller token footprint when the model is capable enough to read dense rendered text.In one example, about 48,000 characters of system prompt and tool documentation would take around 25,000 tokens as plain text. Rendered into a 1573 × 1248 image, the same content reportedly used about 2,700 image tokens.That difference is where the cost reduction comes from.The rough logic is:1. Text token cost grows with the amount of text.

1. Image token cost is largely determined by pixel dimensions.
2. Dense code, JSON, tool output, system prompts, and logs often contain many tokens per line.
3. If the model can still read the compressed image reliably, the same context can become cheaper to send.Some developers joked that this is a literal case of “a picture is worth a thousand words.” In this case, the joke is unusually close to the technical reality.## What pxpipe Actually Doespxpipe is not a new model, and it is not a traditional OCR engine. It works as a local proxy between Claude Code and the model API.Before a request is sent out, pxpipe looks for large blocks that are suitable for compression. It then renders those blocks into compact PNG pages and places them back into the request as image inputs. The model reads those pages using its normal vision channel.In plain terms, pxpipe behaves like an automatic micro-printer for long context. It does not make the model “OCR” text in the strict engineering sense. Instead, it relies on the model’s built-in ability to read screenshot-like visual input.The pxpipe README explains that it focuses on bulky input context such as:- Large tool_result bodies, including file reads, command output, and logs.

• Older collapsed conversation history.
• Static system prompts and tool documentation.It deliberately avoids converting everything. Recent turns, user messages, exact identifiers, small blocks, sparse prose, and model output remain text.## Why It Can Save So MuchThe core pricing mismatch is that image inputs and text inputs are measured differently.For text-heavy developer workflows, the source material is often token-dense. Code, logs, JSON, stack traces, and tool schemas can be expensive when sent as plain text. pxpipe’s author estimates that in real Claude Code traffic, dense content can pack roughly 3.1 characters per image token, compared with about 1 character per text token.That ratio gives pxpipe room to reduce cost when the text is dense enough.The author also shared a comparison demo. In the original text version, a test run reportedly ended with a bill of $42.21 and a nearly full context window. In the pxpipe version, the same task completed at $6.06 with much more context space left.The important detail is that pxpipe only compresses the request side. The model’s response still streams back normally as text. It does not compress output tokens.## Benchmark Results and the Main CaveatThe method is impressive, but it is not lossless. Dense image context depends heavily on the model’s visual reading ability.The pxpipe benchmark screenshot shows that Fable 5 performs well on several image-context tasks, including novel arithmetic, gist recall, state tracking, and some dense-render recall tests. But exact string recall is a weak point, especially on models that are not strong dense-text readers.![图片展示的是Fable 5在不同测试任务中的表现数据。表格包含测试、样本数N、文本、pxpipe（图像）和tokens等列。如“novel arithmetic”测试，claude
• fable
• 5和claude
• opus
• 4
• 8的文本均为100%，pxpipe（图像）分别为100%和93%，tokens变化均为-38%。此外，还有“gist recall A/B”“state tracking”等测试数据。该图与上下文紧密相关，是对文档中Fable 5在图像
• 文本任务表现的直观呈现。](https://we0-cms.oss-cn-beijing.aliyuncs.com/cms-assets/image/2026/07/91a2665d-2d20-4b76-9dfe-a9416cf2685c-09-fc96a503-72cb-43c4-9f12-52f05dcbd382.png)A simplified version of the reported benchmark table looks like this:| Test | N | Text | pxpipe Image | Token Change |
  |-|-|-|-|-|
  | Novel arithmetic, claude-fable-5 | 100 | 100% | 100% | -38% |
  | Novel arithmetic, claude-opus-4-8 | 100 | 100% | 93% | -38% |
  | Gist recall A/B, Fable 5 | 98 per arm | 98/98 | 98/98 | — |
  | State tracking, Fable 5 | 18 per arm | 18/18 | 18/18 | — |
  | Confabulation on never-stated facts, Fable 5 | 16 per arm | 0/16 | 0/16 | — |
  | Verbatim 12-char hex recall, Opus | 15 | 15/15 | 0/15 | — |
  | Verbatim 12-char hex recall, Fable 5 | 15 | — | 13/15 | — |The danger is clear: image-based context can be good enough for broad semantic understanding, state tracking, and many coding tasks, but it can silently misread exact strings.IDs, hashes, secrets, fixed numbers, and other byte-exact values should not be pushed into dense images. pxpipe’s own notes make this point: the tradeoff is serious, and the failure mode can be a confident but wrong answer rather than an obvious error.## What pxpipe Keeps as TextBecause the compression is lossy, pxpipe does not blindly render every input block as an image. It keeps sensitive and precision-critical content in text form.Examples that should stay as normal text include:- IDs and hashes.
• Secrets and keys.
• Exact numeric values.
• Recently active conversation turns.
• User messages.
• Sparse prose that is not token-dense enough to benefit.This is also why the project positions the savings as workload-dependent. If the request is mostly long natural-language prose, the compression may not be profitable. If the request is packed with code, JSON, logs, and tool output, the savings can be much larger.## How to Try pxpipeThe author gives a very short startup flow. Run the proxy locally, then point Claude Code at the proxy.```Bash
  npx pxpipe-proxy # proxy on 127.0.0.1:47821
  ANTHROPIC_BASE_URL=http://127.0.0.1:47821 claude # point Claude Code at it

http://127.0.0.1:47821/
```The dashboard can show token savings, side-by-side text-to-image conversions, a kill switch, and live model tags. This makes it easier to see exactly what is being compressed and what is passing through unchanged.## Google’s 2022 CLIPPO Paper Had Already Pointed in This DirectionAfter pxpipe started spreading, some researchers pointed out that the core idea is not completely new.A related line of work appeared in Google’s 2022 paper **CLIPPO: Image-and-Language Understanding from Pixels Only**. The central idea in CLIPPO is to treat text as pixels rather than as a separate tokenized text stream.![图片展示的是Lucas Beyer关于Fable 5成本节省技巧的推文。他提到当前沿实验室突然削减成本或宣称“找到了大幅减少推理所需内存的方法”时，其秘诀在于视觉始终获胜。图片中还呈现了Google Research发表的CLIPPO论文，其核心思想是将文本视为像素而非单独的文本流，通过共享Vision Transformer处理图像和渲染文本，与传统CLIP风格模型相比，CLIPPO在相同参数下可完成图像、文本和多模态任务，且训练时间缩短一半。](https://we0-cms.oss-cn-beijing.aliyuncs.com/cms-assets/image/2026/07/fc619df0-1ec1-499e-be61-c9d4694419cf-11-29036419-6e72-4814-861e-9112de35adb1.png)Traditional CLIP-style models often use two towers: one for images and one for text. CLIPPO removes that split by rendering text as RGB images and sending both images and rendered text through a shared Vision Transformer.![图片展示了CLIP和CLIPPO的模型架构对比。左侧CLIP模型中，图像通过CONV层进入Vision Transformer，文本经WORD EMB和TOK处理后进入Text Transformer，两者通过Contrastive交互。右侧CLIPPO模型中，图像和文本均通过CONV层进入Transformer，取消了图像和文本的分离处理。该图与上下文紧密相关，直观呈现了CLIPPO将文本作为RGB图像处理并共享Vision Transformer这一核心思想，是理解CLIPPO模型架构的关键示例。](https://we0-cms.oss-cn-beijing.aliyuncs.com/cms-assets/image/2026/07/ab6bfa22-4731-412e-aad2-ebe018b87259-12-fe95229e-2cc9-4fb6-8b98-6447db331a95.png)The takeaway is important: text does not always have to enter a model as discrete text tokens. It can also be converted into pixels and processed through vision pathways.## DeepSeek-OCR and Optical Context CompressionThe discussion also brought up **DeepSeek-OCR**, which focuses on optical compression for long context. Its repository describes the project as “Contexts Optical Compression.”![图片展示了两条推文。上方推文由JQ发布，内容提到大约一年前，Deepseek在其Deepseek OCR项目中尝试了将文本处理为图像的技术，当时人们对此压缩可能性感到兴奋。下方推文由Lucas Beyer回复，表示自己隐约记得此事。这两条推文与文档中关于pxpipe、DeepSeek-OCR等技术的讨论相关，说明pxpipe并非单一成本节省技巧，还连接了光学压缩等趋势。](https://we0-cms.oss-cn-beijing.aliyuncs.com/cms-assets/image/2026/07/e18d3fee-895e-4f98-bc1f-0a6b75e83154-13-76cabe63-a07e-49fb-b271-82995ed0c43a.png)![图片展示的是一个GitHub页面，页面标题为“deepseek
- ai/DeepSeek
- OCR: Contexts Optical Compression”。页面显示贡献者1人，问题248个，星标23k，fork 2k。下方有Matthew Campbell的评论，提到Deepseek在2025年10月也发布过类似内容，不确定这次还有什么新意。该图片与文档中关于pxpipe和DeepSeek
- OCR的讨论相关，表明pxpipe与DeepSeek
- OCR在光学压缩方面有相似之处，引发对二者关系的思考。](https://we0-cms.oss-cn-beijing.aliyuncs.com/cms-assets/image/2026/07/c078a32c-73e0-4766-bc59-9c40d0253f1e-14-ab418c5b-0ed8-4a8c-b44b-fa0edae93c3a.png)In that sense, pxpipe is not just a one-off cost trick. It connects several trends:1. CLIPPO showed that text can be processed as images.
2. DeepSeek-OCR explored long-context optical compression.
3. Fable 5 appears strong enough at dense visual reading for this to become useful in real coding workflows.There is still a hard limit: exact-string reliability. Some commenters suggested that the problem might improve simply by scaling up stronger vision-language models.![这张图片展示了两条社交平台的推文对话，是对pxpipe相关技术问题的讨论。Shardul发布的推文指出，该技术存在信息丢失的弊端，像身份标识、哈希值这类需要精准完整的内容可能被错误解读；另一条Lucas Beyer的推文则简洁回应，认为只需扩大模型规模就能解决该问题。该对话对应文档中提及的pxpipe存在“精确字符串可靠性”局限，需依托更强的视觉语言模型优化的相关内容。](https://we0-cms.oss-cn-beijing.aliyuncs.com/cms-assets/image/2026/07/575261c3-6956-4e4e-b4cd-69fe2d468cc8-15-56d3aa86-021e-499a-8560-6f6ded3163de.png)## Practical Takeawayspxpipe is most useful when the context is large, dense, and not precision-critical. Coding sessions are a natural fit because agents often re-read files before editing them, which can reduce the risk of acting on a misread image block.It is less suitable for workflows where exact character-level recall matters. If a task depends on identifiers, hashes, credentials, exact legal language, financial numbers, or similar precision-sensitive content, image-based compression should be treated carefully.A sensible way to use pxpipe is to keep it as an optimization layer, not as a trust boundary. Let it compress bulky context where the math works, but keep critical values in text and review the dashboard when debugging strange model behavior.## FAQ### What is pxpipe?pxpipe is a local proxy that reduces token usage by rendering bulky Claude Code input context into compact PNG images. It is designed for dense context such as tool outputs, logs, code, system prompts, and older conversation history.### How does pxpipe reduce Fable 5 costs?It takes advantage of the fact that image token cost is tied mainly to pixel dimensions, while text token cost grows with the amount of text. If a model can read dense rendered text reliably, large blocks can be cheaper as images than as plain text.### Does pxpipe compress model output?No. pxpipe only compresses selected input blocks before the request is sent. The model’s response still streams normally as text, so output tokens are not reduced.### Is image-based context compression lossless?No. It is a lossy compression method. It can work well for broad context, state tracking, and many coding tasks, but exact strings such as IDs, hashes, secrets, and precise numbers may be misread.### Can I use pxpipe with any model?Not safely. pxpipe’s own documentation treats model support as limited and workload-dependent. Some models read dense rendered text much worse than others, so unsupported or weaker models should pass through as text unless explicitly enabled.### What kinds of content should stay as text?IDs, hashes, secrets, exact numbers, user messages, recent turns, and other precision-critical blocks should stay as text. pxpipe is better suited for long, dense, less byte-sensitive material such as logs, tool docs, and old history.### How do I run pxpipe locally?Start the proxy with `npx pxpipe-proxy`, then run Claude Code with `ANTHROPIC_BASE_URL=http://127.0.0.1:47821 claude`. The local dashboard is available at `http://127.0.0.1:47821/`.## Related Tools- [pxpipe](https://github.com/teamchong/pxpipe): A local proxy that renders bulky Claude Code context into PNG images to reduce input token usage.
- [Claude Code](https://code.claude.com/docs/en/overview): Anthropic’s agentic coding tool for terminal, IDE, desktop, and browser workflows.
- [Anthropic Messages API](https://platform.claude.com/docs/en/api/messages): The API surface that Claude-style message requests are sent through.
- [Anthropic Token Counting](https://platform.claude.com/docs/en/api/messages/count_tokens): The official API reference for estimating token counts in message requests.
- [DeepSeek-OCR](https://github.com/deepseek-ai/DeepSeek-OCR): An open-source project exploring optical compression for long-context text.## Related Links- [Original BAAI Hub Article](https://hub.baai.ac.cn/view/56137): The Chinese source article that discussed the viral pxpipe cost-saving method.
- [pxpipe GitHub Repository](https://github.com/teamchong/pxpipe): Project source code, README, benchmarks, limitations, and usage commands.
- [CLIPPO Paper on arXiv](https://arxiv.org/pdf/2212.08045): The 2022 paper exploring image-and-language understanding from pixels only.
- [DeepSeek-OCR GitHub Repository](https://github.com/deepseek-ai/DeepSeek-OCR): Official repository for Contexts Optical Compression.
- [Claude Code Documentation](https://code.claude.com/docs/en/overview): Official documentation for using Claude Code across different environments.
- [Anthropic Computer Use Tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool): Official documentation for Claude’s screenshot-based computer interaction capability.
- [Anthropic Messages API](https://platform.claude.com/docs/en/api/messages): Official reference for sending message-based requests to Claude models.## Summarypxpipe shows a clever way to reduce Fable 5 input costs: render token-heavy context into compact images and let the model read those images through its vision capability. For dense coding workloads, this can significantly reduce request-side token usage and lower end-to-end cost.The tradeoff is that the method is lossy. It can preserve enough meaning for many coding and state-tracking workflows, but it should not be trusted for byte-exact recall of IDs, hashes, secrets, or precise numbers.The broader point is that text does not always have to stay text inside AI systems. CLIPPO, DeepSeek-OCR, and pxpipe all point toward the same idea: pixels can become a practical compression layer for long context.**The best use case is clear: compress bulky, low-precision context, but keep critical exact values in normal text.**