OpenShell: De beveiligingsruntime achter NemoClaw

OpenShell: De beveiligingsruntime achter NemoClaw

Als NemoClaw de beveiligingsstack is, dan is OpenShell het fundament. Ontwikkeld door NVIDIA's security engineering team gedurende de afgelopen 18 maanden, biedt OpenShell sandboxing op kernel-niveau voor AI-agentuitvoering — zodat zelfs een volledig gecompromitteerde agent geen toegang kan krijgen tot resources buiten zijn gedefinieerde beveiligingsgrens.

Dit artikel is een technische diepe duik in OpenShell's architectuur, zijn isolatiemechanismen en hoe het beveiligingsbeleid handhaaft met minimale prestatie-overhead.

Waarom isolatie op kernel-niveau?

Traditionele applicatiesandboxing — containers, VM's, isolatie op procesniveau — was ontworpen voor software die voorspelbaar gedrag vertoont. AI-agenten zijn fundamenteel anders. Ze genereren hun eigen uitvoeringsplannen tijdens runtime, maken tool-aanroepen die interageren met externe systemen, en kunnen nieuw gedrag vertonen dat geen testsuite had voorzien.

Deze onvoorspelbaarheid vereist een beveiligingsmodel dat werkt op het laagst mogelijke niveau: de kernel. OpenShell onderschept elke systeemaanroep die een agentproces maakt, classificeert deze tegen het actieve beveiligingsbeleid en neemt een toestaan/weigeren-beslissing voordat de aanroep de kernel bereikt.

Agent Process
     │
     ▼
OpenShell eBPF Layer  ←── Policy Engine
     │
     ├── ALLOW → System Call → Kernel
     │
     ├── DENY → Error returned to agent
     │
     └── ESCALATE → Human approval queue

eBPF: De technologie achter OpenShell

OpenShell is gebouwd op eBPF (extended Berkeley Packet Filter), een Linux kernel-technologie die het mogelijk maakt aangepaste programma's te draaien in kernel-ruimte zonder de kernel zelf te wijzigen. NVIDIA's team schreef een reeks eBPF-programma's die specifiek zijn geoptimaliseerd voor AI-agent workloads:

Systeemaanroep-interceptor

De systeemaanroep-interceptor koppelt aan het sys_enter-tracepoint en evalueert elke systeemaanroep tegen het actieve beleid:

// Simplified OpenShell eBPF syscall interceptor
SEC("tracepoint/raw_syscalls/sys_enter")
int openshell_syscall_enter(struct trace_event_raw_sys_enter *ctx) {
    u32 pid = bpf_get_current_pid_tgid() >> 32;
    struct sandbox_policy *policy = bpf_map_lookup_elem(&sandbox_policies, &pid);

    if (!policy)
        return 0;  // Not a sandboxed process

    long syscall_nr = ctx->id;
    int decision = evaluate_policy(policy, syscall_nr, ctx->args);

    if (decision == DENY) {
        // Send event to userspace audit log
        emit_security_event(pid, syscall_nr, DENY);
        // Override return value to -EPERM
        bpf_override_return(ctx, -EPERM);
    } else if (decision == ESCALATE) {
        // Pause the process and notify approval queue
        emit_approval_request(pid, syscall_nr, ctx->args);
        send_signal(pid, SIGSTOP);
    }

    return 0;
}

Bestandssysteembewaker

De bestandssysteembewaker beperkt welke bestanden en mappen een agent kan benaderen. Het werkt op VFS-operaties (Virtual Filesystem) en onderschept open-, read-, write-, unlink- en rename-aanroepen:

# Filesystem policy for a customer support agent
filesystem:
  # Agent can read its own configuration
  - path: "/etc/nemoclaw/agent.yaml"
    permissions: [read]

  # Agent can read/write to its workspace
  - path: "/var/nemoclaw/workspace/**"
    permissions: [read, write, create]

  # Agent can read shared data
  - path: "/var/nemoclaw/shared/**"
    permissions: [read]

  # Everything else is denied by default
  defaultAction: deny

Netwerkbewaker

De netwerkbewaker haakt in op socket-operaties om de netwerktoegang van agenten te controleren op verbindingsniveau:

SEC("cgroup/connect4")
int openshell_connect4(struct bpf_sock_addr *ctx) {
    u32 pid = bpf_get_current_pid_tgid() >> 32;
    struct network_policy *policy = bpf_map_lookup_elem(&net_policies, &pid);

    if (!policy)
        return 1;  // Allow non-sandboxed processes

    __be32 dst_ip = ctx->user_ip4;
    __be16 dst_port = ctx->user_port;

    if (!is_allowed_destination(policy, dst_ip, dst_port)) {
        emit_security_event(pid, NETWORK_BLOCKED, dst_ip, dst_port);
        return 0;  // Block connection
    }

    return 1;  // Allow connection
}

Architectuur voor beleidshandhaving

OpenShell-beleid wordt gecompileerd naar eBPF-bytecode voor maximale handhavingssnelheid. De compilatiepipeline werkt als volgt:

