How to Use Ox Alpha for Free With OpenRouter and OpenCode

Ox Alpha is currently available for free through OpenRouter and OpenCode. You can call it directly through an OpenAI-compatible API, connect it to the OpenCode coding agent or access the zero-retention version offered through OpenCode Zen.

As of August 24, 2026, the two model identifiers are:

• OpenRouter: stealth/ox-alpha
• OpenCode Zen: x-preview-f-free
• OpenCode configuration: opencode/x-preview-f-free

Ox Alpha is still a stealth preview model. Its developer has not been publicly identified, while OpenRouter and OpenCode act as gateways between the model and the applications using it.

For its specifications, context window and known limitations, start with our complete Ox Alpha AI guide.

TL;DR

The fastest way to use Ox Alpha depends on what you want to build:

Access method	Model ID	Current cost	Data policy	Best for
OpenRouter API	stealth/ox-alpha	Free input and output tokens	Prompts and completions retained; not used for training	Direct API integrations
OpenRouter inside OpenCode	openrouter/stealth/ox-alpha	Free model usage	OpenRouter route policy applies	Coding inside a repository
OpenCode Zen	opencode/x-preview-f-free	Free for a limited time	Zero retention; no model training	Private coding workflows

The free status is part of the current preview and can change. Do not hard-code the assumption that Ox Alpha will remain free indefinitely.

What Are OpenRouter and OpenCode?

OpenRouter and OpenCode are not the developers of Ox Alpha.

OpenRouter is an AI model router. It exposes hundreds of models through a common API and sends each request to the corresponding inference provider.

OpenCode is an open-source coding agent that runs inside a terminal. It can use models supplied by OpenRouter, OpenCode Zen and other providers to inspect repositories, edit files, execute commands and test its own changes.

OpenCode Zen is the model gateway operated by the OpenCode team. It provides tested model and provider combinations designed specifically for coding-agent workloads.

This distinction matters because the gateway you choose determines:

• The API endpoint and model ID
• Rate limits and availability
• Data-retention rules
• Provider configuration
• How the model receives tools and repository context

Method 1: Use Ox Alpha Through the OpenRouter API

The direct OpenRouter API is the best option when you want to integrate Ox Alpha into an application, automation, internal tool or custom AI agent.

The official Ox Alpha listing on OpenRouter currently shows free input and output tokens.

Step 1: Create an OpenRouter API Key

Create or sign in to an OpenRouter account, generate an API key and store it as an environment variable.

On macOS or Linux:

export OPENROUTER_API_KEY="your-api-key"

On Windows PowerShell:

$env:OPENROUTER_API_KEY="your-api-key"

Do not insert API keys directly into source files or commit them to Git.

Step 2: Send Your First Ox Alpha API Request

OpenRouter provides an OpenAI-compatible chat completions endpoint:

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": "system",
        "content": "You are a senior software engineer. Inspect the supplied requirements, identify risks and return an implementation plan."
      },
      {
        "role": "user",
        "content": "Design a migration plan from a monolithic REST API to an event-driven architecture. Include rollback steps and test requirements."
      }
    ]
  }'

The generated answer is returned in:

choices[0].message.content

Step 3: Call Ox Alpha With Python

The same endpoint can be called with Python without installing a model-specific SDK:

import os
import requests

response = requests.post(
    "https://openrouter.ai/api/v1/chat/completions",
    headers={
        "Authorization": f"Bearer {os.environ['OPENROUTER_API_KEY']}",
        "Content-Type": "application/json",
    },
    json={
        "model": "stealth/ox-alpha",
        "messages": [
            {
                "role": "system",
                "content": (
                    "You are a senior code reviewer. Find correctness, "
                    "security and maintainability problems."
                ),
            },
            {
                "role": "user",
                "content": (
                    "Review the following authentication flow. "
                    "Return the findings ordered by severity."
                ),
            },
        ],
    },
    timeout=300,
)

response.raise_for_status()
result = response.json()

print(result["choices"][0]["message"]["content"])

For production use, add request retries, timeout handling, response validation and logging that does not expose prompts or credentials.

Ox Alpha API Capabilities

The OpenRouter version of Ox Alpha currently exposes:

• A 1,048,576-token context window
• Up to 131,072 completion tokens
• Text, image and video input
• Text output
• Tool calling through tools and tool_choice
• JSON output through response_format

