How OxAlpha works: inside a thinking-first reasoning model

Thinking-first generation: why OxAlpha reasons before answering

Most language models generate an answer token by token the moment a prompt arrives. OxAlpha does not. OxAlpha is a thinking-first model, which means OxAlpha allocates a dedicated budget of reasoning tokens before a single word of the final answer exists. During this phase, OxAlpha decomposes the problem, tests candidate approaches, checks intermediate results against the constraints in your prompt, and discards paths that fail. Only when this internal work settles does OxAlpha begin writing the visible response.

The practical effect is easy to observe. Ask OxAlpha a multi-constraint scheduling puzzle, a tricky refactoring question, or a proof-style math problem, and there is a pause before the stream starts. That pause is OxAlpha spending reasoning tokens. On hard problems the reasoning phase can be long; on trivial ones OxAlpha keeps it short. Community measurements suggest this is a large part of why OxAlpha scores around 80% on an aggregate reasoning suite where GPT-5 lands near 65% — see the OxAlpha benchmark data for the full community numbers and their caveats.

What the reasoning phase actually does

Reasoning tokens are ordinary tokens that OxAlpha generates for itself rather than for you. In that private scratch space, OxAlpha restates the task, enumerates edge cases, drafts partial solutions, and revises them. Because the scratch space is separate from the answer, OxAlpha can be wrong there, notice the error, and recover — without the false start ever appearing in your output. A single-pass model has no such second chance: its first draft is its final draft.

Why thinking-first changes the results

The benefit shows up most clearly on tasks with many interacting constraints. In long-horizon coding, OxAlpha holds an entire refactor plan in its reasoning space before touching a line, so step twelve stays consistent with step one. In structured output work, OxAlpha validates the shape of its JSON against your schema during the thinking phase, which is why malformed output from OxAlpha is rare in community testing. And in tool-calling agents, OxAlpha reasons about which tool to invoke and what arguments to pass instead of pattern-matching on the tool name. None of this requires special prompting — thinking-first is the default behavior of OxAlpha on every request.

How OxAlpha handles a 1M-token context window

OxAlpha reads up to one million tokens of input in a single request. In concrete terms, that is roughly 3,000 pages of text, an entire mid-sized codebase, or several hours of transcripts — ingested at once, with no retrieval layer required. OxAlpha can then produce up to 131K tokens of output, enough for a complete technical report or a multi-file code change in one response.

A big window only matters if the model actually uses it, and this is where OxAlpha stands out in community testing. Long-context models often suffer from “lost in the middle” degradation, where facts buried deep in the input get ignored. Testers report that OxAlpha retrieves details from deep positions in the window with unusual consistency, and that the thinking phase helps: OxAlpha can spend reasoning tokens locating and cross-referencing the relevant passages before composing its answer.

What a 1M-token window unlocks

• Whole-repository work. Paste an entire project and OxAlpha reasons across every file at once, tracing calls between modules no retrieval system would pair together.
• Long-document analysis. OxAlpha compares contracts, papers, or logs end to end instead of summarizing fragments in isolation.
• Long-horizon sessions. A conversation with OxAlpha can run for hundreds of turns before the window fills, so context from hour one still shapes the answer in hour three.

OxAlpha also accepts multimodal input — text, images, and video — inside the same window. The full breakdown of what OxAlpha can do with these inputs lives on the OxAlpha capabilities page.

There is no special trick to filling the window. Both access routes described below accept the same long inputs, and OxAlpha treats a pasted document, an uploaded image, and an earlier turn of conversation as equal citizens of the same context. The only practical limit is upload size in whatever client you use; the model itself keeps reading until the million-token ceiling.

How to access OxAlpha: free chat and the OpenRouter API

Option 1: the free OxAlpha chat

The fastest path is the free OxAlpha chat on this site. There is no sign-up, no waitlist, and no cost: open the page, type a prompt, and OxAlpha responds. The chat streams the answer as OxAlpha generates it, so you see the thinking pause followed by the response in real time.

Option 2: the OpenRouter API

For programmatic use, OxAlpha is listed on OpenRouter under the model id stealth/ox-alpha, free of charge. The endpoint is OpenAI-compatible, so existing client libraries work unchanged — point them at OpenRouter and set the model id:

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": "Why is the sky dark at night?"}
    ],
    "reasoning": {"effort": "high"},
    "stream": true
  }'

The reasoning parameter and reasoning_details

Two API fields matter most when you call OxAlpha. The reasoning parameter controls how much thinking OxAlpha performs: request a higher effort and OxAlpha spends more reasoning tokens before answering, which raises accuracy on hard problems at the price of latency. Dial it down and OxAlpha answers faster with a lighter thinking pass. In the response, the reasoning_details field returns a trace of the thinking phase alongside the final message, so you can inspect how OxAlpha reached its conclusion, log the trace for debugging, or display it in your own interface. Because OxAlpha streams, the reasoning arrives first, followed by the answer tokens.

