Announcement

OpenBox for OpenShell: Egress Governance for NVIDIA OpenShell Sandboxes

OpenBox for OpenShell puts a fail-closed OpenBox verdict on every outbound request from a NVIDIA OpenShell AI agent sandbox. One Helm chart, no agent changes.

Published on

Subscribe to our newsletter

By submitting your email, you agree to our Privacy Policy and consent to receiving updates from us

OpenBox for OpenShell: Governance at the Exit of Every NVIDIA OpenShell AI Agent Sandbox

A fail-closed policy decision point on the egress path of every OpenShell sandbox, installed with one Helm chart.

By Tahir Mahmood, Co-founder and CTO, OpenBox AI   ยท  Last updated 19 November 2026

In brief:OpenBox for OpenShell adds AI governance at the exit of every NVIDIA OpenShell sandbox. Before any model call, tool call or web request leaves a sandbox, OpenBox evaluates it against your policies, guardrails and behaviour rules, then allows it, blocks it, holds it for human approval, or halts the sandbox. If no verdict arrives in time, the request is refused, never waved through. Each sandbox becomes one sealed, readable session in the OpenBox dashboard and an entry in the AI Inventory. It installs with one Helm chart, and agents and sandbox images do not change. What sets it apart: it decides before the request leaves, covers the whole egress surface (model, tool, web and the WebSocket upgrade), and cannot be switched off from inside the sandbox.

What we built

OpenBox for OpenShell is available today for NVIDIA OpenShell v0.1.8. It is a fail-closed checkpoint on the egress path of every sandbox: before anything an AI agent sends leaves its sandbox, OpenBox decides whether it may. It installs as one Helm chart next to your existing OpenShell gateway, and nothing about your agents changes.

AI agents are starting to do real work on their own: calling AI models, using tools, browsing the web, touching company systems. OpenShell, an open-source project from NVIDIA, gives each agent its own sandbox. OpenBox for OpenShell adds the one thing a sandbox does not provide: a verdict on everything the agent sends out. Allowed requests go out, risky ones wait for a person, and every step is recorded.

It ships as two small services that plug into the OpenShell gateway. The services are written in Rust, built for NVIDIA OpenShell v0.1.8, and distributed as a container image and Helm chart 0.2.0.

Why a sandbox is not enough

A sandbox stops an agent from damaging the machine it runs on. It does not judge what the agent sends out. That judgement is the gap OpenBox for OpenShell closes.

Companies want agents to do useful work: research, write code, process invoices, answer customers. To do any of it, an agent has to reach the world, and each reach is a moment where something can go wrong. This is why runtime enforcement comes before compliance:

โ— Data leaving. An agent pastes customer data into an outside service.

โ— Actions without sign-off. An agent makes a payment or deletes records that a person should have approved.

โ— No record. Afterwards, nobody can say exactly what the agent did, in what order, and why it was allowed.

โ— Agents nobody knows about. Sandboxes get created and forgotten, running with no oversight.

A sandbox solves a different problem. It keeps the agent off the rest of the computer; it does not weigh what the agent sends out, which is the judgement OpenBox adds. Logging is not AI governance, because a log tells you what happened after it already happened.

A building with a guarded exit

The simplest way to picture it: OpenShell is the building, and it gives every agent its own locked room, the sandbox. OpenBox is the governance platform where a company writes its rules for AI and reviews what agents did. This project connects the two with two components, each named after its job.

The door guard. It stands at the exit of every room. Each time an agent tries to send something out, the guard describes it to OpenBox, gets a verdict, and opens the door only if the answer is yes. When the reply comes back, it writes that down too.

The front desk. It signs every room in and out. No room opens without being governed, nobody can quietly remove the guard from a room, and the register of rooms is always current.

What happens to one request

Every outbound request follows the same path: the agent hands it to the door guard, the door guard asks OpenBox Core for a verdict, and the door opens, stays shut, or waits for a person. In order:

1. OpenShell hands the outgoing request to the door guard before sending it anywhere.

2. The door guard works out what kind of request it is: a call to an AI model, a tool call, or a plain web request.

3. It records the step in the sandbox's session in OpenBox and asks OpenBox Core for a verdict, all within a 29-second budget, so the answer always beats OpenShell's 30-second limit.

4. The verdict becomes go or no with a reason code. A halt also stops the whole sandbox.