Ox Alpha supports JSON responses, but OpenRouter states that JSON-schema enforcement is not currently available. Your application should therefore validate all structured output before using it.

A large context window also does not mean every request should contain an entire repository. Long inputs increase latency and make it harder for the model to identify the files that actually control a behavior. Repository maps, dependency summaries and targeted file selection remain useful.

Method 2: Use Ox Alpha in OpenCode Through OpenRouter

This configuration combines OpenCode’s terminal agent with the Ox Alpha model supplied through OpenRouter.

The official OpenCode provider documentation supports connecting OpenRouter directly.

Step 1: Install OpenCode

On macOS, Linux or WSL:

curl -fsSL https://opencode.ai/install | bash

Alternatively, install it with npm:

npm install -g opencode-ai

Navigate to your repository and start OpenCode:

cd /path/to/your/project
opencode

Step 2: Connect OpenRouter

Inside the OpenCode terminal interface, run:

/connect

Select OpenRouter and paste your OpenRouter API key.

Then open the model selector:

/models

Search for Ox Alpha or the model ID:

stealth/ox-alpha

Step 3: Add Ox Alpha Manually If It Is Missing

If the model does not appear in the selector, add it to the project’s opencode.json file:

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "openrouter": {
      "models": {
        "stealth/ox-alpha": {
          "name": "Ox Alpha"
        }
      }
    }
  },
  "model": "openrouter/stealth/ox-alpha"
}

Restart OpenCode and run /models again.

Step 4: Initialize the Repository

Inside OpenCode, run:

/init

OpenCode will inspect the project and generate an AGENTS.md file containing repository instructions and conventions.

Review that file before starting an autonomous coding task. The model will use it to understand how the project is structured, how tests are executed and which development rules it must follow.

Step 5: Give Ox Alpha a Verifiable Task

Avoid vague prompts such as:

Improve this project.

Use a task with a defined scope, constraints and verification procedure:

Inspect the authentication middleware and identify why expired refresh
tokens are accepted.

Before editing files:

1. Trace the complete refresh-token flow.
2. Identify the root cause.
3. Propose the smallest safe change.
4. List the tests that must pass.

After I approve the plan, implement the change and run the relevant tests.
Do not change public API response formats.

This structure forces the agent to inspect the repository before it starts modifying files.

Method 3: Use Ox Alpha Free Through OpenCode Zen

OpenCode Zen currently lists the model as Ox Alpha Free.

Its OpenCode model reference is:

opencode/x-preview-f-free

According to the current OpenCode Zen documentation, input tokens, output tokens and cached reads are free during the preview. The offer is explicitly described as available for a limited time.

Step 1: Connect OpenCode Zen

Start OpenCode and run:

/connect

Select OpenCode Zen.

The current setup process asks you to sign in, add billing details and create an API key. Adding billing information does not change Ox Alpha’s current zero-dollar token price, but it is part of the Zen account setup.

Paste the generated key into OpenCode.

Step 2: Select Ox Alpha Free

Run:

/models

Select:

Ox Alpha Free

The underlying Zen model ID is:

x-preview-f-free

Step 3: Pin Ox Alpha in the Project Configuration

To make Ox Alpha the default model for a repository, add this to opencode.json:

{
  "$schema": "https://opencode.ai/config.json",
  "model": "opencode/x-preview-f-free"
}

This prevents a new OpenCode session from silently starting with another model.

OpenRouter or OpenCode Zen: Which Route Should You Choose?

Use OpenRouter when:

• You need direct API access
• You are building a custom agent or application
• You already have an OpenRouter integration
• You want to use the same API for several models
• You need to switch models without rewriting the integration

Use OpenRouter inside OpenCode when:

• You want Ox Alpha to inspect and modify a repository
• You need terminal commands, file editing and test execution
• You want control over the gateway while using OpenCode as the agent harness

Use OpenCode Zen when:

• You want the shortest OpenCode setup
• Zero-retention processing is important
• You want the provider configuration tested by the OpenCode team
• You do not need to manage a separate OpenRouter connection

If you are deciding whether Ox Alpha is capable enough to replace a paid coding model, read our Ox Alpha, GPT-5.6 and Claude 5 comparison.

OpenRouter and OpenCode Have Different Data Policies

The model may be called Ox Alpha on both platforms, but the published data policies are different.

Ox Alpha Through OpenRouter

