Retrieval & RAG

Your RAG bill is mostly reading.
Clarke reads for less.

Clarke is a Sonnet-class model, tuned and served on Radium at $1.50 per million input tokens, with no tokens-per-minute limit. Change the base URL, key and model name, and your retriever, index and SDK stay as they are.

Start with $25 in free credit. No card required.

Get your API key
Drop‑in for
Anthropic SDK
OpenAI SDK
GitHub Copilot
Claude Code CLI
LangGraph
Vercel AI SDK
LlamaIndex
VS Code
Lite LLM
Anthropic SDK
OpenAI SDK
GitHub Copilot
Claude Code CLI
LangGraph
Vercel AI SDK
LlamaIndex
VS Code
Lite LLM
Our Models

One model for each stage of your RAG pipeline

Clarke matches retrieval and chat without frontier pricing. Route harder synthesis to Hal, and extraction to Tycho.

Coding
Agents
Tool Calling

Hal 1.0

Maximum Capability

Comparable to Anthropic
Opus 5.5 or OpenAI GPT-6 Astra

Retrieval
RAG
Chat

Clarke 1.0

Balanced Performance

Comparable to Anthropic
Sonnet 5.5 or OpenAI GPT-6 Sol

Classification
Extraction

Tycho 1.0

High-Efficiency Scale

Comparable to Anthropic Haiku
5.5 or OpenAI GPT-6 Luna

Designed for the work you already run these models for.

Tycho 1.0

Ingest & chunk

Structure and label documents before indexing

Keep As-is

Embed & index

Split, vectorise and store.

Keep As-is

Retrieve

Match the query to the nearest chunks

Clarke 1.0

Generate

Read the chunks, write the answer

Model Comparison

Scored against frontier models on real product tasks

Radium Hal 1.0
50
77
 / 
80
 correct
Anthropic Opus 5.5
50
75
 / 
80
 correct
Tasks in category
Runs per task
Scored by
80
1
Exact-match JSON schema
Radium Hal 1.0
50
20
 / 
20
 correct
Anthropic Opus 5.5
50
15
 / 
20
 correct
Tasks in category
Runs per task
Scored by
20
1
Exact-match JSON schema
Radium Hal 1.0
50
17
 / 
20
 correct
Anthropic Opus 5.5
50
20
 / 
20
 correct
Tasks in category
Runs per task
Scored by
20
1
Exact-match JSON schema
Radium Hal 1.0
50
20
 / 
20
 correct
Anthropic Opus 5.5
50
15
 / 
20
 correct
Tasks in category
Runs per task
Scored by
20
1
Exact-match JSON schema
Radium Hal 1.0
50
20
 / 
20
 correct
Anthropic Opus 5.5
50
20
 / 
20
 correct
Tasks in category
Runs per task
Scored by
20
1
Exact-match JSON schema

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

The number that matters

Control the cost per answered question

Every new account gets $25 in credit. No card required.

Get your API key
Dense cluster of white dots scattered against a dark background, resembling stars or particles.
RAG specs

Built for the part of RAG you pay for

Retrieved passages are most of the input, and input is most of the bill.

Input price

$1.50 / 1M

Clarke's price per million input tokens, 25% below Sonnet 5.5 at list. A question with eight retrieved passages costs under a cent.

Tokens per minute

No limit

1,000 requests a minute with a burst of 33, set per organization from day one. A 9am spike in questions is just traffic.

Prompt caching

Up to 90%

Saved with prompt caching on the system prompt and instructions that repeat on every query. Only the retrieved chunks change.

What changes

Three values change

Change the base URL, the API key and the model name. Your SDK, retriever, prompts and evals carry on as they are.

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.radium.cloud/v1",
)

response = client.chat.completions.create(
    model="clarke-1.0",
    messages=[
        {"role": "user", "content": "Hello, Radium!"}
    ],
)

print(response.choices[0].message.content)
import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "YOUR_API_KEY",
  baseURL: "https://api.radium.cloud/v1",
});

