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.

Get your API key
Read the benchmark report
Abstract curved dotted lines forming a symmetrical, wave-like pattern on a light background.
Workloads

Radium models are designed for workloads you run everyday

Code

Autocomplete, refactors, tests, and review, running on the same class of model your team already uses.

Support

Customer conversations answered in your voice, on your policies, at the volume support actually runs.

Retrieval

Answers pulled from your own documents, with the source attached and the context window to carry it.

Copilots

The tools your team works in all day, answering questions about your own work, for everyone on it.

Our Models
Coding
Agents
Tool Calling

Hal 1.0

Maximum Capability

Comparable to Anthropic
Opus 4.6 or OpenAI GPT 5.4

Discover Hal 1.0
Retrieval
RAG
Chat

Clarke 1.0

Balanced Performance

Comparable to Anthropic
Sonnet 4.6 or OpenAI GPT-4o

Discover Clarke
Classification
Extraction

Tycho 1.0

High-Efficiency Scale

Comparable to Anthropic Haiku
4.5 or OpenAI GPT-4o mini

Discover Tycho
OpenAI SDK
Anthropic SDK
Python
TypeScript
curl
Go
Java
C#
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);
Python
TypeScript
curl
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.

Get your API key
Dense cluster of white dots scattered against a dark background, resembling stars or particles.
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.