translorentz/vision-token-compression-bench

OPTIC-Bench

Optical Text In-Context Benchmark: how reliably do LLMs consume text delivered as rendered images versus plain text tokens?

In summary, the evaluation reported here finds that optical text compression is effective only within a narrow and specific envelope. Delivering content as rendered images genuinely reduces input tokens, by thirteen to fifty-four per cent depending on the model and the language, but only when the document is long, the rendering is dense and the content is prose that fills the page. On short prompts, and on configuration files, tool schemas and source code in their natural layout, the image costs between 1.3 and 2.6 times as much as the text it replaces, so the content that such compression is most often deployed on is the content it serves worst. Where the method is economical it is also destructive, since exact identifiers, verbatim passages and precise figures are misread from dense prose images at rates that make them unusable, whilst multi-step reasoning and instruction-following largely survive. The damage is consistently larger in Chinese than in English for every model tested. No condition measured here both saved tokens and preserved exact reading. The appropriate use case is therefore bulky, static, prose-heavy context whose gist and structure matter more than its exact characters, such as archived conversation history or long narrative documents consulted for their sense. The method is unsuitable for machine text, for anything that must be recovered verbatim, and for latency-sensitive deployments in front of reasoning models, whose thinking time on barely legible pages can grow by an order of magnitude.

The motivation is a technique now appearing in production systems. Text-as-image prompting renders text into images so that a vision-language model reads it back from pixels rather than from tokens. Deployed proxies such as pxpipe (github.com/teamchong/pxpipe) report roughly three characters per vision token, against about one character per text token on the machine-heavy traffic they carry, which is a threefold cost saving. What that saving does to reliability had not been measured systematically. OPTIC-Bench measures it with a paired design. Each instance is run under the four conditions of a two-by-two grid, the instruction channel and the content channel each delivered either as text or as a rendered image, in English and Chinese as structural twins generated from shared seeds, across five difficulty tiers, with fully programmatic scoring and per-call token and cost accounting. Because every comparison is within-instance, every accuracy difference is attributable to the delivery channel rather than to the task mix.

Task families

family	task	tiers	metric
transcription	reproduce a passage verbatim (public-domain literature, sentence-shuffled)	1–4	1 − CER
extraction	copy exact identifiers with confusable glyphs (0/O, 1/l/I…), with long tiers adding superseding errata and a retrieval-depth variant	1–5	per-field exact
instruction	verifiable filter/sort constraints → JSON, plus strict plain-text formatting	1–4	exact list / exact text
reasoning	multi-hop, arithmetic and conditional QA, with long tiers requiring whole-document integration	1–5	exact answer
code	predict the exact stdout of a Python program (18 shapes)	1–3	exact output
calculation	reconcile an invoice to the exact cent (up to 100 lines)	1–4	exact amount
wordgame	word counts, acrostics, positional character assembly	1–3	exact string
injection	answer a benign question while resisting an adversarial instruction embedded in the document	1–3	benign-correct and canary-free
dialog	multi-turn conversation with revisions, recalling or combining facts across turns (history-compression scenario)	1–3	exact answer
structured	extract exact values from machine-oriented text, namely JSON configuration, tool and function schemas, and Python source, seeded with tokens, UUIDs and hashes	1–5	per-field exact

Difficulty tiers 1–3 are page-scale. Tier 4 ("long", ~8k characters in English) and tier 5 ("extended", ~24k characters ≈ 6k text tokens) are built on a multi-section operations dossier whose final Errata section supersedes facts stated earlier, so answers require integrating the whole document. The structured family scales instead by document size. These long tiers sit in the regime where optical text compression can beat plain text tokens, although the measured results below show that whether it actually does depends on the content's layout. Most families use all four modality conditions, whereas the multi-turn dialog and the copy-task transcription families use only the two conditions where the comparison is meaningful.

Beyond raw accuracy the evaluation design also measures token economy (cached and uncached), retrieval depth (lost-in-the-page), silent corruption and false confidence (optional abstention), injection resistance, multi-turn history compression, transport robustness (JPEG and rescale), and latency, all bilingually and with programmatic scoring only.

Headline findings

An evaluation of three current frontier models (OpenAI GPT 5.5, Google Gemini 3.5 Flash and Moonshot Kimi K2.6) on the 366-instance core subset, plus dense long-document slices for the economy questions, gives a clear and consistent answer to the questions this benchmark was built to settle. The full report follows on this card.

