Through OrcaRouter both cards sit on one invoice, which makes the Qwen3.8 Flash Next cache pricing worth reading closely: the base model prices a cache read at $0.0184 per million and a cache write at $0.23, while the abliterated build prices reads at $0.15 and lists no write rate at all [OURS]. Three numbers, one prefix, and a design decision that most teams make by accident.

What a cache write is

When you send a prompt whose prefix the provider has not seen, it has to compute that prefix and store it. That work is the write, and the base model charges three times its input rate for it — $0.23 against $0.15.

After the write, subsequent requests with the same prefix skip the computation and pay the read rate instead: $0.0184, which is about eight times cheaper than fresh input.

The structure rewards repetition and punishes one-offs. A prefix sent once costs more than not caching it. A prefix sent a hundred times costs almost nothing after the first.

The arithmetic of a repeated prefix

Take a one-million-token prefix — a large codebase or a long instruction set — sent ten times.

Base model, cached: first call writes at $0.23; nine calls read at $0.0184 each. Total $0.396.

Base model, no cache: ten calls at $0.15. Total $1.50.

The cache saves 74%, and the write cost is amortised by the third call [OURS].

Abliterated build, cached: if the write is billed at the input rate of $0.80 and reads at $0.15, the ten-call total is $2.15. Without caching, $8.00 — the saving is 73%, essentially the same proportion at a different absolute level [OURS].

So caching helps both cards by the same fraction. What changes is the number it helps from.

Why the tuned build lists no write rate

The page lists a read rate and no write rate, which means you should not assume one. Two possibilities: writes are billed at the input rate, or writes are not billed separately at all.

The difference matters at scale. On a million-token prefix sent a hundred times a day, a $0.80 write charged on every cold start is a real line item; a zero write rate is not.

The way to settle it is the first invoice, not the documentation. Until then, budget conservatively — assume writes cost the input rate — and treat any difference as a pleasant surprise.

Designing a prefix that actually caches

Three rules determine whether the cache ever hits.

Byte-identical, from position zero. A timestamp, a request ID, or a randomised tool list in the first line invalidates everything after it.

Stable above, variable below. Instructions, schema, and the fixed part of the corpus at the top; the question, the specific file, the day’s logs at the bottom.

Long enough to matter. Very short prefixes are not worth caching on either card; the saving per call is fractions of a cent.

A useful discipline is a prompt template with named slots, where the first N characters are guaranteed identical across calls and everything variable lives in the tail. The template from the companion piece on prompt budgets is one example; any structure with the same property will do.

Where the cache stops helping

Two situations, and they are common.

Requests that never repeat. One-off questions with unique evidence get no benefit and, on the base model, pay the write premium for nothing. Disable caching on that path if your client allows it.

Prefixes that change daily. A corpus that is re-indexed nightly still amortises well within a day; one that changes hourly may not.

The pattern that benefits most is the one security work produces naturally: the same codebase, the same style guide, the same output schema, with different questions on top. That is close to the ideal cache workload, and it is worth engineering for deliberately rather than discovering by accident.

The interaction with a quarter window

A 262,144-token ceiling changes the cache maths in a subtle way: the prefix has to fit inside the window alongside the variable part.

If your stable prefix is 200,000 tokens, only 62,144 remain for the question and the evidence. That is a real constraint — and it argues for a smaller, denser prefix: the file tree and the manifests rather than the whole corpus.

Smaller prefixes also write faster and cheaper, which means the cache starts paying back sooner. On this card, a 30,000-token prefix sent twenty times a day is a better use of the mechanism than a 200,000-token prefix sent twice.

Measuring whether it worked

Two numbers tell you whether your cache design is doing anything: the hit rate and the average input cost per request.

Both are on the provider’s usage report if you are billed through it, and both are cheap to log on your side if not. A hit rate near zero means the prefix is not byte-stable; an average input cost that tracks the fresh-input rate means the same thing. A hit rate above fifty percent with a cost per request near the cache rate means the design is working.

Check it a week after the change rather than a month. Cache problems are silent, and a month of paying full input rate for what should have been cached is a bill nobody notices until it is large.

One graph is enough: average input cost per request, by day, over the first fortnight. A step down after the change is the cache working; a flat line is the cache not working, whatever the documentation says.

If the line is flat, check the serialisation before the model. Key ordering in a JSON prefix is the most common silent invalidator.

The takeaway

A read costs about an eighth of fresh input on both cards — and on the base, about a twelfth of a write. The proportion is similar; the absolute numbers are not.

Build the prompt so the prefix is byte-stable, send it more than three times, and the cache pays for itself. Send unique prompts and it is a small tax — which on the tuned card is a five-times-larger small tax.

One last figure worth carrying into the design review: on this card the cache read is a tenth of the input rate on the base and roughly a fifth on the tuned build. Either way, a workload that repeats a prefix is paying several times more than it needs to until someone structures the prompt for it.