1. 1.YAML-beleidsbestanden worden geschreven door beveiligingsteams in een menselijk leesbaar formaat
2. 2.Beleidscompiler zet YAML om naar een tussenrepresentatie (IR)
3. 3.Nemotron-beleidsvalidator controleert de IR op logische consistentie en conflicten
4. 4.eBPF-compiler genereert geverifieerde bytecode die in de kernel wordt geladen
5. 5.Runtime-verificateur zorgt ervoor dat de eBPF-programma's termineren en geheugenveilig zijn

De gehele compilatiepipeline draait in minder dan 2 seconden voor typische beleidssets, en beleid kan hot-reloaded worden zonder de agent te herstarten.

# Compile and load a policy
nemoclaw policy compile policies/customer-support.yaml
nemoclaw policy load customer-support

# Hot-reload a modified policy (no agent restart required)
nemoclaw policy reload customer-support

# Verify policy is active
nemoclaw policy status
# Output:
# POLICY              STATUS    LOADED AT            RULES
# customer-support    active    2026-03-19 14:30:01  47
# network-default     active    2026-03-19 14:30:01  12
# filesystem-strict   active    2026-03-19 14:30:01  23

Operator-goedkeuringsworkflows

Een van OpenShell's meest onderscheidende functies is het ingebouwde operator-goedkeuringssysteem. Wanneer een agent een actie probeert die als hoog risico is geclassificeerd, pauzeert OpenShell de uitvoering van de agent en stuurt het goedkeuringsverzoek door naar een menselijke operator.

Hoe goedkeuring werkt

1. 1.Agent probeert een systeemaanroep met hoog risico (bijv. schrijven naar een beschermd bestand, verbinden met een niet-goedgekeurd eindpunt)
2. 2.OpenShell's eBPF-programma stuurt SIGSTOP naar het agentproces
3. 3.Er wordt een goedkeuringsverzoek gegenereerd en verzonden via het geconfigureerde kanaal (Slack, Teams, PagerDuty, e-mail)
4. 4.De operator beoordeelt de verzoekcontext en keurt goed of wijst af
5. 5.Bij goedkeuring stuurt OpenShell SIGCONT om de agent te hervatten; bij afwijzing wordt EPERM geretourneerd

Het goedkeuringsverzoek bevat de volledige context:

{
  "request_id": "apr-2026031914-00042",
  "agent": "customer-support-agent-01",
  "action": "email.send",
  "target": "[email protected]",
  "context": {
    "ticket_id": "TKT-12345",
    "customer_name": "[REDACTED]",
    "reason": "Agent wants to send a follow-up email to the customer regarding their refund request",
    "email_preview": "Dear Customer, your refund of $250 has been processed..."
  },
  "risk_level": "medium",
  "policy_rule": "external-communication-requires-approval",
  "timestamp": "2026-03-19T14:30:42Z"
}

Goedkeuringstimeout en standaardacties

Operators kunnen configureren wat er gebeurt wanneer een goedkeuring verloopt:

approvalConfig:
  timeout: 15m
  onTimeout: deny          # deny | allow | escalate
  onEscalate:
    target: security-team
    channel: pagerduty
  maxPendingApprovals: 10  # Queue limit per agent
  autoApprove:
    # Automatically approve if the same action was approved
    # 3 times in the past 24 hours for this agent
    repeatThreshold: 3
    repeatWindow: 24h

Prestatiekenmerken

OpenShell is ontworpen voor productieworkloads waar latentie ertoe doet. Hier zijn de gemeten overheads op een DGX Spark:

Ter vergelijking: een typische LLM-inferentieaanroep duurt 500ms-5000ms, dus de overhead van OpenShell is verwaarloosbaar in de context van agent-workloads.

Vergelijking met bestaande sandboxing

OpenShell's belangrijkste onderscheidende factor is dat het van de grond af is ontworpen voor AI-agent workloads, met ingebouwde ondersteuning voor natuurlijketaal-beleid, menselijke goedkeuringsworkflows en GPU-versnelde beleidsevaluatie.

Aan de slag met OpenShell

OpenShell kan zelfstandig worden gebruikt, zonder de rest van de NemoClaw-stack:

# Install OpenShell standalone
curl -fsSL https://github.com/NVIDIA/OpenShell | bash

# Create a minimal sandbox policy
cat > my-policy.yaml << 'EOF'
apiVersion: openshell.nvidia.com/v1
kind: SandboxPolicy
metadata:
  name: my-first-sandbox
spec:
  isolation:
    network: restricted
    filesystem: workspace-only
    syscalls: minimal
EOF

# Run any process inside the sandbox
openshell run --policy my-policy.yaml -- python my_agent.py

OpenShell is open source onder Apache 2.0 en beschikbaar op nvidia/openshell op GitHub. In het volgende artikel verkennen we praktijkgerichte implementatiescenario's voor bedrijven met de volledige NemoClaw-stack.