Overdrive

Deference Overdrive is the fast route for supported models. An Overdrive request runs only on the one provider that model is pinned to, at that endpoint's own price. The route never falls back: when the pinned provider cannot serve, the request fails rather than take a slower route.

It is one suffix on the model id. Your key, base URL, SDK and credit all work unchanged.

Use it

Append :overdrive to a supported model id, such as openai/gpt-oss-120b:overdrive, and send it as model on any endpoint that takes a text model: Chat Completions, Messages or Responses.

curl https://deference.si/v1/chat/completions \
  -H "Authorization: Bearer $DEFERENCE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-oss-120b:overdrive",
    "messages": [{ "role": "user", "content": "Say hello in one sentence." }],
    "max_tokens": 100
  }'

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://deference.si/v1",
    api_key=os.environ["DEFERENCE_API_KEY"],
)

response = client.chat.completions.create(
    model="openai/gpt-oss-120b:overdrive",
    messages=[{"role": "user", "content": "Say hello in one sentence."}],
    max_tokens=100,
)
print(response.choices[0].message.content)

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://deference.si/v1",
  apiKey: process.env.DEFERENCE_API_KEY,
});

const response = await client.chat.completions.create({
  model: "openai/gpt-oss-120b:overdrive",
  messages: [{ role: "user", content: "Say hello in one sentence." }],
  max_tokens: 100,
});
console.log(response.choices[0].message.content);

The Anthropic SDK works the same way — its base URL keeps no /v1.

import os
import anthropic

client = anthropic.Anthropic(
    base_url="https://deference.si",
    api_key=os.environ["DEFERENCE_API_KEY"],
)

message = client.messages.create(
    model="openai/gpt-oss-120b:overdrive",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Say hello in one sentence."}],
)
print(message.content[0].text)

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({
  baseURL: "https://deference.si",
  apiKey: process.env.DEFERENCE_API_KEY,
});

const message = await client.messages.create({
  model: "openai/gpt-oss-120b:overdrive",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Say hello in one sentence." }],
});
console.log(message.content);

The response body names the base model, without the suffix: openai/gpt-oss-120b. Billing, Activity and MCP receipts keep the id you sent.

Coding tools such as Claude Code and Codex work with any Overdrive model whose supported_parameters lists tools, since they send tools on every request. Nothing is stripped: the caller identifiers they send are forwarded as on any standard call.

Models

These are the models Overdrive serves at launch. Each is pinned to one provider: Cerebras.

Prices are the pinned endpoint's prices per million tokens, including the 5% routing fee — the prices you pay. Models and GET /v1/models show the same numbers.

Each Overdrive model in GET /v1/models carries an overdrive object, and its display_name ends in · Overdrive:

"overdrive": {
  "provider": "Cerebras",
  "fallback": false,
  "observed": {
    "statistic": "median",
    "window": "30m",
    "output_tokens_per_second": 957,
    "time_to_first_token_ms": 186,
    "observed_on": "2026-10-19"
  }
}

observed is the pinned endpoint's speed observed across all traffic, 30-minute window: the median output speed and median time to first token over the 30 minutes before the row synced, with the day it was read. It covers every caller's requests to that endpoint, so it moves with their prompt lengths and load. It is an observation, not a floor, and null when no fresh observation synced.

A model's capabilities and limits follow its pinned endpoint, which can differ from the same model's other providers: qwen/qwen3.8-27b:overdrive has a 65,536-token context where the base listing has 1,000,000. Check supported_parameters on GET /v1/models/{id} before you rely on tools, structured outputs or reasoning. A request that sends a parameter the pinned endpoint does not list fails instead of running without it, with 404 upstream_404 ("The model provider rejected the request"), and nothing is charged.

Endpoints

Overdrive answers Chat Completions, Messages and Responses, streamed (stream: true) or not. Any other endpoint — legacy Completions, Embeddings, Images — returns 400 unsupported_endpoint.

Pricing and holds

An Overdrive call costs the pinned endpoint's price plus a 5% routing fee. Deference adds no markup. That total can be higher or lower than the same model's usual route, which is priced by whichever provider serves the call.

The hold works as on every request — an estimated cost is reserved, then the measured cost is charged — but because the route cannot fall back to a pricier provider, the estimate uses the pinned endpoint's own prices. See Pricing.

Overdrive needs credit. Free credit never pays for it, so an account with only free credit left gets 402 free_credit_not_eligible:

This account has only free credit, which pays for open-weight text models up to $2 per 1M output tokens and $0.05 per request (set max_tokens to lower the estimate), without server tools, plugins, files, image or video URLs, or provider routing, and never for Incognito or Overdrive models. Add credit in the dashboard to use this model.

Over MCP the same refusal returns insufficient_credit.

What an Overdrive request refuses

Fields that would leave the pinned route, keep state, or add work its price does not cover are refused before the request runs. Nothing is held or charged.

A base model id that has no Overdrive row also returns 404 model_not_found. A missing or stale pinned route fails the request rather than serve it elsewhere: a 429 upstream_429 means the provider is rate-limited, not that the request took another route.

Function tools you define yourself still work where the model's endpoint supports them: the model proposes the call and your code runs it, in your own environment.

The MCP server accepts Overdrive ids on deference_run_model and refuses its web_search option on them with invalid_input. Its receipt keeps the :overdrive id and carries the same overdrive object GET /v1/models shows. See MCP tools.

What Deference stores

Deference keeps the billing record — key, model, provider, tokens, cost and times — so the charge can be reconciled and shown in Activity. Prompt and response text are never stored; the request's Content reads Not stored, as on every text call.

Otherwise an Overdrive request is an ordinary route: the client and session are recorded, and caller identifiers such as user and metadata go upstream unchanged. Overdrive strips nothing, and none of Incognito's protections apply — no zero-data-retention policy and no confidential hardware. For that route, see Incognito.

Check what served a call

Open the request in Activity. Provider reads Cerebras, the provider the routing layer reported for that call.

A streamed call records the time to its first token. When it succeeds with at least 128 output tokens, Activity also shows its output speed in tokens per second: the output tokens after the first, over the time from the first output token to the last, as Deference received them. A non-streamed call shows neither.

What Overdrive does not do

Overdrive pins a supported model to one provider, at that endpoint's price, with no fallback to a slower route. Within that boundary, read the limits plainly:

• No speed is promised. The observed block in GET /v1/models and a call's own timing in Activity both vary with the prompt, the load and the provider.
• The price is the pinned endpoint's rate plus the 5% fee: it can be higher or lower than the usual route's.
• Availability is the pinned provider's. When it cannot serve — rate-limited, down or delisted — the request fails rather than fall back. Retry, or send the base id for the usual route.
• Free credit never pays for an Overdrive call.
• Ordinary handling applies: identifiers pass through, the client and session are recorded, and none of Incognito's protections carry over.