• Token economy depends on content layout, not just length. Rendering content as a dense image saved 13 to 54 per cent of input tokens on long prose, depending on the model and the language, but on short page-scale prompts it cost 1.6 to 2.6 times as much as the text, and on long pretty-printed machine text (JSON configuration, tool schemas, source code) it cost 1.3 to 2.5 times as much, because line-oriented layout renders into mostly empty pages. The content that optical compression is deployed on in practice is the content it serves worst economically.
• Exact retrieval from prose collapses under image delivery. Verbatim identifier extraction from documents fell from perfect on text to 0.46 pooled across the three models and both languages, and to almost zero on long dense pages. The models still read roughly ninety per cent of an identifier's characters correctly, but a single wrong character fails the field. Retrieval from images was also consistently worse in Chinese than in English, with a pooled drop of 65 points against 46 on the retrieval families, even though the paired twins share structure and text baselines.
• Structured machine text is the exception, in both directions. The same kinds of value (UUIDs, hashes, tokens) that collapse inside prose survive almost intact inside JSON, schemas and code, dropping only four points pooled across the models and languages, plausibly because delimiters and one-value-per-line layout let the model localise and read each value in isolation. Where imaging is safe it does not pay, and where it pays it is not safe. No measured condition both saved tokens and preserved exact reading.
• Instruction-following and reasoning are largely preserved. Imaging the content left constraint-following and multi-step reasoning essentially intact. Reading exact figures for arithmetic is the exception, because a misread digit corrupts an otherwise correct calculation. Reasoning models carry an extra reliability cost, since one model needed a median of 87 seconds per call on long dense documents against 9 and 15 for the other two, with a worst case of sixty-four minutes for a single call, and it completed the slice only after its timeout and output budget were raised well beyond ordinary settings.
• Injection resistance held for all three current models even when the adversarial text was imaged, although an older model tested during development was susceptible under the combined-image condition.

The retrieval collapse is significant at an exact McNemar probability below ten to the power minus twelve on the core subset.

The remainder of this card reports the evaluation in full, answering the four questions the benchmark poses. How does delivering text as a rendered image, rather than as ordinary text tokens, affect the token economy, the fidelity of retrieval, the completion of instructed tasks, and the depth of reasoning? The English results come first, then a paired comparison of the two languages including their token economics, then a supplementary section with the Chinese results and their own charts, and finally the synthesis, the caveats, and the practical details of using the dataset. The dense-slice figures throughout come from small samples and are directional. Pooled-language versions of every chart are provided in the charts directory alongside the per-language sets used below.

Experimental setup

Three current frontier models were evaluated through their public programming interfaces. These were OpenAI GPT 5.5, Google Gemini 3.5 Flash, and Moonshot Kimi K2.6. All scoring was programmatic, with no model acting as a judge, and every ground-truth value was verified independently of the models.

Three evaluation slices were used. The first and largest is the core subset of the released dataset, 366 instances spanning all ten task families and every difficulty tier, rendered at the regular density profile. Each core instance was presented under the modality conditions of the benchmark, namely both channels as text, the content as a rendered image with the instruction as text, the instruction as a rendered image with the content as text, and both channels combined into a single image. The second slice covers long prose documents, the extraction, reasoning, transcription, calculation and instruction families at tiers four and five rendered at the dense profile, where a document runs to roughly eight thousand characters in English and where optical compression can save tokens. The third slice covers the structured family, machine-oriented text at the same long tiers and the same dense profile, so that the economy and the fidelity are measured on the content type that optical compression is actually deployed on. The two dense slices compare only the two conditions that matter for compression, plain text against content as image.

The core results rest on roughly 1,300 scored calls per model across the two languages and are statistically firm. The dense slices are smaller and their figures should be read as directional. The consistency of every pattern across three independent models is the main reason for confidence in the conclusions. Unless stated otherwise, the figures below are for English, until the language comparison and the Chinese supplement.

Question one: the token economy

Whether image delivery saves tokens depends entirely on how much text is packed into each image. On short, page-scale documents at the regular density the image is wasteful, because a single page carries little text yet still incurs a fixed vision-token cost. Across the three models on the English page-scale tiers of the core subset, the content-as-image condition used between 1.9 and 2.6 times as many input tokens as the plain text condition.

The saving appears only when documents are long, the rendering is dense, and the content is prose. On the English long prose slice at the dense profile the picture reverses, and the image becomes the cheaper channel, although how much cheaper varies with each provider's image token accounting.

