HD Moore and his colleagues at Dragos spent five months — July through November 2026 — loading two million AI prompts with silent tracking alarms called canary tokens. They used five flavors of bait: AWS keys, SSH passwords, unique URLs, DNS names, and git references. Any access to these tokens was, by definition, a confession. What they heard over those five months was not silence.
The AI supply chain, it turns out, is not a phone call. It is a sorting network with hands you never agreed to shake.
A Tripwire Looks Exactly Like a Real Secret
Imagine you hide a key under a doormat, but this key opens nothing. It was made for one purpose only: to tell you, the moment someone picks it up, that someone was here. That is a canary token. It has no legitimate use. Any access is, by definition, a confession.
The logic is elegant in its simplicity. A canary token looks indistinguishable from a real AWS access key, a genuine SSH password, a live URL. The difference is invisible to anyone who finds it. The trap only springs for the guilty.
HD Moore and his colleagues at Dragos spent five months, July through November 2026, loading two million AI prompts with exactly these kinds of silent alarms. They used five flavors of bait: AWS keys, SSH passwords, unique URLs, DNS names, and git references. Each one was distinct, trackable, and completely harmless — unless someone, somewhere along the route from user to GPU, read something they were never supposed to touch.
The experimental logic is clean enough to fit on a napkin. Send the prompts. Watch the tokens. Silence means the data traveled safely. Any signal means a breach. No signal analysis required, no log forensics, no ambiguity. The canary either sings or it doesn't.
What they heard over those five months was not silence.
The Route Your Prompt Takes Before the Model Sees It
Type a question into an AI tool at work and you are probably imagining something like a phone call: your words travel to one place, a model thinks, an answer returns. The actual journey looks more like a package moving through a sorting network, handed from carrier to carrier before it arrives anywhere near a GPU.
A single API request routinely passes through the model developer, a cloud operator, and one or more third-party resellers before the model ever sees a word of it. Inference aggregators sit in the middle of this chain selling access to dozens of models through a single endpoint, a convenience that adds routing hops the user cannot inspect or count. The quote that emerged from the Dragos investigation cuts straight to it: "Customers thought they were buying a model and were actually buying a routing chain."
Each hop is a point of custody, and custody is where trust either holds or breaks. The Dragos research found that resellers on AI marketplaces were using standard logging capabilities to view and retain customer prompts, without any disclosure to the users generating them. Standard logging. Not a sophisticated intrusion. The same feature any developer uses to debug an application, turned quietly toward data the customer never meant to share.
Here is the structural problem. A user submitting proprietary code or sensitive business data has no way, from their side of the connection, to verify which organizations physically handled that data before the reply arrived. The gap between the assumed processing location and the actual physical route is not a bug in one provider. It is a property of how inference markets assembled themselves.
Three Providers Were Already Broken
The canary tokens revealed something worse than curious resellers. Three AI hosting providers in the study were actively compromised by external attackers — not partners, not employees cutting corners, but adversaries who had broken in and were quietly helping themselves to whatever passed through.
Here is what made it surgical: the attackers intercepted prompts before they reached the model. Not after processing, not from a log file harvested later. At the entry point, on the way in. If a provider received a prompt and then rejected it as a policy violation, the attacker had already seen it. The model's guardrails, the provider's content filters, every control that operates at the model level — all of them were downstream of the interception point, and therefore irrelevant.
This is worth pausing on, because it dismantles a common mental model. Many users assume that privacy protections sit around the AI model itself, like a vault. What the Dragos research shows is that the vault may be intact while the loading dock has been wide open for months.
Zero Data Retention settings offered no protection here at all. ZDR is an agreement between a customer and a provider: "we will not store your data." It says nothing about what an attacker who has already gained access to that provider's infrastructure can observe in real time. The policy cannot bind someone who is ignoring the policy entirely. A locked filing cabinet is cold comfort when someone is reading the documents as they are delivered, before they ever reach the drawer.
Three providers. External attackers. Prompts intercepted before the model could even refuse them.
Twenty-Four Days Later, in an Office in China
Somewhere between May and November 2026, every prompt sent through the resellers AtlasCloud, Novita, and StreamLake was quietly making a detour. Not to a carefully vetted secure endpoint, but to MiniMax, a Chinese AI lab, via its standard commercial API. Novita AI would later describe this as a routing error, active for roughly six months without detection. A mistake, they said. Perhaps. But the canary tokens were watching regardless.
Here is what the tokens recorded: MiniMax accessed secret tracking URLs embedded in roughly two-thirds of prompts explicitly flagged as Zero Data Retention. These were prompts that carried the clearest possible signal — do not store this. The flag was ignored, or the system routing the data never consulted it at all.
Then came the detail that is hardest to explain away as an accident. One canary URL, seeded inside a prompt, surfaced again 24 days later, inside the internal chat of a Chinese company. Someone had opened it. Someone had shared it. The gap between submission and access was not milliseconds, the lag of a machine fetching a resource. It was three and a half weeks — the rhythm of a person finding something interesting and passing it along.
The timing data on the other accesses tells a similar story. Tracking links in OpenRouter requests were still being retrieved 40 to 130 hours after the model had already replied to the original user. The inference was done. The GPU had moved on. Whatever was reaching back for those URLs at hour 97 or hour 128 was not a process completing a task. It was something else, operating on its own schedule, against data it was never supposed to hold.
Zero Data Retention Is a Handshake, Not a Lock
A ZDR badge is only as strong as the weakest hop in the chain.
Think of Zero Data Retention as a contract clause, not a vault door. When a provider signs up for ZDR status, they are making a policy pledge: we will not log your prompts, we will not retain your data. That pledge is real and, under ordinary conditions, worth something. But a contract requires honest parties. An attacker who already controls the infrastructure does not care what the contract says. They read the data before the policy is ever applied, the same way a dishonest librarian can photograph a book before logging its return.
This is precisely what the Dragos research made visible. Zero Data Retention cannot protect data from someone who already has the keys to the building. The setting governs what happens to data at rest; it has nothing to say about data at the moment of transit, in the hands of a compromised host. That gap is structural, not a bug waiting for a patch.
The consequences were concrete enough to force action. OpenRouter, the aggregator routing requests across dozens of back-end providers, removed 125 endpoints from ZDR eligibility entirely and off-boarded three unnamed providers after the findings landed. Phala Network separately disclosed that request data for DeepSeek V4 Flash deployments routed through OpenRouter had been exposed. These were not theoretical risks quietly catalogued in an appendix. They were specific networks, stripped of a trust label they could not honestly carry.
The Credentials That Went Walking
Stolen secrets do not sit still. When the Dragos canary AWS keys made their way into attacker hands, those attackers put them to work immediately: tens of thousands of API calls probing S3 buckets and Secrets Manager, systematically testing what permissions the keys carried. That is not reconnaissance. That is a burglar who found the keyring and is trying every door in the building.
Then there is the person in France. Somewhere in the five months of the experiment, a canary SSH password — embedded inside an ordinary AI prompt — ended up being typed, by a human hand, into a root login attempt on a remote server. Someone read it off a screen and sat down at a keyboard. The credential had traveled from an AI inference hop to an attacker's clipboard to a terminal prompt. The automation ended; the human effort began. That transition is the part that should stop you cold.
The pattern extends beyond the Dragos experiment. In November 2026, Together AI disclosed a separate incident: an AI coding agent had committed live credentials directly into a public GitHub repository. No interception required. The agent simply did not know it was handling a secret. The credential sat in public version history, available to any automated scanner that happened to look.
Three incidents, three different failure modes. Intercepted keys used at scale. A stolen password typed by hand into a root login. A coding agent leaking what it never recognized as sensitive. The credential — once loose — does not care how it arrived there. It just goes where it is useful.
What the AI Supply Chain Canaries Cannot Tell Us
The five-month experiment answered several questions sharply. It left others completely open, and that gap is not a footnote. It is the shape of the problem itself.
Dragos confirmed three AI hosting providers were actively compromised. Their names have not been disclosed. The volume of real user data stolen alongside the canary tokens — the legitimate trade secrets and source code and medical queries that traveled the same routing chain — remains unquantified. A number exists somewhere. We do not have it.
The question of why matters most. A Chinese AI lab accessed prompts marked for Zero Data Retention. Whether that data fed a training corpus, supplied a surveillance apparatus, or served some third purpose entirely is unresolved. HD Moore put the economic logic plainly: "The prompts and replies — the inference data itself — are often more valuable than the GPU resources used to process them." That motive explains the behavior. It does not tell us what happened next.
Here is the strange part. The canary experiment was never designed to catch everything. It was designed to prove the structure was broken. It succeeded. Two million prompts, five types of tracked secrets, and an AI supply chain that consistently treated user data as a resource in transit rather than a secret worth keeping. The names change. The architecture does not.