5. When the response comes back, the door guard records it and closes that step in the session.

A door guard decision log reads one line per decision (illustrative, not real traffic):

openbox: eval sandbox=research-bot dest=api.openai.com   decision=allow ms=412

openbox: eval sandbox=research-bot dest=pastebin.com   decision=deny 
reason_code=openbox_blocked

openbox: eval sandbox=finance-bot  dest=payments.internal decision=deny  reason_code=openbox_approval_required

openbox: eval sandbox=finance-bot  dest=payments.internal decision=allow  
# same request, after a person approved

openbox: eval sandbox=scraper-07   dest=203.0.113.9   decision=deny 
reason_code=openbox_halted   # sandbox stopped

The verdicts, and the safe default

OpenBox returns a verdict for each request, and when it cannot answer in time the answer is no. The verdicts come straight from your OpenBox governance decisions, the same rules you already manage.

Verdict

In plain words

What the agent receives

ALLOW

Fine, go ahead.

The normal response

CONSTRAIN

Go ahead; the request is rewritten to meet the constraint (redact, narrow, or strip headers).

The response to the rewritten request

CONSTRAIN FAILED

A constraint that cannot be met; the request does not go out.

HTTP 403 openbox_constrain_failed

BLOCK

Not allowed. The rule's reason is logged.

HTTP 403 openbox_blocked

APPROVE

A person must say yes first. Once they do, the agent sends the same request again and it goes through.

HTTP 403 openbox_approval_required, then the normal response on retry

HALT

Something is badly wrong: stop this agent entirely.

HTTP 403 openbox_halted; the sandbox is shut down

NO ANSWER

OpenBox did not reply in time. We assume no, never yes.

HTTP 403 openbox_unavailable

PENDING

Still deciding: the default when OpenBox Core takes more than 2 seconds.

HTTP 403 openbox_pending; the identical retry gets the verdict

RESPONSE BLOCKED

A response carries a secret, under responses: block. The request went out; its response is not delivered.

HTTP 403 openbox_response_blocked

Approval works as refuse, then retry. OpenShell cannot keep a request waiting while a person decides, so the first attempt is refused with a clear reason and the identical retry passes once approved. This is human-in-the-loop made enforceable rather than advisory.

What it does, from plain to technical

Here is what it does, each stated two ways: plainly, then for a devops or security reader.

A verdict on every outbound request

Before anything leaves an agent's sandbox, OpenBox decides whether it may.

For technical readers: Registered as OpenShell supervisor middleware; every egress request (model calls, MCP tool calls, HTTP) is classified and evaluated by OpenBox Core before it is forwarded.

Governance that cannot be switched off from inside

Every new sandbox is governed automatically, and nobody can quietly remove the checkpoint.

For technical readers: A gateway interceptor attaches OpenBox to each sandbox at create time and refuses policy or provider-profile changes that would remove or bypass it.

A readable record of every session

Each sandbox is one session in the OpenBox dashboard: the prompts, each model call, each tool used and each request, in order, with what went in, what came out and how long it took.

For technical readers: Spans per activity, opened and closed by the door guard; the session is opened and closed by the front desk with the sandbox lifecycle.

Content stays inside by default

Core sees a hash of each prompt and body and the kinds of sensitive data found, not the content itself. Sending the text is opt-in, per host if you like.

For technical readers: Since the data-minimisation default, OpenBox Core receives hashes and findings by default, not content; a per-host setting opts in to sending text (docs/install.md, What Core receives).

No stalls when OpenBox Core is slow

If Core takes more than 2 seconds, the agent is told it is pending and the identical retry collects the verdict, so work is not blocked.

For technical readers: openbox_pending is the default once Core passes 2 s; the door guard can also answer from local rules or reuse a verdict for an identical request (fast-path verdicts).

Tamper-evident evidence

Turn on signing, and OpenBox writes a tamper-evident record of every verdict that anyone can check independently.

For technical readers: With a signing key, the door guard writes a signed, hash-chained record of every verdict, verifiable by anyone with the public key alone (openbox-evidence).

An inventory of every sandbox

A live list of every AI sandbox that exists, so nothing runs unseen.

For technical readers: The front desk registers each sandbox in the OpenBox AI Inventory and reconciles against the gateway, so the list stays correct even after missed events.

Human in the loop

Risky actions wait for a person to approve them instead of happening silently.

