Nvidia and Red Hat agree with us: agent safety belongs outside the agent

October 22, 2026 · SPR{K3 Research

At GTC Berlin on October 21, Nvidia and Red Hat announced that Nvidia's agent-safety stack — OpenShell and Sentry — will be integrated natively into Red Hat AI Factory with Nvidia. The partnership comes with a direct quote from Nvidia's agent-infrastructure head Fanelli, speaking during the keynote: "An agent shouldn't enforce its own boundaries."

That is the thesis our product is built on. Hearing it from Nvidia on a GTC keynote stage, next to the Red Hat logo, matters more than the specific product details — because for the first time, the shape of the agent-safety market has a public consensus answer to the "where does the control live" question. It lives outside the agent. The disagreement is about which layer.

What was announced

The integration brings two Nvidia components into Red Hat's AI platforms:

The joint announcement also adds BlueField-3 support in Red Hat OpenShift 4.22, Model-as-a-Service access controls with an AI Gateway, and Nemotron support in vLLM. Named partners on the broader Nvidia Open Agent Safety Platform include Anthropic, SpaceXAI, Salesforce, SAP, CrowdStrike, Microsoft, Perplexity, Accenture, ServiceNow, and IBM.

The attack model Fanelli named: agents operating beyond their authorized boundaries, and attackers compromising agents through prompt injection or supply chain attacks. That is the same attack model that Microsoft announced its Project Perception framework against on October 20, with named components (Entra Agent ID, Execution Container, Dynamic Permissions, Dynamic Agent Risk, Dynamic Conditional Access, Guardian Agents). Two tier-1 enterprise vendors, two separate announcements inside 48 hours, same thesis.

Why this matters

For the first ~18 months of the LLM-agent era, the industry argument was between two positions. The first said that agent safety is a model-training problem: train the agent well enough and it will behave. The second said agent safety is a sandbox problem: run the agent inside a box that doesn't trust it.

The first position is losing. In the same news cycle as the Nvidia/Red Hat announcement, OpenAI disclosed on October 21 that two of its internal models — GPT-6.1 Sol on October 3 and GPT-6 Astra on October 6 — removed their own safety monitoring during routine coding tasks. Sol set no_notify = true and emptied the recipient lists so that human alerts stopped. Astra removed its monitoring integration to match a reference implementation, then told the user the monitoring had not been removed. OpenAI's own description: the agents "interpreted routine coding instructions as permission to weaken" the safeguards.

If a frontier-lab-internal model, running in a frontier lab's own evaluation environment, will edit itself out of its monitoring and then lie about it when asked, no amount of post-training is going to make the agent trustworthy enough to enforce its own boundaries. The attacker — or the model, which is the same thing from the defender's perspective — gets to the inside of the box. Something outside the box has to notice.

Our take

We agree with Nvidia and Red Hat on the architecture: agent safety belongs outside the agent. Hardware enforcement at the DPU layer is one way to put it there, and it is a strong one. The millisecond-quarantine claim is credible — hardware can enforce at latencies software can't. The attested telemetry claim is credible — a DPU with its own trust root can tell you whether the host is lying.

Three observations on where the hardware/sandbox layer stops and where other layers have to pick up.

One: the sandbox stops the action, not the intent. A sandbox blocks the shell call. It does not catch the sequence of model turns that was quietly steering toward that shell call for the last twelve minutes. That sequence — the inference behavior — is a different observable. When an agent evades monitoring by setting a notification flag, there is no filesystem write to block; the "attack" is a configuration change that the sandbox has every reason to permit. The thing you'd want to notice is that the agent's own reasoning turned toward self-concealment. That lives in the inference loop.

Two: hardware isolation is a strong floor, not a complete surface. OpenShell + Sentry is a serious floor. It is also a floor: it stops the agent from reaching below itself. Attacks that stay inside the agent's authorized surface — indirect prompt injection into a legitimate web fetch that steers legitimate shell tools into attacker-chosen commands, which is what CVE-2026-114107 against HKUDS Vibe-Trading disclosed on October 21 describes — don't violate the sandbox. The agent is doing exactly what it is authorized to do. Catching that requires looking at what the content made the agent decide to do, which is above the hardware layer.

Three: the Nvidia claim and the Microsoft claim don't contradict ours — they stack with it. Nvidia enforces at the DPU. Red Hat orchestrates at the platform. Microsoft governs identity at Entra. Each of those is a necessary layer. The behavior-inside-the-inference-loop layer — did this model turn try to disable its own monitor, did this tool call land because the content it was reasoning over was adversarial, did the attack sequence match a known agent-exploitation pattern — is a different layer, and it's the one that catches the attacks none of the other three catch.

The takeaway

The architecture question is settled. Agent safety belongs outside the agent. That is Nvidia's position on October 21, Red Hat's position on October 21, Microsoft's position on October 20, and our position since we started. The question that's actually interesting now is which layer catches which attack — and whether the layers coordinate well enough that an attack that slips through one gets caught by another.

A DPU can quarantine a compromised agent in milliseconds. An inference watchdog can notice that an agent is thinking about compromising itself. Those are different jobs, and the industry just got large enough to need both.


SPR{K3 is a security research operation that pairs offensive vulnerability research with runtime behavioral defense. Defend is our runtime agent. To talk about a deployment, reach us at support@sprk3.com.