Ox Alpha on OpenRouter: Model ID, Pricing & API

Quick answer: Ox Alpha is live on OpenRouter as model ID stealth/ox-alpha — a multimodal reasoning model (text + image + video in, text out) with a 1,048,576-token context window and a 131,072-token max output, currently priced at $0 per 1M prompt tokens and $0 per 1M completion tokens during its free preview. You call it through the standard OpenAI-compatible endpoint https://openrouter.ai/api/v1/chat/completions with a Bearer token, and because reasoning is mandatory, the sensible default is reasoning_effort: "max".

If you've landed on the OpenRouter model page recently, you've probably hit the same wall I did: the listing is genuinely impressive (free, 1M context, 131K output) but light on the practical stuff — what exactly to send in a request, which parameters are honored, and what it actually means that the provider is an anonymous "Stealth" outfit with no published benchmarks. That gap is what this guide closes.

This article is based on the OpenRouter model listing, the public OpenRouter models API, and official announcement data, updated August 22, 2026. We describe the model as the listing presents it; we have not run independent benchmarks on Ox Alpha ourselves.

Model Card: stealth/ox-alpha at a Glance

OpenRouter's own positioning: Ox Alpha is "a reasoning model designed for coding, sustained agentic work, and production workloads," suited for "long-horizon software engineering, complex reasoning, and workflows that combine text with visual context." The API-level usage signals back that up — within about two days of release, the model had consumed roughly 657B prompt tokens and 7.95B completion tokens, with the five busiest apps all being agentic coding tools: Hermes Agent (~120B tokens), Claude Code (~108B), Oh-My-Pi (~93.5B), DeepSeek Harness (multimodal-bridge) (~84.8B), and ZCode (~51.5B).

Calling Ox Alpha with curl

OpenRouter exposes an OpenAI-compatible chat completions endpoint, so a plain curl works:

curl https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "stealth/ox-alpha",
    "messages": [
      {"role": "user", "content": "Review this Rust codebase and propose a refactor plan for the error-handling layer."}
    ],
    "reasoning_effort": "max"
  }'

Three things worth noting:

1. The model ID is stealth/ox-alpha — the provider namespace is stealth, not a company name, because the provider is anonymous.
2. Reasoning cannot be turned off (the API reports reasoning.mandatory: true), so pick an effort level explicitly instead of leaving it implicit — max is the default and the right starting point for hard agentic tasks.
3. You only need $OPENROUTER_API_KEY — no per-provider credential, since OpenRouter fronts the single "Stealth" provider for you.

Calling Ox Alpha with Python

The openai SDK pointed at OpenRouter's base URL works, but a plain requests call is the most transparent for a tutorial:

import requests

resp = requests.post(
    "https://openrouter.ai/api/v1/chat/completions",
    headers={
        "Authorization": "Bearer $OPENROUTER_API_KEY",
        "Content-Type": "application/json",
    },
    json={
        "model": "stealth/ox-alpha",
        "messages": [
            {
                "role": "user",
                "content": "Trace this flaky test to its root cause and suggest a fix.",
            }
        ],
        "reasoning_effort": "max",
        "max_tokens": 131072,
    },
)
resp.raise_for_status()
print(resp.json()["choices"][0]["message"]["content"])

Note the max_tokens cap: the API reports a 131,072-token output ceiling (max_completion_tokens), so the value above is the true upper bound. In practice you rarely need that much; setting it high simply removes the risk of truncating long agentic outputs.

Parameters That Actually Work on Ox Alpha

The OpenRouter models API lists the following supported parameters for stealth/ox-alpha:

• reasoning_effort — max (default), high, or low. There's no "off" switch; reasoning is mandatory. Use low for cheap lookups, high/max for multi-file engineering work.
• max_tokens — output cap, up to the 131,072 ceiling.
• tools / tool_choice — full function/tool calling support, which is what makes the model usable inside agent loops (Claude Code, Oh-My-Pi, and the other top consumers are all driving it this way).
• response_format — structured/JSON outputs are supported.
• reasoning / include_reasoning — control how reasoning is handled in the request and whether it appears in the response.
• temperature — defaults to 1; lower it if you want more deterministic completions.
• top_p — defaults to 0.95; top_k is also available.

That's a production-shaped parameter surface — notably, this isn't a chat-only demo model. The combination of mandatory reasoning, tool calling, structured outputs, and a 1M-token context is aimed squarely at long-running agent workloads.

Billing and Routing: What "$0" Actually Means

