AI agent runtime security works only when the controls run outside the agent's environment. A compromised agent can change anything it can reach. That includes its logs, its policy files, and the values it reports to other systems. So the component that makes a security decision must run where the agent cannot reach it. Treat every value that comes from inside the workload as untrusted input.

NVIDIA's Sentry design and Vercel's sandbox hardening both apply this rule, at different layers. Most teams cannot buy NVIDIA's hardware, but they can use the same design on ordinary cloud VMs. This post shows where each control goes and gives a checklist for standard infrastructure.

Why controls inside the agent's environment fail

An agent runs tools in a loop. It reads files, runs commands, and calls networks. If an attacker takes control of the agent, the attacker gets the same access. Prompt injection is one way this happens. A sandbox escape is another.

Many agent controls run in the same environment as the agent. Examples are a system prompt that lists forbidden actions, a log file on the same disk, and a policy file that the agent's process reads. A compromised agent can ignore, edit, or delete each of these. Our post on AI agent guardrails explains why a system prompt is not policy enforcement. This post covers the next question: where the enforcement must physically run.

NVIDIA states the requirement directly: "Monitoring and enforcement need to operate outside the agent's reach so that it can't alter or disable them" (NVIDIA). The same post gives the log example: "An agent that changes a log inside its own environment cannot make the same change to the protected record maintained on BlueField-4."

The public sources give no industry-wide count of agent incidents. The best scale signal is from Vercel. Its sandbox security challenge received 1,285 reports in two weeks. Vercel says this volume "is only possible because researchers now hunt at AI speed" (Vercel). Attackers can use the same speed.

How four organizations answer the same problem

Platform vendors, cloud providers, and sandbox providers now agree on the principle. They put enforcement at different layers.

Organization What it published Where enforcement runs Status
NVIDIA Sentry runtime security design On a BlueField-4 DPU, on the node's only network path to the model Design; "planned availability early next year"
Vercel Sandbox hardening after a Trail of Bits review and a public challenge On the host and control plane, outside the guest microVM In production; audited
Microsoft Agent security principles and Entra Agent ID Controls "outside the model"; a distinct identity per agent Principles and identity product
AWS Four security principles and a scoping matrix Architecture first; scope controls by connectivity and autonomy Guidance

Microsoft's security team writes that the controls for what an agent "can access, what actions it can take, and whether it should continue operating must sit outside the model, where the model cannot bypass or tamper with them" (Microsoft Security). The same post quotes Satya Nadella: "The most trustworthy agentic system will not be the one with the model we trust most. It will be the one designed that enables us to trust the model least."

Identity is a separate layer. Microsoft's Entra Agent ID guidance says to "Give separately managed agents distinct identities" (Microsoft Learn). An identity tells the enforcement point which agent is calling. It does not enforce anything by itself. Our post on agent identity management covers why agents should not hold their own keys.

AWS replied to a NIST request for information with four principles. It says that "The most important extension is architectural" (AWS Security). AWS also publishes a scoping matrix that "categorizes four distinct agentic architectures based on connectivity and autonomy levels" (AWS Security). The matrix helps a team decide how much of the design below it needs.

NVIDIA Sentry: enforcement on the network path

NVIDIA Sentry runs on the BlueField-4 DPU. A DPU (data processing unit) is a network card with its own processors, memory, and operating system. It has its own trust domain, separate from the host CPU.

In the Sentry design, "agents execute on NVIDIA Vera CPUs, while BlueField-4 sits on the node's only path to the model." Sentry "inspects agent-to-model communications and enforces access policies without relying on the agent to report its own behavior" (NVIDIA).

Agent traffic path in the NVIDIA Sentry designAgent on Vera CPUtreated as untrustedthe only network pathL4 firewall (DOCA Flow)per-agent rules, in silicon on BlueField-4permitted traffic onlyL7 proxy (DOCA Tower)Envoy, TLS termination, OPA policy checkModel
DIAGRAMAgent traffic path in the NVIDIA Sentry design. Source: NVIDIA, Inside NVIDIA Sentry.

