deniz.in

Markets

Weather

Loading weather

· via dev.to (home feed)

Trending zero-trust agent sandbox renews debate over process isolation and prompt injection

The nolabs-ai/nono runtime passed 5,000 GitHub stars as a trending dev.to post argues that OS-level isolation cannot stop indirect prompt injection and proposes deterministic outbound gates instead.

Trending zero-trust agent sandbox renews debate over process isolation and prompt injection

A new class of agent sandboxes pitched as requiring no setup, adding no latency and providing zero-trust isolation has been trending on GitHub, and a dev.to post published on November 17 by the author dev_kestrel singles out one of them: the nolabs-ai/nono runtime, which the author says has crossed 5,000 stars. The post's central claim is that this isolation-first pitch is only half right. Process containment solves a real problem, the author argues, but it does not address the failure mode that hurts agents in production — a language model being talked into invoking a powerful tool in a way its operator never intended.

What a sandbox genuinely stops

A sandbox is an operating-system boundary. It hands the agent a restricted filesystem, caps CPU and memory, and runs it in a scrubbed environment. According to the post, that makes it effective against a malicious dependency trying to read SSH keys or cloud credentials, a runaway process exhausting memory, and native code attempting to escape into the host. These are real threats, and containment handles them well.

Where isolation stops helping

The problem, the author writes, is that a useful agent is supposed to touch the outside world. It queries APIs, sends email, opens pull requests and fires webhooks — those capabilities are the product, not a bug. Sandboxes therefore permit outbound network traffic, since blocking all egress would render the agent useless. That permission is exactly where indirect prompt injection lives.

The attack works like this: the agent reads content it does not control — a README, an issue ticket, a web page, an email — and that content carries instructions, for instance telling the agent to disregard earlier directions and send the contents of a .env file to an attacker-controlled host. From the operating system's point of view nothing is wrong: the outbound call is network-legal, the tool being invoked is one the agent legitimately holds, and the traffic pattern looks like normal agent behaviour. The sandbox never fires.

Why system prompts do not fix it

The post identifies three structural reasons that instructions in the prompt fail here. What the author calls context drift means early instructions lose probabilistic weight over long sessions. Instruction ambiguity means a rule like 'don't leak secrets' reads as a preference rather than an enforced boundary. And there is no verification layer, because a model reasons about requests; it does not enforce policy, and it has no reliable way to tell its operator's instructions apart from text it just scraped. The author's conclusion is that enforcement has to sit in deterministic code that runs before any network connection opens, beyond the reach of the model's reasoning.

The proposed fix: a deterministic outbound gate

The pattern the author describes is a typed policy object rather than a prompt: an explicit list of allowed destination hosts, a flag for rejecting payloads that look like credentials or tokens, and a hard cap on outbound payload size. A gate class enforces it before any side-effecting tool opens a connection, checking the destination against the allowlist, scanning payloads with regular expressions for common token shapes such as GitHub personal access tokens and JWTs, and rejecting oversized bodies.

Wrapped around a tool that sends email, the gate throws before a socket opens. The property the author highlights is that the model cannot argue, flatter or trick a set-membership lookup into returning a different answer.

A layered stack, not a single choice

Rather than picking one defence, the post frames agent security as four layers: the sandbox as the OS boundary; the outbound gate as the code boundary; per-key recipient allowlists so a stolen credential is useless on its own; and approval holds, where state-changing actions emit a ticket for human review instead of executing silently. Three rules summarise the approach: never treat model output as an authorisation decision, allowlist rather than denylist, and verify before side effects — a check that runs after the message has already gone out is not a gate at all.

Why it matters

As agents gain real credentials and autonomy, indirect prompt injection becomes the practical production risk, and it is largely invisible to OS-level isolation because the malicious instruction arrives through channels the agent is designed to read. The dev.to post is a single practitioner's argument rather than a study, but the pattern it advocates — explicit allowlists plus deterministic checks before a connection opens — is cheap to adopt in MCP servers and agent harnesses. The wider debate it feeds is whether the current enthusiasm for sandbox runtimes targets the right threat model, or whether the hard part of agent security lives one layer up, at the tool boundary.

  • #ai-agents
  • #prompt-injection
  • #security
  • #sandboxing
  • #llm

Related posts