How to Use Ox Alpha on OpenRouter

Ox Alpha is available through OpenRouter with the model ID stealth/ox-alpha. You can test it in the browser before writing code, then use OpenRouter’s OpenAI-compatible API for a repeatable evaluation. The current API price is zero, but the model is a stealth preview: availability, price, and provider behavior can change.

Before sending a prompt, read the data warning. The OpenRouter Stealth provider page says the anonymous provider retains prompts and completions and does not use them for training. That is not the same as zero retention. Use public, synthetic, or approved test material; do not paste credentials, unreleased source code, customer data, or other secrets into a model whose operator is not named.

Choose the simplest access path

Start with chat if your question is simply “can the model understand this task?” Move to code when you need a comparison that another developer can repeat.

1. Try Ox Alpha in OpenRouter chat

1. Open the Ox Alpha chat route.
2. Sign in to OpenRouter if requested.
3. Confirm that Ox Alpha or stealth/ox-alpha is the selected model. Do not assume a fallback model is equivalent.
4. Use a small, non-sensitive task first. Ask the model to explain the intended changes before producing code.
5. Save the prompt, answer, date, and any visible reasoning or model settings. If the request fails, record the status instead of silently trying until one output looks good.

A good first test is a self-contained bug with an expected answer and a hidden edge case. Avoid an open-ended “build my whole application” prompt. A small task makes instruction following, correctness, and hallucination easier to inspect.

2. Create and store an OpenRouter API key

Open OpenRouter API keys, create a key for this evaluation, and store it in an environment variable. Do not paste the key into source code, screenshots, commit history, or a system prompt.

export OPENROUTER_API_KEY="your-key-here"

The variable lasts for the current shell session. For a deployed application, use the secret manager provided by the hosting platform. Keep the key server-side; browser JavaScript would expose it to visitors.

An API key is still required for direct requests even when the model’s token price is $0. Authentication, model billing, and model price are separate concerns.

3. Send the minimum curl request

OpenRouter exposes an OpenAI-compatible chat-completions endpoint. This request sends one user message and asks for a compact response:

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 function specification. List three edge cases before proposing code."
      }
    ],
    "temperature": 0
  }'

The endpoint and authentication pattern follow the OpenRouter quickstart. temperature: 0 reduces sampling variation for an evaluation, although a provider may not guarantee identical output across runs. Add optional HTTP-Referer and X-Title headers only if you want OpenRouter to attribute requests to an application; they are not required for the call.

Check the HTTP status and the returned model field. Treat a missing model, authentication failure, malformed response, or empty choice as a failed test. Do not replace an error with a fabricated success object.

4. Call Ox Alpha from Python

Install the official OpenAI Python client, which can target OpenRouter by changing the base URL:

python -m pip install openai

import os

from openai import OpenAI

client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key=os.environ["OPENROUTER_API_KEY"],
)

response = client.chat.completions.create(
    model="stealth/ox-alpha",
    temperature=0,
    messages=[
        {
            "role": "system",
            "content": "State assumptions, keep scope narrow, and verify before claiming success.",
        },
        {
            "role": "user",
            "content": "Find the bug in this self-contained example and propose the smallest fix.",
        },
    ],
)

print(response.choices[0].message.content)

Reading os.environ["OPENROUTER_API_KEY"] fails immediately if the secret is absent, which is preferable to sending an invalid request and hiding the configuration error. For an evaluation runner, also store the response model, finish reason, usage fields, elapsed time, and the exception or HTTP status when a call fails.

5. Use a coding system prompt

The best prompt depends on the harness, but a coding evaluation benefits from explicit scope and verification rules. Start with a short template rather than a large persona:

You are working on one bounded coding task.

Before editing:
1. Restate the requested outcome in one sentence.
2. Identify the files and tests that establish current behavior.
3. Flag missing information instead of inventing it.

While editing:
- Make the smallest change that satisfies the request.
- Preserve unrelated behavior and existing conventions.
- Do not add abstractions, flags, or dependencies without a current need.

Before finishing:
- Run the relevant tests and build.
- Report the commands, results, and any unverified interaction.

This prompt tests planning, scope control, and evidence. It does not grant broad permissions. Your agent framework should separately restrict filesystem, network, shell, and secret access.

6. Use an agent-task system prompt

Long-running agents need a clear terminal condition and failure behavior:

Complete the stated task using the available tools.

- Keep an explicit checklist and update it as evidence changes.
- Inspect before modifying; never assume a file, API, or command exists.
- When a tool fails, read the error and investigate the root cause.
- Retry only temporary network or rate-limit failures, with a strict limit.
- Never treat a partial write, empty response, or skipped test as success.
- Stop when the requested outcome is verified or when a specific blocker
  requires user authority. Report the blocker with the evidence collected.

Do not ask the model to reveal hidden chain-of-thought. Ask for concise plans, assumptions, tool summaries, and verifiable outputs. Those artifacts are easier to audit and compare.

7. Run a fair evaluation

Create a frozen test set from work your team understands. Include a small bug, a multi-file change, a large-context navigation task, a tool failure, and a case where the correct response is to request clarification. Remove secrets and private identifiers. Use the same prompt, repository commit, tools, permissions, timeout, and retry count for every model.

Score accepted task completion, test pass rate, regressions, review minutes, latency, number of turns, and any unsupported claim. Keep raw outputs. A single impressive run is not a reliability measure. The public benchmark page shows why task count and harness disclosure change how a score should be read.

Production caveats

• Price can change. Check Ox Alpha pricing and availability immediately before a large batch.
• The model can disappear. Handle an unavailable model as a visible operational failure and keep an approved fallback outside the test.
• Capacity is not guaranteed. Limit retries to temporary rate-limit or server errors, use backoff, and surface final failure.
• The provider is anonymous. Do not use sensitive inputs without a completed risk decision.
• Long context is not free quality. Curate the relevant files and test retrieval rather than dumping a repository blindly.
• Tool calls need controls. Restrict permissions, inspect arguments, isolate the environment, and require tests before accepting writes.
• Preview behavior can drift. Record the model ID, date, settings, and provider path with every result.

For a first controlled run, use the curl example, one known task, and temperature zero. If the result is useful, move to the Python runner and compare it with a named baseline. If the result is weak, preserve it; failed cases are more valuable for a decision than repeated prompts tuned until the model succeeds.

Finally, read what is confirmed about Ox Alpha and the identity/data-retention investigation before moving from public test material to real code.

Last updated: 2026-08-23