Imagine giving an agent a project to inspect, then watching it propose sending a file to an outside service. The useful question is who can refuse that move. Nvidia’s Open Agent Safety Platform puts permission enforcement outside the agent’s conversation, combining OpenShell’s runtime controls with a separate Sentry watchdog design. The two components intervene in different ways, so following the proposed request is a good place to begin.

OpenShell controls what an agent can reach

OpenShell places the workload inside a sandbox. Nvidia’s technical description separates the gateway that manages policies from the supervisor checking outbound requests. The sandbox restricts files and processes, with network access mediated outside the workload. A page can try to persuade the model to send a file. The proposed transfer still has to meet a policy controlled elsewhere.

The interesting case is a request that sounds helpful. Suppose a task permits reading a project and contacting one service. The agent decides another destination would make the work easier. A narrowly configured policy can refuse the new route even while the agent continues proposing it. Sandboxing supplies that kind of process boundary. Whether the task can finish within it is a separate part of evaluating the setup.

Sentry moves a watchdog beyond the agent’s host

The second part, Sentry, is a reference design for monitoring agents on Nvidia’s BlueField-4 data processing unit. Nvidia says the separation lets the watchdog detect and quarantine suspect activity in milliseconds, with Vera CPU support planned in the platform architecture. That timing and protective effect are vendor claims. Sentry is presented as a reference design, while OpenShell is available as an open-source runtime. Readers should not treat an announced design as a broadly deployed security service.

Separate observation becomes useful when a process inside the host can affect its own records or checks. A watchdog outside that environment gives oversight another point from which to act. To judge the benefit, ask which activity it sees, what triggers quarantine and what an operator can inspect afterward. Those details determine whether an intervention can be understood and the work safely resumed.

Test the refusal beside the legitimate task

TechCrunch’s launch report notes that OpenShell predates the combined platform announcement. The new proposition is the pairing of runtime restrictions with separate monitoring hardware. AP’s account records Nvidia’s argument that this could have stopped earlier rogue-agent incidents. Those counterfactual claims depend on the exact incident and policy, neither of which is established by a launch demonstration.

For a proposed small-task evaluation, record the permitted files, destinations and operations before the run. Introduce an out-of-scope request, inspect which policy refuses it, then check whether the legitimate task still completes. Finally examine a mistaken request that remains inside the allowed route. These observations separate enforcement, task usefulness and permitted-but-wrong behavior without claiming that Newsroom ran the test.

A credential and a watchdog answer different questions

An instruction tells the model what to do. A runtime permission decides whether a process can carry out a proposed action. The distinction is especially useful for credentials: a task may need an authenticated request without giving the workload a reusable key for unrelated destinations. Nvidia describes keeping real credentials outside the workload and binding their use to authorized requests. The practical question is what authority each permitted route actually provides.

Sentry adds observation and intervention beyond the agent’s host. It complements the permissions that narrow the task at the start. Consider a policy that allows far more than the job needs: the watchdog has a larger space of permitted behavior to judge. Restrict everything and the task may become unusable. A workable configuration needs both a useful job and a record that explains why an intervention occurred.

For example, a policy might allow an agent to read a shared service while the task needs only one record. Retrieving the wrong record can still be a mistake within that permission. The runtime can enforce an access rule, while task design and review address whether the allowed request was appropriate. Keep both questions in the evaluation so a successful refusal does not hide an error elsewhere in the work.

Ask to see the intervention and its cost

Ask for an evaluation that names the task and permitted resources, introduces the adversarial material and shows the exact intervention. Then look for false alarms, unfinished legitimate work and added latency. These are different costs. A system that blocks a transfer while preserving the ordinary task offers a more informative result than a broad claim that the agent is secure.

For a first comparison, keep the task fixed and change one permission. Record the allowed request, the refused request and what the agent does next. OpenShell’s available code gives technical teams a route to inspect that behavior. Sentry’s separate-hardware design needs its own evaluation. The question to carry into either is specific: which decision stopped this action, and can the operator show the record?

FAQ

How do OpenShell and Sentry differ in this article?

OpenShell applies configured task policy outside the agent workload. Sentry is described as a separate hardware watchdog design with its own claims to evaluate.