Multi-Document Analysis
Run multi-document analysis on Hal at $2 / $10 per 1M tokens. OpenAI and Anthropic compatible, so you change the base URL, key and model.
What drives the cost
Multi-document analysis loads the bill in one place, which is the documents themselves. Every question re-reads the quarterly report, the budget and the invoices even when the reply is one sentence, and a reconciliation runs in several passes over those same documents. The written explanation adds output tokens on top, and on Hal an output token costs $10 per million against $2 for an input token, so document volume sets most of the bill and the length of the explanation sets the rest.
The cost of one call is the input tokens multiplied by the input price, plus the output tokens multiplied by the output price, divided by one million. Current rates are on the pricing page, and the tokenomics page explains where the cost behind a token comes from.
One reconciliation in three passes, to replace with your own numbers
The figures below are assumptions for illustration. A reconciliation of one quarterly report against one budget runs in three passes, where the first extracts the figures, the second reconciles them and the third writes the variance explanation, and every pass sends the documents again along with the output of the pass before it.
| Assumption | Value |
|---|---|
| Quarterly report and budget workbook, sent on every pass | 55,000 tokens |
| Instructions, output schema and citation format | 2,500 tokens |
| Pass 1, extract figures, input and output | 57,500 and 1,800 tokens |
| Pass 2, reconcile, input and output | 59,300 and 2,400 tokens |
| Pass 3, variance explanation, input and output | 61,700 and 1,600 tokens |
| Input tokens per reconciliation | 178,500 |
| Output tokens per reconciliation | 5,800 |
| Cost per reconciliation on Hal | $0.415 |
| Cost per 100 reconciliations on Hal | About $41.50 before prompt caching |
The arithmetic runs as follows. 178,500 input tokens multiplied by $2.00 and divided by 1,000,000 is $0.357, and 5,800 output tokens multiplied by $10.00 and divided by 1,000,000 is $0.058, so one reconciliation costs $0.415. The same token counts at Claude Opus 4.7 list prices of $5.00 and $25.00 give $0.8925 plus $0.145, which is $1.0375, and at GPT-5.5 list prices of $5.00 and $30.00 they give $0.8925 plus $0.174, which is $1.0665.
| Model | Input and output price per 1M | Input cost, 178,500 tokens | Output cost, 5,800 tokens | Per reconciliation | Per 100 reconciliations |
|---|---|---|---|---|---|
| Hal 1.0 | $2.00 / $10.00 | $0.357 | $0.058 | $0.415 | $41.50 |
| Claude Opus 4.7 | $5.00 / $25.00 | $0.8925 | $0.145 | $1.0375 | $103.75 |
| GPT-5.5 | $5.00 / $30.00 | $0.8925 | $0.174 | $1.0665 | $106.65 |
Input is about 97 percent of the tokens in this example and about 86 percent of the cost, so the number of documents and the number of passes decide the bill. At a 70 percent input and 30 percent output blend Hal runs 60 to 65 percent below Claude Opus 4.7 and GPT-5.5 at their list prices.
Twenty questions over one document set
The same document set is usually asked many questions. Assume 55,000 tokens of documents, 2,000 tokens of question and schema on each call, 900 output tokens per answer and 20 questions in a month, so each question costs 57,000 input tokens and 900 output tokens. One question is then $0.114 plus $0.009, which is $0.123, and the month is $2.46 on Hal before prompt caching. The same 20 questions cost $6.15 at Claude Opus 4.7 prices and $6.24 at GPT-5.5 prices.
| Assumption | Value |
|---|---|
| Documents, sent on every call | 55,000 tokens |
| Question and output schema per call | 2,000 tokens |
| Output per answer | 900 tokens |
| Questions per month | 20 |
| Input tokens per question and per month | 57,000 and 1,140,000 |
| Output tokens per month | 18,000 |
| Month on Hal, before prompt caching | $2.46 |
| Month on Claude Opus 4.7 | $6.15 |
| Month on GPT-5.5 | $6.24 |
| Month on Hal, with the documents cached | About $0.58 |
Prompt caching is where a document set pays for itself. On Hal a cached input token costs $0.20 per million, which is 10 percent of the $2.00 input price, and the other models list their own cached rates on the pricing page. With cache_control on the Anthropic-compatible endpoint, the first read of 55,000 document tokens costs $0.11 at full price and the 19 later reads cost 1,045,000 tokens multiplied by $0.20 and divided by 1,000,000, which is $0.209, so the documents cost $0.319 across the month. Adding 40,000 question tokens at $2.00 per million, which is $0.08, and 18,000 output tokens at $10.00 per million, which is $0.18, gives about $0.58 for the month against $2.46 uncached.
Measure your own document sets before you plan around any of these numbers, since the token count of a scanned statement and a typed budget differ by a factor that only your files can show.
Which model to use
Hal is the default for the reconciliation itself. It carries figures from one document to another, checks one total against another, follows a chain of documents where the answer depends on a prior document, and writes the variance explanation with citations to the source document and section. Hal takes scanned pages as images alongside text, which matters when the budget is typed and the supporting statements are scans. Hal is comparable to Claude Opus 4.7 and GPT-5.5 overall, and Radium has published no multi-document analysis benchmark, so run the test in the section below before you move traffic.
Clarke takes the retrieval-style questions over a single document, such as what a clause says or what one line item was set at. Its context window is 200,000 tokens, which is the largest on Radium, and Clarke is comparable to Claude Sonnet 4.6 and GPT-5.4. Sending single-document questions to Clarke leaves Hal free for the multi-document work where its reasoning pays for itself.
Tycho does the work around the reconciliation. Use it to classify incoming documents, extract figures into structured records and route each document to the right pass, at $0.10 per million input tokens and $1.50 per million output tokens. Tycho is comparable to Claude Haiku 4.5 and GPT-5.4 mini. The pattern of extracting and classifying first and reconciling second is set out in Document extraction and classification.
| Step | Model | Model ID |
|---|---|---|
| Reconciling figures across reports, chains of documents and variance explanations with citations | Hal | hal-1.0 |
| Scanned pages and any figure that has to be read from an image | Hal | hal-1.0 |
| Retrieval-style questions answered from one document | Clarke | clarke-1.0 |
| Extracting figures and classifying documents before the reconciliation | Tycho | tycho-1.0 |
| Summaries, triage and routing of incoming documents | Tycho | tycho-1.0 |
Route by the cost of a wrong figure.
What this workload needs from the API
An analysis pipeline depends on a short list of API capabilities, and each one should be confirmed against your own client before production traffic moves.
| Capability | Why this workload needs it | On Radium |
|---|---|---|
| Context window | Holding several long documents plus the instructions in one call, so a figure is reconciled against its source in a single pass | Hal 128,000 tokens, Tycho 128,000, Clarke 200,000 |
| Reasoning | Reconciling figures across documents and following a chain of documents where one answer depends on another | Hal and Clarke only |
| Structured output | Returning figures with the source document and section as JSON that your reporting code can check | JSON mode and JSON schema, on all three models |
| Prompt caching | Re-reading the same documents on every question and every pass | cache_control on the Anthropic-compatible endpoint |
| Repeatable runs | Comparing two passes over the same figures, and separating run-to-run variation from a real difference | temperature, top_p and seed on the OpenAI-compatible endpoint |
| Images as input | Scanned statements and printed pages that carry figures | Hal accepts text and images |
| Tool calling | Fetching a document, a section or a figure between passes | Supported on all three models, with multi-step tool loops on Hal and Clarke |
Four things do not carry over unchanged. Radium does not offer the Responses API, embeddings or file search, so a pipeline built on those services keeps using chat completions and its current provider for the rest. Model names from other providers return a model-not-found error until you change them to hal-1.0, clarke-1.0 or tycho-1.0. When reasoning is enabled the response includes a thinking block before the text block, so read the last content block instead of the first. A document set that runs past 128,000 tokens needs retrieval or chunking before it reaches the model, and the pattern for that is in Retrieval and RAG.
Compare all three models on the model overview. The switching guide walks through the evaluation against Anthropic and OpenAI, and the migration guide lists what changes and what stays the same. Work involving long multi-step runs is covered on the agent workloads page.
Check each row against your own client before the cutover.
How to switch
Radium serves OpenAI-compatible and Anthropic-compatible APIs, so an existing analysis pipeline keeps its SDK, its prompts, its schemas and its retry logic. Three values change, which are the base URL, the API key and the model name. The OpenAI-compatible base URL is https://api.radium.cloud/v1, and the Anthropic-compatible base URL is https://api.radium.cloud because the Anthropic SDK adds the /v1 path itself.
Steps
- Create an account at deploy.radium.cloud and generate a key at deploy.radium.cloud/keys. New accounts get $25 in credit with no card required.
- Set RADIUM_API_KEY as a secret in the service or job that runs the analysis, and keep it out of the repository and out of browser code.
- Change the base URL and the model name, then run the pipeline in shadow mode, with its output going to a log while your current provider keeps feeding the reports.
- Compare both sets of answers on the same document sets, then move the traffic over.
Switching back means pointing the base URL at your previous provider, and guides for both SDKs are in the Radium docs.
How to test it on your own reconciliations
Cost is easy to compute and accuracy is the part that takes work, so test before you move anything. Take the last month of analysis your team produced, meaning the quarterly reports against the budgets and the invoices against their purchase orders and contracts, and run the same documents and the same instructions through your current model and through Hal.
- Choose work whose answer you already trust. A reconciliation your team finished by hand gives you a reference set of figures, so every figure the model returns can be checked against the source document rather than against another model.
- Score only what a machine or a person can check. That means the output validates against the JSON schema, every figure matches the source to the cent, and every citation points to a document and a section that exist in the set you sent.
- Run each side twice. Use temperature 0 and a fixed seed where the endpoint allows one, so you see how much of any difference is run-to-run variation before you blame the model.
- Read the pairs that differ most. Sort the reconciliations by how far the two outputs differ in their totals and read the top of the list side by side, since a person decides which output is better.
- Count what goes into the report. A wrong figure and a missing citation cost different amounts when they reach a variance report, so weigh them by the cost of each reaching your reader.
Send the section headings and the document boundaries along with the text, because a figure that arrives without its header can end up attributed to the wrong line. Give the model the whole chain when the answer depends on several documents, since an answer drawn from one report and read against another is where reconciliations break. Multi-document sets that pass 128,000 tokens need retrieval or chunking first, and the pattern for that is in Retrieval and RAG, while the extraction and classification step that feeds the reconciliation follows Document extraction and classification.
Decide the threshold before you look at the results.
When Radium is the wrong choice
Radium fits when reconciliation across reports and invoices is a meaningful share of your AI spend, when the accuracy of a figure matters more than the line item on the bill, and when your pipeline accepts a custom endpoint. There are cases where switching is the wrong move.
- Your volume is small. If the analysis bill is a few hundred dollars a month, the evaluation will cost more than the switch saves.
- Your document sets exceed 128,000 tokens and the answer needs all of them at once. Hal holds 128,000 tokens, so a set larger than that needs retrieval or chunking in front of it, and building that is a project on its own.
- Your pipeline depends on the Responses API, embeddings or file search. Radium offers none of the three, so those calls stay where they are.
- Your analysis product chooses the model for you. Only a client that accepts a base URL, an API key and a model name can point at Radium.
- Every figure has to be traced by hand anyway. The model can return the source document and section for each figure when the prompt asks for it, and if your process still requires a person to re-check every figure against the source, the saving comes only from the drafting time.
If none of these apply, run the comparison on the last month of reconciliations.
Frequently asked questions
How much does multi-document analysis cost on Radium?
Hal costs $2 per million input tokens and $10 per million output tokens. A three-pass reconciliation of one quarterly report against one budget, using about 178,500 input tokens and 5,800 output tokens, comes to about $0.415 before prompt caching, which is $41.50 per 100 reconciliations. The same token counts cost about $1.04 on Claude Opus 4.7 and about $1.07 on GPT-5.5 at their list prices, and prompt caching cuts further cost on repeated reads of the same documents. Rates are on the pricing page.
Which Radium model should I use for multi-document analysis?
Use Hal (hal-1.0) for reconciling figures across reports, chains of documents and variance explanations with citations, including scanned pages sent as images. Use Clarke (clarke-1.0) for retrieval-style questions answered from a single document, and Tycho (tycho-1.0) for extracting figures and classifying documents before Hal reconciles them.
Is Radium as good as Claude Opus 4.7 or GPT-5.5 at this kind of analysis?
Hal is comparable to Claude Opus 4.7 and GPT-5.5 overall. On Radium's own 80-task structured suite, Hal 1.0 scored 96.25 percent correct against 93.75 percent for Claude Opus, which is 77 of 80 tasks against 75 of 80, in a single run scored by exact-match JSON schema. Hal ran with thinking off, and the benchmark is Radium's own, with no endorsement from Anthropic. Results against GPT-5.5 are pending. Radium has published no multi-document analysis benchmark, so run the plan in the section above on your own documents and decide on those results. Full results are on the benchmarks page.
Does Radium train models on our documents?
No. Radium does not use customer data to train models. Data is encrypted in transit, and enterprise customers can request retention and residency details during a security review.
What does not work when I switch an analysis pipeline to Radium?
The Responses API, embeddings and file search are not available, so a pipeline built on them needs chat completions or a separate provider for those calls. Model names from other providers return a model-not-found error until you change them to hal-1.0, clarke-1.0 or tycho-1.0. When reasoning is enabled a thinking block comes first, so read the last content block of the response, and 429 and 503 responses are retryable with backoff and jitter.
What do I do with a document set larger than 128,000 tokens?
Put retrieval or chunking in front of the model. Hal holds 128,000 tokens and Clarke holds 200,000, so a set above those limits is split or indexed first, and the pattern for both is in Retrieval and RAG. The step that pulls figures out of individual documents before the reconciliation follows Document extraction and classification, where Tycho does the extraction and classification at $0.10 per million input tokens.