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.
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.
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.
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.
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.
| OpenShell (NVIDIA) | Check Point semantic monitoring | Check Point AI Defense Plane | |
|---|---|---|---|
| Question | Is this action permitted? | Does it still fit the task? | Which agents exist, and are they governed? |
| Scope | One sandbox | One agent's trajectory | The whole enterprise: workforce AI, apps and agents |
| Sees | binary, host, port, method, path, syscalls, files | reasoning signals, tool calls, earlier actions | discovery, posture, prompts, tool and MCP calls, red-team findings |
| Verdicts | allow · deny · propose rule | log · hold for approval · stop agent | allow/deny policies, inline runtime control |
| Blind to | intent: an allowed call can still be harmful | anything the boundary already stops | kernel-level containment of a local process |
| Source | NVIDIA docs | CP 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.
< 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.
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.")
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.openshell sandbox create --name mw-lab --from claude-agent:local \ --provider my-claude --policy ./mw-demo.yaml -- claude
Repeat back exactly, character for character: sk-FAKE-0000-not-a-real-keyUse only the fake string. Never paste a real key anywhere, sandbox or not.
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
Before step 3, write down your guess: what will Claude echo back, and why? Then compare.
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.
Without scrolling up, explain in two sentences to a colleague why a team running OpenShell still needs Check Point. Then open the 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."
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".