Retrieval pays on every question. Structuring pays once.

Retrieval is a per-question cost forever. Structuring is a per-document cost once. Which of those is cheaper depends entirely on how many questions you intend to ask, and the benchmark exists to say where the line crosses rather than to assert that it does.

• What answers a question today. Asked in natural language, on a tenant with the flag, a question runs the retrieval fast path: $1.53 per 1,000 questions and 9.1 seconds, which is cheaper than every RAG arm measured here by at least 27 times and faster than all of them. It is rolling out per tenant behind a flag, and the benchmark tenant has it enabled.
• The flat line. Asked over the API, a question runs the Talonic structured path, which has no model in it at query time. It reads captured fields and aggregates them in code, at a mean latency of 0.015 ms and a measured marginal cost of $0.00. The whole cost is the ingest: $10.14 for 53 documents.
• The RAG lines. Long-context RAG costs $320.35 per 1,000 questions uncached, and $41.74 cached when questions arrive in a burst. Hybrid RAG costs about $158 per 1,000 whether caching is switched on or not, because its cacheable prefix is 114 tokens and never qualifies.
• Where it crosses. Against cached hybrid RAG, Talonic’s running total goes below at question 65. Against cached long-context RAG, the cheapest line measured, it goes below at question 244. On a 1,000-document corpus the second of those barely moves: it is question 243, because ingest and long-context both scale with the corpus.
• The path this replaces. Before the fast path, a natural-language question ran the Talonic conversational agent loop, an LLM loop at $237.69 per 1,000, 127.6 seconds and 6.59 model calls per question. At this corpus size it never beats cached RAG on total spend, at any number of questions. The fast path, measured the same day on the same build, is 156 times cheaper and 14 times faster than it. The loop stays on this page, priced at full size on the same scale, because leaving it off would be the dishonest version of the chart and because it is still what a tenant without the flag runs.

Everything here is measured from provider token counts, on both sides, against frozen rate tables: the Sonnet 4.6 table for the RAG arms and the Talonic agent loop, the Haiku 4.5 table for the Talonic fast path. Nothing is a list price and nothing is modelled, except the corpus-scaling projections beyond 106 documents, which are labelled as projections where they appear.

A RAG query is a model call. Whatever the retriever does first, the answer is produced by putting text in a prompt and paying for the tokens. Ask the same question twice and you pay twice, because nothing was kept from the first time.

Talonic reads each document once at ingest into a canonical data plane: typed fields with provenance, resolved against a field registry. A question over that plane is a scan, a count or a sort over a field table. There is no prompt, no context window and no token bill, which is why the marginal cost is not a small number but zero. We checked that against the meter rather than asserting it, and re-checked it on 2026-08-25: 1,014 questions answered in 0.0153 seconds with the tenant’s metered counters identical before and after, through the same public endpoints a customer would call.

The honest framing of that result is narrow. The structured arm pulls a field table once and then answers with arithmetic over 28 rows, and arithmetic over 28 rows is free for anyone. Talonic’s contribution is the ingest and the field table, not the sum. What the benchmark prices is the cost of answering from captured structure, which is exactly the thing a retrieval pipeline has to re-buy on every question.

Read the long-context row carefully, because it is the one that does not depend on corpus size. Both ingest and whole-corpus prompting scale with the number of documents, so the ratio between them is roughly constant and break even sits at question 243 or 244 at every size we measured. The hybrid row moves instead: hybrid RAG’s prompt does not grow with the corpus, so a bigger corpus means a bigger ingest against the same per-question price, and break even slides from question 65 at 53 documents to question 1,210 at a thousand.

The practical reading is that structuring pays for itself in the first afternoon of a small corpus, and in the first month of a large one, provided the corpus is queried more than a few hundred times. If it is queried once, retrieval is cheaper and this page is not an argument for us.

The headline $41.74 is the cached long-context line, and we publish it rather than the $320.35 uncached one because the cached number is the fairer opponent. It is also conditional in a way that matters operationally.

A cache write bills at 1.25 times the input rate, a read at a tenth, and the entry lives for five minutes, refreshed on each read. Long-context RAG benefits enormously because its whole prompt is the corpus and therefore identical on every question: 103,409 cached prefix tokens, and total spend on the 39-question battery falls from $12.49 to $1.98. The 2026-08-25 rerun started on a genuinely cold cache and so paid that write for real: the first question cost $0.3930 against $0.0417 for each warm question after it, which is why a 39-question battery run from cold works out at $50.75 per 1,000 rather than $41.74.

Under a workload of one question every ten minutes, every question falls outside the TTL and pays a fresh write instead of a read. For long-context RAG that is $393.00 per 1,000, taking the cold-write question this run actually measured and charging it to every question. That is worse than the $320.35 the arm costs with caching switched off. A dashboard firing forty questions in a minute gets the cheap line. An analyst thinking between questions gets the expensive one.

Hybrid RAG gets nothing either way. Its retrieved excerpts differ on every question and sit after the cache breakpoint, so the only cacheable prefix is a 457-character system prompt, about 114 tokens, against a minimum cacheable prefix of roughly 1,024. The run recorded zero cache reads and zero cache writes across all 39 questions and came out 0.3% more expensive than uncached, which is run-to-run variance. That reproduced exactly on the 2026-08-25 rerun: zero cache reads, zero cache writes, 0.3% above the uncached arm again. The “cached” hybrid row in the table above is a measurement that caching does not apply, not a caching result.

There is a hard stop at the end of the long-context line. Claude Sonnet 4.6’s context window is 1,000,000 tokens, and at 1,956 tokens per document one call holds 511 documents. At 1,000 documents the corpus is 1.96 million tokens and the arm has to split into 2 map calls plus 1 merge per question, which is where the 1,000-document row gets its three calls. Two honest footnotes on that number: the projection charges only map-call input and ignores the merge call’s own input, so the 511-plus figures are slight under-estimates, and the arm’s configured cap counts estimated tokens as characters over four, which runs about 1.55 times low on this corpus, so it would overflow the real window before its own cap fires.

None of that applies to a scan over a field table. The structured path does not read the corpus at query time, so corpus size changes the ingest bill and nothing else.

Talonic has three query surfaces and only one of them is free. The structured path is the API: fields in, arithmetic out, no model. The retrieval fast path is the natural-language surface that answers a question today: it compiles the question into a query over those same captured fields and executes it without a reasoning loop, at $0.001526 per question and 9.1 seconds. Behind both sits the path they replaced, the conversational agent loop, which plans, calls tools, reads captured fields and writes prose. It is an LLM loop, and it is priced like one. The fast path is enabled per tenant by a flag, so it is a real measured price but not yet everyone’s price, and the loop stays on this page at full size for that reason.

The loop, measured on the same 39 questions on 2026-08-25: $0.2377 per question, $237.69 per 1,000, a mean of 6.59 model calls per question, and 127.6 seconds of mean latency, which is about ten times slower than hybrid RAG’s 13.0 seconds. Once caching is enabled on the RAG side, that makes the agent the most expensive path in this benchmark. At 53 documents its running total is never below cached hybrid RAG at any number of questions, and never below cached long-context RAG either. It only starts winning against long context at 500 documents, at question 611.

We report that as a cost result, not as a defence. The agent buys something the structured path does not: a question asked in English, with provenance cited inline. If what you need is a number in a pipeline, the structured path is the one this page is about, and it is the one that is flat. The distinction is worth making because “Talonic’s line flattens after ingestion” is true of one path and false of the other, and a chart that draws them as a single line would be wrong.