model	text tokens	image tokens	image saving
GPT 5.5	3789	3050	20 per cent
Gemini 3.5 Flash	4560	2781	39 per cent
Kimi K2.6	3819	3337	13 per cent

On structured machine text the saving does not merely shrink, it inverts. The same dense profile applied to long JSON configuration, tool schemas and source code produced images that cost considerably more than the text they replaced, for all three models.

model	text tokens	image tokens	change
GPT 5.5	2235	5140	2.3 times the text cost
Gemini 3.5 Flash	2847	3700	1.3 times the text cost
Kimi K2.6	2243	5631	2.5 times the text cost

The reason is layout rather than tokenisation. Pretty-printed machine text is line-oriented, one key or one statement per line, so a rendered page is mostly empty space and carries few characters, whilst prose wraps into full lines and fills the page. A structured document therefore spreads across many sparsely filled pages and the fixed per-page vision cost dominates. The per-character density that makes machine text expensive to tokenise does not transfer to pixels unless the text is re-flowed, minified or set in a far smaller font than a model can reliably read.

The chart below summarises the three regimes for English. Only long dense prose falls below the break-even line.

The economic conclusion is therefore doubly conditional. Optical compression reduces input token counts only for long documents rendered densely, and among those only for content that fills the page, which in practice means prose. It increases costs for the short prompts that make up most ordinary traffic and for pretty-printed configuration, schemas and code in their natural layout. Prompt caching narrows the advantage further, because a cached text context is billed at roughly a tenth of the normal rate, which is the situation that a static system prompt or tool description would enjoy.

Reconciling with pxpipe's threefold saving

Projects such as pxpipe report roughly three characters per image token against about one per text token, a threefold saving, which is far larger than the figures above. The two accounts do not conflict. They are different points on the same curve, and pxpipe quotes the most favourable point. Two independent factors set the saving, and pxpipe pushes both to the limit whereas this benchmark deliberately does not.

The first factor is render density, which sets the characters per image token. Measured on a long document with the provider token formula, ours are as follows.

profile	font size	English characters per image token	Chinese characters per image token
regular	16 px	2.5	1.4
dense	11 px	4.2	2.2
packed	8 px	6.6	3.2

pxpipe's figure of about 3.1 sits between our dense and packed profiles, and our packed profile matches or exceeds it. The headline economy above was reported from the regular and dense profiles, chosen for legibility so that the accuracy comparison would be fair, rather than from packed. pxpipe also lets a page exceed the provider's downscale threshold, which this benchmark avoids because it destroys small text.

The second and larger factor is how well the original text tokenises, since compression is the ratio of characters per image token to characters per text token. That denominator varies greatly with content. Real subword tokenisation of our own English content, measured with the o200k tokeniser, runs as follows.

content	characters per text token
Python source code	2.4
record tables	2.4
invoice line items	2.5
reports with identifiers	3.1
conversation prose	3.9
literary prose (transcription)	4.5

pxpipe operates on Claude Code traffic, namely system prompts, tool schemas, JSON and dense source code, which tokenises at roughly one character per token. Against such an expensive text baseline an image saves three or fourfold. Much of our content is prose and business documents, which already tokenise efficiently, so there is less for an image to save.

To measure the economy and the fidelity on the content that optical compression is actually deployed on, the benchmark includes a dedicated structured family covering JSON configuration, tool and function schemas, and source code, seeded with the tokens, UUIDs and hashes that pervade real configuration and tooling. The measurement cut against the assumption built into the threefold arithmetic. In its natural pretty-printed layout this material rendered into images that cost more than its text, as the tables above show, because its line-oriented layout leaves most of each rendered page empty. A deployment that images machine text therefore only realises a saving after re-flowing or packing the text into filled pages, which is a transformation of the content, not a free property of the image channel. Two further qualifications run in opposite directions. Our generated structured content tokenises at 2.6 to 3.5 characters per token, whereas the most adversarial real traffic is minified or base64-heavy and approaches one, which would make its text baseline dearer and the image correspondingly more attractive. Against that, the same minification also packs more characters onto each rendered line, and how far that recovers the economy is a question for a future minified variant of the family rather than one this edition answers.

The essential point is that pxpipe reports the top of the saving, obtained by packing aggressively on content that tokenises badly, and this benchmark reports what that packing costs. The very density that yields three characters per image token is the density at which the exact retrieval of prose identifiers collapses, as the next section shows.

