The AI Leak That Said Everything Was Fine
Cloudflare disclosed that an open model on Workers AI leaked other customers' data into 155 responses, each one marked as a success. The cause was ordinary: the memory behind the model was smaller than the context window it advertised.

Picture a coat check that hands out more tickets than it has hooks. Most nights nobody notices. Then one busy evening a guest hands over a ticket, the attendant reaches for a hook that has already been reused, and calmly returns someone else's coat. No alarm goes off and nobody apologizes. The guest walks out in a stranger's jacket.
In plain terms, that is what Cloudflare disclosed on 26 October. Its Workers AI service ran the open model GLM-5.3, and between 27 August and 9 September 2026, data from other customers' requests leaked into 155 responses. Every one of those responses came back with HTTP 200, the web's way of saying "all good."
What actually broke
While a large language model reads your prompt, it keeps a working memory called the KV cache. You can think of it as the scratch pages the model writes on as it works through your text. Cloudflare advertised a context window of 1,048,576 tokens for GLM-5.3, but the pool of memory behind it held only 681,280 tokens.
That gap alone should have produced a polite rejection for oversized prompts. But the service split the work into two stages using the open-source serving engine SGLang: a prefill stage that reads the prompt and a decode stage that writes the answer. A bug in that split let through requests that should have been rejected. The decode stage then read stale pages left behind by someone else's request and answered from them.
That explains why the pattern is so clean. Every affected prompt was over 681,280 tokens. Below the real memory limit, nothing went wrong. Above it, the system quietly borrowed from strangers.
The most dangerous failure is not the one that crashes. It is the one that returns 200 and hands you someone else's coat.
The bug report that went to sleep
This is the part that should make every operator wince. According to the beri.net analysis, the SGLang bug was filed in July and auto-closed for inactivity during the exposure window. So the warning existed, and an automated cleanup closed it while the leak was live.
Nobody did anything dramatic or malicious. A spec-sheet number got ahead of the hardware behind it, an edge case in shared open-source plumbing went unfixed, and a housekeeping rule closed the ticket. Three ordinary decisions added up to a cross-customer data exposure.
Why this matters beyond Cloudflare
Context windows are this season's headline spec. Mistral's Large 4, whose weights went up on Hugging Face on 29 October, also advertises a 1M context. Long context is genuinely useful: you can put a whole codebase, a stack of contracts or months of support tickets into a single prompt. But the number on the spec sheet and the memory actually provisioned behind it are two different things, and the Cloudflare case shows what happens when they drift apart.
Three lessons apply well beyond this one case:
- A spec is a promise, not a measurement. If a provider says 1M tokens, ask what happens near the top of that range and whether anyone has tested it there.
- Shared infrastructure means shared failure. Multi-tenant inference is cheap because every customer draws from the same pool. When the walls inside that pool fail, other customers get hurt, not just you.
- A success code says nothing about the content. A response can arrive fast, return 200, and still be wrong in the worst possible way. Monitoring that only watched status codes and latency would have shown a healthy service.
What the fix looks like
As summarized by beri.net, Cloudflare's remediation has three parts. It now requires SGLang v0.5.22 at minimum, it sizes the memory pool to about twice the advertised context, and it adds a new checksum flag on the KV cache so stale or mismatched pages can be caught instead of served.
Each part does a different job. The first patches the code. The second puts real headroom behind the promise. The third checks the data itself instead of trusting the pipeline. That third part is the one worth copying everywhere: don't assume the plumbing is right, verify what comes out of it.
The quieter lesson for buyers
Most companies using AI don't run their own inference. They call an API and trust it. This disclosure is a good reason to ask any provider harder questions, especially about long-context workloads, which is where people tend to paste their most sensitive material: full contracts, customer histories, internal documents.
To Cloudflare's credit, the disclosure is specific. It gives dates, a count, a token threshold, the root cause and the fix, and that detail is exactly what lets customers check whether they were affected. Every provider should be held to that standard. Every buyer should also know which of their own workloads run close to the advertised limits, because that is where the system's promises and its actual capacity are most likely to come apart.
Why I design for the quiet failure
The failure that worries me most is the quiet one. When I built a dozen-plus scheduled routines that pull from ad, commerce and CRM APIs and post digests unattended, the design question was never "what if it crashes?" Someone notices a crash. The question was "what if it runs, reports success, and skips a day?" So each routine works out its own window from what is already covered, and a late or missed run backfills instead of silently skipping.
The same instinct shaped an automated records bridge I built for a multi-clinician healthcare practice. It syncs into the CRM behind a safety gate, with no sensitive data left on disk. Sensitive data should not sit around in places nobody is watching.
Cloudflare's checksum flag applies that idea to AI inference. Check the output against what it should be, not just the status code. If your AI pipeline only raises an alarm on errors, it can't see the failure that matters most.
One signal a day. No noise.
A 3-minute read when something genuinely shifts in AI, automation, or defense tech. Free, most weekdays.
Free, most weekdays. No spam, unsubscribe anytime.Sources
- beri.net - Cloudflare Workers AI GLM-5.3 KV cache cross-customer exposure - https://www.beri.net/article/cloudflare-workers-ai-glm-5-3-kv-cache-cross-customer-exposure-sglang-disaggregated-prefill-decode-v0-5-22
- Cloudflare - KV cache exposure remediation - https://blog.cloudflare.com/kv-cache-exposure-remediation/
- GitHub - SGLang issue #30233 - https://github.com/sgl-project/sglang/issues/30233
- beri.net - Mistral Large 4 open weights analysis - https://www.beri.net/article/mistral-large-4-open-weights-1t-a52b-licence-maas-pricing-coding-agent-index-vs-glm-5-3-self-host
Quick answers
What happened with Cloudflare Workers AI and GLM-5.3?
Cloudflare disclosed on 26 October 2026 that between 27 August and 9 September 2026, data from other customers' requests leaked into 155 GLM-5.3 responses on Workers AI. Every affected prompt was over 681,280 tokens.
What caused the GLM-5.3 data leak?
The KV cache pool held 681,280 tokens, less than the advertised 1,048,576-token context. A bug in SGLang's split between the prefill and decode stages let through requests that should have been rejected, so the decode stage read stale memory pages from another customer's request and returned them with HTTP 200.
How did Cloudflare fix the KV cache exposure?
Cloudflare now requires SGLang v0.5.22 at minimum, sizes the KV cache pool to about twice the advertised context, and adds a new checksum flag on the KV cache.
What should buyers of AI APIs learn from this?
An advertised context window is a promise, not a measurement, and a success code does not prove a response is correct. Ask providers how they behave near the advertised limit, how customers' requests are isolated from each other in shared infrastructure, and whether outputs are checked for integrity.