The design has two network layers:

  1. Layer 4 firewall. DOCA Flow runs a firewall for each agent, "accelerated in silicon on BlueField-4." It blocks connections to unauthorized destinations.
  2. Layer 7 proxy. The firewall forwards permitted traffic to DOCA Tower. DOCA Tower is "Built on Envoy," does TLS termination, and checks requests with Open Policy Agent (OPA). OPA is an open-source policy engine that evaluates rules written in its Rego language. NVIDIA says OPA "can evaluate requests in under a millisecond, depending on policy complexity and configuration."

Sentry also inspects the host. DOCA Argus does "live memory introspection" "without host-resident agents." It tracks containers, processes, and loaded libraries by hash. Its warning signs include unapproved tools, use of ptrace to attack another process, too much outbound traffic, unauthorized file changes, CPU spikes, and large-scale file deletion.

The key claim is about a sandbox escape. Sentry "can contain and quarantine agents within milliseconds" "without the cooperation of the agent or the host software." NVIDIA adds: "Even if an agent escapes its sandbox, NVIDIA Sentry retains its monitoring and enforcement capabilities." NVIDIA gives no exact containment time.

Sentry sits on top of NVIDIA OpenShell, a software layer that "separates policy enforcement from the agent workload, so a compromised agent can't change its own restrictions." DOCA Tower also integrates with SPIFFE/SPIRE for workload identity.

Vercel Sandbox: stop trusting values from the guest

Vercel Sandbox runs untrusted code. "Each sandbox runs on its own Firecracker microVM with a dedicated guest kernel, and the device model is deliberately tiny" (Vercel). A microVM is a small virtual machine that starts fast and exposes few devices to the guest.

Vercel tested this design in two ways. First, Trail of Bits reviewed it with two engineers over four engineer-weeks and reported 20 findings. Second, Vercel ran a public challenge with a $1M prize for two weeks, starting in August.

Challenge outcome Count Share of reports
Reports received 1,285 100%
Duplicates 877 68.2%
Not applicable 319 24.8%
Valid 57 4.4%
Informative 32 2.5%

The 57 valid findings were 1 Critical, 5 High, 9 Medium, and 42 Low. Vercel paid $242,000. The shares are our calculation (count divided by 1,285), and the rows add to 1,285.

Vercel's write-up gives three lessons:

  1. The host trusted values from the guest. "Our control plane accepted values returned by software running inside the microVM, and every one of those values is tenant input." In one exploit, software inside the guest returned {storage_url, size, checksum} for a snapshot, and host services trusted it. Vercel moved snapshot creation "into a host-side service" and made storage paths project-scoped with strictly validated URLs. The fix "shipped within a week."
  2. Several parsers read the same policy. "Egress enforcement was split across subsystems that each parsed the same network policy independently, and they did not always agree." Vercel now uses "one canonicalization routine per data type, one component per decision," and revalidates connections when policy changes.
  3. The next kernel bug will come. A researcher found a zero day in the Linux kernel's networking stack, triggered by crafted packets sent from inside the microVM. Vercel's guidance: keep host and guest kernels up to date, reduce the kernel attack surface, disable nested virtualization, and use Firecracker's jailer to run each microVM process with restricted permissions.

Vercel also notes that "a boundary that depends on a secret staying secret is not a boundary." In that case, the secret was a random 96-bit identifier. The challenge also found a cross-tenant leak through device-mapper, reported by a Vercel intern. Cross-tenant leaks are not limited to sandboxes. Our post on cross-tenant leaks in AI infrastructure covers the same class of failure in a cache layer.

Not every kernel attack was shown in production. The host memory leak was demonstrated against Vercel production sandboxes. The crash and code execution were shown on the researcher's own machines. The fixes are under private review and CVEs are pending.