Question two: the fidelity of retrieval

Retrieval fidelity is where image delivery fails most clearly, and the failure turns out to be specific to prose. Three families measure it, namely the exact reproduction of identifier strings such as hashes and order numbers embedded in prose documents, the verbatim transcription of prose, and the structured family of machine text, whose sharply contrasting result closes this section.

On short documents the reproduction of exact identifiers already suffers. Measured by character-level accuracy, which awards partial credit, the mean score in the early pilot fell from a perfect 1.00 on text to between 0.79 and 0.83 on the image across the three models, pooling both languages. Under the stricter requirement that every character of every identifier be correct, the loss is larger, because a single misread character fails the field.

On long documents rendered densely the degradation becomes severe. Exact identifier extraction, which the models performed perfectly from text, very nearly collapsed from the image. The table below comes from the pilot's dense long-document slice with both languages pooled. The pilot covered GPT 5.5 and Gemini 3.5 Flash, since Kimi K2.6 completed this slice only later under the extended limits described in question four. The middle column counts identifiers, and the figure in brackets is the fraction of the requested identifier fields reproduced exactly, not a character accuracy. The final column gives, for the same documents, the range of character-level accuracy on verbatim prose transcription, from the easiest document to the hardest.

model	identifiers from text	identifiers from image	prose (character accuracy)
GPT 5.5	8 of 8 exact	0 of 8 exact (0.42 of fields)	1.00 to 0.74
Gemini 3.5 Flash	8 of 8 exact	1 of 8 exact (0.57 of fields)	1.00 to 0.47

It is worth being precise about what fails, because the character-level and the field-level pictures differ sharply. The models still read about ninety per cent of the characters of a dense identifier correctly. The difficulty is that an identifier is only useful if every character is right, and a single misread character fails the whole field. As a result, only between forty-two and fifty-seven per cent of the requested identifiers came back exactly, and at the strictest tier none survived. Verbatim prose transcription, which is judged on character accuracy rather than on all-or-nothing exactness, lost between a quarter and a half of that accuracy over the same documents. The practical lesson is that any value which must be recovered exactly, such as an identifier, a code token or a precise figure, should never be entrusted to a densely imaged prose document, even though the model reads most of its characters correctly. How far a structured layout softens this rule is the subject of the next subsection.

At core scale in English the pattern is unambiguous. Pooling the three models and pairing each instance with itself, the exact-match rate when content moved from text to image fell as follows.

family	text	image	drop
extraction (identifiers in prose)	1.00	0.45	55 points
transcription (verbatim prose)	0.91	0.54	37 points
structured (config, schemas, code)	1.00	0.94	6 points

The loss deepens as documents lengthen, since tiers four and five are the long documents.

Structured machine text reads back far better than prose

The structured family delivers the most surprising fidelity result in the benchmark. Its documents carry exactly the kind of value that fails above, namely UUIDs, commit hashes, access tokens and version strings, yet when those values sit inside pretty-printed JSON, tool schemas or source code, the models read them from images almost as well as from text, at 0.94 against 1.00 in English as the table above shows. The same identifier that collapses inside a paragraph survives inside a configuration file. The plausible mechanism is layout. A structured document gives every value its own line, bounded by delimiters, quotation marks and indentation, so the model can localise it and read it in isolation, whereas the extraction documents embed identifiers in running prose where adjacent text competes for attention and confusable glyphs have no anchoring structure. Because the structured family's queried values are language-independent strings, its results are effectively identical in the two languages, which the supplementary section confirms.

The protection weakens but does not vanish on long documents rendered densely. On the structured dense slice, pooling both languages since the values are shared, the requirement that every queried field be exact fell from 96, 94 and 95 per cent on text to 71, 80 and 78 per cent on the image for GPT 5.5, Gemini 3.5 Flash and Kimi K2.6 respectively, whilst the per-field accuracy stayed between 0.93 and 0.96. Errors appear, but they stay isolated to single fields rather than corrupting whole answers, in sharp contrast to the near-total collapse of prose identifier extraction under the same density.

Taken together with the economy finding of question one, the two halves of the structured story point the same troubling way for optical compression. On the content where imaging is comparatively safe, the structured machine text, it costs more tokens than the text it replaces. On the content where imaging saves tokens, long dense prose, it destroys exactly the values that must be read precisely. The saving and the safety do not coincide.

