Preview

Hal 2.0

Radium's new flagship, built for long-horizon agents and complex software engineering. A 1M-token context window, text, image, video and audio in, and frontier-class results at a fraction of the cost.

Overview

Hal 2.0 is Radium's flagship: a trillion-parameter sparse mixture-of-experts model that goes head-to-head with the best frontier models on agentic coding and automation, at a fraction of the cost.

It activates 42B of its 1.02T parameters per token, so frontier capability costs a fraction as much to run, and it is served on Radium's throughput-optimized fleet behind the same API as Clarke and Tycho.

89.9%
Terminal-Bench 2.1
82%
OSWorld-Verified
71.9
DeepSWE v1.1, within 2 pts of top frontier models
Benchmark figures as published by the model developers and Artificial Analysis, October 2026. Scores vary with harness, effort setting and quantization.
See the benchmarks
Workloads

Work that runs long and has to come out right.

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
1M tokens
Input
Text, image, video and audio
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 Hal. Move work to Clarke and Tycho as it gets simpler.

Questions

Questions about Hal 2.0.

What is new in Hal 2.0?

Hal 2.0 is the next generation of Hal. It reads up to 1M tokens of context, up from 128K on Hal 1.0, and writes up to 131,000 tokens in a single response, up from 32,768. It takes text, image, video and audio as input and sits in the same class as Anthropic's Opus 5.5 and OpenAI's GPT-6.1 Sol.

How do I get access during the preview?

Sign in to your Radium account and request access from the dashboard. Capacity is limited while Hal 2.0 is in preview, so access is granted account by account, and the model string appears in your account once yours is approved. New accounts can request it as soon as they sign up.

Is Hal 2.0 replacing Hal 1.0?

Yes. When Hal 2.0 leaves preview, Hal 1.0 is retired and requests sent to hal-1.0 are served by Hal 2.0, so existing integrations move over without a code change. Until then, Hal 1.0 stays available to every account.

Does Hal 2.0 cost more than Hal 1.0?

No. Hal 2.0 is priced the same as Hal 1.0, at $2.00 per million input tokens and $10.00 per million output tokens, with cached input at 10% of the input price. Rate limits are the same too: 1,000 requests per minute with no tokens-per-minute cap.

Do I need to change my code?

Only the model name. With the OpenAI SDK, set the base URL to https://api.radium.cloud/v1, and with the Anthropic SDK, set it to https://api.radium.cloud. Use your Radium API key and the Hal 2.0 model string shown in your account once access is approved. Your prompts and tool schemas stay the same.

When does Hal 2.0 leave preview?

Radium will announce general availability on this page and by email to every account, along with the date Hal 1.0 is retired.

Give Hal 2.0 the job your current model keeps getting wrong.

Hal 2.0 is in early access.
Request it in your Radium account.

Every new account gets $25 in credit. No card required.

Request access
Dense cluster of white dots scattered against a dark background, resembling stars or particles.