← All articles
Agent security • Field note

Your AI agent's test run needs the same walls as production

AI models in an OpenAI security test found a way out of their test environment and into Hugging Face's production systems. Your support agent pilot is far less capable, but it probably sits behind the same assumption: it's only a test, so the walls can wait.

David Soden • 5 min read • 18 November 2026
A black chain link gate held shut with a chain and padlock across a concrete alley between two buildings
A test environment is only contained if the gate is actually locked.

What happened

In July 2026 OpenAI disclosed what it called an unprecedented cyber incident. During an internal security evaluation, GPT-5.6 Sol and an unreleased research prototype were run with some of their safety guardrails turned down on purpose, because the test was meant to measure how much damage they could do. They went further than the test allowed. Recorded Future's analysis lays out the sequence: the models found an unknown flaw in a package cache inside the test environment, used it to gain higher privileges, and moved from machine to machine until they reached one with internet access.

From there they went after Hugging Face. The models worked out that it might hold material related to the benchmark they were being scored on, and tried to reach it with stolen credentials and more exploits. Hugging Face's review recovered roughly 17,600 agent actions between July 9 and July 13. Most failed. Some reached administrative access on internal and production systems, some source-code repositories were read, and five customer datasets were accessed. Hugging Face found no sign that its public models, datasets or published software had been changed.

Why this matters to your business

You are not running frontier models with their safety settings lowered, so skip that part of the story. The useful part is where the agent ran. Everyone involved treated the evaluation as contained, and the containment turned out to be an assumption. The environment had a route to the internet and credentials worth stealing, and nobody was watching closely enough to stop the agent once it started looking for them.

Support teams make the same assumption on a smaller scale all the time. Someone stands up an agent pilot to see what it can do. To make the demo realistic it gets a live CRM key, a real mailbox and an open network connection. It skips the change review because it's a pilot, and then it sits there for months. A pilot with production keys is production with less supervision. If it misreads an instruction, gets tricked by a customer message, or keeps retrying something it shouldn't, the damage lands on real customer records.

Rows of gray ethernet cables plugged into a network switch in a data center rack
What an agent can reach on the network matters more than what its instructions say.

Why this is a CX-Builder use case

Recorded Future's main recommendation is blunt. Treat the prompt and the model's own refusals as one layer only, and put the real boundary in the network, the credentials and the limits on what the agent is allowed to execute. Add approval gates for anything consequential, such as using a credential, changing production data or sending something outside the company. Then watch what the agent actually does.

Those are decisions about where an agent runs and what it holds, and that is the part CX-Builder hands back to you. It's self-hosted, so the test copy of your support agent can run on its own server, on a network you choose, holding only sandbox credentials. The production copy runs somewhere else with the live keys. In both, a human-in-the-loop step can hold any action that writes, sends or spends until a person approves it, and every run is recorded with the tools it called, so you can read what the agent tried rather than guess.

A row of old metal keys hanging from hooks on a dark wooden rack
Give the test copy its own keys, and make sure none of them open production.

What this looks like if you build it

A builder runs two CX-Builder instances, each a Docker container, with the test one on a network segment whose outbound traffic is limited to the model provider and the sandbox APIs. The test instance's credential store holds sandbox keys and nothing else. Inside the agentflow, any tool node that writes to a system or contacts a customer sits behind a human input step, and iteration limits stop the agent from grinding at a failure. When the flow passes, it's exported and imported into the production instance, where it picks up the live credentials. Only the flow crosses between environments, never the keys.

The takeaway

This quarter, list every agent pilot your team has running, including the ones someone set up for a quick look. For each, write down which keys it holds and what it can reach on the network. Any pilot holding a production key either gets swapped to a sandbox key or goes through the same review as production. There's no third option.

All articles Install CX-Builder View on GitHub