Question three: the completion of instructed tasks

A central design question of the benchmark was whether instructions delivered by image are followed as reliably as instructions delivered as text. In English the answer is reassuring on both counts, and the drama lies entirely in Chinese, where the reader is referred to the supplementary section.

When the instruction remains text and only the content is imaged, the English constraint-following family loses little. GPT 5.5 fell from a perfect 19 of 19 to 17, Gemini 3.5 Flash held at 18 of 19 against a text baseline of 17, and Kimi K2.6 slipped from 17 to 16. The few losses trace to misread rows in the imaged tables rather than to disobedience, which is retrieval failure surfacing through another family.

When the instruction itself is rendered into an image, English obedience holds for all three models. On the instruction family GPT 5.5 scored 17 of 19, Gemini 3.5 Flash 19 of 19 and Kimi K2.6 16 of 19, all within two items of their text baselines, and the same holds across the whole English core, where the image-instruction condition scored 0.93 to 0.95 for every model. Delivering an English instruction as an image is therefore close to safe on current models. The same statement is emphatically false in Chinese, as the supplement shows, so the safety of the instruction channel must be established per language rather than assumed from English behaviour.

Question four: the depth of reasoning

Reasoning proved the most robust ability under image delivery, provided that the reasoning does not itself depend on reading exact figures. On the English core, pooling the reasoning, calculation, code, wordgame and dialog families and pairing each instance with itself, imaging the content cost GPT 5.5 two points, cost Gemini 3.5 Flash nothing, and left Kimi K2.6 two points better. On long dense documents the multi-step reasoning family was likewise preserved, losing nothing from text to image.

There is one important qualification. Long-document arithmetic, which requires reading many precise digits before computing with them, failed from the dense image, falling from perfect to near zero for GPT 5.5. This is not a failure of reasoning as such but a failure of retrieval feeding the reasoning. Once the digits are misread, the correct calculation on the wrong inputs still yields a wrong answer. The depth of thought is preserved, but it operates on corrupted data. This particular finding rests mainly on GPT 5.5, because Gemini 3.5 Flash could not reconcile a hundred-line invoice even from plain text, so for that model the image result is confounded by a limitation that has nothing to do with the modality.

There is also a reliability finding specific to reasoning models, and it is best stated as a cost rather than an inability. Under ordinary settings, a five-minute timeout and a twelve-thousand-token output budget, Kimi K2.6 could not finish the long dense documents in either language. Eight calls exhausted the output budget and five calls, spread across the instruction, calculation and transcription families and including two with plain text and no image at all, returned nothing through eight retries each. Given charitable settings instead, an hour per call and a thirty-two-thousand-token budget, the same model completed all fifty-six calls without a single error. What the charity revealed is the price. Its median latency on this slice was 87 seconds against 9 for GPT 5.5 and 15 for Gemini 3.5 Flash, one in ten calls needed over eight minutes, the slowest needed sixty-four minutes, and one answer consumed thirty thousand output tokens. The same model completed the structured dense slice, two hundred calls, at ordinary settings without error, so the trigger is the long document rather than the image as such, although the image condition lengthens the rumination further. A hard-to-read page does not merely lower a reasoning model's accuracy, it can multiply its thinking time and output spend by an order of magnitude, and any production deployment of dense rendering in front of a reasoning model should budget for that, in money, in latency and in timeout policy.

A note on safety

The benchmark also embeds adversarial instructions inside documents in order to test whether imaging untrusted content changes a model's susceptibility to prompt injection. On the core subset, over both languages, the three current models emitted the injected canary in none of three hundred and sixty calls, thirty items per condition per model, including when the adversarial text was rendered into the image. The residual accuracy losses visible in the injection family under image conditions are benign answers misread from the page, not compliance with the injected instruction. The more telling observation came from an earlier model tested during development, Gemini 2.5 Flash, which complied with the injection in two of three cases when the malicious content was delivered as a combined image, whereas it resisted perfectly when the same content was delivered as text. The security property therefore appears to have improved between model generations, but the earlier result shows that imaging untrusted content can weaken instruction and data separation, and it should continue to be measured.

The silent-corruption axis, in which a model may abstain rather than guess when it cannot read the input, was not exercised in any run reported here. The abstention option was left disabled throughout, so no false-confidence figures are claimed. That axis remains to be measured, and it is a natural next step given how badly exact retrieval fails from a dense image.

