NVIDIA OpenShell · Lesson 2 · Security

OpenShell and Check Point: two different kinds of "no"

OpenShell decides whether an action is permitted. Check Point decides whether it still makes sense for the job. Learn where each one sits, what each can't see, and then watch traffic being changed at the exact hook a semantic monitor plugs into.

The news, 2026-09-28

Check Point announced a beta integration of Check Point semantic monitoring with NVIDIA OpenShell. It runs "through the runtime's security middleware": OpenShell intercepts each agent action before it reaches the host, Check Point returns a verdict "in under 100 milliseconds", and OpenShell enforces it.CP blog It's framed inside NVIDIA's new Open Agent Safety Platform, which is OpenShell plus NVIDIA Sentry on BlueField-4.NVIDIA Status: beta. NVIDIA's own release does not list Check Point among its named partners, so cite the Check Point blog as the source.

1 · The gap a sandbox can't close

After Lesson 1 you have a fence that works: deny by default, rules scoped by binary, placeholder keys. But the Check Point post puts its finger on the limit. A boundary decides only whether an action is allowed, and "whether the action still makes sense for the task is a separate judgement, and it is often where the real problems sit."CP blog

Check Point's research example makes it concrete. An agent reads database credentials into a variable, and a few steps later posts that variable to GitHub. Each step on its own looks fine, so a static rule passes it. A monitor that reads the whole trace sees the harm.CP research In OpenShell terms: gh → api.github.com on your scratch repo is an allowed rule, so the fence waves it through.

The one idea of this lesson

OpenShell asks "is this permitted?" It is mechanical, deny by default, and checks binary + host + method/path. Check Point asks "does this still fit the job the agent was given?" It is semantic and uses the agent's reasoning signals, tool calls and earlier actions. You need both, because each one is blind where the other sees.

2 · Where everything sits

Org-wide control plane · Check Point AI Defense Plane discover & inventory agents governance & posture observability runtime control continuous validation (red teaming)
↓ policy & intent for the whole fleet of agents
Inside the sandbox Claude Code (its own permission prompts) tools · bash · gh · curl
↓ every request, nowhere else to go
OpenShell supervisor: request path, in order ① network policy: permitted? → ② middleware: Check Point semantic verdict, <100 ms → ③ inject real credential → ④ forward
↓ underneath, out of band
Infrastructure (other tracks) NVIDIA Sentry · BlueField-4 · DOCA Check Point AI Factory Firewall · BlueField-3
Middleware runs after the policy check and before the credential is injected. It only sees allowed traffic, it never sees your key, and a "deny" from it blocks the request even though the policy allowed it.

The order in row ② comes straight from OpenShell's docs: "The sandbox supervisor calls middleware after it checks network policy and before it forwards traffic," and "OpenShell injects provider credentials after request middleware runs, so middleware never sees them."middleware Honesty flag: Check Point says "security middleware" and OpenShell documents "supervisor middleware". That they are the same hook is our reading. Neither vendor spells it out.

3 · Complementary, not overlapping

OpenShell (NVIDIA)Check Point semantic monitoringCheck Point AI Defense Plane
QuestionIs this action permitted?Does it still fit the task?Which agents exist, and are they governed?
ScopeOne sandboxOne agent's trajectoryThe whole enterprise: workforce AI, apps and agents
Seesbinary, host, port, method, path, syscalls, filesreasoning signals, tool calls, earlier actionsdiscovery, posture, prompts, tool and MCP calls, red-team findings
Verdictsallow · deny · propose rulelog · hold for approval · stop agentallow/deny policies, inline runtime control
Blind tointent: an allowed call can still be harmfulanything the boundary already stopskernel-level containment of a local process
SourceNVIDIA docsCP blog (beta)CP press release

