Policy Enforcement — The Video Signal

Sep 28, 2026 · 5:30

How to Secure & Run AI Agents with NVIDIA OpenShell

NVIDIA OpenShell 0.1 provides a secure, governed runtime boundary for AI agents, preventing compromised agents from executing unauthorized actions. It allows developers to deploy agents—which are LLMs capable of tool calls and code execution—in a sandboxed environment where all components (tools, subagents, etc.) inherit consistent policy, credential, and audit controls from launch. The system supports live policy updates, delegated subagent controls, and multi-tenant deployments via Kubernetes.

Key takeaways

Runtime Boundary Enforcement
OpenShell creates a boundary around the agent that the agent cannot escape, similar to OS-level app restrictions. This prevents malicious actions, such as an agent attempting to upload private data to a public repository, even if compromised.
Policy Granularity and Control 2:00
Policies can be configured at the level of binaries, destinations, methods, and paths. The system supports reviewing and approving network requests in real-time, ensuring the agent only performs intended actions.
Multi-Tenant and Production Deployment 4:00
For large-scale production environments, OpenShell supports Kubernetes deployment (specifically OpenShift) and utilizes multi-tenant SDKs to manage sandboxes for multiple users and business units.

Watch on YouTube Full article

Sep 16, 2026 · 4:42

Middleware for Managed Deep Agents

Middleware is a mechanism for extending the lifecycle of Managed Deep Agents, allowing developers to implement custom behaviors such as policy enforcement, fault tolerance, and rate limiting. The demonstration covers two primary use cases: using prebuilt middleware (like `PIIMiddleware`) to redact sensitive data before it reaches the LLM, and building custom middleware from scratch using decorators like `wrap_tool_call` for logging and auditing tool usage.

Key takeaways

Middleware Functionality
Middleware extends the agent's lifecycle to manage behaviors like policy enforcement, fault tolerance, and rate limits when interacting with tools or the LLM.
PII Redaction Demo 0:01
Using prebuilt `PIIMiddleware` automatically detects and redacts sensitive information (e.g., customer emails) from the input, preventing the data from reaching the LLM or being stored in LangSmith.
Custom Middleware Development 0:03
Custom middleware can be built using decorators (e.g., `wrap_tool_call`) and hooks to intercept and log events, such as every tool call, at specific points in the agent's process.

Watch on YouTube Full article

Sep 2, 2026 · 49:34

Ask the Experts: How NVIDIA OpenShell Secures Autonomous Agents | Nemotron Labs

OpenShell is presented as a secure runtime environment designed specifically for long-running, autonomous AI agents that execute complex tasks like reading files and calling APIs. It moves beyond simple behavioral guardrails by enforcing strict isolation, identity, policy, and audit at the runtime layer. The system utilizes a Control Plane (Gateway) to manage policies and credentials, which then launch compute drivers (Docker, Podman, Kubernetes, VM) into isolated sandboxes where agent activity is strictly governed by declarative YAML policies.

Key takeaways