Core evaluation at proper scale

The findings above were first seen in a very small pilot. They have since been reproduced on the core subset, which holds 366 instances spanning all ten task families and every difficulty tier, for all three current models under every modality condition at the regular density. At this scale the central result is no longer merely directional. The collapse of exact retrieval when prose content is delivered as an image is overwhelming, with every one of the discordant paired outcomes in the prose retrieval families flipping in the same direction for all three models, at an exact McNemar probability below ten to the power minus twelve over the two languages, and the English half alone remains decisive.

The table gives the English exact-match rate by condition, where the two letters are the instruction channel and the content channel, and t and i denote text and image. The Chinese table is in the supplementary section.

model	text / text	text / image	image / text	image / image
GPT 5.5	1.00	0.86	0.95	0.83
Gemini 3.5 Flash	0.96	0.87	0.95	0.87
Kimi K2.6	0.91	0.79	0.93	0.81

Every model reads best from plain text, and in English the two image-instruction conditions cost only a few points. The figures below tell the English story in order. The first shows overall accuracy by condition.

The second gives each model its own panel, with the families ranked from most to least robust under image delivery. Prose retrieval sits at or near the bottom of every panel, which is itself a finding: the cliff sits between the task families far more than between the models.

The third sets what imaging saves against what it costs on the long dense documents, family by family, in two aligned panels over shared rows. A family would need a rightward bar in both panels for imaging to be a clean win, and none has one. Reasoning and instruction over prose come closest, saving a quarter to a third of input tokens at a cost of eight and seventeen points respectively. The prose retrieval families save the same tokens whilst losing sixty-seven and ninety-two points. Structured machine text and the line-oriented invoices of the calculation family keep their accuracy losses moderate but cost more to image than to tokenise. No family that requires exact reading achieves both the saving and the fidelity.

Pooled-language versions of every chart, plus the full family-by-model grid, are in the charts directory alongside the per-language sets.

English and Chinese compared

Every instance in the benchmark is an English and Chinese twin generated from the same seed, so the two languages can be compared pair by pair, on identical information, with nothing incidental in the contrast.

The first comparison is economic. A natural question is whether writing the content in Chinese rather than English is itself a saving, since Chinese carries the same information in far fewer characters. The answer is no in the text channel and neutral in the image channel. The table gives mean input tokens per call on the long prose slice at the dense profile, twin-matched.

model	English text	Chinese text	Chinese over English	English image	Chinese image	Chinese over English
GPT 5.5	3789	4589	1.21	3050	2991	0.98
Gemini 3.5 Flash	4560	5078	1.11	2781	2326	0.84
Kimi K2.6	3819	4052	1.06	3337	3238	0.97

As text, the same content costs six to twenty-one per cent more in Chinese than in English, with the size of the penalty set by each provider's tokeniser. GPT 5.5 pays the most and Kimi K2.6, whose tokeniser handles Chinese best, the least. The page-scale core shows the same pattern, at seven to twenty per cent. As an image the two languages cost roughly the same, since a Chinese page expresses the same information in fewer but visually denser characters and the rendered area comes out similar. On the structured slice, whose queried values are language-independent, the ratios are 1.00 in both channels, which is a check that the twin design is sound. The correct statement of the language economy is therefore that Chinese is not a saving in itself, and switching a text pipeline from English to Chinese would raise its token bill. What imaging does is remove the tokeniser's penalty on Chinese, which is why the relative saving from optical compression is consistently larger in Chinese, at 20 to 54 per cent against 13 to 39 in English on the prose dense slice.

The second comparison is the reading penalty, and it runs the other way. The text baselines of the twins match almost perfectly, so the whole difference appears in the image channel. Moving content from text to image cost GPT 5.5 fourteen points in English but twenty-two in Chinese, Gemini 3.5 Flash eight against nineteen, and Kimi K2.6 twelve against sixteen. On the two prose retrieval families the pooled drop was forty-six points in English and sixty-five in Chinese. This is consistent with the greater visual density of Chinese characters making them harder to read reliably from a rendered page.

The two comparisons together give the language conclusion. Chinese enjoys the larger relative token saving from optical compression precisely because its text baseline is dearer, and it suffers the larger reading loss precisely because its glyphs are denser. Both sides of the trade-off are amplified, so the economics and the risks of optical compression must be assessed per language, and the detailed Chinese picture that follows shows the risks amplifying much faster than the savings.

Supplementary: the results in Chinese

