pxpipe turns your context into a photograph

Every turn with a coding agent re-sends the same freight: the system prompt, the tool documentation, the conversation so far. You pay for it every time, in dollars or in how fast you hit a rate limit.

pxpipe is a local proxy that intercepts each Claude Code request and re-renders the bulky, stable part as PNG pages. The model reads a picture of your context. A picture of a thousand words costs less than a thousand words.

The README is candid that the technique is lossy and that failures are “silent confabulations, not errors.” At our September 11 check, the repository had 7,380 stars and a 315-point Hacker News thread. We found no independent measurement in the coverage we checked.

Tested: commit 3425cc83b676f9df540c0adebaaaf96a11abee76 on September 11 and 14, 2026. Scope: 49 sessions across four tasks: 25 on Fable 5 and 24 on Opus 5, using Claude Code 2.1.268 and provider-recorded usage. Result: every Opus session passed. Imaging used about 60% fewer input tokens on the long task, but 5.5% more on bug fixes; other savings depended on the control. Fable imaging refused the long task three times. Verdict: adopt with care for the Opus opt-in on work you can verify; skip long Fable sessions.

A proxy among free levers

pxpipe is MIT-licensed, published as pxpipe-proxy on npm, and a one-owner project: the top contributor holds 402 commits, the next 22, and CONTRIBUTING.md calls it “built over a weekend.”

You point Claude Code at it with ANTHROPIC_BASE_URL. Per request it decides whether imaging pays, renders the eligible content, moves your cache marker onto the last image, and forwards the result. A free token-counting probe on the original body records what the text would have cost.

Its neighbours are prompt caching, /compact, and cheaper models, all free and first-party. Claude Code already caches your prefix. Switching from Fable 5 to Sonnet 5 takes 80% off your input rate, losslessly. pxpipe’s default allowlist covers exactly one Claude model, the expensive one.

It also ships pxpipe export, which renders files to PNG pages on disk with no interception. That part we recommend without reservation.

How we measured it

pxpipe ran in a disposable virtual machine with no host mounts, every outbound packet dropped except one loopback port. Claude Code ran on the trusted side and never entered it.

A proxy grading its own savings is a barber assessing your haircut, so our own code sat on both sides: one forwarder swapped the subscription credential for a placeholder before pxpipe, another restored it before the provider and logged the usage block off every response. Every number below comes from that log.

We tested four tasks in three configurations: direct, pxpipe with imaging off, and pxpipe with imaging on. Each model had two repeats per task and configuration, with one extra Fable failure check. Prompts, corpora, tools, Claude Code version, and effort stayed fixed; the answer key stayed outside the task directories. Sessions were shuffled within each run. Opus’s long task ran first, followed by the other three tasks as a separate block. At this revision, Opus requires PXPIPE_MODELS=claude-opus-5; Fable is enabled by default.

The exact-recall prompt, verbatim:

The directory `records/` holds 30 generated shard manifests.
Each data row has the columns: seq | job_id | kind | region | rows | sha:checksum | trailing_marker.

Answer these five questions. Every value is a 12-character lowercase hex string and must be copied EXACTLY, character for character. Do not guess, normalise, abbreviate, or reconstruct a value. If you cannot read a value exactly, return the literal string "UNKNOWN" for that field instead of guessing.

p1: In shard-15.log, the row whose seq is 003: report its job_id, its checksum (the value after "sha:"), and its trailing_marker (the last field on the line).
p2: In shard-09.log, the row whose seq is 008: report its job_id, its checksum (the value after "sha:"), and its trailing_marker (the last field on the line).
p3: In shard-21.log, the row whose seq is 007: report its job_id, its checksum (the value after "sha:"), and its trailing_marker (the last field on the line).
p4: In shard-00.log, the row whose seq is 000: report its job_id, its checksum (the value after "sha:"), and its trailing_marker (the last field on the line).
p5: In shard-28.log, the row whose seq is 018: report its job_id, its checksum (the value after "sha:"), and its trailing_marker (the last field on the line).

