Balanced performance

Clarke 1.0

Radium's model for everyday production traffic: answers from retrieved documents, copilots, support conversations and structured output.

Overview

Clarke is the model Radium puts on most production traffic: answers from retrieved passages, copilots inside the tools your team uses, customer conversations and structured output.

Radium selects open-weight models, tunes them and serves them behind one API, where a router and a reinforcement learning engine choose the model for each request.

5x
Faster to first text
0.69 s
End to end, p50
$0.75
Per million input tokens
Against Claude Sonnet on Radium's own 40-task speed test. GPT-5.4 results on the same test are pending.
See the benchmarks
Workloads

Most production traffic goes to Clarke.

Benchmarks

Five times faster to first text than Claude Sonnet.

Clarke and Claude Sonnet ran the same 80 structured tasks with fixed answers, then 40 tasks at four concurrent requests for speed. Clarke starts answering about five times sooner and finishes sooner, while Sonnet scored higher on accuracy and writes slightly faster once it starts. GPT-5.4 results on the same tasks are pending.

Clarke
0.47 s
Claude Sonnet
2.36 s
GPT-5.4
Pending
Seconds to first text, p50. Shorter is faster.
85%
Correct answers
Claude Sonnet 100%
GPT-5.4 pending
85.6
Output tokens per second
Claude Sonnet 100.0
GPT-5.4 pending
0.69 s
End to end, p50
Claude Sonnet 2.82 s
GPT-5.4 pending
2.27 s
End to end, p95
Claude Sonnet 3.74 s
GPT-5.4 pending

The infrastructure, measured by others.

2x
Lower latency than AWS
Measured at CMU
30%
Higher MFU than GCP
Measured at Stanford CRFM
The stack

One model ID, and the whole stack under it.

  1. PlatformThe Radium API, its router and RL engine, and a pool of tuned open-weight models.OpenAI- and Anthropic-compatible, so your SDK and prompts stay where they are.The router and RL engine choose the model for each request.Radium's model curation team selects and tunes the 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.
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 the model name. 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="__MODEL__",
    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: "__MODEL__",
    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": "__MODEL__",
    "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: "__MODEL__",
			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("__MODEL__")
        .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("__MODEL__");
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="__MODEL__",
    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: "__MODEL__",
  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": "__MODEL__",
    "messages": [{"role": "user", "content": "Hello, Radium!"}]
  }'
Endpoints
OpenAI- and Anthropic-compatible
Context window
200,000 tokens
Input
Text and images
Structured output
JSON mode and JSON schema
Tool calling
Parallel calls, strict schemas, multi-step loops
Streaming
OpenAI and Anthropic formats, with tool call deltas
Rate limits
1,000 requests a minute, burst of 33, no tokens-per-minute limit
Coming later
Responses API, embeddings and batch
Read the docs→
The lineup

Start on Clarke and send the hard requests to Hal.

Questions

Questions about Clarke.

How is Clarke built?

Radium builds Clarke from open-weight models that its model curation team selects and tunes, and serves them behind one API with a router and a reinforcement learning engine that choose the model for each request.

How do I move a workload to Clarke?

Set the base URL to https://api.radium.cloud/v1, use a Radium API key and set the model to clarke-1.0. Your SDK, prompts and tool schemas stay the same.

What does Clarke cost?

$0.75 per million input tokens and $4.50 per million output tokens, and cached input is $0.075. New accounts get $25 of credit with no card needed.

Does Radium train on my data?

Your prompts and outputs are never used to train a model.

How was Clarke benchmarked?

On Radium's own suite of 80 structured tasks with fixed answers and 40 tasks for speed, against Claude Sonnet, with GPT-5.4 results on the same suite pending. The full method, confidence intervals and limits are on the benchmark results page.

When should I use Hal instead?
When a request needs deep reasoning over many steps or a change across several files. Hal shares the same endpoint and key, so moving a request is a change to the model name.

Move your everyday traffic to Clarke.

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.