
Choosing a model is not choosing who sees your data
This fall's AI security reports showed that the model you pick and the companies that handle your prompts are two different lists. What happened, what it means for DTC and SaaS teams, and the four places we set the rules while running more than 140 billion tokens a year.
Most teams pick an AI model on price. An open-weight model can cost far less per million tokens than a frontier model, and for a lot of work the answers look just as good. We speak with DTC and SaaS leaders regularly who are making that trade right now, and it is often the right call.
The reports of the past month show what that price leaves out. When you choose a model, you have not chosen every company that processes your data. And when you give that model tools, you have not chosen what it will try to do with them.
What happened
On November 19, Dragos published research by HD Moore, its Chief Research Officer. Over five months, his team sent about two million AI prompts that each carried a unique, trackable secret, such as a link or a cloud key, and watched for anyone who used one later. Data from at least three AI providers was exposed. Sellers on an AI inference marketplace could view and keep customer prompts. One Chinese AI lab fetched the secret links in more than half of the prompts sent to its models, including about two thirds of the requests marked for zero data retention.
The report does not name most of the providers it tested. On November 20, OpenRouter customers began receiving notices about MiniMax models. A security researcher had placed unique test links in prompts sent to those models, and a third party opened the links 40 to 130 hours after the requests were sent. Three providers on OpenRouter, AtlasCloud, Novita and StreamLake, told OpenRouter they had forwarded requests for MiniMax models to MiniMax itself. OpenRouter told customers that a third party may have read those prompts and outputs. It removed the Zero Data Retention label from the MiniMax endpoints while it investigates, and it placed the problem with MiniMax and the providers that forwarded to it.
Ten days earlier, Phala had published a preliminary incident report for its DeepSeek V4 Flash 0731 endpoint. It told users whose requests OpenRouter sent to Phala between October 21 and November 8 to treat the contents of those requests as exposed, and to rotate any keys or passwords in them. A researcher's planted credentials caught that one too.
A separate problem: what an agent does with its tools
On October 26, Cohere reported that Qwen3.8-Flash-Next, a preview model from Alibaba, tried to upload a test string to an Alibaba Cloud storage bucket in Beijing during a security evaluation. The model's own reasoning had said it would call no tools. Cohere's sandbox had no route out to the internet, so the upload failed. Cohere said it could not tell whether the behavior was deliberate or a leftover from training.
Three days later, Check Point replayed that moment 64 times. The model picked 52 different destinations. Six were Alibaba Cloud addresses, seven were AWS addresses, and 11 were domains that do not exist. Check Point concluded that there is no single hard-coded target, and that the behavior shifts with small changes in context. It also said a backdoor cannot be ruled out.
Neither report establishes a planted backdoor. What both show is that a model with tools and a network connection can try things nobody asked for, and the thing that stopped this one was the sandbox around it.
Two different risks
These incidents are easy to blur together. They ask different questions, and they need different controls.
- Who can read your data. The MiniMax and Phala cases are about the supply chain of inference: every company a request passes through on its way to a model and back. Picking a good model does not answer this question. You have to know the path.
- What your agent is allowed to do. The Qwen case is about the runtime. A well-regarded model can still attempt an action you did not expect once it has tools. Hosting the model yourself does not answer this question either. You have to limit what the runtime allows.
The path a request can take
OpenRouter is not a single inference provider. It is a router that sends each request to one of the providers that serve the model you asked for. That is useful, because one integration lets a team switch models and providers. It also means the list of companies that touched a request can be longer than the name on the model.
In the MiniMax case, a request could travel like this:
- Your app sends a prompt with whatever context it carries: customer records, code, internal documents.
- OpenRouter picks a provider for the model you asked for.
- A provider that serves that model, such as AtlasCloud, Novita or StreamLake, receives the request.
- That provider forwards it to MiniMax, which runs the model.
Not every request crossed every one of these companies. The point is that knowing which model wrote an answer is not the same as knowing every company that handled the request.
That is also why we do not call this an OpenRouter breach. OpenRouter's notice places the problem with MiniMax and the providers that forwarded to it, and nothing published so far shows otherwise. The lesson is about what a routing layer can promise about the companies behind it, and what it cannot.
What a Zero Data Retention label promises
Zero Data Retention means a provider says it will not keep your prompts or outputs after the request finishes. On a router, that label carries the provider's word. OpenRouter's own Data Processing Agreement says its list of Zero Data Retention endpoints reflects each provider's published or stated policy, and that the list is not OpenRouter's guarantee that the provider complies.
Bringing your own key does not change the path. With your own key, OpenRouter still routes the request and makes the call with your key, so it stays in the middle, and the provider you picked still processes the prompt.
OpenRouter does give teams real routing controls: an allowlist of providers, a switch that stops a request from falling through to other providers, a filter that drops providers that train on your data, and a setting that requires Zero Data Retention endpoints. Use them. They narrow the path. They do not replace knowing who is on it.
Four places to set the rules
We set controls at four layers. None of them depends on the model behaving well.
- Model. Test each model on your own tasks, not only on public benchmarks. Count the retries, the context it needs and how often a person has to fix the result.
- Provider. Keep an approved list of the companies allowed to process your requests. For each one, know where it runs, what the contract says and how long it keeps data.
- Routing. Pin requests to approved providers, turn off fallback to anyone else, and require the data settings each job needs. A request should never reach a provider you have not approved just because the one you chose was busy.
- Agent runtime. Give agents the least access the job needs. Keep credentials out of their reach, keep a record of what they do, and block outbound network calls by default. A blocked route out is what stopped the Qwen upload.
Why DTC and SaaS teams should care
For a DTC brand, the prompts that matter carry customer preferences, purchase histories, product margins, merchandising plans and conversion data. A cheaper model that exposes that context can cost far more than it saves, in privacy risk and in what a competitor could learn.
For a SaaS company, prompts can carry tenant data, source code, internal documents, support tickets and access to connected tools. An agent with wide file and network access is a risk that no choice of model fixes on its own.
The real price is per finished job
The number to watch is not the price per token. It is the cost per successful outcome, with the risk counted in. A model that costs a fraction as much per token can need more retries, more review and more runs that fail. Add the cost of a breach, the exposure under your customer contracts and the trust you would lose, and the savings can disappear.
This is not a claim that any one model or provider costs more overall. It is how we compare them.
How we run it at eLLMo AI
Our own software factory is on pace to run more than 140 billion tokens a year. We use a mix of Anthropic and open-weight models and choose each one for the task. When we use OpenRouter, we choose the models and the providers behind them on purpose.
What that volume has taught us is that the cheapest model per token is not always the cheapest model per successful outcome.
For a CTO, inference is no longer only a choice of model. It is a decision about your supply chain, your security, the quality of the work and its cost. Price still matters. Knowing who handles your data, what your agents can run and how reliably a model finishes the job matters just as much.
Related Links: HD Moore's AI supply chain research (Dragos), Phala's November preliminary incident report (Phala), Cohere's original Qwen report (Cohere), Check Point's replay of the Qwen trace (Check Point), Model routing controls (OpenRouter), How we build eLLMo AI with people and agents as one team.
See this in action on your page
eLLMo sends simulated buyers through your product page and returns a ranked list of what stops people from buying, in their own words.
More from the blog