Frontier-class models, without the frontier bill.
Hal, Clarke and Tycho take the work you send to Opus, Sonnet and Haiku today, through the SDKs already in your code, at 60% to 76% below Anthropic's list prices.
Radium runs three models, one for each tier you already buy from Anthropic and OpenAI, and each one is a complete system with its own API, router and pool of tuned open-weight models.
Hal is the most capable of the three, built for reasoning across sources, writing and fixing code, and agents that run for many steps. Clarke takes everyday production traffic, and Tycho the high-volume classification, extraction and routing. All three speak the OpenAI and the Anthropic APIs, so moving a request between them, or from your current provider, is a change to the model name.
Lead with Hal. Hand routine work to Clarke and volume to Tycho.
Hal
Reasoning across sources, writing and fixing code, and agents that call tools for many steps.
- Comparable to
- Opus 4.7
- Per 1M tokens
- $2.00 / $10.00
Clarke
RAG, copilots, customer support and the bulk of production traffic.
- Comparable to
- Sonnet 4.6
- Per 1M tokens
- $0.75 / $4.50
Tycho
Classification, extraction, summaries and routing, at the lowest price per token.
- Comparable to
- Haiku 4.5
- Per 1M tokens
- $0.10 / $1.50
Pick the model by what a wrong answer costs.
Each workload below has a page with the cost math, the model to use, what it needs from the API and how to test it on your own traffic.
Agents
Long loops of planning and parallel tool calls, with no tokens-per-minute limit to slow a job down.
Code
Review comments, refactors and multi-file changes, with Clarke taking tests and docs.
RAG
Answers from retrieved passages. Your vector database, embeddings and reranker stay.
Copilots
Assistants inside the tools your team works in, answering from your own docs.
Support
Customer conversations in your voice and on your policies, at support volume.
Extraction
Fields pulled from documents and records sorted into labels, at volume.
Summaries
Calls, tickets and documents summarized as they come in.
The three models side by side.
| Hal | Clarke | Tycho | |
|---|---|---|---|
| Model ID | hal-1.0 | clarke-1.0 | tycho-1.0 |
| Built for | Reasoning, code, multi-step agents | RAG, copilots, support, most traffic | Classification, extraction, routing |
| Comparable to | Claude Opus 4.7GPT-5.5 | Claude Sonnet 4.6GPT-5.4 | Claude Haiku 4.5GPT-5.4 mini |
| Input, per 1M | $2.00Opus 4.7 lists $5 | $0.75Sonnet 4.6 lists $3 | $0.10Haiku 4.5 lists $1 |
| Output, per 1M | $10.00Opus 4.7 lists $25 | $4.50Sonnet 4.6 lists $15 | $1.50Haiku 4.5 lists $5 |
| Cached input, per 1M | $0.20 | $0.075 | $0.02 |
| Context window | 128K tokens | 200K tokens | 128K tokens |
| Max output | 32,768 tokens | 16,384 tokens | 8,192 tokens |
| Reasoning | Yes | Yes | No |
| Tool calling | Parallel, multi-step | Yes | Yes |
| Structured output | JSON mode and schema | JSON mode and schema | JSON mode and schema |
| Endpoints | OpenAI, Anthropic | OpenAI, Anthropic | OpenAI, Anthropic |
List prices are Anthropic's published rates for the comparable model. Full rates and a cost estimate are on the pricing page.
Each model against the Claude model it replaces, win or lose.
All six models ran the same 80 structured tasks with fixed answers, then 40 tasks at four concurrent requests for speed. Hal scored a little higher than Claude Opus and writes over four times faster. Clarke and Tycho start answering sooner than Sonnet and Haiku, but scored lower on accuracy and write slightly slower.
| Model | Correct answers | Output tokens/s | First text, p50 | End to end, p50 |
|---|---|---|---|---|
| Hal | 1.95 s | 2.31 s | ||
| Claude Opus | 1.77 s | 1.92 s | ||
| Clarke | 0.47 s | 0.69 s | ||
| Claude Sonnet | 2.36 s | 2.82 s | ||
| Tycho | 1.23 s | 1.49 s | ||
| Claude Haiku | 2.03 s | 2.05 s |
Radium's own test, run without Anthropic's involvement, on structured tasks only, so long context, tool use and open-ended writing are outside it. Radium's models ran with thinking off, Opus and Sonnet with adaptive thinking and Haiku with a 1,024-token thinking budget. GPT results are pending. Full method and results
Every model runs on the whole Radium stack.
Each model has its own API, its own router and reinforcement learning engine, and its own pool of open-weight models that Radium's model curation team selects and tunes. Underneath, all three share the same infrastructure and hardware.
- PlatformHal, Clarke and Tycho, each a complete system.OpenAI- and Anthropic-compatible, so your SDK and prompts stay where they are.A router and RL engine per model choose which model in the pool serves each request.Radium's model curation team selects and tunes the open-weight models.
- InfraDistributed computing across data center sites, on modified server firmware and Radium's own switch software.
- HardwareRacks of GPU servers in data centers across several sites.
The infrastructure, measured by others.
Switching takes three values.
Point the SDK you already use at Radium with a new base URL, a Radium key and a model name. The same three values move a request between Hal, Clarke and Tycho, and switching back is the same change in reverse.
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: "hal-1.0",
messages: [{ role: "user", content: "Hello, Radium!" }],
});
console.log(response.choices[0].message.content);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: "hal-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("hal-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("hal-1.0");
var response = await chatClient.CompleteChatAsync(
new UserChatMessage("Hello, Radium!"));
Console.WriteLine(response.Value.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: "hal-1.0",
max_tokens: 1024,
messages: [{ role: "user", content: "Hello, Radium!" }],
});
console.log(message.content[0].text);- Endpoints
- OpenAI-compatible at api.radium.cloud/v1, Anthropic-compatible at api.radium.cloud
- Structured output
- JSON mode and JSON schema on all three models
- Tool calling
- On all three models, and your application runs the tools
- Streaming
- OpenAI and Anthropic formats
- Prompt caching
- cache_control on the Anthropic-compatible endpoint
- Not yet
- Responses API, embeddings and batch
Hal 2.0 is in preview.
The next Hal is open to a limited group, and invites go out in waves as capacity opens. Request access to join the next wave.
Questions about the models.
Which model should I start with?
Hal, for the hardest work: reasoning across sources, code and agents that run for many steps. Once a workload runs well, move the routine requests to Clarke and the high-volume classification, extraction and routing to Tycho to lower the bill. Replay a sample of your own requests through each one to decide.
Can I use more than one model?
Yes. All three share one endpoint and one API key, so each request can name a different model. A common pattern is Tycho to sort incoming requests and Hal for the ones that need it.
How are the models built?
Each model is a complete system: an API, a router paired with a reinforcement learning engine, and a pool of open-weight models that Radium's model curation team selects and tunes. The router chooses which model in the pool serves each request.
How do they compare to Claude and GPT?
Hal is comparable to Claude Opus 4.7 and GPT-5.5, Clarke to Claude Sonnet 4.6 and GPT-5.4, and Tycho to Claude Haiku 4.5 and GPT-5.4 mini. On Radium's own test Hal beat Opus on accuracy and output speed, while Clarke and Tycho answered sooner than Sonnet and Haiku but scored lower on accuracy. The full results are on the benchmark page.
What do they cost?
Hal is $2.00 per million input tokens and $10.00 per million output tokens, Clarke $0.75 and $4.50, and Tycho $0.10 and $1.50. Cached input costs less, and new accounts get $25 of credit with no card needed.
Does Radium train on my data?
No. Your prompts and outputs are never used to train a model.
What does not carry over when I switch?
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. The Responses API, embeddings and batch are not available yet. With reasoning on, a thinking block comes first, so read the last content block of the response.
Put your hardest requests on Hal.
One line of code to switch.
A different class of performance.
Every new account gets $25 in credit. No card required.