const response: OpenAI.Chat.ChatCompletion =
  await client.chat.completions.create({
    model: "clarke-1.0",
    messages: [{ role: "user", content: "Hello, Radium!" }],
  });

console.log(response.choices[0].message.content);
curl https://api.radium.cloud/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "model": "clarke-1.0",
    "messages": [{"role": "user", "content": "Hello, Radium!"}]
  }'
package main

import (
	"context"
	"fmt"

	openai "github.com/sashabaranov/go-openai"
)

func main() {
	cfg := openai.DefaultConfig("YOUR_API_KEY")
	cfg.BaseURL = "https://api.radium.cloud/v1"
	client := openai.NewClientWithConfig(cfg)

	resp, err := client.CreateChatCompletion(
		context.Background(),
		openai.ChatCompletionRequest{
			Model: "clarke-1.0",
			Messages: []openai.ChatCompletionMessage{
				{Role: openai.ChatMessageRoleUser, Content: "Hello, Radium!"},
			},
		},
	)
	if err != nil {
		panic(err)
	}

	fmt.Println(resp.Choices[0].Message.Content)
}
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.*;

OpenAIClient client = OpenAIOkHttpClient.builder()
    .apiKey("YOUR_API_KEY")
    .baseUrl("https://api.radium.cloud/v1")
    .build();

ChatCompletion completion = client.chat().completions().create(
    ChatCompletionCreateParams.builder()
        .model("clarke-1.0")
        .addUserMessage("Hello, Radium!")
        .build());

System.out.println(
    completion.choices().get(0).message().content().orElseThrow());
using OpenAI;
using OpenAI.Chat;

var client = new OpenAIClient(
    new ApiKeyCredential("YOUR_API_KEY"),
    new OpenAIClientOptions
    {
        Endpoint = new Uri("https://api.radium.cloud/v1"),
    });

var chatClient = client.GetChatClient("clarke-1.0");
var response = await chatClient.CompleteChatAsync(
    new UserChatMessage("Hello, Radium!"));

Console.WriteLine(response.Value.Content[0].Text);
import anthropic

client = anthropic.Anthropic(
    api_key="YOUR_API_KEY",
    base_url="https://api.radium.cloud",
)

message = client.messages.create(
    model="clarke-1.0",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Hello, Radium!"}
    ],
)

print(message.content[0].text)
import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({
  apiKey: "YOUR_API_KEY",
  baseURL: "https://api.radium.cloud",
});

const message: Anthropic.Message = await client.messages.create({
  model: "clarke-1.0",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello, Radium!" }],
});

console.log(message.content[0].text);
curl https://api.radium.cloud/v1/messages \
  -H "Content-Type: application/json" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -d '{
    "model": "clarke-1.0",
    "max_tokens": 1024,
    "messages": [{"role": "user", "content": "Hello, Radium!"}]
  }'

What changes

The base URL in your client

The model string

The invoice

What stays the same

The retriever and reranker

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

Cost

What the difference looks like monthly

Same tasks, different rate, two bills to compare.

Monthly spend on frontier RAG generation traffic
Share moved
Estimated monthly savings
$0
0% lower
than current bill

Clarke 1.0 against Sonnet 5.5 list pricing as of October 2026, for a RAG question with 4,900 input and 350 output tokens.

See the working
Pricing Breakdown

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.

Frontier Token
Radium Token

The switch is three values, and so is the way back

Get your API key
FAQ
Does Radium replace our vector database?

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.

What about embeddings? Do those move too?

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.

Will answer quality change if we swap the generation model?

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.

Do citations and structured output still work?

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.

How does it handle large retrieved context windows?

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.

Does prompt caching help, since our system prompt repeats every query?

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.

Which model should the generation step use?

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.

What are the rate limits when query volume spikes?

1,000 requests per minute with a burst of 33, and no tokens-per-minute limit, set per organization from day one. There's no spend history to build first. Above 1,000 requests a minute you can still get a 429, so keep a retry with backoff for those.

How do we test this without touching production traffic?

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.

Can we switch back?

Change the three values back. Nothing upstream of the generation call, your retriever, your index, or your chunking, ever pointed anywhere else.