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.

• The flat line. The Talonic structured path runs no model at query time. It reads captured fields over the public API and aggregates them in code, at a mean latency of 0.013 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 $321.23 per 1,000 questions uncached, and $41.90 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 245. On a 1,000-document corpus the second of those does not move: it is still question 244, because ingest and long-context both scale with the corpus.
• The line that is not flat. The Talonic conversational agent is an LLM loop at $244.52 per 1,000 and 137.7 seconds per question. At this corpus size it never beats cached RAG on total spend, at any number of questions. It is on this page because leaving it off would be the dishonest version of the chart.

Everything here is measured from provider token counts, on both sides, at the same frozen rates. 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: 1,014 questions answered in 0.0132 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 244 or 245 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,211 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.90 is the cached long-context line, and we publish it rather than the $321.23 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.53 to $1.62. A cold first question pays $0.3932 for the write, which is why a 39-question battery run from cold works out at $50.57 per 1,000 rather than $41.90.

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 $398.23 per 1,000, worse than the $321.23 it 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. 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 two query surfaces and only one of them is free. The structured path is the API: fields in, arithmetic out, no model. The agent path is the conversational product: it plans, calls tools, reads captured fields and writes prose. It is an LLM loop, and it is priced like one.

Measured on the same 39 questions: $0.2445 per question, $244.52 per 1,000, a mean of 6.59 model calls per question, and 137.7 seconds of mean latency, which is about eleven times slower than hybrid RAG’s 12.1 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 647.

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.

• Corpus: 53 XBRL financial-statement extracts from SEC 10-K filings, 28 distinct companies, 267,629 characters, about one page each. These are extracts, not full 10-K filings.
• Model: global.anthropic.claude-sonnet-4-6 on AWS Bedrock, eu-central-1, for every arm that calls a model. Temperature is left at the model default and never sent, which on the Bedrock Converse API for Anthropic models is 1.0.
• Retrieval configs: hybrid arm is BM25 plus Titan v2 dense embeddings, reciprocal rank fusion at k=60, top-k 24 chunks, 8,000-character chunks with 800-character overlap. Long-context arm puts the whole corpus in one context, with a configured cap of 900,000 estimated tokens.
• Battery: 39 questions (scaling/queries_n28_v4.jsonl) on every arm. The structured arm additionally ran a 100-question battery. A fixed 12-question subset ran at both 53 and 106 documents for the corpus-scaling comparison.
• Prices: Sonnet 4.6 at $3.00 per million input tokens and $15.00 per million output tokens, on both sides, from a frozen local rate table fixed by the preregistration. Caching is priced at 1.25 times input for a write, 0.1 times for a read, with a 300-second TTL.
• Talonic source: the public key-authed API only. GET /v1/credits/usage/log, GET /v1/usage, GET /v1/credits/balance and GET /v1/documents. No internal endpoints and no database access.
• Estimation: neither side is a billed invoice. Both are provider-reported token counts priced against a frozen local table. Talonic’s figure is computed by the platform from token counts with no margin added; the RAG figures are computed the same way from the Bedrock usage block. Both tables price Sonnet 4.6 identically, so the two sides are comparable.
• n: 39 questions per arm at 53 documents, 12 questions per arm at 106 documents, plus 100 questions on the structured path.
• Date and spend: run 2026-08-24, $36.99 of Bedrock spend this session. No Talonic agent turns were run for this benchmark: every Talonic figure reads spend that run 13 already incurred on 2026-08-20.
• Verification: every number was re-derived by an independent adversarial review (bench/verify-cost/VERDICT.md) that recomputed the arms from the raw run files without reference to the arms’ own recorded costs. Its corrections are applied here, including the break-even basis.

The RAG arms are fully reproducible from the talonic-rag-benchmark suite: corpus manifest, query set, retrieval configurations and price table were all frozen before any query ran.

The second form re-derives results.json from the existing run outputs for $0. The Talonic figures are read from the public API, so they are auditable end to end. Contact us for the benchmark bundle.