Back to Home

OpenShell's Credential Split: Agents Can't See the Keys

Most agent security pitches still end with a model that refuses nicely. The OpenShell story that Red Hat engineers told at KubeCon + CloudNativeCon North America on November 11 ends somewhere less comfortable: with a network that drops traffic by default and a credential the agent never gets to hold.

Derek Carr, a senior distinguished engineer at Red Hat, and Mrunal Patel, a distinguished engineer, walked through the design in a theCUBE interview. Their trigger was not a benchmark gap. It was the pattern of prompt injection reports followed by quiet data exfiltration, where an agent with legitimate access gets talked into using it against its own operator.

What deny-by-default actually constrains

OpenShell is a sandboxed runtime built around a supervisor that sits outside the agent process. The agent runs unprivileged, its syscalls are filtered in the kernel, and there is no direct network path out. Requests leave through one brokered channel, and the supervisor evaluates each one at binary, destination, method, and path level before anything moves.

Carr's framing of the requirement was blunt. "Agents can't get access to your secrets," he said. "They need deny-by-default networking, and you need a rich policy framework for what happened and when for this class of apps."

The credential handling is the part worth slowing down for. An operator can grant an agent access to specific endpoints while the credentials for those endpoints stay hidden from the agent and scoped to that endpoint alone. The agent learns that a call succeeded. It never learns the token that made it succeed, and it cannot replay that token against a different host.

  • Network: egress is denied unless an endpoint is explicitly allowlisted, with protocol and method limits applied per rule.
  • Secrets: credentials are injected at the supervisor and never returned to the sandboxed process.
  • Scope: a credential is bound to one endpoint, so a redirect toward an attacker host fails closed instead of following the agent.
  • Authority: operators push policy updates live, without restarting the workload or rebuilding the image.

That set explains why the runtime keeps appearing next to hardware. In the reference architecture NVIDIA published in October, enforcement lands on BlueField-4 data processing units running Sentry, outside the host CPU that the agent's harness can reach. The runtime layer does the policy work. The DPU makes the policy unkillable from inside the workload, which matters when the workload is the thing you distrust.

The justification loop is the interesting control

Blocked actions in most stacks produce a line in a log and nothing else. OpenShell adds a policy advisor that asks the agent to explain, in plain language, why it wanted the action that was denied. The operator gets two artifacts side by side: what the runtime refused, and what the model said it was trying to do.

That pairing is more useful than it sounds. A denial on its own is ambiguous. It might be a harness calling the wrong tool, a user asking for something outside policy, or injected text steering the agent toward an internal endpoint. Stated intent gives the reviewer a first hypothesis, and repeated denials of the same shape suggest a rule is wrong rather than an agent is hostile.

The same loop is where the design gets slippery. The justification is produced by the model that was just blocked, and when the block came from injected content, the explanation can inherit that influence. Read it as testimony from an interested party, not evidence. It belongs in the audit trail beside the deterministic policy verdict, never above it.

From KubeCon demo to OpenShift default

Red Hat's stated goal is to make deploying an agent on OpenShift as routine as deploying an application. The pieces exist in varying states of maturity. OpenShell entered the CNCF Sandbox on November 10 after NVIDIA contributed it, the project has drawn 380 contributing organizations since its first commit in January, and Red Hat AI Factory with NVIDIA already lists agent support.

In practice that means a deployment where the agent workload ships with no egress, a supervisor handles brokered calls, and policy lives as a versioned object the platform team reviews. The agent image barely changes. The cluster configuration changes a lot, which is exactly where most pilots stall.

  • Inventory endpoints before enabling deny-by-default, because an incomplete allowlist becomes an outage rather than a warning.
  • Name the owner of policy revisions, since live updates let the runtime team widen an agent's reach without a code review.
  • Log every denial with the agent's justification attached, then sample them weekly for rules that fire far too often.

Underneath all of this is the capacity argument Carr kept returning to. Many companies are struggling to get one agent into production, let alone thousands or millions. A runtime with an enforceable boundary changes the review question from "will it behave" to "what is it allowed to reach", and that is the difference between a demo and a fleet.

The open question is not whether deny-by-default works. It is whether enterprises will do the inventory work that makes it safe. A deny rule with a sloppy allowlist is a slower outage, and a policy advisor that logs eloquent excuses is not a control until somebody reads them.

Comments

No comments yet. Be the first to share your thoughts!