OpenRouter, an AI model marketplace and routing platform, began offering a new model called “Ox Alpha” for free on August 20. The listing gives developers a million-token context window—enough capacity to work with very large codebases or document collections—without disclosing who built or operates the model.

OpenCode, a separate coding platform with its own AI gateway, also lists a model under the Ox Alpha name and says access is free for a limited time. Developers can therefore reach Ox Alpha through more than one service, with different identifiers and terms attached to each route.

Early tests show why developers are interested. Ox Alpha has successfully changed real software projects, found specific information inside extremely large prompts and interpreted images and video frames. It has also missed many standalone coding problems and sometimes failed to use the tools required to finish a task. The results make it promising enough to investigate without showing that businesses can depend on it.

No company has publicly identified itself as Ox Alpha’s developer or operator. That missing identity becomes a concrete business risk when developers move beyond public experiments and begin submitting proprietary code, internal documents or other valuable information. Without a named provider, businesses cannot perform normal supplier checks or establish who is ultimately accountable for handling that material.

The published data disclosures add another layer of uncertainty. OpenRouter’s Ox Alpha page says the anonymous provider retains prompts and completions but does not use them for training. OpenRouter’s general Stealth Program agreement says user content may be collected, shared with the provider and used for training and improvement. OpenCode separately says its Ox Alpha route uses zero retention and does not use customer data for training.

Those statements do not describe one consistent data policy. Businesses cannot tell from the Ox Alpha name alone which terms apply, assume that OpenCode’s assurances extend to other routes or determine which of OpenRouter’s conflicting statements governs its service.

For businesses, the immediate decision is whether Ox Alpha can be evaluated on low-risk work without treating an anonymous, temporary service as an approved supplier or production dependency.

The model’s significance depends first on whether Ox Alpha can do enough valuable work to justify the attention and trust it is requesting.

OpenRouter lists Ox Alpha under the identifier stealth/ox-alpha and describes it as designed for coding, complex reasoning and software work that continues across many steps. The platform also makes clear that it only routes requests: an anonymous third party develops and operates the model.

Developers interact with OpenRouter, but the unnamed provider remains responsible for operating the underlying model. Businesses therefore cannot treat OpenRouter’s identity as a substitute for knowing which company is behind Ox Alpha and handling their requests.

The OpenRouter listing gives Ox Alpha a context window of 1,048,576 tokens and allows responses of up to 131,072 tokens. A context window measures how much information a model can consider during a task, so the million-token limit could accommodate a large software repository, an extensive document collection or a long history of agent activity.

Ox Alpha also accepts images and video alongside text, allowing developers to include screenshots, diagrams or video frames in a task. It returns text, supports external tools and can produce JSON-formatted data for software applications, although it cannot guarantee that the output follows a precise JSON schema.

OpenRouter currently charges nothing for either the prompts sent to Ox Alpha or the model’s responses. OpenCode offers Ox Alpha through its separate Zen and Go services and says access is free for a limited time.

Removing the token cost changes the kinds of experiments developers can afford to run. Long software tasks may resend much of a repository every time the agent takes another step, while large-document tests can consume hundreds of thousands of tokens in a single request. A zero price allows developers to explore those demanding workloads without watching the bill grow alongside the context.

OpenCode’s dashboard currently attributes approximately 26 trillion tokens, more than 300,000 users and over 8 million completed sessions to Ox Alpha, ranking it second among models by recent OpenCode usage. However, its displayed reporting period begins June 30—before OpenRouter’s August 20 release date—and OpenCode does not explain the discrepancy. The figures therefore show substantial platform-reported use without establishing how much occurred after the public launch.

OpenRouter also reports trillions of tokens of Ox Alpha use, but its programming page displays two different totals. One ranking shows 7.51 trillion tokens, while the model detail on the same page shows approximately 15.8 trillion. OpenRouter does not provide an explanation for this discrepancy.

Despite those reporting problems, both platforms report substantial Ox Alpha use. Traffic cannot show whether those trillions of tokens produced valuable work, which makes independent performance testing more useful than the size of the traffic.

A public DeepSWE run provides the most extensive evidence so far of Ox Alpha doing sustained software-engineering work. DeepSWE measures whether an AI model connected to agent software can inspect an existing code repository, decide what needs to change, edit the files and continue working until the project’s tests pass. Its 113 assignments come from 91 repositories across five programming languages.

Using the exact OpenRouter model identifier, Ox Alpha completely solved 66 of the 113 assignments, producing a 58.4% resolution rate. The full run lasted 20 hours and 39 minutes, with one attempt allowed for each task.

