NeuronEdge Enclave is now part of Mindpool — the execution boundary in a reference architecture for AI your organization owns.

/docs/quickstart

5-minute self-host

Install NeuronEdge Enclave on any Linux + KVM host. Create a workspace, run a command, snapshot and fork — then wire it up via Python or TypeScript.

prerequisites

You need a Linux x86_64 host with /dev/kvm — a bare-metal server, a cloud VM with nested virtualization (Azure Dv4+/Ev4+, AWS, GCP), or a local Linux machine with KVM enabled. For the standard tier, you also need Firecracker + jailer at /opt/ne-enclave/bin/ — the install script handles this if they're in your PATH. macOS is dev-only — use a Linux VM or the Azure dev-box script in deploy/.

  1. 01

    Install

    $install.sh
    curl -fsSL https://github.com/Mindpool-Labs/ne-enclave/releases/latest/download/install.sh | sh

    The installer downloads the static-musl nee binary and verifies its SHA-256 checksum, then runs nee install — which creates the ne system user, the directory layout, renders hardened systemd units, fetches the default guest image, and starts the services.

    $verify
    nee doctor                          # preflight: KVM, Firecracker, jailer
systemctl status ne-supervisor ne-api
  2. 02

    Create a workspace + run a command

    $REST API
    # Create a workspace (REST API at localhost:8080)
curl -s http://127.0.0.1:8080/v1/workspaces \
  -H 'Content-Type: application/json' \
  -d '{
    "workspace_id": "hello",
    "kernel_image_path": "/var/lib/ne-enclave/images/kernels/<digest>/vmlinux",
    "rootfs_image_path": "/var/lib/ne-enclave/images/rootfs/<digest>/rootfs.img",
    "vcpu_count": 1,
    "mem_size_mib": 512
  }'

# Run a command inside the sandboxed microVM
curl -s http://127.0.0.1:8080/v1/workspaces/hello/exec \
  -H 'Content-Type: application/json' \
  -d '{"command": "echo", "args": ["hello from a microVM"]}'

    The command runs inside a Firecracker microVM with its own kernel — isolated from the host. The response includes stdout, stderr, and exit code.

  3. 03

    Use the SDK — Python

    $pip
    pip install neuronedge-enclave
    $Python
    from ne import Client

c = Client("http://127.0.0.1:8080")

# Create
ws = c.create_workspace("my-agent",
    kernel_image_path="/var/lib/ne-enclave/images/kernels/.../vmlinux",
    rootfs_image_path="/var/lib/ne-enclave/images/rootfs/.../rootfs.img")

# Execute
result = c.execute_command(ws.workspace_id, command="pip", args=["install", "requests"])
print(result.stdout)

# Write a file
c.write_file(ws.workspace_id, path="main.py", content=b"print('hello from the agent')")

# Read it back
print(c.read_file(ws.workspace_id, path="main.py"))

# Snapshot + fork (agent planning loops)
snap = c.snapshot(ws.workspace_id)
plan_b = c.fork_workspace(snap.snapshot_id, new_workspace_id="plan-b")

# Clean up
c.destroy_workspace(ws.workspace_id)
  4. 04

    Use the SDK — TypeScript

    $npm
    npm install @neuronedge/enclave
    $TypeScript
    import { Client } from "@neuronedge/enclave";

const c = new Client("http://127.0.0.1:8080");

const ws = await c.createWorkspace({
  workspace_id: "my-agent",
  kernel_image_path: "/var/lib/ne-enclave/images/kernels/.../vmlinux",
  rootfs_image_path: "/var/lib/ne-enclave/images/rootfs/.../rootfs.img",
});

const result = await c.executeCommand(ws.workspace_id, {
  command: "echo",
  args: ["hello from TypeScript"],
});

console.log(result.stdout);

what just happened

You created a Firecracker microVM — a full hardware-virtualized guest with its own kernel — ran a command inside it, wrote a file, snapshotted it, and forked it. Every action was captured as a signed audit event. The workspace was isolated from the host at the hardware level.

The same API works for the confidential tier — just set NE_CONFIDENTIAL_MODE=1 on a SEV-SNP CVM host. See the deploy guide for the confidential-tier activation path.

/docs/next

Next steps

Run your next agent in a hardware-isolated, governed sandbox.

Read the architectureRead the threat model