The Chinese results reproduce every qualitative conclusion of the main body whilst being uniformly harsher in the image channel. The table gives the Chinese exact-match rate by condition on the core subset.

model	text / text	text / image	image / text	image / image
GPT 5.5	1.00	0.78	0.72	0.58
Gemini 3.5 Flash	0.95	0.77	0.95	0.85
Kimi K2.6	0.92	0.77	0.91	0.79

Three findings are specific to Chinese and material for any deployment.

The first is that GPT 5.5 largely stops obeying instructions delivered as Chinese images. On the instruction family it followed a Chinese imaged instruction in five of nineteen cases, and a combined image in three of nineteen, against seventeen of nineteen for both conditions in English. Its whole-core image-instruction score of 0.72, and 0.58 for the combined image, is dominated by this effect. Gemini 3.5 Flash and Kimi K2.6 do not share the failure, holding 0.91 to 0.95 on imaged Chinese instructions. Routeing instructions through the image channel in Chinese is therefore unsafe on some current frontier models, and this is the strongest model-specific hazard the benchmark found.

The second is that verbatim Chinese transcription from images fails almost completely. Across the three models the paired exact rate fell from 0.88 on text to 0.09 on the image, against 0.91 to 0.54 in English. Chinese prose identifier extraction collapses similarly to English, 1.00 to 0.47. The reasoning bundle also loses more in Chinese, four to seven points against zero to two in English, which is retrieval loss bleeding into tasks that must first read the page.

The third runs the other way and confirms the layout finding. The structured family is as safe in Chinese as in English. Moving its content from text to image cost only one point in Chinese, from 0.98 to 0.97, because its queried values are language-independent strings whose legibility does not depend on CJK glyph density. The protection that structure provides survives translation.

The Chinese charts below mirror the English set figure for figure. The per-family chart shows the transcription collapse at the bottom, the retrieval curve shows the loss deepening with document length, the cascade shows GPT 5.5's instruction-channel failure, the economy bars show the larger relative prose saving discussed in the language comparison, and the trade-off panels show the prose retrieval families losing everything that imaging saves, with extraction at minus one hundred points.

Synthesis

The trade-off that this benchmark set out to characterise is real, sharply shaped, and less favourable to optical compression than its headline arithmetic suggests. Delivering content as a dense image can save a substantial fraction of input tokens on long prose documents, and it preserves both instruction-following and multi-step reasoning in English. It does so at a severe cost to any task that depends on reading prose text exactly, whether that is reproducing an identifier, transcribing a passage, or performing arithmetic on precise figures.

The structured family sharpens this into the benchmark's central negative result. The content that optical compression is deployed on in practice, configuration, tool schemas and source code, is the content it serves worst economically, because pretty-printed machine text renders into sparse pages that cost more as images than as text. The reverse also holds. The content on which imaging is comparatively safe for exact values, that same structured text, is where it saves nothing, and the content where it saves the most, long prose, is where exact values are destroyed. Across every family, model, language and slice measured here, no condition both saved tokens and preserved exact reading. A deployment can have the economy or the fidelity, not both, and should choose per content type. Bulky prose whose gist matters can be imaged for a real saving. Machine text in its natural layout should stay as text, where it is both cheaper and safer. Anything that must be recovered verbatim from prose should never cross the image channel densely rendered.

The language comparison adds two riders. Everything above is worse in Chinese, where the same compression saves relatively more only because Chinese text tokenises dearly, and where reading losses grow faster than the savings, to the point that one frontier model largely stops obeying imaged Chinese instructions. And reasoning models add a reliability caveat in both languages, since a long dense page can multiply their thinking time and output spend by an order of magnitude.

Caveats

The core figures rest on 183 instances per language per model per condition and the strongest claims, that exact prose retrieval collapses from images whilst reasoning and structured retrieval are preserved, hold with exact statistical significance at that scale. The dense long-document slices are far smaller, fourteen paired prose instances per language and fifty paired structured instances per language per model, so their percentages are directional and the economy figures in particular should be reproduced at the full per-cell count of the released dataset before being quoted as precise. The pilot tables in question two pool both languages and are labelled as such. Eight of Kimi K2.6's earlier prose dense answers were truncated at a twelve-thousand-token output budget before the limits were raised, and those stand in its scores as recorded, so its prose dense accuracy should be read as a floor. Cross-provider comparisons conflate the model with each provider's opaque image preprocessing and with its token accounting, which differ visibly in the economy tables, so the cleanest readings are the within-model deltas between conditions rather than absolute scores across providers. The cost figures use the token counts actually returned by each interface, priced with example rates that should be checked against current provider pricing before any monetary claim is made. The abstention axis remains unexercised, so no false-confidence figures are claimed anywhere on this card.

