Production-proven

Hal 1.0

Radium's model for the hardest work in production: reasoning across sources, writing and fixing code, and agents that run for many steps.

Overview

Hal is the model Radium puts on the hardest work in production: reasoning across documents, writing and fixing code, and agents that keep calling tools until the job is done.

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.

4.6x
Faster output
96.25%
Correct answers
$2
Per million input tokens
Against Claude Opus on Radium's own 80-task test. GPT-5.5 results on the same test are pending.
See the benchmarks
Workloads

The hard requests go to Hal.

Benchmarks

4.6 times the output speed of Claude Opus.

Hal and Claude Opus ran the same 80 structured tasks with fixed answers, then 40 tasks at four concurrent requests for speed. Hal scored a little higher on accuracy and wrote its answers far faster, and it takes slightly longer to start. GPT-5.5 results on the same tasks are pending.

Hal
499.5
Claude Opus
107.7
GPT-5.5
Pending
Output tokens per second
96.25%
Correct answers
Claude Opus 93.75%
GPT-5.5 pending
1.95 s
To first text, p50
Claude Opus 1.77 s
GPT-5.5 pending
2.31 s
End to end, p50
Claude Opus 1.92 s
GPT-5.5 pending
4.02 s
End to end, p95
Claude Opus 2.78 s
GPT-5.5 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 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 Hal.

Does Radium train its own foundation model?

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

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

What does Hal cost?

$2.00 per million input tokens and $10.00 per million output tokens. 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 Hal benchmarked?

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

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.