The arbitrage has a shelf life. The discipline doesn’t.

Every frontier provider meters the same way: you pay for the tokens that enter the model, every time they enter it. That billing model quietly assumes a document is read once. Agents don't work like that. A single specification gets re-read on the follow-up question, again when a subagent picks up the thread, again on the retry after a failed tool call, and again next week when someone resumes the work.

So the cost of a document isn't its size. It's its size multiplied by how many times it crosses the wire. That multiplier is where the money actually goes, and it is invisible on a pricing page — which is exactly why it goes unmanaged.

Packaging attacks the multiplier, not the price. Convert once, pay the conversion once, then every subsequent read is against a much smaller artifact. The per-token price never changes. The number of tokens does.

On our local test set the packaged artifact runs 84.1% smaller across five real document batches, and 54.2% smaller on the 11-page research PDF broken down on the home page. Those are measured numbers from the charts below, not projections.

The gap widens with the read multiplier and with the price of the model doing the reading — a document re-read twenty times by a frontier model is where the arithmetic stops being academic. There is also a threshold effect worth knowing about: some models price long prompts on a separate, higher tier. A document that lands just over such a threshold raw and comfortably under it packaged saves more than the token count alone suggests.

Run your own numbers

We would rather say this plainly than have you discover it later. The gap exists because providers currently bill naive repeated reads at full freight. That is a solvable problem on their side, and several fixes are already visible:

• Server-side caching the caller doesn't manage. Cache reads already price around a tenth of full input. Make that automatic and unmanaged, and much of the repeat-read premium disappears on its own.
• Per-account read dedupe. If a provider recognises it has already ingested this exact document for this account, it can decline to charge for it twice.
• Cheaper long-context tiers. Every drop in the price of a large prompt shrinks the reward for making prompts small.
• Metering something other than raw tokens. Subscription throttles, effort budgets, and request quotas all decouple the bill from token count.

Any one of these narrows the arbitrage. We expect them. A tool whose entire value proposition is a pricing quirk is a tool with an expiry date on it, and pretending otherwise would be a strange thing to put on the same site as our test data.

Here is the thing about every fix listed above: none of them makes documents free. They move where the cost shows up.

As providers get better at controlling how far a token — or a subscription — goes, the binding constraint stops being price per token and becomes budget per task: the context window, the effort budget, the rate limit, the number of requests a plan allows before it throttles. Those are all capacity limits, and a capacity limit punishes bloat whether or not anyone is billing per token for it.

Under a token meter, a lean representation is cheaper. Under a capacity meter, a lean representation is the difference between finishing the task and running out of room. The bloated document doesn't get more expensive — it gets impossible, and it crowds out the reasoning you actually wanted the context spent on. The arbitrage is a temporary bonus. Fitting more useful work into a fixed budget is permanent.

Two of Docpipe's properties have nothing to do with pricing, and would still be worth having if reads were free tomorrow.

Exact values survive verbatim. Numbers, IDs, dates, hashes, and quoted clauses stay as text, word-for-word, enforced in code rather than by policy. A model summarising a contract from memory can get a figure subtly wrong. A packaged document cannot, because the figure was never paraphrased.

Everything compressed stays recoverable. Every summarised block keeps a handle back to the exact source it came from, so when a task suddenly needs the fine print, the agent fetches that one piece instead of reloading the file.

Those are correctness guarantees. They don't expire when a price list changes.