• Price: Ox Alpha is free on OpenRouter right now — $0 per 1M prompt tokens and $0 per 1M completion tokens. The page labels this "PRICE: Free," and it's explicitly a preview-period state; post-preview pricing has not been disclosed.
• Routing: OpenRouter routes to a single provider named "Stealth" with direct forwarding and no routing decision — there's no auto-failover, no cheapest-provider selection, nothing to tune. The provider is what it is.
• Implication: if Stealth is down or degraded, you're down or degraded. There's no second upstream to fall back to.

Data Policy: What Stealth Retains

The Stealth declaration on the model page is worth reading in full, but the operative lines are:

"Ox Alpha is a stealth model. It is developed and operated by a third-party provider who has chosen to remain anonymous during this preview."

"OpenRouter routes requests to it and is not its developer, owner, or provider."

"Prompts and completions are retained by the provider and are not used for training; all other use is governed by the Stealth Model Terms."

In plain terms: prompts and completions are retained by the provider, they are not used for training, and everything beyond that falls under the Stealth Model Terms. If your project handles sensitive data, that retention clause is the thing to get your compliance hat on for — before you wire this into a production pipeline, not after.

The Part Nobody Else Tells You: A Pre-Production Checklist for a Stealth Model

Every other writeup stops at "it's free and has 1M context." Here's the checklist I'd run before betting production agentic workloads on stealth/ox-alpha — none of this is FUD, it's just what an anonymous, benchmark-less, preview-stage model forces you to think through:

1. Is the free window a contract or a promotion? The $0/$0 price is a preview-period state, and post-preview pricing is not disclosed. Budget for the price to change — design your cost accounting so a future per-token rate is a config change, not an architecture change.
2. Single provider means no failover. OpenRouter does direct forwarding to the one "Stealth" provider with no routing decision. If Stealth's availability dips (OpenRouter's 3-day monitoring shows availability at 99.14% and uptime at 99.99%), your requests are affected — there is no second upstream. If your SLA can't tolerate that, keep a fallback model in your routing layer.
3. Can you accept the data policy? Prompts and completions are retained by the provider (not used for training, per the listing). For confidential codebases, that retention is a real consideration — check the Stealth Model Terms against your own data-handling requirements.
4. There are no official benchmarks. The Performance section of the model page has no intelligence/coding/agentic scores, and as of August 22, 2026, Artificial Analysis does not list the model. Community-reported figures — such as an ~80% result on a 10-task DeepSWE subset and a claimed 87.5% on Kingbench — are small-sample, community-reported and not independently verified; treat them as anecdotes, not evaluation. Until independent numbers exist, run your own evals on your own workloads.
5. Identity is undisclosed. Provider identity, architecture, and parameter count are all not disclosed. There is unconfirmed community speculation (based on fingerprint/tokenizer/video-encoder comparisons) that Ox Alpha may be a hidden multimodal variant of a GLM-series model — but that is pure speculation, unconfirmed, and not something to make architecture decisions on.

If you've checked those five boxes and the answers are acceptable, the model is genuinely pleasant to work with: fast enough for interactive use (OpenRouter reports ~24 tokens/s throughput and ~5.81s latency at P50), free during the preview, and built for exactly the kind of sustained agentic coding its top consumers are doing. And if you'd rather skip the API plumbing entirely, you can try Ox Alpha free on glm5.app right in your browser.

FAQ

What is the model ID for Ox Alpha on OpenRouter? stealth/ox-alpha. The provider namespace is stealth because the third-party provider is anonymous during the preview.

How much does Ox Alpha cost on OpenRouter? $0 per 1M prompt tokens and $0 per 1M completion tokens during the free preview. Post-preview pricing has not been disclosed.

Does Ox Alpha support tool calling and structured outputs? Yes. tools, tool_choice, and response_format are all in the model's supported parameters, alongside reasoning_effort, max_tokens, temperature, top_p, and top_k.

What context window and max output does Ox Alpha have? 1,048,576 tokens (1M) of context and a 131,072-token max output ceiling (max_completion_tokens).

Who is the provider of Ox Alpha? A single provider called "Stealth" — an anonymous third party that has chosen not to be identified during the preview. OpenRouter routes requests to it and is not its developer, owner, or provider.

Sources

• OpenRouter: Ox Alpha model page
• OpenRouter Models API
• Stealth Model Terms
• OpenRouter API docs

Last updated: August 22, 2026. Pricing, availability, and data-policy details above are as shown on the official pages at that date; preview-period terms (free pricing, anonymous provider, retention policy) can change, so verify against the official listing before relying on them in production. The fastest way to kick the tires is to chat with Ox Alpha in your browser — no API key or billing setup needed.