Completing 66 assignments shows that Ox Alpha can do more than generate plausible pieces of code. It successfully found its way through existing projects, made working changes and avoided breaking the surrounding software often enough to produce a meaningful result.

Twenty-two additional assignments passed at least 90% of the tests created for the requested feature but did not reach complete resolution. Two more implemented the new feature while causing older parts of the software to fail. Ox Alpha therefore came close on a substantial share of the unfinished work, but developers would still have to diagnose and repair the remaining problems.

Eleven assignments ended after Ox Alpha repeatedly failed to use the software tools required to continue, while five exceeded the benchmark’s 90-minute task limit. Coding-agent software gives a model tools for opening files, running commands, applying changes and checking the result. When Ox Alpha stopped using those tools, it could no longer act on the project even if its underlying reasoning was headed in a useful direction.

A separate LiveCodeBench evaluation removed that agent environment and tested whether Ox Alpha could solve standalone programming problems directly from the prompt. The model could not inspect a repository, run tools or revise its answer after seeing a failed test. Under those conditions, it solved 49 of 175 problems, producing a 28% pass rate from one unrevised answer per problem.

The two results describe different ways developers might use the model. DeepSWE shows Ox Alpha working through a software project with the ability to inspect, act and iterate. LiveCodeBench shows what happens when the model must produce the correct code immediately. Ox Alpha performed better in the extended agent workflow, although the different datasets prevent the two percentages from becoming a direct comparison.

Long-context testing supports another important part of the model’s appeal. An investigation conducted through OpenCode hid three pieces of information inside prompts containing 934,221 tokens, and Ox Alpha retrieved all three. The researchers also found that the service continued accepting prompts until the input approached the advertised million-token limit.

Retrieving planted information across that much text confirms that the large context window works at a basic level. Developers still need to test whether Ox Alpha can follow relationships and reason accurately across their own large codebases or document collections, where the relevant information may be harder to find.

The OpenCode investigation also showed that Ox Alpha could interpret images and sampled video frames, supporting OpenRouter’s description of its visual inputs.

Separately, a developer documented an Ox Alpha coding session in a YouTube video. He asked the model to build a personal-finance dashboard, let it work for approximately 45 minutes and reported that the run used about 84,000 tokens. After checking the pages and features, he described the resulting application as usable. The demonstration is not a controlled benchmark, but it shows what one developer received from an extended, real-world coding request.

Altogether, the tests present Ox Alpha as a useful but inconsistent model. It completed meaningful work inside real software projects and handled extremely large prompts, while its direct coding answers and tool use were less reliable. Developers have enough evidence to justify testing it on their own work, but they should expect to review the output and verify that the model actually finished the job.

A model capable of handling real codebases and extensive documents makes the anonymous provider more consequential. Developers have therefore begun looking for technical characteristics that might reveal what sits behind the Ox Alpha name.

Investigators tried asking Ox Alpha what it was, but that approach could not reveal who built it. The OpenCode investigation found that the service had instructed the model to identify only as “ox-alpha.” Any name the model supplied was therefore a response to instructions set by the service, not independent evidence of its origin.

The researchers looked instead for technical fingerprints that could remain visible even after a provider changed the model’s public name. The strongest clue came from the way Ox Alpha counts tokens.

Before an AI model can process text, it breaks the text into smaller pieces called tokens. Different model families often split code, punctuation, spaces, emojis and multilingual text in distinctive ways. If two services report the same token-count changes across carefully chosen samples, they may be using the same tokenizer—the system that performs that division—or closely compatible technology.

One black-box study used that principle to compare OpenRouter’s Ox Alpha endpoint with Z.ai’s GLM-5.3 and Xiaomi’s MiMo-V2.5. “Black-box” means the researchers could not inspect the underlying model files; they could only send requests and compare what the services returned.

The researchers created 24 text samples containing English, Chinese, Japanese and Arabic text, along with code, JSON, unusual spacing, web addresses and emojis. Those variations were chosen because different tokenizers are more likely to divide them differently. The same samples were then sent to Ox Alpha, GLM-5.3 and MiMo-V2.5.

Ox Alpha consistently reported 75 more prompt tokens than GLM-5.3, probably because of fixed hidden instructions or formatting added by the service. Once the researchers removed that fixed difference, every change produced by the 24 samples matched GLM-5.3. MiMo-V2.5 matched only five of the 24, and the difference varied rather than staying fixed.

