Our Models

Frontier-class models, without the frontier bill.

The same class of models you build on today, running on infrastructure we own and operate, for about half of what the closed labs charge.

Abstract curved dotted lines forming a symmetrical, wave-like pattern on a light background.
Workloads

Radium models are designed for workloads you run everyday

Our Models
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 or OpenAI GPT-6 Sol

Classification
Extraction

Tycho 1.0

High-Efficiency Scale

Comparable to Anthropic Haiku
4.5 or OpenAI GPT-6 Luna

The same workloads, at a lower cost to operate

Hal 1.0

Opus 5.5

GPT-6 Astra

Description

Radium's most capable model for complex reasoning, multi-step agents, and deep code analysis.

Anthropic's most capable model for complex reasoning, coding, and agentic workflows.

OpenAI's flagship reasoning model for advanced agents and coding tasks.

Pricing
$2.25 / input MTok
$11.50 / output MTok
$4 / input MTok
$20 / output MTok
$10 / input MTok
$50 / output MTok
Extended thinking
Yes
Yes
Yes
Adaptive thinking
Yes
Yes
No
Priority Tier
Yes
Yes
No
Comparative latency
2.31k ms p50
1.92k ms p50
Not benchmarked
Context window
128k tokens
1M tokens (beta)
1.05M tokens
Max output
128k tokens
128k tokens
128k tokens
Reliable knowledge cutoff
May 2025
May 2025
Aug 2025
Training data cutoff
Aug 2025
Aug 2025
Aug 2025

Clarke 1.0

Sonnet 5

GPT-6 Sol

Description

Radium's default production model for RAG, copilots, agents, and customer-facing AI.

Anthropic's balanced model for production reasoning and coding at scale.

OpenAI's multimodal flagship model for general-purpose and coding tasks.

Pricing
$1.50 / input MTok
$7.00 / output MTok
$2 / input MTok
$10 / output MTok
$2 / input MTok
$10 / output MTok
Extended thinking
Yes
Yes
No
Adaptive thinking
Yes
Yes
No
Priority Tier
Yes
Yes
No
Comparative latency
690 ms p50
2.82k ms p50
Not benchmarked
Context window
Extended
1M tokens (beta)
128k tokens
Max output
128k tokens
128k tokens
16,384 tokens
Reliable knowledge cutoff
May 2025
Aug 2025
Oct 2023
Training data cutoff
Aug 2025
Jan 2026
Oct 2023

Tycho 1.0

Haiku 4.5

GPT-6 Luna

Description

Radium's most cost-efficient model for classification, extraction, summarization, and support automation.

Anthropic's fastest model, built for low-latency, high-volume tasks.

OpenAI's small, low-cost model for lightweight, high-volume tasks.

Pricing
$0.50 / input MTok
$2.25 / output MTok
$1 / input MTok
$5 / output MTok
$0.10 / input MTok
$0.50 / output MTok
Extended thinking
Yes
No
No
Adaptive thinking
Yes
No
No
Priority Tier
Yes
Yes
No
Comparative latency
1.49k ms p50
2.05k ms p50
Not benchmarked
Context window
128k tokens
200k tokens
128k tokens
Max output
128k tokens
64k tokens
16,384 tokens
Reliable knowledge cutoff
May 2025
Feb 2025
Oct 2023
Training data cutoff
Aug 2025
Jul 2025
Oct 2023
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!"}]
  }'
Moving Workloads

OpenAI and Anthropic's APIs are drifting apart. Radium works with both.

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.
Metrics

Measured against the models it can replace.

One integration speaks both the OpenAI and Anthropic dialects and serves all three models. The two formats are drifting apart, and moving between them is turning into real work. Radium answers in whichever one your stack already speaks.

Read our benchmark report
Compared to
55%
Cost
+2.5pt
Faster
4.6x
Throughput
96.25%
Exact-Answer Quality
Security

Your workload runs on hardware we own.

01

We own and operate
every layer

Your models run on infrastructure that is ours end to end, not rented with a markup on top.

02

Your data trains nothing

What you send stays yours, and is not used to train anyone's next model.

03

Regional hosting

Choose where your workloads run, for teams that answer to data-residency requirements.

The economics of enterprise AI

Understanding the
hidden costs of AI

Tokenomics
A glance behind the curtain of ai
Abstract dark background with large overlapping circles and a pattern of tiny white dots.

Moving workloads
from OpenAI
or Anthropic

Model guide
A Radium Switching Guide
Dark abstract pattern with curved lines and dots converging towards the center.

What owning the
stack buys you

Technology
A LOOK behind the curtain
Abstract dark geometric pattern with intersecting lines and dotted texture.

Everything you
need to build

Resources
A RADIUM DEVELOPER REFERENCE
Abstract curved shape made of small white dots on a black background.