A practical rule of thumb from OxAlpha users: use high effort for architecture reviews, debugging sessions, and math-heavy work; use low effort for reformatting, extraction, and other tasks where OxAlpha barely needs to think. Because OxAlpha is free at every effort level, the only budget you are managing is time, which makes experimentation cheap — run the same prompt at two effort settings and compare what changes in the reasoning trace.

OxAlpha in three steps: prompt, reason, stream

However you connect, every OxAlpha request follows the same three-step loop:

• Step 1 — you send a prompt. Your message, plus any files, images, or prior turns, enters the OxAlpha context window — up to a million tokens of it. Nothing is truncated or summarized on the way in.
• Step 2 — OxAlpha reasons. OxAlpha generates its private chain of reasoning tokens: decomposing the task, exploring approaches, and verifying intermediate steps. The effort level you chose sets the budget for this phase.
• Step 3 — the answer streams back. Once the thinking settles, OxAlpha writes the final response and streams it token by token, with reasoning_details available if you asked for the trace.

This loop is identical whether OxAlpha writes prose, emits strict JSON for structured-output pipelines, or drives tool calls in an agent. It is also why comparisons with single-pass models can look lopsided on reasoning-heavy tasks — the OxAlpha vs GPT-5 comparison walks through concrete examples.

One more detail worth knowing: because the phases are separate, interruptions are clean. If you stop a streaming OxAlpha response midway, the reasoning that produced it is already complete — you lose the tail of the answer, not the logic behind it. Retrying the same prompt tends to give a consistent result, since OxAlpha re-derives the plan rather than improvising a new one each time.

Limitations: what OxAlpha does not tell you

An honest explainer must include the caveats, and OxAlpha carries real ones. First, OxAlpha is a stealth model: nobody outside its makers knows which lab trained OxAlpha, what data it saw, or why it is free. Treat prompts you send to OxAlpha accordingly, and avoid sharing secrets or regulated data with any model of unknown provenance. Second, OxAlpha offers no service-level agreement. A stealth model can be renamed, rate-limited, or withdrawn without notice, so production systems should keep a fallback model configured.

Third, the thinking-first design costs latency: for a one-line factual question, OxAlpha can feel slower than a lightweight model because the reasoning pass runs regardless. Fourth, all published OxAlpha numbers are community-run and directional, not official scores — the ~80% aggregate reasoning figure comes from independent testers, not from a lab report. Finally, like every language model, OxAlpha can still be confidently wrong; the reasoning trace makes errors easier to spot, but it does not make them impossible. This site is an independent community resource, unaffiliated with any AI lab or with OpenRouter — more on that on the about page.

How OxAlpha works: FAQ

Does OxAlpha show its reasoning?

Yes, on request. Through the API, the reasoning_details field returns the thinking trace that OxAlpha produced before the answer. The free chat shows a thinking indicator while OxAlpha reasons and then streams the final response.

Do reasoning tokens count against the OxAlpha output limit?

Reasoning tokens are generated tokens, so heavy thinking consumes part of the generation budget. In practice the 131K output ceiling leaves ample room: OxAlpha typically spends a few thousand tokens thinking, even on hard problems.

Can I turn the thinking phase off?

You can shrink it. Setting a low reasoning effort makes OxAlpha answer with a minimal thinking pass, which cuts latency. You cannot fully disable it — thinking-first behavior is core to how OxAlpha was built, and it is the main reason OxAlpha tops community reasoning charts.

Is OxAlpha really free to use?

Yes. OxAlpha costs $0 both in the free chat here and via OpenRouter as stealth/ox-alpha. No card, no trial clock. Why an unattributed model this capable is free remains unknown — the leading theory is a stealth capability test by a major lab.

How does OxAlpha stay accurate across a million tokens?

Two mechanisms work together: the architecture behind OxAlpha preserves attention across deep positions, and the reasoning phase lets OxAlpha explicitly search the context for relevant passages before answering. Community long-context tests show strong recall even near the middle of the window.

Does the three-step loop work for tool calling too?

Yes. When OxAlpha decides to call a tool, the decision comes out of the same reasoning phase: OxAlpha thinks, emits a structured tool call, reads the result back into context, and reasons again. That loop repeats until OxAlpha has what it needs to answer.

How does OxAlpha compare with other thinking models?

Several frontier models now reason before answering, so the mechanism itself is not unique to OxAlpha. What separates OxAlpha in community testing is the combination: a 1M-token window, strong deep-context recall, an exposed reasoning trace, and a price of zero. On the aggregate reasoning suite, OxAlpha at ~80% leads Fable 5 at ~62% and Grok 4 at ~58%, and the benchmark page linked above covers each matchup in detail.

Where can I learn more about OxAlpha?

Start with the capability overview and benchmark pages linked above, then read the general OxAlpha FAQ for questions about origin, privacy, and pricing. Everything here is community-documented: when OxAlpha changes, these pages are updated to match observed behavior rather than official announcements, because official announcements do not exist.