A Passport and a Visa for Every AI Agent: SecureW2 Brings Identity and Management to NVIDIA OpenShell

While NVIDIA OpenShell confines AI agents inside secure sandboxes, enterprises still need to verify which agent is calling, whose authority it holds, and how to revoke access immediately if anomalies arise. SecureW2 provides the missing identity and authorization layer alongside OpenShell—issuing each sandbox a cryptographic SPIFFE identity ("passport") tied to a human owner and exchanging it for short-lived, narrowly scoped OAuth tokens ("visas") on outgoing calls. Through the Agent Control Manager and Agentic Control Portal, security teams gain centralized visibility, automated policy enforcement, and instant kill-switch revocation without exposing credentials inside the sandbox.

SecureW2 pairs with NVIDIA OpenShell to give every AI agent a verifiable SPIFFE "passport" for identity and a short-lived, revocable OAuth "visa" for scoped tool access.

Agents have become part of our company’s internal work, not just something we look at for customers. Once agents are running on your own systems, three vital questions come up:

  • Which agent is calling?
  • Whose authority is it using?
  • How do you stop it when something looks wrong?

We recognize how important it is to have the answers to all three. That’s why SecureW2 supports the NVIDIA OpenShell Reference Architecture for Safe AI Agents.

OpenShell confines every agent in a sandbox. SecureW2 gives every agent (through its supervisor) inside that sandbox an identity of its own, and when possible, access that is short-lived, scoped and easy to revoke.

OpenShell Confines the Agent. Something Still Has to Say Who It Is.

NVIDIA OpenShell is open source. It confines an agent’s filesystem, processes and network egress with kernel controls and policy, and keeps credentials out of the agent’s reach.

While current solutions out there are being redesigned to fit agentic AI, OpenShell is the first ground-up attempt.

But OpenShell doesn’t supply identity. In an ideal environment, it consumes the open SPIFFE standard: each sandbox presents a SPIFFE identity, and OpenShell uses it when the agent needs a credential for a tool.

Someone has to issue that identity, tie it to a real person and stand behind it.

That’s the part SecureW2 provides.

We already issue certificate-based identity to users and devices on enterprise networks, and now agents are the newest addition.

SecureW2 Agent Control Manager runs next to OpenShell in your cluster and gives each agent an identity and a token. It also provides OpenShell with per-agent authorization policies. These policies determine which agent is allowed to do what, and more importantly, what agents aren’t allowed to do.

Only when agents make an outgoing call will the supervisor get a credential from us and stamp it on the request.

Why Not Do Both?

Some approaches to agent identity build on certificates, while others build on tokens. The philosophy SecureW2 has always brought to the table is: Why choose?

They do different jobs:

  • A certificate is built to prove who something is.
  • A token is built to record what it may do.

Identity is strong, authorization is flexible (and short enough to prevent it from doing harm long term).

SecureW2 and NVIDIA OpenShell: The Passport and the Visa

The diagram below explains the process:

A Diagram showing the process of how SecureW2 and NVIDIA OpenShell work together.

The passport is the agent’s identity. A person signs in with a client certificate that SecureW2 issues and starts an agent. Agent Control Manager gives that agent’s sandbox its own SPIFFE identity, issued only after Kubernetes confirms where the agent runs and records that person as the agent’s owner.

The visa is the agent’s access, and it is the owner’s to give. When the agent calls a tool, Agent Control Manager exchanges its passport for a short-lived OAuth token that it signs. The token says:

  • On whose behalf the agent acts
  • Which agent is acting
  • Which service the token is for
  • What it may do there
  • When the token expires

For example, one agent may read tickets; another may also edit them. The tool (an MCP server or an internal API) checks the token’s signature against our published keys and decides there and then, without calling back to SecureW2.

For outside services, each person links their own account once. The Agent Control Manager vault keeps that credential for their own agents only.

Inside the sandbox, the agent never holds a token. Before every outgoing call, OpenShell’s supervisor checks the kill switch and what that agent is allowed to do, then attaches the token. This ensures an agent never does more than it is allowed to, even when the token could, and a compromised agent has nothing worth stealing.

When Something Goes Wrong

You do not want to revoke an identity; you want to revoke its access. A signed token has a catch here: once issued, it stays valid until it expires, because the service never asks again. Short lifetimes keep that window to minutes, and what matters is how quickly you act within it.

Agent Control Manager allows an even faster reaction. It can immediately disable all http/websocket access for a specific agent, including inference (running the model itself), so the agent will immediately stop.

SecureW2 takes its risk signals from those tools. When one marks an agent as high-risk, its next visa is refused. It loses access within seconds, while its passport stays intact for the investigation and its owner keeps working. Since we provide a kill switch for agents, access doesn’t have to wait for a token to run out.

We revoke the visa, not the passport.

One Console for Every Agent

Administrators see every agent in one place: the SecureW2 Agentic Control Portal, in our cloud. It shows which agents are running, who owns them, what they may reach and what they’ve done. It’s also where you connect the risk signals that Adaptive Agent Defense acts on.

The Agentic Control Portal, where administrators see and manage their agents, shown with sample data.
The Agentic Control Portal, where administrators see and manage their agents, shown with sample data.

Built for Where Agents Actually Run

SecureW2 runs this design on Amazon EKS, with agents reasoning on various models through Amazon Bedrock, and it’s how we run our own agents. The identity and the token follow open standards (SPIFFE, OpenID Connect and OAuth token exchange), so any MCP server or API can check them with an ordinary library.

As agentic AI continues to rapidly evolve, it feels like the wild west, with dangerous consequences if we do not get this right now instead of later. SecureW2 brings dynamic to agentic AI. Whether better signals, better tokens or better PKI like PQC, whatever the future brings, we have your back.

Join the SecureW2 early access program for agent identity