OpenShell Architecture 2:00
The architecture consists of a Control Plane (Gateway), which manages identity, lifecycle, and policies. This gateway launches compute drivers into sandboxes, where an internal supervisor enforces the defined security policies on the agent process.
Policy Granularity and Enforcement 4:00
Policies are set using declarative YAML configurations to enforce fine-grained control over resources (e.g., read/write access to specific file system paths) and network capabilities. The system can dynamically update policies in real time, ensuring the principle of least privilege is maintained.
Advanced Security and Robustness 22:00
To prevent agents from circumventing defined policies (breakout), OpenShell incorporates formal verification methods. The Policy Prover inspects the entire policy set to mathematically prove that no unintended access paths exist, even as complexity increases.
Defense in Depth (Swiss Cheese Model) 34:10
Security is achieved through layering. OpenShell can be combined with other tools and middleware—such as integrating a safety model (e.g., Mistral's ShieldStroll) into the policy engine—to create multiple, redundant layers of protection.

Watch on YouTube Full article

Aug 22, 2026 · 19:53

Give the Agent a Budget, Not a Token — Sachin Malhotra, Anthropic

The presentation argues that granting AI agents 'unbounded power' via simple tokens is dangerous. Instead of narrowing the token scope (a boolean fix), engineers must implement a comprehensive 'budget' system with four dimensions: how much, how fast, what can be undone, and who notices. Key solutions include using asymmetric verbs (prioritizing loud failures), enforcing rate limits on writes, implementing trip wires over static allow lists, and utilizing an 'undo test' to size the overall safety policy.

Key takeaways

Budget vs. Token 7:03
A token is a boolean (yes/no) scope; a budget is multi-dimensional, considering volume, velocity, reversibility, and observability. The failure was giving the agent unbounded power, not the model itself.
Asymmetric Verbs 10:05
Prioritize granting agents access to operations that fail loudly (e.g., unskipping a test, which causes CI to go red) and keep critical failure verbs (like skipping a test) reserved for human intervention with an audit trail.
Rate Limits & Trip Wires 13:54
Implement rate limits on every write operation, ensuring the ceiling refills automatically. Use trip wires (monitoring aggregate behavior) instead of static allow lists, as trip wires adapt to real-world data.
The Undo Test
This test asks if the agent can autonomously roll back its own changes and what the blast radius would be if it failed. If not, a second key (human involvement) and an audit record are required.

Watch on YouTube Full article

Aug 18, 2026 · 9:03

What Is the AI Security Trilemma? Smart, Fast, or Secure AI?

The AI Security Trilemma describes the inherent conflict in designing advanced AI systems: it is challenging to achieve high levels of intelligence (Smart), speed (Fast), and security (Secure) simultaneously. The core issue is that increasing a model's capability (e.g., giving it more tools or memory) expands its attack surface, while implementing robust security measures (like sandboxing or human oversight) introduces friction and latency.

Key takeaways

The AI Security Trilemma Defined
AI systems must balance three conflicting goals: Smartness (capability/reasoning), Speed (low latency/real-time action), and Security (preventing attacks like prompt injection). Sacrificing one often compromises the others.
Capability Increases Attack Surface 3:50
As AI agents gain abilities—such as memory, internet access, tool use (APIs), or sensor input/actuator output—the system becomes more powerful but also presents new pathways for attack.
Security Measures Introduce Friction 2:30
Implementing security controls like inspection, filtering, guardrails, sandboxing, and logging is necessary but inherently introduces friction, which slows the system down. This conflict makes achieving real-time safety difficult.
Mitigation via AI Security Proxies 7:00
A promising approach is implementing an AI security proxy—a policy enforcement layer placed outside the core model. This layer inspects inputs, sanitizes outputs, and controls tool permissions, allowing the model to remain smart and fast while externalizing the security function.

Watch on YouTube Full article

Aug 17, 2026 · 23:32

Policy Enforcement and Tamper-Evident Audit Chains | Imran Siddique | MCP Release Party - Seattle

This session introduces cMCP, an open-source gateway designed to enhance Model Communication Platform (MCP) security by enforcing policies and creating tamper-evident audit chains. While existing governance tools like the Agent Governance Toolkit (AGT) manage policy application, cMCP addresses the critical gap of ensuring that the governance mechanism itself—including policies and logs—cannot be tampered with. The solution leverages Confidential AI principles, running core components within hardware enclaves to guarantee verifiability for regulated industries.

Key takeaways

Beyond Governance: Verifiable Trust 17:22
The focus is shifting from merely having policies (governance) to proving that the governance itself has not been tampered with. This requires bringing critical elements into a confidential enclave, ensuring verifiable audit trails and policy integrity.
cMCP Gateway Functionality 6:30
cMCP acts as an open-source gateway wrapping any MCP server without requiring changes to the underlying system. It enforces policies (like Cedar) before every tool call and chains all actions into a tamper-evident record.
Standardized Audit Trail (Trace) 12:10
The concept of 'Trace' is being standardized to provide an absolute, verifiable record of system state, including the model ID, policy hash, machine state, and all actions taken. This verification relies on hardware guarantees.

Watch on YouTube Full article