Ox Alpha openrouter: Setup Guide & API Performance

Ox Alpha openrouter refers to using the stealth/ox-alpha reasoning model through OpenRouter’s API and Playground. The model is designed for coding, complex reasoning, sustained agentic work, and tasks that combine text with visual context. OpenRouter lists Ox Alpha as a stealth model, meaning the upstream developer and operator have not been publicly identified during the preview period.

The model was released on August 20, 2026, and the OpenRouter listing shows a 1M-token context. This makes Ox Alpha particularly relevant for large codebases, multi-step planning, repository analysis, and workflows that require extensive instructions or reference material.

OpenRouter is the access layer rather than the model’s owner or developer. Requests are forwarded to one listed provider, so users should distinguish between OpenRouter account features and the provider’s model behavior.

The most visible production signals on the listing come from coding and agent applications. Hermes Agent, Claude Code, omp, DeepSeek Harness, and pi are among the applications shown as sending traffic to the model. These signals suggest that Ox Alpha is being tested in persistent coding and automation environments, although application popularity should not be treated as a guarantee of quality for every task.

The OpenRouter page lists Ox Alpha as free at the time of the August 22, 2026 snapshot. Both weighted average input and output prices are shown as $0 per million tokens. This pricing can make the model useful for experimentation, batch prototyping, and agent workflows, but users should still review current terms and rate limits before placing important workloads.

The provider table shows one upstream provider named Stealth. Because there is only one provider listed, OpenRouter has no provider-routing choice to make for this model. The displayed provider metrics include 5.30 seconds P50 latency, 23 tokens per second P50 throughput, and 100.00% uptime for the measured period.

The performance panel also reports broader percentile averages. Latency rises substantially at higher percentiles, while end-to-end latency includes the time required for the complete request lifecycle. Tool-call reliability is another important consideration: the listing reports an average tool-call error rate of 2.27% for Stealth.

Caching is also visible in the performance data. The page reports an average cache hit rate of 81.72%, while the pricing history table shows an 85.6% cache hit rate and a 100.0% one-day token share for the listed provider. These values are operational measurements, not permanent specifications, and can change as traffic and infrastructure change.

For the current listing and measured figures, consult the Ox Alpha API pricing and provider page on OpenRouter. The page is the best reference for changing prices, latency, uptime, availability, and provider information.

Ox Alpha’s stealth status is central to understanding the model. The provider is anonymous during the preview, and OpenRouter states that it routes requests to the provider without being the model’s developer, owner, or provider.

The listing also states that prompts and completions are retained by the provider and are not used for training. That statement should be read alongside the Stealth Model Terms and any current OpenRouter account policies. Retention and training are separate questions: a request may not be used for training while still being retained for operational or contractual purposes.

Before sending private code, credentials, customer information, or regulated data, apply a clear data-handling policy. A strong default is to redact secrets, minimize context, and provide only the files or records needed for the current task.

A large context window also creates a quality risk. Sending an entire repository may be technically possible, but irrelevant files can dilute priorities and increase the chance that the model misses the most important constraints. Use a compact project map, explicit objectives, and targeted file excerpts whenever possible.

The OpenRouter integration is described as OpenAI-compatible, so many existing SDKs can work by changing the base URL or model identifier. The essential model slug is stealth/ox-alpha.

A minimal TypeScript request using the OpenRouter SDK follows the structure shown on the model page:

import { OpenRouter } from "@openrouter/sdk";

const openrouter = new OpenRouter({
  apiKey: process.env.OPENROUTER_API_KEY
});

const response = await openrouter.chat.send({
  model: "stealth/ox-alpha",
  messages: [
    {
      role: "user",
      content: "Review this function and explain its edge cases."
    }
  ]
});

console.log(response.choices[0].message.content);

For streaming, add stream: true and process server-sent chunks as they arrive. The final chunk can include usage details, including reasoning-token information when available through the SDK response structure.

The OpenRouter page also presents image and video content examples through image_url and video_url objects. Because multimodal payload formats can vary by SDK, test the exact request shape in a controlled environment before building it into an automated pipeline.

Ox Alpha is most useful when the prompt defines a durable objective rather than asking for an isolated answer. For coding, provide the repository purpose, the relevant files, constraints, test commands, and the expected output format. For agentic tasks, separate planning from execution and require the model to report what changed.

When a request fails, isolate the cause instead of changing every setting at once. First verify the API key and model slug. Next test a plain text message. Then add streaming, tools, or visual inputs separately. This sequence makes it easier to identify whether the issue is authentication, payload shape, provider availability, or client behavior.

A reliable production wrapper should record request duration, status code, model name, token usage, and tool-call failures without storing sensitive prompt content unnecessarily. Add bounded retries for temporary failures, but avoid uncontrolled repetition when a tool can create files, send messages, or modify external systems.