For technical readers: REQUIRE_APPROVAL returns a deny with openbox_approval_required; approval state is shared across door guard replicas through Redis, so the identical retry passes on any replica.

Safe when things break

If OpenBox cannot answer in time, the request is refused with a clear reason. It is never waved through by accident.

For technical readers: Fail-closed by default with a 29 s evaluation budget inside OpenShell's 30 s middleware timeout; a documented break-glass procedure exists for outages.

Tamper-evident sealing is the same attestation and cryptographic proof OpenBox applies across the platform, which is why AI governance needs proof, not logs.

Under the hood

Two Rust services and a shared store run beside the gateway. The door guard gives the verdict on every outbound request and records every response; the front desk governs sandbox creation and policy changes and keeps the inventory current; Redis lets every door guard replica see the same approvals.

Component

Job

Ports and failure mode

Door guard

Verdict on every outbound request; records every response; stops halted sandboxes.

:50051 gRPC; 2+ replicas; fails closed

Front desk

Governs sandbox creation and policy changes; opens and closes sessions; keeps the inventory current.

:50061 and :50062; governing fails closed; recording fails open and catches up

Shared store

Redis, so every door guard replica sees the same approvals.

Redis; on failure a retry may need reapproval

Identity. The door guard signs in to OpenBox with the agent's own cryptographic identity, a workload key, and talks to the OpenShell gateway over mutual TLS.

Observability. Prometheus metrics and health checks on the door guard, OpenTelemetry traces, and forwarding to a company's SIEM.

Coverage. HTTP requests, AI model calls, MCP tool calls, and the WebSocket upgrade request. Raw TCP, hosts marked tls: skip, and WebSocket messages after the upgrade get an allow or deny by host and port only, without a per-request verdict.

Operations. A runbook covers metrics and alerts, slow verdicts, outages, halts and a break-glass mode.

What sets OpenBox for OpenShell apart

Most AI governance tools watch agents after the fact, or guard the model alone. OpenBox for OpenShell enforces at the sandbox exit: it decides on every outbound request before it leaves, covers the whole egress surface, and cannot be removed from inside the box. Four differences carry the market case.

Enforcement before egress, not observation after. The verdict happens before the request leaves the sandbox, and fail-closed means no verdict is a refusal. Governance starts where monitoring ends: a log tells you what already happened, a checkpoint decides what is allowed to happen.

The whole egress surface, not just model calls. OpenBox evaluates model calls, MCP tool calls, HTTP and the WebSocket upgrade request. A model-level guardrail governs the model's input and output, and an LLM gateway sees provider calls; neither covers the tool and web actions an agent takes on its own.

Governance that cannot be switched off from inside. The front desk attaches the checkpoint to every sandbox at create time and refuses any policy or provider-profile change that would remove or bypass it. An in-agent SDK depends on the agent keeping it; this does not.

Provable evidence, not logs. Turn on signing, and every verdict is written to a signed, hash-chained record that anyone can verify with the public key alone. For a regulated buyer, that is a record you can prove, not one you hope held.

Where each approach governs, and when it acts:

Approach

What it governs

When it acts

Removable from inside the agent?

Logging and observability

Activity records

After the action

Records only; it does not stop anything

Model-level guardrails

The model's input and output

At the model call

Tool and web egress are outside its scope

LLM gateway

Model and provider calls

At the model call

Tool, web and MCP egress are not covered

In-agent governance SDK

What the agent chooses to report

Inside the agent

Yes; it depends on the agent keeping it

OpenBox for OpenShell

Every egress request: model, MCP tool, HTTP, WebSocket upgrade

Before the request leaves the sandbox

No; enforced at the gateway, it cannot be removed from inside

It also runs where the agents run. The two services sit beside your OpenShell gateway, the door guard signs in with the agent's own workload identity over mutual TLS, and governance evidence forwards to your SIEM. One set of OpenBox policies, the rules a company already manages, covers every sandbox, with no agent or image changes and one Helm chart to install.

How a team switches it on

There are no changes to the agents, their sandbox images or the commands people already use. An ops engineer installs one package next to the existing OpenShell gateway, gives it the agent's credentials from the OpenBox dashboard, and adds three short blocks to the gateway's config.

# install next to the OpenShell gateway

