Production models for RAG pipelines
Built for the synthesis step your retrieval feeds into, and priced forrunning on every query. Same SDK, one line of configuration.
Start with $25 in free credit. No card required.


Our top‑tier models across everystage of your RAG pipeline
Clarke matches retrieval and chat without frontier pricing. Route harder synthesis to Hal, and extraction to Tycho.
Hal 1.0
Comparable to Anthropic
Opus 5.5 or OpenAI GPT-6 Astra
Clarke 1.0
Comparable to Anthropic
Sonnet 5.5 or OpenAI GPT-6 Sol
Tycho 1.0
Comparable to Anthropic Haiku
5.5 or OpenAI GPT-6 Luna
Designed for the work you already run these models for.
Ingest & chunk
Structure and label documents before indexing
Embed & index
Split, vectorise and store.
Retrieve
Match the query to the nearest chunks
Generate
Read the chunks, write the answer
Scored against frontier models on real product tasks
Independent Radium benchmark, not endorsed by Anthropic. Claude and Opus are Anthropic PBC trademarks, used for identification only. Results are a single run, provided “as is,” and not a guarantee of future performance. See the full benchmark report
Control the cost per completed task
Every new account gets $25 in credit. No card required.

Built for long-context retrieval and structured answers
The numbers that matter when your chunks are measured in thousands of tokens.
128k
Stuffs 50+ retrieved chunks without truncation. System prompt + retrieved context + user query all in one call.
<120ms
Time-to-first-token for a typical RAG call: system prompt + 30 retrieved chunks + user query. Not a warm-cache best case.
4k
Room for a full answer with inline citations and a summary paragraph. Streaming delivers tokens as they are generated.
What changes
The base URL in your client
The model string
The invoice
What stays the same
The agent loop
The Anthropic or OpenAI SDK
Tool and function calls
Parallel tool calls
Streaming, including tool deltas
Structured output
Retry and error handling
Evals, tracing and observability
What the difference looks like monthly
Same tasks, different rate, two bills to compare.
Hal 1.0 against Claude Opus 5.5 list pricing, using real per-task token averages from the production benchmark. See the working
Six cost layers sit inside a frontier token. Two sit inside ours
The same arithmetic holds whether the call comes from an agent loop or a retrieval chain.


The switch is one line, and so is the way back

No. Retrieval, your index and your reranker stay exactly where they are. Radium sits downstream of retrieval and answers the query once the context is assembled.
Not on day one. Embeddings keep running through whatever provider generates them today. Only the generation call, the model that reads the retrieved chunks and writes the answer, points at Radium.
That's the right question, which is why we publish model comparisons instead of asking you to trust a claim. Clarke is scored against the frontier tier it replaces on the same production tasks. Run your own retrieval eval against both endpoints before you decide.
Yes. Tool calling, structured outputs and JSON schema behave the same way, because the API is compatible rather than similar. If your chain asks the model to return sources alongside an answer, that shape doesn't change.
Context window and maximum output are published in the model reference. A call that stuffs ten or twenty retrieved chunks into the prompt is a normal request, not an edge case.
It should help more here than almost anywhere else. A RAG system prompt and its instructions repeat on every call; only the retrieved chunks change. Prompt caching is supported and priced separately from the rest of the input.
Clarke for most retrieval and chat traffic. Route to Hal when a query needs multi-hop reasoning across several retrieved documents, and to Tycho for the classification and extraction steps upstream in ingestion.
Published, and above what most agent traffic needs. Agents burst rather than trickle, so if your ceiling is the problem we raise it rather than throttle you, because we own the capacity.
Point a staging chain at the endpoint and run the queries you already run. Compare cost per answered query on both endpoints before anything user-facing changes.
Remove one environment variable. Nothing upstream of the generation call, your retriever, your index, or your chunking, ever pointed anywhere else.