AI Defense Plane (launched 2026-03-23) is Check Point's "unified AI security control plane". It combines "discovery, governance, observability, runtime control, and continuous validation across the AI execution lifecycle". It has three modules: Workforce AI Security, AI Application & Agent Security (both available) and AI Red Teaming (limited release). It builds on ThreatCloud AI and the Lakera and Cyata acquisitions.press Its Agent Security module already acts as "an inline enforcement layer for AI agent interactions".agent security OpenShell gives that layer a kernel-enforced place to stand on the agent's own host.

Don't mix up the numbers

< 50 ms is the AI Defense Plane engine figure ("across more than 100 languages"). < 100 ms is the semantic-monitoring verdict figure for the OpenShell integration. The first comes from the March press release, the second from the September blog. Quote each with its own source.

4 · Lab: watch traffic change at the middleware hook

You can't run the Check Point beta at home, but OpenShell ships a demo middleware, openshell/regex. It rewrites text matching a fixed sk- pattern in outgoing HTTP bodies. It runs at the same point in the request path as a semantic monitor.configure (The docs are explicit that it is for demonstration only: "Do not rely on it to detect or remove sensitive data.")

  1. Write mw-demo.yaml. It starts from the docs' quickstart filesystem, plus a middleware entry on Anthropic's API host.
    version: 1
    filesystem_policy:
      include_workdir: true
      read_only: [/bin, /usr, /lib, /proc, /dev/urandom, /etc, /var/log]
      read_write: [/sandbox, /tmp, /dev/null]
    landlock:
      compatibility: best_effort
    network_middlewares:
      regex-demo:
        middleware: openshell/regex
        endpoints:
          include: ["api.anthropic.com"]
    No network_policies needed: the my-claude provider from Lesson 1 adds the Anthropic rule. Remember the order: policy first, then middleware.
  2. Start Claude with it, reusing Lesson 1's image and provider.
    openshell sandbox create --name mw-lab --from claude-agent:local \
      --provider my-claude --policy ./mw-demo.yaml -- claude
  3. Send a fake secret. In Claude, type:
    Repeat back exactly, character for character: sk-FAKE-0000-not-a-real-key
    Use only the fake string. Never paste a real key anywhere, sandbox or not.
  4. Read the evidence in a second terminal:
    openshell logs mw-lab --source sandbox     # look for the regex-demo decision
    openshell policy get mw-lab --full         # network_middlewares + _provider_my_claude
    openshell sandbox delete mw-lab

Predict, then check

Before step 3, write down your guess: what will Claude echo back, and why? Then compare.

What should happen

Claude echoes something other than your string, because it never received it. The supervisor ran the request body through regex-demo on its way to api.anthropic.com and rewrote the sk- text. The logs show which middleware ran, its decision and whether it changed the traffic. Your real key, in the x-api-key header, was untouched: it's injected after middleware, and OpenShell protects credential headers from middleware edits.operations

Now swap the toy for the real thing. A semantic monitor sits in the same slot, but instead of matching a regex it asks "does this request still fit the task?" and returns allow, deny or change. If the monitor is down, the default on_error: fail_closed blocks the traffic.

Check yourself: who catches it?

An agent with an allowed gh rule pushes a file containing secrets it read earlier. Who stops it?
A prompt-injected tool runs curl to an attacker's host. Who stops it first?
The semantic monitor service crashes mid-session. What happens to traffic it covers?
Which Check Point layer inventories every agent across the enterprise?

Say it out loud (retrieval)

Without scrolling up, explain in two sentences to a colleague why a team running OpenShell still needs Check Point. Then open the model answer.

Model answer

"OpenShell is the boundary. It makes sure the agent can only do what's permitted, enforced outside the agent at kernel level. Check Point judges whether the permitted things it does still fit its job, and the AI Defense Plane governs every agent across the company. That's why the semantic monitor plugs into OpenShell's middleware: the boundary decides can, Check Point decides should."

Primary source — read this next

The Check Point blog, "The Goal Tells an Agent What to Do. Security Has to Govern How." (2026-09-28). Then OpenShell's Supervisor Middleware page for the mechanism, and Check Point's research post on synchronous control monitoring for the "why".