AI Agents and Tool Use

AI Agents and Tool Use

Run AI agent loops and multi-step tool use on Hal at $2 / $10 per 1M tokens. OpenAI and Anthropic compatible, so you change the base URL, key and model.

hal-1.0
November 16, 2026
At a glance
Recommended model
Hal
Model ID
hal-1.0
Price per 1M tokens
$2 input / $10 output
Compatibility
OpenAI and Anthropic compatible APIs. Change the base URL, key and model.
Last updated
November 16, 2026

What drives the cost

AI agents and multi-step tool use load the bill in one specific place, which is the transcript the model rereads on every step of the loop. A step plans the next move, calls one tool or several tools in parallel, appends the results to the transcript and sends the whole thing back to the model, so the same prefix is billed as input tokens once per step. Output tokens are fewer and costlier, because each step writes tool arguments and the run ends with a final answer, so the number of steps touches both halves of the bill. On Hal an input token costs $2 per million and an output token costs $10 per million.

The cost of one call is the input tokens multiplied by the input price, plus the output tokens multiplied by the output price, divided by one million, and the cost of a run is that sum taken over every step of the loop. Current list rates are on the pricing page, and the tokenomics page explains where the cost behind a token comes from. Prompt caching changes the input term, because a cached token bills at $0.20 per million on Hal, which is 10 percent of the input price.

One worked example to replace with your own numbers

Assume an agent task that finishes in 33 steps, which is the length of one run Radium measured on Hal, with a 3,000-token fixed prefix of instructions and tool definitions that is sent on every step and a transcript that grows by 1,700 tokens per step. These are illustrative assumptions for the arithmetic, so substitute the trace from your own runs.

AssumptionValue
Steps to finish the task33
Fixed prefix sent on every step, instructions and tool schemas3,000 tokens
Transcript growth per step, tool results, tool arguments and model text1,700 tokens
Input tokens on step 13,000
Input tokens on step 3357,400
Input tokens across the run, 33 × (3,000 + 57,400) ÷ 2996,600
Output tokens, 32 tool steps at 600 plus a 1,800-token final answer21,000
Input cost on Hal, 996,600 × $2 ÷ 1,000,000$1.993
Output cost on Hal, 21,000 × $10 ÷ 1,000,000$0.210
Cost per run on Hal$2.203
Cost per 1,000 runs on HalAbout $2,203 before prompt caching

The comparison figures hold those token counts fixed and swap in the list prices of the comparison models, so the arithmetic stays visible and checkable. Input is 98 percent of the tokens and 90 percent of the cost in this run, so input price and step count decide the bill.

ModelInput priceOutput priceInput costOutput costCost per run
Hal, hal-1.0$2.00$10.00996,600 × $2 ÷ 1,000,000 = $1.99321,000 × $10 ÷ 1,000,000 = $0.210$2.203
Anthropic Claude Opus 4.7, list price$5.00$25.00996,600 × $5 ÷ 1,000,000 = $4.98321,000 × $25 ÷ 1,000,000 = $0.525$5.508
OpenAI GPT-5.5, list price$5.00$30.00996,600 × $5 ÷ 1,000,000 = $4.98321,000 × $30 ÷ 1,000,000 = $0.630$5.613

Per 1,000 runs those figures read about $2,203 on Hal against about $5,508 on Claude Opus 4.7 and about $5,613 on GPT-5.5, which are the per-run costs above multiplied by 1,000. At a 70 percent input and 30 percent output blend Hal is 60 to 65 percent less than both Anthropic Claude Opus 4.7 and OpenAI GPT-5.5 at their list prices.

Step count is the number that turns a saving into a loss. In one measured agent run Hal took 33 steps against 31 for Claude Opus and finished the same task, and results against OpenAI GPT-5.5 are pending because GPT-5.5 has not been run on the same work yet. Two steps apart in a run of more than a million input tokens is a small gap, and a cheaper model that took twice as many steps would cost roughly twice as much despite the lower price per token. Read the step count on every run and compare it with your current provider before you trust any price comparison.

The fixed prefix is resent on every step because the protocol carries the transcript whole, and the 3,000-token prefix above is sent 33 times for 99,000 input tokens, which costs about $0.20 at Hal's input price. On the Anthropic-compatible endpoint, cache_control bills a cached token at $0.20 per million, so those 99,000 tokens cost about $0.02 once they are cached. A loop with a stable tool schema and instructions pays full price for the prefix once and the cached rate on every later step.

Measure your own traces before you plan around any of these numbers.

Which model to use

Hal is the default for the loop itself. It is built for multi-step agents and tool calling, and it holds the plan, the tool arguments and the long transcript together as the run grows across many steps. Hal is comparable to Anthropic Claude Opus 4.7 and OpenAI GPT-5.5 overall, and it costs $2 per million input tokens and $10 per million output tokens, so it is the model to trust with the steps where a wrong tool call is expensive. Radium publishes benchmark results on its own task suite, and no agent-specific public benchmark exists, so run the test in the section below before you move any traffic.