Two meanings of "outside"

The two sources use "outside" in different ways.

  • Vercel means outside the guest VM. Decisions run on the host or in the control plane.
  • NVIDIA means outside the host too. Decisions run on a separate hardware trust domain.

Vercel's third lesson accepts that an attacker can reach the host through a kernel bug. Sentry is a design for exactly that case. Neither source refers to the other.

One more point is our inference, not a claim in either source. The Vercel zero day arrived as network packets from inside the microVM. The network path is where Sentry places enforcement, and that path also carries attacks. A network enforcement point must itself be hardened and kept small.

Where each control runs

The diagram places each control from both designs in a layer. The top layer is the least trusted. Each lower layer is harder for a compromised agent to reach.

Where each agent control runsUNTRUSTED: INSIDE THE AGENTAgent processclassifiers check tool calls and reasoning tracesRuntime policyOpenShell keeps enforcement apart from the agent workloadSandbox VMFirecracker microVM, own guest kernel, jailerHost and control planevalues derived server-side or signed with a host keyL4 firewallDOCA Flow blocks unknowndestinationsL7 proxyDOCA Tower on Envoy, TLStermination, OPABlueField-4 DPUmemory introspection, containment, protected records
DIAGRAMWhere each agent control runs. Source: NVIDIA Sentry design post; Vercel Sandbox challenge findings.
Layer Control Can a compromised agent change it? Source
Agent process Classifiers on tool calls and reasoning traces, "inline or out of band" Yes, if they run in the agent's process NVIDIA
Runtime policy OpenShell policy, kept apart from the workload Not by design; depends on the isolation below it NVIDIA
Sandbox VM Firecracker microVM, jailer, no nested virtualization Only through an escape, such as a kernel bug Vercel
Host and control plane Values "derived server-side or signed with a key the guest cannot reach" Only after a host compromise Vercel
Network gateway Layer 4 firewall, then a layer 7 proxy with OPA Not if it is the only network path NVIDIA
Hardware DPU memory introspection, containment, protected records Not from the host, per NVIDIA's design NVIDIA

Use the classifiers in the top layer as early warnings. Do not let them be the only control for an action that matters.

A checklist for ordinary cloud VMs

Most teams run agents on standard cloud VMs or containers. They can apply the same rules without a DPU. The table maps each control to a source and to a step on standard infrastructure.

Control Origin Step on ordinary cloud VMs
Egress proxy the agent cannot change Sentry's DOCA Flow and DOCA Tower design Run the proxy on a separate host or network. Block all other outbound routes with cloud network rules.
No trusted values from the guest Vercel, lesson 1 Derive values such as file size, checksum, and storage path on the host. Or sign them with a key that the guest cannot reach.
One policy decider Vercel, lesson 2 Parse each policy in one service, with one normalization routine per data type. Recheck open connections when policy changes.
Plan for the next zero day Vercel, lesson 3 Patch host and guest kernels. Remove unused kernel features. Disable nested virtualization. Run each VM process with restricted permissions.
Logs outside the workload Sentry's protected record Send logs to a store that the agent's identity can append to but not edit or delete.
Approved workloads only Sentry checks Allow only container images on an approved list. Compare process hashes with the SBOM. Check command-line arguments.
Secrets and personal data stay inside Sentry checks Redact PII and secrets at the proxy before traffic leaves.
Govern agent protocols Sentry checks Route A2A and MCP traffic through the same proxy and policy.
Distinct identity per agent Microsoft Entra Agent ID Give each separately managed agent its own identity. The proxy uses it to select the policy.

To set up the egress control first:

  1. List every destination that each agent needs: model APIs, tool APIs, and data stores.
  2. Deploy a proxy on a host that the agent's VM cannot log in to.
  3. Set the VM's network rules to allow outbound traffic only to the proxy.
  4. Write the allow-list in one policy service that the proxy queries.
  5. Log each request and decision to an append-only store.
  6. If the proxy cannot reach the policy service, block the request.
  7. Test the setup from inside the VM: try a direct connection to an unlisted host and confirm that it fails.

