AI agents are quickly moving from answering questions to taking actions: calling APIs, using credentials, modifying repositories, querying internal systems, and coordinating other agents. That creates a familiar security problem with a new twist. A sandbox can tell us what an agent is allowed to access. It does not necessarily tell us whether a particular action is consistent with what the agent intended to do.
Suppose an agent is allowed to access GitHub. That permission may be necessary for the task. But if the agent’s plan was to inspect an issue, should a later request to modify a repository be treated as equally valid just because the sandbox permits GitHub access?
That is the gap we wanted to explore with NVIDIA OpenShell. The result is a new ArmorIQ integration for OpenShell that adds intent-aware enforcement to OpenShell’s existing middleware path, without modifying the agent itself.
Github: https://github.com/armoriq/armoriq-openshell-middleware
Demo Part 1: Request-time intent enforcement through OpenShell middleware. [See it in action here]
Demo Part 2: Capture the model-selected plan on the response path, then enforce subsequent actions against it on the request path. [See it in action here]
OpenShell already gives us the right enforcement point
One of the most useful properties of OpenShell is that the agent does not need to own the security decision. The OpenShell supervisor already controls outbound communication from the sandbox and can invoke middleware before a request reaches its target. That gives us a clean enforcement path. The important architectural point is simple:
ArmorIQ decides. OpenShell enforces.
We do not need to introduce another proxy in front of the agent. We do not need to modify OpenShell’s sandbox model. And we do not need the agent to carry an ArmorIQ SDK. The agent remains unmodified. The integration simply adds another piece of context to an enforcement boundary that already exists.
Our prepared design follows exactly this model. The middleware intercepts traffic the way a proxy would, extracts the action from the request, and calls ArmorIQ’s existing /iap/sdk/enforce path for a decision. OpenShell remains responsible for stopping denied requests.
Step 1: enforce the action
The first demo shows the straightforward integration. When an agent makes an outbound request, OpenShell invokes the ArmorIQ middleware. For MCP traffic, the middleware can recover the actual tool invocation. For ordinary HTTP traffic, the middleware still has useful execution context such as:
We verified this against real OpenShell request structures. A real MCP tools/call body exposes the tool name and arguments while retaining the surrounding HTTP identity. A plain HTTP API call may not have a tool name, but can still be identified by binary, method, host, and path.
ArmorIQ evaluates the action and returns a verdict if the action is allowed or if the action is denied. The middleware never owns the connection. It returns a decision. OpenShell enforces that decision at the proxy boundary. That separation is exactly what we wanted.
The OpenShell supervisor remains the enforcement point; ArmorIQ provides the authorization logic.
But action-level policy is not yet intent enforcement
This is where the second demo matters. Checking whether a tool invocation is allowed by policy is useful. But policy enforcement alone does not answer the deeper question:
Was this action actually part of what the agent intended to do?
That distinction matters. An agent can make a request that is perfectly valid from the perspective of:
network policy,
sandbox permissions,
identity,
credentials,
and even tool-level authorization,
while still drifting away from the plan it originally formed. This is the difference between:
“Can the agent call this tool?”
and:
“Should the agent call this tool as part of this execution?”
The second demo adds the missing half.
Step 2: capture the plan, then enforce against it
OpenShell gives us another useful interception point on the response path. That allows ArmorIQ to observe the model-selected tool calls before the agent executes them. The two hooks now form an intent-continuity boundary.
The response path answers:
What did the agent decide it was going to do?
The request path answers:
Is what the agent is doing now consistent with that decision?
That is the key transition in this integration. Demo Part 1 shows that ArmorIQ can participate in OpenShell enforcement. Demo Part 2 shows that OpenShell can become plan-aware without modifying the agent. That is much more interesting.
Why this is different from ordinary authorization
Traditional authorization usually starts with identity to figure out if an agent can access a service. But the same agent may execute many different objectives over time. The infrastructure identity may be the same across all three. The justified authority may not necessarily be. That means agent security increasingly needs another dimension:
ArmorIQ calls this intent continuity. The goal is not just to determine whether a principal has permission. The goal is to preserve the relationship between:
why the agent is acting,
what it planned to do,
and what it actually attempts to execute.
OpenShell gives us a practical place to enforce that relationship.
Human approval still fits
Not every unexpected action should necessarily become a permanent failure. Sometimes the correct response is escalation. ArmorIQ already supports a human-review and delegation flow. The OpenShell integration reuses that pattern, but there is one important systems constraint. Middleware evaluation is synchronous. Human approval is not.
OpenShell cannot reasonably hold a connection open for minutes while someone reviews an action. So the model becomes that particular call is denied first and creates an approval request which a human review which triggers an authority change which is detected by ArmorIQ middleware which in turn triggers an agent to retry and pass given the authority allows it now. This is a much cleaner fit with OpenShell’s request path. The middleware returns quickly and deterministically. The review happens asynchronously. Approval takes effect when the agent retries. Our design explicitly treats retry as essential to this flow. An agent that treats a denial as final will never observe a later approval.
Not another agent control plane
There is already no shortage of agent gateways, policy engines, security products, and orchestration layers. We did not want to add another one. The OpenShell integration follows a simpler principle:
Put intent context into an enforcement boundary that already exists.
OpenShell still owns the sandbox, the supervisor, the network path, and the enforcement point. ArmorIQ contributes context conventional sandbox enforcement does not have - intent: the objective, the plan, and the authority justified by them. That is why we see the two systems as complementary.
A useful shorthand is:
OpenShell provides the enforcement path. ArmorIQ adds intent continuity across it.
Middleware has a boundary
Middleware is a strong enforcement point, but it only sees activity that crosses the proxy path. Some important effects may never become HTTP requests at all. For example a local file write, a process spawn, a raw socket, a local IPC operation, or another syscall contained entirely inside the sandbox. That means request-time enforcement is useful, but it is not the final layer.
Our prepared design makes this distinction explicitly. Middleware covers outbound request enforcement; KAP is intended to carry the same objective-derived authority down to the syscall boundary for effects that never appear in HTTP traffic.
Conceptually, an action associated with an intent can go to OpenShell middleware or have local effects. The latter cannot be addressed by this approach or by OpenShell. This is why we see middleware as the first deployable integration point, not the final one.
From middleware to objective-bound execution
Our earlier work explored lower-level enforcement through KAP, where authority derived from an objective is attached directly to a process and enforced closer to the kernel boundary. That approach lets us reason about things middleware cannot see.
It also introduces an obvious deployment challenge. As pointed out in our discussion with the OpenShell team, asking enterprises to change or customize kernels is a high bar. We agree.
So we are also exploring a non-kernel execution boundary we are calling iVisor. The idea is roughly analogous to the role a system such as gVisor plays: create a userspace enforcement layer that can carry objective-bound execution semantics without requiring enterprises to deploy a custom kernel.
The goal is not to replace OpenShell. It is to extend the same principle below the middleware layer:
Bind execution to the objective that authorized it, even for effects that never become an HTTP request.
That work is still early. The OpenShell middleware integration is the concrete first step.
Try it
The middleware implementation is available here:
GitHub
https://github.com/armoriq/armoriq-openshell-middleware
The two demos show the progression:
Demo Part 1 Request-time intent enforcement through OpenShell middleware.
The agent remains unmodified, and the integration uses OpenShell’s middleware interfaces rather than requiring changes to the agent runtime. That is the part we find most compelling. OpenShell already gives us a strong place to enforce what an agent is allowed to do.
ArmorIQ adds the ability to ask whether what the agent is doing is still consistent with why it was allowed to act in the first place.



