A Perfect Score for an AI Sandbox Escape
On November 1, the JFrog Security Research team published details of an AI sandbox escape so severe that it reached the maximum rating the industry uses to measure danger. Tracked as CVE-2026-120338, the flaw sits inside Prefab UI, an open-source component maintained by PrefectHQ and used to render model-generated interfaces. JFrog rated it CVSS 10, the ceiling of the scale, for the case where an unauthenticated attacker can reach the server. Where a login is required, it still scores 9.9.
A 10 is not handed out casually. It means an attacker needs no special access, no user interaction, and no chain of lucky conditions. The bug alone, reached over the network, is enough to read and write files on the host and ultimately run code of the attacker's choosing. In JFrog's proof of concept the researchers pulled the contents of a server's password file and dropped a marker into its temporary directory, two moves that would let a real intruder establish a foothold.
The discovery, credited to JFrog researcher Yuval Moravchick, lands at an awkward moment. Companies have spent the past year rushing to connect large language models to real tools through the Model Context Protocol, the emerging standard that lets an AI agent call software functions on a user's behalf. Prefab UI's feature for drawing interfaces from untrusted code was meant to be one of the safe building blocks in that stack. Instead it became the weak link.
How the Sandbox Became a Doorway
The feature at the center of the AI sandbox escape is called Generative UI, an opt-in capability that takes code, often written by a model, and runs it to produce a user interface. Prefab UI's documentation framed that execution as isolation for untrusted code. The isolation, it turns out, had a hole in the floor.
Under the hood, caller-supplied Python runs inside Pyodide, a build of Python compiled to WebAssembly, which itself runs inside a Deno subprocess. The design intent was a read-only box. The problem is how the two layers talk. Prefab UI's runner left Deno's own API sitting on the JavaScript global object, and Pyodide exposes that global to Python through its built-in js module. In practice that means a few lines of Python inside the supposed sandbox can reach straight through to the host and call Deno.readTextFileSync or Deno.writeTextFileSync against real files.
That reach would be harmless if Deno had been locked down. It was not. According to JFrog, the sandbox launched the Deno process with unrestricted read, write, and network permissions all switched on, despite public docs describing the process as read-only. The result is an AI sandbox escape in the literal sense. Whatever the server's operating-system user can touch, the injected Python can touch too. In one version, 0.20.2, JFrog showed the write primitive being used to plant a hidden startup file in the Python environment's package directory, so the next process to use that environment would silently execute the attacker's import.
The usual way in is almost ordinary. A FastMCP server that registers the Generative UI provider exposes a tool named generate_prefab_ui, and that tool forwards its code argument to the sandbox with no additional check. Any client permitted to call the tool can therefore trigger the AI sandbox escape. If the server sits open on the network with no authentication, no client permission is needed at all, which is exactly the scenario that earns the perfect 10.
Why This One Lands Differently
Plenty of critical bugs get disclosed every week. This AI sandbox escape matters more than most because of where it lives. The whole promise of the current agent boom is that models can be trusted to generate and run code inside guard rails. Prefab UI's Generative UI was a guard rail. When the rail fails, the model's output stops being a convenience and becomes an attack surface.
The affected versions run from 0.14.0 up to, but not including, 0.21.0, a wide band that covers months of releases. Any team that adopted the Generative UI feature during that window and left it reachable has been exposed. Because the exploit arrives as what looks like a legitimate request to generate an interface, it can blend into normal traffic in a way that a crude intrusion attempt would not.
There is a structural lesson here that goes beyond one package. Sandboxes built from borrowed runtimes, a WebAssembly Python inside a JavaScript engine inside a subprocess, inherit the permissions of every layer. A single over-granted flag at the bottom quietly cancels the isolation promised at the top. As more AI plumbing is assembled from these stacked components, the odds of another AI sandbox escape slipping through rise with every integration. Blumefield has tracked a steady run of agent-related security incidents through the autumn, and this fits the pattern.
The Fix, and What It Doesn't Fix
The remedy is straightforward to apply and should not wait. PrefectHQ shipped Prefab UI 0.21.0 on October 26, several days before public disclosure, and the published security advisory guidance is simply to upgrade to 0.21.0 or later. The patched release revokes Deno's filesystem read, filesystem write, and network permissions after startup and before any generated code is accepted, starts the process with prompts disabled, and limits the bootstrap network to a single content-delivery host. The repair landed in pull request 538.
Upgrading closes the door, but it does not undo what a visitor may have already done while the door was open. JFrog's write-up documents the file-planting technique without claiming that an upgrade cleans up afterward. Any server that ran a vulnerable version and was reachable should be treated as potentially touched, with a specific hunt for stray startup files or other artifacts the sandbox could have written. A clean binary on top of a dirty environment is still a dirty environment.
For teams that cannot patch immediately, JFrog's interim advice is blunt. Do not register the Generative UI provider on any server that untrusted clients can reach. In the authenticated case the vulnerability is recorded as CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H, a profile that reads as network reachable, low complexity, and total loss of confidentiality, integrity, and availability once triggered.
A Preview of the Agentic Security Era
The Prefab UI case is small in raw numbers and large in what it signals. The industry has moved faster than its own security practices, standing up agent frameworks, tool protocols, and code-executing helpers in months rather than years. Each new layer is sold on autonomy, the idea that software can be handed a task and left to run. The uncomfortable corollary is that the same autonomy, once subverted, runs the attacker's task just as willingly.
Expect more of these. The combination of model-written code, permissive runtimes, and services left open for convenience is a recipe that will keep producing high-severity findings. The defenders who come out ahead will be the ones who treat every AI sandbox escape as a question about the whole stack, not just the top layer, and who assume that any box holding untrusted code will eventually be tested by someone who does not play fair.
For now the action is clear. Audit for Prefab UI, confirm the version, upgrade past 0.21.0, and check whether the Generative UI feature was ever exposed. The perfect 10 is a headline, but the real story is the architecture that made it possible. You can follow Blumefield for continued reporting as the agentic security era writes its next chapter.