Clarke takes simpler loops and high-volume sub-agents, such as a worker that reads one ticket, calls two tools and writes a short answer, or a sub-agent spawned in fan-out to process a slice of a larger task. It costs $0.75 per million input tokens and $4.50 per million output tokens, it supports multi-step tool loops and reasoning, and its 200,000-token context window is the largest of the three, which helps when a sub-agent inherits a long transcript.

Tycho does routing, triage and classification steps inside the loop, such as deciding which tool to call next, whether a result is complete, which queue a ticket belongs to and whether a step can be skipped. It costs $0.10 per million input tokens and $1.50 per million output tokens.

StepModelModel ID
Main planning loop, tool arguments against strict schemas, decisions over a long transcriptHalhal-1.0
Simpler loops, high-volume sub-agents, fan-out workers and routine tool callsClarkeclarke-1.0
Routing, triage and classification steps inside the loopTychotycho-1.0

Route each kind of step by the cost of the wrong next tool call.

What this workload needs from the API

An agent loop depends on a short list of API capabilities, and each one should be confirmed against your own client before production traffic moves.

CapabilityWhy this workload needs itOn Radium
Multi-step tool loopsPlanning a step, calling tools, reading results and continuing until the task is doneHal and Clarke, with tool calling on all three models
Parallel tool calls and strict schemasSending several independent calls in one turn and validating the arguments before they runSupported, with your application executing the tools
Prompt cachingThe transcript prefix is resent on every step of the loop, and the stable part should bill at cache ratescache_control on the Anthropic-compatible endpoint, cached input $0.20 on Hal, $0.075 on Clarke, $0.02 on Tycho
Structured outputParsing tool arguments and the final answer back into the loopJSON mode and JSON schema on all three models
Streaming, including tool call deltasShowing what the agent is doing while a long run is still workingOpenAI and Anthropic stream formats
ReasoningChoosing the next tool call on a hard step and planning across several stepsHal and Clarke only
Context windowHolding a transcript that grows with every step and every tool resultClarke 200,000 tokens, Hal 128,000, Tycho 128,000
Throughput headroomFanning out across many concurrent agents and long runsNo tokens-per-minute limit, treat 429 and 503 as retryable and back off with jitter
Repeatable runsComparing two runs of the same task on the same transcripttemperature, top_p and seed on the OpenAI-compatible endpoint

Four things do not carry over unchanged. The Responses API is unavailable, so a loop built on it calls chat completions. Embeddings and file search are unavailable, so retrieval that uses them keeps its current retrieval provider while the agent loop moves. Model names from other providers return a model-not-found error until they are changed to hal-1.0, clarke-1.0 or tycho-1.0. When reasoning is enabled the response includes a thinking block before the text block, so read the last content block, which holds the answer.

LangGraph, LlamaIndex, CrewAI, PydanticAI, the OpenAI Agents SDK, the Vercel AI SDK and LiteLLM work by changing provider config. Compare the three models on the model overview, and read the switching guide and the migration guide for the details of a move. For the product overview and the savings estimator, see Radium for agents.

Check each row against your own client before the cutover.

How to switch

Radium serves OpenAI-compatible and Anthropic-compatible APIs, so an existing agent loop keeps its SDK, its framework, its tool definitions and its retry logic. Three values change, which are the base URL, the API key and the model name. The OpenAI-compatible base URL is https://api.radium.cloud/v1 and the Anthropic-compatible base URL is https://api.radium.cloud, because the Anthropic SDK adds the /v1 path itself.

Steps

  1. Create an account at deploy.radium.cloud and generate a key at deploy.radium.cloud/keys. New accounts get $25 in credit with no card required.
  2. Store the key as a secret in the service or the CI job that runs the agent, and keep it out of the repository and out of browser code.
  3. Point the base URL at Radium, set the model names, and run one agent in shadow mode, with its output going to a log while your current provider keeps serving the task.
  4. Compare the two runs on the same tasks, then move the traffic and raise the fan-out gradually.

Switching back means pointing the base URL at your previous provider, and the model names go back with it. Guides for both SDKs are in the Radium docs.

How to test it on your own agent tasks

Cost is easy to compute and the quality of a long loop is the part that takes work, so test before you move anything. Radium has published no agent-specific public benchmark, so the evidence has to come from your own tasks. Pick 30 to 50 real tasks that your agents handle today and replay them through your current provider and through Radium with the same prompt, the same tools and the same termination rule.

  1. Count the steps first. Record steps per task, tokens per step, tool call errors and whether the run finished on both sides, because the 33 against 31 step run that Radium measured shows the gap can be small and it is multiplied by a million input tokens. A cheaper model only saves money when it takes about as many steps.
  2. Score only what a machine can check. That means whether the run reads the final answer in the last content block when reasoning is on, whether every tool call validates against the schema, whether the plan covers the task and whether the output parses as JSON.
  3. Keep the cache warm the way production does. Run the loop with a stable tool schema and instructions so the prefix caches, then read the billed input and the billed cached input separately on both sides.
  4. Read the runs that differ most. Sort the pairs by differences in steps and in the final answer and read the top of the list side by side, because a person decides which run is better.
  5. Project the monthly bill from your own step counts. Multiply input tokens by the input price and output tokens by the output price over the whole run, per the worked example above, and compare that with your current provider on the same tasks.