helm install openbox oci://ghcr.io/openbox-ai/charts/openbox-openshell \

  --version 0.2.0 -n openbox -f openbox-values.yaml \

  --set-file gateway.publicKey=<public_key_path>

 

kubectl -n openbox wait --for=condition=Available deploy --all --timeout=3m

# then add the three printed TOML blocks to the gateway config and restart it

Prerequisites: an OpenShell v0.1.8 gateway on Kubernetes, an agent with a workload identity in OpenBox, cert-manager (or your own certificates), Redis, and Helm 3.8 or later.

Who it is for

Four readers ask four different questions. Here is where each should start.

Security leaders ask, can I prove what our agents did, and stop them when needed? Lead with fail-closed verdicts, halt, governance that cannot be removed from inside, tamper-evident sessions, and SIEM forwarding.

Platform and devops teams ask, what does it cost me to run? Lead with one Helm chart, no changes to agents or images, two Rust services, Prometheus metrics, a runbook and a break-glass mode.

Compliance and risk ask, is there a record, and who approved what? Lead with one readable session per sandbox, human approval for risky actions, the AI Inventory, and sealed evidence.

AI engineers building agents ask, will this break my agent? Lead with nothing changing in the agent, refusals that are clear HTTP 403s with reason codes, and approval that is a simple retry.

The same egress checkpoint is why MCP tool poisoning is governable here: a poisoned tool call is still an outbound request, and it still gets a verdict.

Why self-hosted, exit-path governance is the right model

โ€œA sandbox keeps an agent off the machine it runs on, but it never judges what the agent sends out. OpenBox for OpenShell puts that judgement on the exit path: every outbound request gets a verdict from your own policies before it leaves, and if we cannot answer in time the request is refused, not waved through. Each sandbox becomes one sealed, readable session, so a regulated team can prove what an agent did instead of hoping the logs line up. Nothing in the agent changes, and the checkpoint cannot be removed from inside the box.โ€

Tahir Mahmood, Co-founder and CTO, OpenBox AI

Frequently asked questions

Does OpenBox for OpenShell slow agents down?

Each request waits for a verdict, so there is some added time per request. Most of it is OpenBox evaluating the company's rules. When OpenBox Core takes more than 2 seconds, the agent gets openbox_pending and the identical retry collects the verdict, so work is not blocked. There is still a hard cap: if no verdict arrives inside the 29-second budget, the request is refused.

What happens if OpenBox is down?

Requests are refused with the reason code openbox_unavailable, so nothing slips through unchecked. Teams run two or more door guards so one failure does not stop work, and there is a documented break-glass mode for real outages.

Do developers need to change their agents?

No. Agents, sandbox images and the openshell commands stay the same. The only new thing an agent may see is a refusal with a clear reason, and for approvals, retrying the same request after a person says yes.

Can an agent turn the checks off?

No. The front desk refuses any change to a sandbox's policy that would remove or weaken the OpenBox checkpoint.

Where do the rules come from?

From OpenBox, the same place a company already manages its AI policies, guardrails and approvals. One set of rules covers every sandbox.

Is the record trustworthy?

With signing on, the door guard writes a hash-chained record of every verdict, verifiable by anyone with the public key, so a later change is detectable.

About OpenBox

OpenBox is an AI agent governance platform that provides trust scoring, behavioural guardrails, policy enforcement, real-time monitoring and cryptographic audit trails. It wraps the agents enterprises already run, across frameworks, and governs them at runtime through the guardrails and policies a company already manages. OpenBox was co-founded by Asim Ahmad and Tahir Mahmood. OpenBox for OpenShell extends that model to NVIDIA OpenShell sandboxes, and joins the OpenBox AWS Marketplace launch in bringing runtime governance to where agents actually run.

Sources

1. openbox-openshell repository, OpenBox AI. github.com/OpenBox-AI/openbox-openshell. Accessed 19 November 2026.

2. OpenBox documentation, OpenBox. docs.openbox.ai. Accessed 19 November 2026.

Trustworthy AI
Starts Here

By submitting your email, you agree to our Privacy Policy and consent to receiving updates from us

Trustworthy AI
Starts Here

By submitting your email, you agree to our Privacy Policy and consent to receiving updates from us

Trustworthy AI
Starts Here

By submitting your email, you agree to our Privacy Policy and consent to receiving updates from us

Trustworthy AI
Starts Here

By submitting your email, you agree to our Privacy Policy and consent to receiving updates from us