The pattern suggests that Ox Alpha and GLM-5.3 use the same or a highly compatible tokenizer and chat format. It is stronger evidence than similarities in writing or coding style because the result held across deliberately varied text and code samples.

The researchers also tested how the three services responded to the same API settings. They tried valid and deliberately unsupported requests, such as turning reasoning off, supplying certain output controls or sending an invalid parameter, then compared whether each service accepted the request or returned an error.

Ox Alpha and GLM-5.3 responded the same way across all eight of those tests, while MiMo-V2.5 matched only three. For example, both Ox Alpha and GLM-5.3 rejected an attempt to disable reasoning in the tested OpenRouter configuration. Some of those responses could be controlled by OpenRouter or another layer between the user and the model, so they add support to the tokenizer result without carrying the same weight.

A separate investigation of OpenCode’s Ox Alpha route expanded the tokenizer test to 44 samples designed to distinguish the GLM-5 generation from other model families. Ox Alpha matched the GLM-5-generation tokenizer on all 44. Older GLM-4 models matched 42 and split two emojis differently, giving the researchers a way to distinguish between those generations.

The OpenCode investigation also found GLM-style reasoning controls, Chinese-language validation errors and moderation responses compatible with infrastructure used by Z.ai, also known as Zhipu AI. Those additional clues pointed in the same direction as the tokenizer tests rather than relying on how Ox Alpha described itself.

Altogether, the two investigations provide strong evidence that Ox Alpha uses GLM-family technology. They cannot establish whether the service is running an original GLM model, a modified version or another system built to behave compatibly. They also cannot identify the company operating the endpoint.

Z.ai is therefore a credible theory about Ox Alpha’s technical origins, not a confirmed provider. No company—including Z.ai—has publicly claimed ownership or responsibility for the model.

Developers are probing Ox Alpha’s limits, documenting its failures and drawing attention to the mystery. In the process, they are giving whoever runs Ox Alpha real-world evidence about its performance and reliability, while the surrounding attention reveals developer demand.

Every long Ox Alpha session consumes computing resources even though the developer pays nothing for the tokens. The anonymous provider has not explained why it is willing to fund that usage, but the preview is already producing several forms of value.

Developers are testing Ox Alpha across software repositories, coding agents, large prompts and visual tasks. Their public results reveal which assignments the model can complete, where its tool use breaks down and how close the service comes to its advertised context limit.

Platform activity can provide additional information about which applications attract demand, how long sessions become and how the infrastructure responds under heavy use. Those operational and market signals remain valuable even if the provider follows the model page’s claim that prompts are not used for training.

Public testing also reaches combinations of tools, programming languages and workflows that would be expensive to reproduce inside one company. Each benchmark, failure report and hands-on demonstration adds evidence about how the model behaves outside a controlled laboratory.

Anonymity gives the provider access to that testing without immediately attaching every failure or disputed comparison to a public brand. It has also encouraged developers to investigate the model’s identity, generating more benchmarks and discussion than an ordinary unnamed preview might otherwise receive.

The available evidence does not establish that the provider deliberately designed the mystery as a marketing campaign. The mystery has nevertheless increased participation by giving developers two reasons to test Ox Alpha: discovering what it can do and trying to determine what it is.

OpenRouter has used free anonymous previews before. Quasar Alpha and Optimus Alpha were later revealed as early tests of OpenAI’s GPT-4.1. OpenRouter retired the free alpha endpoints when GPT-4.1 became generally available rather than automatically transferring their users to a paid service.

That history does not establish the plan for Ox Alpha, but it shows how a provider can use a temporary free endpoint to test a model before a named commercial release. It also shows why developers should not assume the current identifier or free pricing will continue.

Ox Alpha could disappear, receive a public identity, lead to a formal release or return under paid terms. OpenCode describes the free access as limited, leaving open the possibility that Ox Alpha will later be offered on paid terms. No source confirms that charges will follow or what the price would be.

Whatever its undisclosed motive, the provider is receiving a large public evaluation and substantial market attention. That may explain why it is willing to finance the preview, but it does not resolve what businesses agree to when they send valuable information through an anonymous service.

OpenRouter’s own website gives businesses two conflicting descriptions of what may happen to information sent to Ox Alpha.

The Ox Alpha model page says the anonymous provider retains prompts and completions but does not use them for training. OpenRouter’s broader Stealth Program agreement says the free access is offered to collect user content for training and improvement.

