High-efficiency scale

Tycho 1.0

Radium's model for high-volume work: classifying, extracting, summarizing and routing text at the lowest price per token.

Overview

Tycho is the model Radium puts on high-volume text: sorting requests into labels, pulling fields out of documents, summarizing calls and tickets, and deciding where each request goes next.

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.

90%
Below Haiku 4.5 per input token
1.23 s
To first text, p50
$0.10
Per million input tokens
Haiku 4.5 lists $1.00 per million input tokens. Speed against Claude Haiku on Radium's own 40-task test, with GPT-5.4 mini results pending.
See the benchmarks
Workloads

High-volume text goes to Tycho.

Benchmarks

Starts answering 40% sooner than Claude Haiku.

Tycho and Claude Haiku ran the same 80 structured tasks with fixed answers, then 40 tasks at four concurrent requests for speed. Tycho starts answering sooner and finishes sooner at the median, while Haiku scored higher on accuracy, writes slightly faster and finishes its slowest requests a little sooner. GPT-5.4 mini results on the same tasks are pending.

Tycho
1.23 s
Claude Haiku
2.03 s
GPT-5.4 mini
Pending
Seconds to first text, p50. Shorter is faster.
91.25%
Correct answers
Claude Haiku 100%
GPT-5.4 mini pending
376.1
Output tokens per second
Claude Haiku 408.3
GPT-5.4 mini pending
1.49 s
End to end, p50
Claude Haiku 2.05 s
GPT-5.4 mini pending
3.05 s
End to end, p95
Claude Haiku 2.91 s
GPT-5.4 mini 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
128,000 tokens
Input
Text only
Structured output
JSON mode and JSON schema
Tool calling
Parallel calls with strict schemas
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 Tycho.

How is Tycho built?

Radium builds Tycho 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 Tycho?

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

What does Tycho cost?

$0.10 per million input tokens and $1.50 per million output tokens, and cached input is $0.02. 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 Tycho benchmarked?

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

Does Tycho read images?
No, Tycho takes text only. Send requests with images to Clarke or Hal, which share the same endpoint and key.

Move your highest-volume calls to Tycho.

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.