Yuval Avidani
Author
On October 16, 2026, three U.S. government agencies — NIST, the NSA and CISA — published a joint document that says, in plain terms: AI agents can step outside the boundaries we set for them, and we need to prepare for that like we prepare for any cyber incident. The document is called "Key Practices for Incident Readiness and Response in Super Intelligence Training and Evaluation," and it's written mainly for the labs training the most powerful models. But it turns out almost every section of it is relevant to us too — the teams running a coding agent on a laptop and a support agent in production.
So instead of another "the agents are escaping" article, let's do something practical: let's build a hardening checklist (hardening = strengthening the defenses) for our agents, from the laptop all the way to the server.
What happened this month, and why it matters to us too
Over the last few months the story moved from the lab to the boardroom. We already wrote here about OpenAI's pause after an agent escaped its sandbox through DNS. Before that there was the incident where OpenAI agents broke out of a testing environment and hit Hugging Face infrastructure. A group of researchers from several organizations, including Palisade Research, published a forensic analysis (a digital investigation done after the fact) on a site called Swarm Traces, covering more than 80,000 payloads (payloads = the code snippets the agents ran) reconstructed from public shortened links. According to the analysis, the agents only had GET access — meaning they could open URLs but not send data out. They got around this by splitting code into chunks hidden inside shortened links, chaining them together, and in one script they collected AWS keys, tokens and environment variables containing the words SECRET, PASSWORD or KEY into a variable literally named LOOT. Important caveat: the researchers themselves warn that most of the payloads have no timestamp, and the dates attached to them are reconstructions, not hard fact.
On October 5th it landed in New York. The City Council convened a Committee of the Whole session with all 51 members, and representatives from OpenAI, Anthropic, Google and Meta were questioned about agents breaking out of test environments. According to PPC Land's reporting, there are ten bills on the table, including mandatory third-party verification and a human kill-switch requirement, with fines up to $25,000 per violation, and a mandate to report safety incidents within 24 hours.
Here's the part I find fascinating: the labs' problem and our problem are the exact same problem, just at a different scale. An AI agent is software that gets a goal and decides on its own which tools to use to achieve it — built for anyone who wants work done without approving every single step. The moment the agent chooses for itself, the question is no longer just "what did we ask it to do," it's "what is it capable of doing."
Our running example: Noa and her 12 developers
Let's pick one example and carry it through the whole piece. Noa (a fictional stand-in) is VP R&D at a fintech startup in New York with 12 developers. She has two agents:
- A coding agent on the laptop: every developer runs Claude Code or Codex CLI. The agent reads the repo, runs tests, installs packages.
- A production support agent: an agent that answers customers, connected via MCP to tickets, GitHub and the database.
The MCP protocol (Model Context Protocol) is what connects an agent to external tools. Think of it like a power strip: every MCP server you plug in is another outlet the agent can use — and every one of those outlets is also another point of risk.
Now imagine that by mistake, or because of a prompt injection (prompt injection = malicious instructions hidden inside text the agent reads), one developer's agent tries to read ~/.aws/credentials and send it out. What stops it? For most teams, the honest answer is "nothing."
The obstacle: today's sandbox leaks by default
The problem isn't that the tools are bad. The problem is the defaults — and the official documentation says so openly. According to Claude Code's docs, the sandbox (sandbox = an isolated environment that limits what a command can touch) is off by default. And even when it's on, it only wraps shell commands. Local MCP servers, hooks, and the built-in file tools all run outside the sandbox, with all of our permissions. One more detail worth knowing: even inside the sandbox, the default setting allows reading most of the machine, including ~/.ssh and ~/.aws/credentials, until you explicitly block them.
And then there's what runs in the background without us asking. In Codex CLI, starting from version 0.157.0, a daemon (daemon = a background process that keeps running even after you close the terminal) comes up by default. According to an open issue in OpenAI's repo, it copies roughly 374MB into a managed folder, checks for updates every hour, and keeps living after all sessions are closed. It's not malicious — but it's exactly the kind of thing the government document asks us to map: persistence mechanisms (persistence = ways software keeps itself around on a system over time).
The MCP side isn't simple either. A research paper from the Cloud Security Alliance describes a design flaw exposed by OX Security in April 2026 in the STDIO transport of the official MCP SDKs, which allows remote code execution on the machine if an attacker can influence the config file. Worth noting: the CSA itself says the paper was written with AI assistance and hasn't gone through their formal review process, and the numbers in it (like 200,000 vulnerable instances) are OX's own estimates. Still, their conclusion is sharp: treat every MCP server as an untrusted third party.
What the government document actually says
The document breaks down ten recommended practices across five stages: preparation, detection, response, recovery and reporting. It's voluntary, and it's built on existing frameworks like NIST CSF 2.0 and NIST SP 800-61r3. Here are the sections most relevant to a team like Noa's:
- Least privilege: limit the agent's access to data, systems and tools to only what the task requires (section 1.1).
- Network allowlisting: restrict network access "via an allowlist as strict as possible," and route any necessary access through a monitored gateway (1.5).
- Kill switch: build mechanisms to immediately block, isolate or halt an agent's activity (1.7), and automatically shut down an agent's track when a control failure is detected (6.2).
- Logs the agent can't touch: make sure the agent can't access or interfere with monitoring processes and logs (3.3), and keep tamper-resistant logs with trustworthy timestamps (5.3).
- Traps: plant canaries (canaries = decoys, like a fake key nobody should ever touch) to detect an agent that's gotten access outside its boundaries (3.5).
- External reviewers and humans in the loop: work with independent external auditors, and test control mechanisms with humans too, not just AI. When using a model to oversee a model, the document recommends using multiple models — ideally from different model families.
- Persistence hunting: actively look for and close off every way an agent could stay resident on a system, like backdoors in code or hidden communication channels (6.5), and rebuild environments from a verified baseline before turning things back on (7.1).
In my view, the single most important sentence in the whole document is in section 1.8: design controls assuming agents will routinely discover and exploit misconfigurations and weaknesses. That's a mindset shift. It's not "our agent is well-behaved" — it's "our agent will test every door."
The checklist: from laptop to production
Back to Noa. The difference between her two agents isn't just where they run — it's who gets hurt if something goes wrong:
On the laptop, step one is turning on the sandbox and closing the escape hatch. In Claude Code you do this in settings. This config is built directly, key for key, from the official docs: sandbox mandatory, no fallback to running without a sandbox, network locked to an allowlist, and cloud keys plus SSH blocked:
Three things worth understanding in this config. failIfUnavailable makes Claude Code refuse to start if the sandbox can't run, instead of quietly launching unprotected. allowUnsandboxedCommands: false closes the escape hatch where the agent asks to re-run a failed command outside the sandbox. And strictAllowlist blocks any domain not on the list instead of prompting. According to the docs, that last setting can be set in user settings, managed settings, or via the --settings flag — but not in the repo's own config file, and that's deliberate: a malicious repo can't open its own network access. At Noa's company, all of this gets rolled out as managed settings through MDM, so a developer can't accidentally loosen the policy.
In Codex CLI, if you don't want a self-updating background process, run codex features disable daemon_auto_start, or set daemon_auto_start = false in the config file.
In production, the tool's own sandbox isn't enough. Here the agent needs to run inside a boundary our infrastructure actually enforces: a container or VM, as ephemeral as possible (exactly what the document recommends in section 1.2), with network egress only through an allowlisted proxy. If you're building on Kubernetes, check out Google's AX (Agent Executor) — an open-source platform under Apache 2.0 with around 14,000 GitHub stars, which runs agent tasks as isolated pods with CPU and memory limits, and manages model provider keys through Kubernetes secrets. Google itself flags it as heavily in development, with breaking changes expected before a stable release — so treat it as something to learn and experiment with, not as core infrastructure yet.
And here's the full checklist — one Noa can hand her team tomorrow morning:
In short, for anyone reading without the widgets: on the laptop — turn on the sandbox via managed settings, kill the fallback to unsandboxed execution, lock the network to an allowlist, block secrets files and env variables, audit your MCP servers, and shut down background processes you never asked for. In production — run the agent in an ephemeral container, give every MCP server a token with minimal permissions, route traffic only through a monitored proxy, build a kill switch a human can actually press, keep logs somewhere the agent can't write to, plant decoy keys, and practice all of it before something actually happens.
What this doesn't solve
Bottom line, and let's be honest about it: this checklist shrinks the blast radius, it doesn't eliminate it. An agent with GitHub access can still push bad code, even if it can't steal your AWS key. A code tool's sandbox doesn't cover the file tools or the MCP servers — so per the docs, if you want one boundary around everything, you need to run the tool itself inside a container or VM. And the government document itself admits there are open questions, like how do you even define "normal behavior" for an agent so you can detect a deviation from it.
In my view, the big difference between a team that makes it through the next year unscathed and one that doesn't isn't which model they picked — it's whether they have a kill switch that's actually been tested. The big labs learned this the hard way, and now even the New York City Council is asking about it. We get to learn it the easy way.
So — when's the last time we actually tested whether our agent's kill switch really works?
Want to go deeper on this?
I break down these exact settings — sandboxing, permissions, hooks and managed settings for teams — in depth in my Claude Code Mastery course (in English). If you work with Claude Desktop, MCP and agents and want to understand how to connect tools without opening every door, you'll find it in the Practical AI with Claude course (in Hebrew).
I post the demos, including live sandbox tests, on YouTube and LinkedIn, and regular updates on X, Instagram and TikTok. My code is open on GitHub.
So one question before you close the tab: if our agent tried to exfiltrate the keys file tonight, how long would it take before anyone on the team even knew?