OpenRouter states that the anonymous inference provider retains prompts and completions. The data is not used for model training, but it is retained.

Ox Alpha Through OpenCode Zen

OpenCode states that the Ox Alpha Free provider follows a zero-retention policy and does not use submitted data for model training. OpenCode also states that Zen models are hosted in the United States.

Therefore, the OpenCode Zen route is the stronger option when retention is the deciding factor. The OpenRouter route offers more flexible API integration but does not provide the same zero-retention commitment for this model.

How to Test Ox Alpha Correctly

A single successful prompt does not establish whether a model is reliable enough for production.

Test it on tasks with objective outcomes:

1. Give the model a failing test and measure whether it finds the root cause.
2. Ask it to implement a feature without changing unrelated files.
3. Run the same task in a clean repository state.
4. Track test success, files changed, tool errors and human corrections.
5. Repeat each task through the same gateway and agent configuration.
6. Review the final diff rather than judging only the explanation.

Do not compare an OpenRouter API response with an OpenCode agent run as if they were identical experiments. OpenCode adds repository discovery, prompts, tools, permissions and execution loops that can materially affect the outcome.

Our Ox Alpha benchmark analysis explains what the existing results show, what they do not prove and how to design a more credible evaluation.

Common Ox Alpha Setup Problems

401 Unauthorized

The API key is missing, invalid or was created for a different provider.

For OpenRouter, verify:

echo $OPENROUTER_API_KEY

Do not display the complete key in shared terminals, screenshots or logs.

In OpenCode, verify that the provider appears in:

opencode auth list

404 Model Not Found

Check the model ID.

For OpenRouter:

stealth/ox-alpha

For OpenCode Zen:

x-preview-f-free

For the OpenCode configuration:

opencode/x-preview-f-free

These IDs are not interchangeable.

Ox Alpha Does Not Appear in /models

Restart OpenCode so it can refresh provider packages and model metadata. If the OpenRouter version remains absent, add it manually to opencode.json.

The model may also disappear when the free preview ends or if a gateway temporarily removes the listing.

429 Too Many Requests

Free access does not guarantee unrestricted capacity. Preview models can have route-specific rate limits, especially during demand spikes.

Use exponential backoff, avoid parallel request bursts and design your application to handle temporary unavailability.

Tool Calls Repeat Without Completing the Task

A model can request a tool, but the surrounding agent must execute that tool and return the result correctly. Confirm that:

• The tool name matches the declared schema
• Required arguments are present
• Tool results are returned to the same conversation
• The agent has permission to edit files or execute commands
• A maximum iteration limit is configured

Tool support in the model is not a replacement for a correctly implemented agent loop.

Frequently Asked Questions

Is Ox Alpha really free?

Yes. OpenRouter and OpenCode Zen currently list Ox Alpha input and output tokens at zero cost. OpenCode describes its offer as limited-time access, and neither route guarantees permanent free pricing.

What is the Ox Alpha OpenRouter model ID?

The OpenRouter model ID is:

stealth/ox-alpha

What is the Ox Alpha OpenCode model ID?

The OpenCode Zen model ID is:

x-preview-f-free

In opencode.json, use:

opencode/x-preview-f-free

Do I need OpenCode to use Ox Alpha?

No. Ox Alpha can be called directly through the OpenRouter chat completions API. OpenCode is useful when you want the model to work as a terminal-based coding agent.

Do I need an API key?

Yes. Both OpenRouter and OpenCode Zen require an API key even while the model’s token price is zero.

Does OpenRouter own Ox Alpha?

No. OpenRouter states that Ox Alpha is developed and operated by an anonymous third party. OpenRouter routes requests to the model.

Can Ox Alpha be used for production applications?

Technically, yes, but it remains a stealth preview model. Production systems should include request timeouts, retries, output validation, monitoring and a fallback model.

Which route is better for private source code?

Based on the currently published policies, OpenCode Zen provides the clearer privacy position because its Ox Alpha route is described as zero retention and no training. OpenRouter states that prompts and completions are retained by the provider, although they are not used for training.

Start With One Real Repository

Install OpenCode, connect one of the two gateways and give Ox Alpha a task that can be verified through tests and a code diff.

Do not ask whether the model feels intelligent. Measure whether it can close an issue, fix a defect, complete a migration and survive its own test suite.

That is the point where Ox Alpha stops being another AI announcement and starts replacing engineering work.