Our post on API gateway design for AI agent traffic covers how to keep the extra hop fast. Our post on the agent kill switch covers the containment path that the proxy and the host can trigger.

Worked example: one compromised agent, three attempts

This is a hypothetical example. A coding agent runs in a VM on a standard cloud account. A prompt injection in a repository file takes control of it. The attacker tries three actions.

  1. Send data to an unknown server. The VM has no outbound route except the proxy. The proxy checks the destination against the allow-list and blocks it. The block is logged outside the VM.
  2. Delete the evidence. The agent deletes its local log file. The proxy already wrote each request to the append-only store, so the record stays complete.
  3. Report a false value. The agent reports a small artifact size and a fake checksum so that the host copies a large file into another project's storage. The host computes size and checksum itself and builds the storage path from the project ID. The reported values are not used.
Attempt Control that runs inside the VM Control that runs outside the VM Result
Exfiltrate data Agent's own tool rules (bypassed) Egress proxy and network rules Blocked
Delete logs Local log file (deleted) Append-only log store Record kept
Report false values Guest-side snapshot code (lied) Host-side checksum and path Not used

In each row, the control inside the VM fails. The control outside the VM holds.

Which response fits your situation

Match the depth of the design to what the agent can reach and who can influence it. The AWS scoping matrix uses connectivity and autonomy for the same purpose.

Your situation Recommended placement
One internal agent, read-only access, no untrusted input Distinct identity, egress proxy, and logs outside the workload
Agent reads untrusted content (web, email, repositories) and has write access Add a sandbox VM, one policy decider, and host-side values. Our post on the lethal trifecta explains the risk.
You run untrusted code for many tenants Use the full Vercel set: microVMs, host-derived or signed values, kernel hardening, and an audit
You run your own GPU cluster with high-value data and many agents Add a hardware trust domain on the network path, such as a DPU-based design, when it is available and tested

For the sandbox choice itself, see where agent code actually runs.

Limits and when this design is the wrong choice

  • Sentry is not shipping yet. NVIDIA plans availability in early 2027. Its claims are design claims from the vendor, with no independent audit. Vercel's design has a third-party review and a public challenge behind it.
  • No cost or latency data. Neither source gives cost or latency overhead, other than OPA's evaluation time. Neither gives results on non-NVIDIA hardware. Measure the proxy hop in your own setup.
  • A short local script may not need it. If an agent has no network access, no secrets, and no untrusted input, a full egress stack adds work without much benefit. Add the controls when any of those three conditions changes.
  • The enforcement point becomes a target. A proxy or policy service that every agent depends on must be patched, monitored, and kept small. If it fails open, it gives no protection.
  • Outside-the-VM is not outside-the-host. A host-side control fails after a host compromise. Vercel plans for this with kernel hardening. NVIDIA plans for it with separate hardware.

Plan agent controls before your agents reach production systems

Agents that touch customer data, code, or money need controls that still work after the agent is compromised. That decides whether an incident is a log entry or a breach. OpenNash puts forward-deployed engineers on your team and works with Fortune 2000 companies to build these controls into production agents.

  1. Map each agent's data, tools, and network destinations.
  2. Place each control in a layer that the agent cannot reach: egress proxy, host-side values, one policy decider.
  3. Build evals and attack tests first, including the three attempts in the worked example.
  4. Ship to production with append-only audit trails, cost controls, and a tested kill path.
  5. Train your team to run, update, and review the policy.

At the end, you own the agents, the policy service, the proxy configuration, the tests, and the runbooks.

Book a call with an OpenNash forward-deployed engineer or email us at hello@opennash.com. In the first session, we review your top AI use cases and data and show which ones give the highest business value and the fastest ROI.