TL;DR
At KubeCon NA on November 10, CNCF accepted Agent Substrate and NVIDIA’s OpenShell as Sandbox projects. Both ship, as defaults, the fence I built by hand in The Closed Track: no credential inside the sandbox, default-deny egress, a hardened runtime. That part of the road is now paved. The part they don’t pave is the part that decided every incident in the series: on whose behalf an allowed call runs, and who can prove it afterwards. Credential injection makes that question more urgent, not less.
Originally published at portfolio.hagzag.com.
Two months ago this took a weekend and still flaked
In September I gave an agent a run_script tool, let a poisoned note steal its 1,230-byte ServiceAccount token, and then fenced the pod with three cuts: drop the token, add egress NetworkPolicy, run under gVisor. One cut was rock-solid. One was racy on k3d with a service mesh. One wouldn’t install on my Apple Silicon laptop at all.
Then the CNCF KubeCon announcement landed. Two new Sandbox projects are about exactly this: Agent Substrate, “a zero-trust runtime for executing AI agents on Kubernetes while isolating untrusted code”, and OpenShell, a runtime that enforces policy “in the infrastructure surrounding an agent”. gVisor joined CNCF in the same announcement.
So I did the obvious thing: I read both projects against the five checkpoints of the Agentic Highway. Not a lab run yet, a reading. I’ll say where that matters.

What shipped, checkpoint by checkpoint
| Series part | Question | Agent Substrate | OpenShell |
|---|---|---|---|
| 1. Safe Highway | Encrypted, authenticated transport? | Envoy router and egress proxies are the only in/out paths | Every connection passes a policy check before it leaves |
| 2. License Plates | Who is this workload? | Short-lived SPIFFE X.509 per actor, by default | Not described in the README |
| 3. Driving Permits | On whose behalf, for which task, until when? | Not described | Not described |
| 4. Closed Track | What can an allowed tool reach? | gVisor or microVM only, default-deny networking, zero credentials in the sandbox | Kernel-level file, syscall and network rules; credentials added only for approved endpoints |
| 5. Black Box | Can you prove who did it? | Logging, metrics, tracing | Telemetry (opt-out) |
Part 4 is covered twice over. Part 2 is half covered. Parts 3 and 5 are not on the page at all.
The closed track, done properly
Three things in these projects are better than what I built, and I’d rather say so plainly.
The credential isn’t there, by design. My strongest finding in Part 4 was that a token you don’t mount can’t be stolen. Substrate states the same rule as a guarantee: actors “never hold actor identity JWTs/certs, API keys, or cloud tokens”. OpenShell says agents “never see real credentials”. Both inject the credential at the egress gateway, outside the sandbox, only for approved destinations. That’s what I did by hand with the LLM key in Part 3, made general.
They fail closed on the runtime. My lab quietly fell back to runc when gVisor wouldn’t install. Substrate doesn’t allow that fallback: “Plain Linux containers are not supported.” On my laptop that means it wouldn’t run at all. I used to call that a limitation. Now I think a sandbox that refuses to start without its sandbox is the honest default, and my fallback was the bug.
Policy changes get reviewed like code. OpenShell runs new access requests, like “reaching a new host with credentials”, through a formal-verification prover that holds them for human review. My NetworkPolicy lived in a YAML file that anyone with kubectl apply could widen.
One thing didn’t change. OpenShell’s Kubernetes install still says “Your CNI must enforce NetworkPolicy.” That’s my racy k3d result, written as a prerequisite. Measure it anyway.
Credential injection moves the problem, it doesn’t remove it
Here’s the take I keep coming back to. In Part 4 the exfil worked even though “the permit was correct”. Every step was authorized. A paved closed track makes the token theft impossible. It does nothing about the authorized call.
With credential injection, a poisoned agent can’t read the key. It doesn’t need to. It asks the gateway to call the approved endpoint, and the gateway adds the key for it. A model provider is an approved endpoint. So is your bucket API. The injected credential is now the most powerful thing in the system, and the only question that limits it is the one from Part 3: which human started this task, through which agents, and is that delegation still valid now?
Substrate’s README does describe the hook: the egress gateway is a “fully replaceable” policy enforcement point, where you bring your own authorization or “cloud IAM policy engine”. That’s honest, and it’s the right seam. But “bring your own policy engine” means the permit system is still yours to build: the token exchange, the sub plus nested act, the TTL, the scope trimming that dropped buckets:delete in my lab.
What I’d still build myself
Delegation. Neither README mentions on-behalf-of. Substrate mints per-actor JWTs that “federate with external identity systems”, which identifies the car, not the trip. I’d put an RFC 8693 exchange in front of the egress gateway and make injection conditional on a valid, task-scoped permit.
The black box. Logs, metrics and traces are testimony. Part 5 showed a hash chain saying chain=OK after an insider rewrote a record, and only the emitter’s signature caught it. A sandbox runtime is the perfect emitter: it sees every call before the credential goes on. Neither project signs what it saw.
Caveats on my own reading. Both are CNCF Sandbox projects, which CNCF itself defines as “not yet widely tested in production”. Substrate says it’s pre-1.0, OpenShell is on 0.1.x. I read Substrate’s guides and OpenShell’s README, not OpenShell’s full docs, so its identity and audit gaps may be smaller than they look. So before running either project, I tested the argument itself in the lab.
Part 6 of the lab: pave the track, then break it
Part 6 of agentic-highway-labs keeps Part 4’s fence and takes every credential out of the sandbox. To be clear about what this is: neither Substrate nor OpenShell runs here. The lab’s egress gateway is a small stand-in that does the one thing both projects ship by default. It holds the store token, adds it to approved requests, and drops everything else. Part 4’s exfil now finds nothing to steal and nowhere to send it.
Then a poisoned note asks for a “cleanup script”. The script doesn’t try to steal the key. It sends a DELETE with Authorization: placeholder and lets the gateway do the rest:
delete=200 {"deleted":"prod-archive"}
egress=INJECT method=DELETE host=mcp-tools:8000 path=/store/v1/buckets/prod-archive credential=store-token sub=- act=- task_id=-
The sandbox never saw the credential. The gateway spent it on behalf of nobody: sub=-. The fix is the two checkpoints this post says are missing, moved to the egress gateway. It verifies the permit the run_script call was made with, asks OPA whether that delegation covers this method on this path, and signs the decision into the black box before the credential goes on:
delete=403 {"error":"prod-archive is under retention lock; scope buckets:delete not in permit"}
egress=DENY method=DELETE ... sub=tester act='executor-agent via planner-agent' task_id=72
Those lines are from running Part 6 as local processes (task part6:local). They show the pattern’s gap, not either project’s. Parts 7 and 8 of the lab run the same break against the real things: Part 7 on Agent Substrate (kind on a Linux host, since it needs gVisor or a microVM), with the permit check behind its experimental ext_proc hook, and Part 8 on OpenShell from its Helm chart, on a CNI that enforces NetworkPolicy. Each part ends with where that project fits in a platform and what you still have to build around it. I’ll report what actually holds.
Conclusion
The closed track is the most visible part of agent security, so it got paved first, and it got paved well. If you’re hand-rolling NetworkPolicy and token mounts around a code-running tool today, stop and evaluate these two. Then look at the call that still gets through: allowed, authenticated, carrying a credential the agent never saw. A sandbox decides what an agent can touch. It can’t tell you who asked.
Discussion