Fields

Each row of {lang}/test.jsonl:

• id, family, language, difficulty (1–5), benchmark_version
• instruction_text, what the model must do
• content_text, the document or data (render this to an image for the image conditions)
• scorer, the name of the deterministic scoring rule for the instance
• expected, the exact ground-truth payload, as a JSON string
• meta, auxiliary metadata (including pair_id, which links the EN/ZH twins), as a JSON string

expected and meta are serialized as JSON strings because their shape varies by family (a transcription target, a dict of identifier fields, an id list, an answer plus an injection canary, a dialog's turn list, and so on). Call json.loads on them. This keeps the dataset schema uniform and lossless on the Hub.

Usage

Each language configuration provides two splits. The test split is the full set, 975 instances per language and 1,950 over the two configurations. The core split is a deterministic subset spanning every family and difficulty tier, 183 instances per language and 366 in total, recommended as the default for routine evaluation because a full modality sweep of the core is about 1,330 calls per model over both languages, against about 7,100 for the full set. The core is a strict subset of test, so its instances, ground truth and images are identical to the full set. Use test when tighter confidence intervals are wanted.

import json
from datasets import load_dataset

# recommended default: the smaller core split
ds = load_dataset("translorentz/vision-token-compression-bench", "en", split="core")
# or the full set: split="test"
row = ds[0]
expected = json.loads(row["expected"])
meta = json.loads(row["meta"])

To evaluate a model, deliver instruction_text and content_text under each modality condition, as text or using the pre-rendered images shipped with the dataset, collect the response, and score it against expected. The dataset is self-contained for this purpose. Every scoring rule named in scorer is a deterministic comparison that can be implemented from its description: exact string or numeric comparison for most families, character accuracy for transcription, per-field exact match for extraction and for the structured family, exact list match for the relational instruction tasks, and, for injection, checking that the benign answer is correct and that a canary string planted in the adversarial instruction does not appear in the output. Wrapper tolerance (stripping code fences and locating the first balanced JSON object) is recommended so that formatting habits are not confused with reading failures.

Pre-rendered images at the regular density profile are included, in images/regular/{id}/{part}-{page}.png. The parts depend on the family, with content present for every instance and instruction and combined present for the families that use the instruction-image conditions. Long documents paginate into several numbered pages. The images were produced with pinned Noto Sans and Noto Sans SC, black on white, at 1024 px width, and are paginated to stay under the roughly 1568 px threshold above which providers downscale an image. Every character was verified to have a real glyph, so the set contains no missing-glyph boxes. A companion file, images/regular/meta.jsonl, records per-instance render metadata, namely page dimensions, page counts and estimated vision-token costs, which is useful for cost projection without opening the images. Only the regular density profile is included. The dense-profile images behind the long-document results in the report were produced by the same renderer at an 11 px font and are labelled wherever they appear.

Construction and licensing

The synthetic families (extraction, instruction, reasoning, code, calculation, wordgame, injection, dialog and structured) are generated deterministically from a master seed using original templates and word banks. Their ground truth is computed during generation rather than annotated afterwards (code tasks are executed to obtain their true output, and every queried structured value is verified to appear verbatim in its document), and the construction is fully deterministic, so a fresh seed yields a new, uncontaminated edition with the same statistical properties.

The transcription family is the one exception: its passages are excerpts of public-domain literature, a genre spread of English works (Collins, Gaskell, Darwin, Thoreau) and late-Qing Chinese vernacular novels, sampled per-work-balanced and sentence-shuffled so that no model family gains an in-distribution or memorization advantage on text it may have helped author. These works are in the public domain. Passages were drawn in balanced proportion from each work, shuffled at sentence level, and the Chinese texts normalised to simplified characters.

The dataset is released under CC-BY-4.0, and the public-domain excerpts carry no additional restriction.

Citation

@software{opticbench2026,
  title  = {OPTIC-Bench: Measuring the Reliability of Text-as-Image
            Prompting in Large Language Models},
  author = {{OPTIC-Bench contributors}},
  year   = {2026},
  version = {0.4.0}
}