Return JSON matching the provided schema.

Work only inside the current directory. Do not read or write any parent directory.

Its corpus, the task file plus thirty shard files, after pxpipe’s renderer:

The first of three pages pxpipe export renders from that corpus at the tested revision, offline. Export and the proxy share the renderer and page geometry. It is not a session image, and on this task the proxy imaged the system prompt and tool docs, not these records, which stayed text under its size gate.

Where the tokens went

Per-session averages on Opus 5, two repeats per cell. Every session passed its answer or code-edit checks. Input-side tokens include fresh input, cache writes, and cache reads.

Task	direct	pxpipe passthrough	pxpipe imaging	imaging vs direct
Exact-value recall	35,704	14,226	10,561	−70.4%
Ledger arithmetic	73,316	60,758	65,588	−10.5%
Three bug fixes	23,088	23,136	24,365	+5.5%
Long session	1,065,804	1,067,965	427,834	−59.9%

Recall’s 70% reduction needs an asterisk: direct took five requests per run, while passthrough and imaging took three. Against passthrough, imaging saved 25.8%. The larger number includes the agent taking fewer steps, not just smaller requests.

Arithmetic used fewer tokens than direct on average, but 7.9% more than passthrough. Bug fixes went from 17,989 tokens in one imaging run to 30,741 in the other, where the agent took two extra requests. Both edits passed; together they used 5.5% more tokens than direct. pxpipe compresses requests. Extra requests can spend the saving.

The original Fable results were mixed too: imaging cut recall and bug-fix input tokens about 34%, raised arithmetic 87%, and refused the long task. Switching models produced a working long session; it did not produce universal savings.

In the original Fable unproxied runs, 89.1% of input-side tokens were cache reads, billed at a tenth of the input rate. The stable prefix pxpipe images is the most cacheable part of the request, so it removes tokens already discounted, and writing images into the cache costs a premium. The maintainer’s own demo/cost-ab/README.md says “Honest verdict: ~break-even on cost. The compression is real (~55% fewer real tokens, verified) but it lands in cache_read.” The README at the same commit leads with a 59 to 70% lower bill. Our token counts do not establish either a lower bill or more subscription headroom.

The long session worked on Opus, failed on Fable

The fourth task is pxpipe’s home turf: a long session reading eighteen large files, then answering questions about the first ones. All six Opus sessions returned all 16 fields correctly. Imaging used about 60% fewer input tokens than either control, with a substantial reduction in both repeats.

There was a cost: imaging averaged 105 seconds against 73 direct, and one imaged run made five extra reads of early metadata. pxpipe also supplies exact identifiers as text beside images, so this is not proof of image-only recall. The short recall task’s values stayed text on both models. The README’s dense-hex recall claim remains untested.

On Fable 5, all three imaging attempts failed identically:

API Error: Fable 5's safeguards flagged this message
(https://www.anthropic.com/legal/aup). This sometimes happens with safe,
normal conversations. Claude Code can't respond to this message with Fable 5.
Details: `[reasoning_extraction]`

Without imaging, Fable completed the same task four out of four times with exact answers. The imaged runs received model refusals, not HTTP errors. The cause remains unknown, and the Opus result does not fix that default path.

Use Opus with checks; skip long Fable sessions

Adopt pxpipe with care for Opus 5 sessions whose answers you can verify.

All four tasks worked on Opus, and the long task retained a large token reduction against both controls. That earns a qualified recommendation. Enable Opus explicitly, check answers, and compare whole-session usage: extra steps can erase savings, and the long task took longer. Keep exact identifiers as text when you cannot verify them. For default Fable long sessions, wait for a successful retest. Subscription-limit benefits remain unmeasured.

If those checks are more work than the saving is worth, use prompt caching, /compact, or a cheaper model. For rendering files into PNG pages, pxpipe export worked offline and does not intercept your conversations.