---
license: cc-by-4.0
language:
  - en
  - zh
task_categories:
  - visual-question-answering
  - image-to-text
  - question-answering
tags:
  - benchmark
  - vision-language
  - token-compression
  - ocr
  - instruction-following
  - code-reasoning
  - bilingual
pretty_name: OPTIC-Bench
size_categories:
  - 1K<n<10K
configs:
  - config_name: en
    data_files:
      - split: test
        path: en/test.jsonl
      - split: core
        path: en/core.jsonl
  - config_name: zh
    data_files:
      - split: test
        path: zh/test.jsonl
      - split: core
        path: zh/core.jsonl
---

# 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.

![When imaging saves input tokens](charts/en/6_economy_bars.png)

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 |

![Where image delivery hurts, by family](charts/en/2_family_text_vs_image.png)

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

![Retrieval degrades with document length](charts/en/3_retrieval_by_difficulty.png)

### 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.

![Accuracy by modality condition](charts/en/1_modality_gradient.png)

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.

![Each model's task profile, ranked](charts/en/7_model_task_cascade.png)

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.

![The dense-document trade-off](charts/en/9_dense_tradeoff.png)

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 image penalty by language](charts/8_language_split.png)

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.

![Accuracy by modality condition, Chinese](charts/zh/1_modality_gradient.png)

![Where image delivery hurts in Chinese, by family](charts/zh/2_family_text_vs_image.png)

![Chinese retrieval degrades with document length](charts/zh/3_retrieval_by_difficulty.png)

![Each model's Chinese task profile, ranked](charts/zh/7_model_task_cascade.png)

![When imaging saves input tokens, Chinese](charts/zh/6_economy_bars.png)

![The Chinese dense-document trade-off](charts/zh/9_dense_tradeoff.png)

## 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.

```python
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

This dataset has the DOI 10.57967/hf/9574 and may be cited as follows.

```bibtex
@misc{bryan_cheong_2026,
    author       = { Bryan Cheong },
    title        = { vision-token-compression-bench (Revision de52ec2) },
    year         = 2026,
    url          = { https://huggingface.co/datasets/translorentz/vision-token-compression-bench },
    doi          = { 10.57967/hf/9574 },
    publisher    = { Hugging Face }
}
```