Hal, Clarke and Tycho

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.

Overview

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.

The models

Lead with Hal. Hand routine work to Clarke and volume to Tycho.

By workload

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.

All use cases
Compare

The three models side by side.

HalClarkeTycho
Model IDhal-1.0clarke-1.0tycho-1.0
Built forReasoning, code, multi-step agentsRAG, copilots, support, most trafficClassification, extraction, routing
Comparable toClaude Opus 4.7GPT-5.5Claude Sonnet 4.6GPT-5.4Claude 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 window128K tokens200K tokens128K tokens
Max output32,768 tokens16,384 tokens8,192 tokens
ReasoningYesYesNo
Tool callingParallel, multi-stepYesYes
Structured outputJSON mode and schemaJSON mode and schemaJSON mode and schema
EndpointsOpenAI, AnthropicOpenAI, AnthropicOpenAI, Anthropic

List prices are Anthropic's published rates for the comparable model. Full rates and a cost estimate are on the pricing page.

Benchmarks

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.

ModelCorrect answersOutput tokens/sFirst text, p50End to end, p50
Hal
96.25%
499.5
1.95 s2.31 s
Claude Opus
93.75%
107.7
1.77 s1.92 s
Clarke
85%
85.6
0.47 s0.69 s
Claude Sonnet
100%
100.0
2.36 s2.82 s
Tycho
91.25%
376.1
1.23 s1.49 s
Claude Haiku
100%
408.3
2.03 s2.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

The stack

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.

  1. 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.
  2. InfraDistributed computing across data center sites, on modified server firmware and Radium's own switch software.
  3. HardwareRacks of GPU servers in data centers across several sites.

The infrastructure, measured by others.

2xLower latency than AWSMeasured at CMU
30%Higher MFU than GCPMeasured at Stanford CRFM
Walk through the stack
API

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.

from openai import OpenAI

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

response = client.chat.completions.create(
    model="hal-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: "hal-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": "hal-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: "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

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

message = client.messages.create(
    model="hal-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: "hal-1.0",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello, Radium!" }],
});

console.log(message.content[0].text);
curl https://api.radium.cloud/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "model": "hal-1.0",
    "messages": [{"role": "user", "content": "Hello, Radium!"}]
  }'
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
Read the switching guide
Preview

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.

Request access
Questions

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.

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