The general agreement goes further, allowing content to be collected, retained, processed and shared with the anonymous provider. It also grants rights for that material to be used in training, evaluation and model improvement.

OpenRouter’s supplemental-terms page currently lists no Ox Alpha-specific exception to the general agreement. The model page may be intended to override the broader terms, but OpenRouter does not say that or explain how businesses should reconcile the two statements. Until OpenRouter clarifies the contradiction, businesses cannot know whether prompts are only being stored or may also be shared and used to improve the model.

OpenCode makes a different promise to developers who access Ox Alpha through its service. It says the provider does not retain customer data or use it for model training, and that the service is hosted in the United States.

OpenCode’s promises apply to its service and should not be assumed to cover Ox Alpha access through OpenRouter, TokenRa or another platform. Data handling may therefore change depending on which service a developer uses to reach the model.

The Ox Alpha name alone does not tell a business which companies will handle its prompts or which contractual terms will apply. Companies choosing Ox Alpha must evaluate both the model and the service used to access it.

Because the provider has not disclosed its identity, businesses cannot perform normal vendor checks. They cannot examine its corporate ownership, legal jurisdiction, security controls, use of subcontractors, incident-response procedures or financial stability. They also have no named operator from which to request a data-processing agreement, service commitment or contractual remedy.

OpenRouter’s general Stealth agreement allows a model to be removed at any time, with or without notice. Even a successful technical test cannot tell a company how long Ox Alpha will remain available or whether it will keep the same name, configuration or price.

Companies can reduce these risks by limiting experiments to public code, synthetic data, disposable prototypes and other non-sensitive material. Developers should review the model’s work and record which service, model identifier, date and configuration they tested because those details may change during the preview.

Proprietary or client-confidential code, credentials, internal security information, personal data and regulated financial or health records should not be submitted to the preview model. OpenRouter’s agreement expressly prohibits several sensitive categories, while the conflicting disclosures give businesses additional reasons for caution.

Businesses should also avoid building Ox Alpha into production systems that would break if the model changed or disappeared. Strong performance during a test cannot replace the support, continuity and accountability expected from a production supplier.

Ox Alpha has shown enough capability to attract serious work, yet no company has publicly claimed responsibility for the model or explained the conflicting data terms. Businesses can still test Ox Alpha on low-risk work, but they should not give it sensitive information or build critical operations around it.

Ox Alpha exposes a growing gap in AI adoption: developers can establish that a model is useful much faster than a business can establish who is accountable for it.

Stealth previews reverse the order companies normally follow when adopting technology. A business usually identifies the supplier, reviews its security and contractual terms, and then allows employees to test the product. Ox Alpha lets developers begin with the test while the supplier remains hidden and the terms remain unsettled.

Companies should therefore treat experimentation and adoption as two separate decisions. A low-risk test can move quickly because it does not require sensitive information or a lasting commitment. Production use should wait until the provider can be identified, its data practices can be understood and the business knows what will happen if the service changes or disappears.

Businesses also need to review the specific service through which employees access a model, because the model name alone does not determine how data is handled. OpenRouter and OpenCode both offer access under the Ox Alpha name, but they make different promises about data retention and training. Approving the model without reviewing the service could leave a company uncertain about who handles its information and which terms apply.

Free stealth previews also give model providers a new way to enter the market. They can build developer interest, expose the model to real-world testing and learn which capabilities attract demand before presenting a named commercial product. The mystery may help drive that attention, but it also encourages developers to begin using the technology before their companies have decided whether the provider is trustworthy.

Anonymous model releases make AI gateways part of the business trust decision. When the model developer stays hidden, businesses depend on the gateway to explain who handles their data, which terms apply and how long the service may remain available. Conflicting disclosures leave that responsibility with the customer at the moment the customer has the least information.

Revealing Ox Alpha’s provider would not automatically solve every problem. Businesses would still need to confirm that the named product is the same version developers tested, that its performance carries over and that its commercial data terms match the service they intend to buy. An identity announcement should begin the supplier review, not replace it.

Ox Alpha is worth watching because it shows that an AI model can earn technical trust while its provider remains unknown. Businesses that keep experimentation separate from reliance can learn from that model without allowing a free preview to make the supplier decision for them.

Editor’s Note: This article was created by Alicia Shapiro, CMO of AiNews.com, with writing support, AEO/GEO/SEO optimization, image concept development, and editorial structuring support from ChatGPT, an AI assistant. All final editorial decisions, perspectives, and publishing choices were made by Alicia Shapiro.