Fan out one more time on the same tasks at the concurrency you use in production and watch for 429 and 503 responses, retrying with backoff and jitter, so the test shows cost under load as well as in a single run. The benchmark page has the suite results Radium has published. Decide the threshold before you look at the results.

When Radium is the wrong choice

Radium fits when agent loops and tool use are a meaningful share of your AI spend and the frameworks you use accept a custom endpoint. There are cases where switching is the wrong move.

  • Your framework is built on the Responses API or on file search. Radium provides chat completions, so those parts stay where they are and only the loop moves.
  • Your retrieval runs on embeddings from the same provider. Radium offers no embeddings, and moving the agent while leaving retrieval in place adds one more system to run.
  • Your volume is small. If the bill is a few hundred dollars a month, the evaluation costs more than the switch saves.
  • Your transcripts run past 128,000 tokens on a single call. Hal holds 128,000 tokens, so a single very long transcript needs compaction, an external store or Clarke at 200,000 tokens before the loop moves.
  • A step in your loop needs reasoning and you planned to run it on Tycho. Reasoning runs on Hal and Clarke, so those steps stay on Hal or Clarke and the saving on that step is smaller.

If none of these apply, replay your last 30 to 50 agent tasks and count the steps.

Frequently asked questions

How much does an AI agent cost on Radium?

Hal costs $2 per million input tokens and $10 per million output tokens, and cached input costs $0.20 per million. On the illustrative 33-step run in the worked example above, with 996,600 input tokens and 21,000 output tokens across one task, a run costs about $2.203 and 1,000 runs cost about $2,203 before prompt caching. The same token counts cost about $5.508 per run, or about $5,508 per 1,000 runs, on Claude Opus 4.7 and about $5.613 per run, or about $5,613 per 1,000 runs, on GPT-5.5, where Anthropic prices Claude Opus 4.7 at $5.00 per million input tokens and $25.00 per million output tokens and OpenAI prices GPT-5.5 at $5.00 and $30.00.

Which Radium model should an agent run on?

Use Hal (hal-1.0) for the main planning loop, the tool arguments and the long transcript, Clarke (clarke-1.0) for simpler loops and high-volume sub-agents at $0.75 per million input tokens and $4.50 per million output tokens, and Tycho (tycho-1.0) for routing, triage and classification steps at $0.10 and $1.50.

Is Hal as good as Claude Opus 4.7 and GPT-5.5 for agent workloads?

On Radium's own 80-task structured suite, which is a single run scored by exact match against a JSON schema, Hal 1.0 was correct on 96.25 percent of tasks (77 of 80) against Claude Opus at 93.75 percent (75 of 80), with Hal running with thinking off. Results against GPT-5.5 are pending, since GPT-5.5 has not been run on the same suite. In one measured agent run Hal took 33 steps against 31 for Anthropic's Claude Opus and finished the same task, with results against OpenAI's GPT-5.5 pending, and Radium has published no agent-specific public benchmark, so replay your own agent tasks on both and compare.

How does prompt caching change the cost of an agent loop?

Every step resends the transcript, so the stable prefix of instructions and tool schemas is billed as input tokens on each step. On the Anthropic-compatible endpoint, cache_control bills a cached token at $0.20 per million on Hal, $0.075 on Clarke and $0.02 on Tycho, and the growing transcript is cached the same way. In the worked example above, the 3,000-token prefix sent 33 times is 99,000 input tokens, which is about $0.20 at the input price and about $0.02 once it is cached.

Does Radium train models on our agent data?

Radium does not use customer data to train models. Data is encrypted in transit, and enterprise customers can request retention and residency details from company security in a security review.

What does not work when I switch an agent framework to Radium?

The Responses API, embeddings and file search are unavailable, so a loop built on the Responses API moves to chat completions and retrieval keeps its current provider for embeddings. Model names from other providers return a model-not-found error until they are changed to hal-1.0, clarke-1.0 or tycho-1.0. When reasoning is enabled on Hal and Clarke, a thinking block comes first in the response, so the loop reads the last content block. LangGraph, LlamaIndex, CrewAI, PydanticAI, the OpenAI Agents SDK, the Vercel AI SDK and LiteLLM use the OpenAI-compatible endpoint at https://api.radium.cloud/v1, and Claude Code connects through the Anthropic-compatible endpoint at https://api.radium.cloud.