enterprise.html

---
layout: default
title: "Enterprise"
description: "The Sandlock core is open source and free. What we sell sits on top of it: the Sandbox HTTP API and the Sandbox Scheduler, licensed software deployed into your cloud account or data center, not a shared cloud."
permalink: /enterprise.html
---

<style>
.layer-stack {
    display: flex;
    flex-direction: column;
    gap: var(--space-4);
    margin-top: var(--space-10);
}

.layer-row {
    display: grid;
    grid-template-columns: 200px 1fr;
    gap: var(--space-8);
    padding: var(--space-6) var(--space-8);
    background: white;
    border: 1px solid var(--gray-200);
    border-left: 3px solid var(--gray-300);
    border-radius: var(--radius-lg);
}

.layer-row.paid {
    border-left-color: var(--accent-500);
}

.layer-head h3 {
    font-size: var(--text-lg);
    font-weight: 800;
    letter-spacing: -0.02em;
    color: var(--gray-900);
    line-height: var(--leading-tight);
}

.layer-head .tag {
    display: inline-block;
    margin-top: var(--space-3);
    padding: 3px 9px;
    font-family: var(--font-mono);
    font-size: 10px;
    font-weight: 600;
    text-transform: uppercase;
    letter-spacing: 0.08em;
    border-radius: var(--radius-sm);
    background: rgba(47, 125, 87, 0.1);
    color: var(--success);
    border: 1px solid rgba(47, 125, 87, 0.2);
}

.layer-head .tag.commercial {
    background: rgba(201, 161, 62, 0.1);
    color: var(--accent-700);
    border-color: rgba(201, 161, 62, 0.25);
}

.layer-body p {
    font-size: var(--text-sm);
    line-height: var(--leading-relaxed);
    color: var(--gray-600);
}

.layer-body p + p {
    margin-top: var(--space-3);
}

.layer-body strong {
    color: var(--gray-900);
    font-weight: 600;
}

.cap-grid {
    display: grid;
    grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
    gap: var(--space-4);
    margin-top: var(--space-8);
}

.cap {
    padding: var(--space-5) var(--space-6);
    background: white;
    border: 1px solid var(--gray-200);
    border-radius: var(--radius-lg);
}

.cap h3 {
    font-size: var(--text-base);
    font-weight: 700;
    color: var(--gray-900);
    margin-bottom: var(--space-2);
    display: flex;
    align-items: center;
    gap: var(--space-2);
}

.cap h3 i {
    width: 16px;
    height: 16px;
    color: var(--accent-600);
}

.cap p {
    font-size: var(--text-sm);
    line-height: var(--leading-relaxed);
    color: var(--gray-600);
}

.claim-row {
    display: grid;
    grid-template-columns: repeat(3, 1fr);
    gap: var(--space-4);
    margin-top: var(--space-10);
}

.claim {
    padding: var(--space-6);
    background: rgba(255, 255, 255, 0.03);
    border: 1px solid rgba(255, 255, 255, 0.07);
    border-top: 2px solid var(--accent-500);
    border-radius: var(--radius-md);
}

.claim .n {
    display: block;
    font-family: var(--font-mono);
    font-size: var(--text-3xl);
    font-weight: 700;
    color: var(--accent-400);
    line-height: 1;
    margin-bottom: var(--space-3);
}

.claim h3 {
    font-size: var(--text-sm);
    font-weight: 700;
    color: white;
    margin-bottom: var(--space-2);
}

.claim p {
    font-size: var(--text-sm);
    line-height: var(--leading-relaxed);
    color: rgba(255, 255, 255, 0.55);
}

.fit-grid {
    display: grid;
    grid-template-columns: repeat(auto-fit, minmax(260px, 1fr));
    gap: var(--space-5);
    margin-top: var(--space-8);
}

.fit {
    padding: var(--space-6);
    background: white;
    border: 1px solid var(--gray-200);
    border-radius: var(--radius-lg);
}

.fit i {
    width: 20px;
    height: 20px;
    color: var(--accent-600);
    margin-bottom: var(--space-4);
    display: block;
}

.fit h3 {
    font-size: var(--text-base);
    font-weight: 700;
    color: var(--gray-900);
    margin-bottom: var(--space-2);
}

.fit p {
    font-size: var(--text-sm);
    line-height: var(--leading-relaxed);
    color: var(--gray-600);
}

.cta-steps {
    display: grid;
    grid-template-columns: repeat(3, 1fr);
    gap: var(--space-5);
    margin: var(--space-12) 0 var(--space-10);
    text-align: left;
}

.cta-step {
    padding-top: var(--space-4);
    border-top: 1px solid rgba(255, 255, 255, 0.12);
}

.cta-step .n {
    display: block;
    font-family: var(--font-mono);
    font-size: 11px;
    font-weight: 600;
    letter-spacing: 0.12em;
    color: var(--accent-500);
    margin-bottom: var(--space-3);
}

.cta-step h3 {
    font-size: var(--text-base);
    font-weight: 700;
    color: white;
    margin-bottom: var(--space-2);
    letter-spacing: -0.01em;
}

.cta-band .cta-step p {
    font-size: var(--text-sm);
    line-height: var(--leading-relaxed);
    color: rgba(255, 255, 255, 0.5);
    margin: 0;
}

@media (max-width: 760px) {
    .cta-steps {
        grid-template-columns: 1fr;
        gap: var(--space-6);
        margin: var(--space-10) 0 var(--space-8);
    }
}

@media (max-width: 900px) {
    .layer-row {
        grid-template-columns: 1fr;
        gap: var(--space-4);
    }

    .claim-row {
        grid-template-columns: 1fr;
    }
}
</style>

<section class="hero hero-page">
    <div class="hero-container">
        <div class="hero-badge">
            <i data-lucide="cloud"></i>
            <span>Commercial offering</span>
        </div>
        <h1>Operate Sandboxes at Fleet Scale, on Your Infrastructure</h1>
        <p class="subtitle">The open-source core confines a process. The commercial layer operates a fleet: the Sandbox HTTP API exposes sandboxes as remote infrastructure with identity and access control, and the Sandbox Scheduler fits a thousand agent sessions into the memory a reservation model spends on twenty. Both deploy into your cloud account or your data center, inside your trust boundary.</p>
    </div>
</section>

<section class="section">
    <div class="section-container">
        <div class="section-header">
            <div class="section-badge">
                <i data-lucide="layers"></i>
                <span>The split</span>
            </div>
            <h2 class="section-title">Open Source at the Core, Commercial at the Fleet Layer</h2>
            <p class="section-subtitle">Everything that confines a process is open source. Everything that operates a fleet of sandboxes is licensed. There are no paywalled flags, no enterprise-only features, and no runtime that phones home.</p>
        </div>

        <div class="layer-stack">
            <div class="layer-row">
                <div class="layer-head">
                    <h3>Sandlock</h3>
                    <span class="tag">Apache-2.0</span>
                </div>
                <div class="layer-body">
                    <p>The sandbox itself: Landlock, seccomp-bpf, the supervisor, copy-on-write, the ACLs, credential injection, the handler API, and every interface from the CLI through the SDKs, the OCI runtime, and the MCP server. <strong>Nothing is gated.</strong> Apache-2.0 and free at any scale; teams run it in production indefinitely with no commercial relationship, and that is by design.</p>
                </div>
            </div>

            <div class="layer-row paid">
                <div class="layer-head">
                    <h3>Sandbox HTTP API</h3>
                    <span class="tag commercial">Commercial</span>
                </div>
                <div class="layer-body">
                    <p>An HTTP API over the core, plus client SDKs: create a sandbox from a container image, run commands in it, move files in and out, checkpoint it, and reconnect later from another process or machine. The layer where sandboxes stop being a function call and start being <strong>infrastructure with identity, lifetime, and access control</strong>.</p>
                </div>
            </div>

            <div class="layer-row paid">
                <div class="layer-head">
                    <h3>Sandbox Scheduler</h3>
                    <span class="tag commercial">Commercial</span>
                </div>
                <div class="layer-body">
                    <p>Places sandboxes across a fleet, treating the checkpoint store rather than a node as a sandbox's home: a node lends memory for the duration of a call and reclaims it afterwards. For a workload that is idle more than 99% of the time, that difference sets the economics of running it.</p>
                </div>
            </div>
        </div>
    </div>
</section>

<section class="section section-alt" id="http-api">
    <div class="section-container">
        <div class="section-header">
            <div class="section-badge">
                <i data-lucide="webhook"></i>
                <span>HTTP API</span>
            </div>
            <h2 class="section-title">A Sandbox Service Running on Your Own Servers</h2>
            <p class="section-subtitle">The capabilities that matter the moment there is more than one machine, more than one tenant, or more than one caller.</p>
        </div>

        <div class="cap-grid">
            <div class="cap">
                <h3><i data-lucide="globe"></i>Any language, with scoped keys</h3>
                <p>A REST surface, so a caller needs no Landlock, no Linux, and no FFI. Keys carry fine-grained scopes across create, exec, files, checkpoints, and MCP, with per-key usage accounting.</p>
            </div>
            <div class="cap">
                <h3><i data-lucide="save"></i>Sandboxes that outlive the call</h3>
                <p>A sandbox has a stable ID, persists across runs, and can be reconnected from a different process or machine. Named checkpoints stop it and restore it later, the same mechanism the Scheduler uses to move it between nodes.</p>
            </div>
            <div class="cap">
                <h3><i data-lucide="container"></i>Container images as the rootfs</h3>
                <p>Name an image and the server extracts it to a cached rootfs, sets up the chroot, and applies copy-on-write, with no image build in your loop.</p>
            </div>
            <div class="cap">
                <h3><i data-lucide="server-cog"></i>Long-running service processes</h3>
                <p>Start a server inside a sandbox, query its status and ports, tail its output, and stop it, as a first-class lifecycle rather than a backgrounded command.</p>
            </div>
            <div class="cap">
                <h3><i data-lucide="bot"></i>Remote MCP</h3>
                <p>Native MCP transports, so Claude Desktop, Cursor, or any MCP client points at the API directly. Register your own Python tools; each call runs in its own sandbox.</p>
            </div>
            <div class="cap">
                <h3><i data-lucide="git-branch"></i>Pipelines across stages</h3>
                <p>The core's split-trust pipelines, available remotely: each stage keeps its own policy, and data flows between them without either stage gaining the other's access.</p>
            </div>
            <div class="cap">
                <h3><i data-lucide="check-check"></i>Evidence for your auditor</h3>
                <p>Fleet-wide posture reports and tamper-evident audit trails: every sandbox, its policy, and every waived protection, exportable in the language your compliance program speaks. Generated on your infrastructure, because nothing here phones home.</p>
            </div>
        </div>
    </div>
</section>

<section class="section section-dark" id="scheduler">
    <div class="section-container">
        <div class="section-header">
            <div class="section-badge">
                <i data-lucide="cpu"></i>
                <span>Sandbox Scheduler</span>
            </div>
            <h2 class="section-title">Provision for Execution, Not for Idle Sessions</h2>
            <p class="section-subtitle">An agent session spends nearly all of its life waiting on the model, and a reservation model pays for that wait. The Sandbox Scheduler keeps each session in a checkpoint store and assigns node memory only while the session is executing.</p>
        </div>

        <div class="claim-row">
            <div class="claim">
                <span class="n">1,000</span>
                <h3>Sessions</h3>
                <p>Two gigabytes each. Under reservation that is 2 TB of memory held continuously, whether or not anything is running.</p>
            </div>
            <div class="claim">
                <span class="n">42 GB</span>
                <h3>Actual footprint</h3>
                <p>Around ten are executing at any instant. Provision for a p99.9 of concurrent live sandboxes and the same thousand sessions fit in 42 GB.</p>
            </div>
            <div class="claim">
                <span class="n">~48&times;</span>
                <h3>More sessions per host</h3>
                <p>The ratio grows with fleet size, approaching 91&times; at a hundred thousand sessions, because concurrency averages out.</p>
            </div>
        </div>

        <p class="table-note" style="color: rgba(255,255,255,0.4); text-align: center; max-width: 70ch; margin-left: auto; margin-right: auto;">Figures are modelled from the duty cycle. Send us your session count, concurrency, and idle profile, and we will size the deployment against your workload.</p>

        <div style="max-width: 76ch; margin: var(--space-16) auto 0;">
            <h3 style="font-size: var(--text-lg); font-weight: 700; color: white; margin-bottom: var(--space-5);">How it works, and what that changes</h3>
            <div class="capability-features">
                <div class="feature-item"><i data-lucide="check"></i><span><strong>The session lives in the store, not on a node.</strong> Nodes write an incremental checkpoint whenever the sandbox goes quiet; a request restores it wherever there is room, sub-second, because creating a sandbox is itself a restore from a golden template. Idle memory goes back in graded steps.</span></div>
                <div class="feature-item"><i data-lucide="check"></i><span><strong>Node failure is not an incident.</strong> Failover, eviction, and rebalancing are the same path: the next request restores the session somewhere else. A node with no headroom refuses and the router moves on, so overcommit cannot become an outage.</span></div>
                <div class="feature-item"><i data-lucide="check"></i><span><strong>Forking a session is free.</strong> Restore one checkpoint any number of times under fresh ids, which is what best-of-N sampling and tree search need. Routers hold no durable state, so run as many as you like.</span></div>
                <div class="feature-item"><i data-lucide="minus"></i><span><strong>Two things do not move with a session.</strong> TCP connections drop on relocation and GPU state does not checkpoint cleanly, so plan long-lived connections and GPU work around that boundary.</span></div>
            </div>
        </div>

    </div>
</section>

<section class="section section-alt" id="deployment">
    <div class="section-container">
        <div class="section-header">
            <div class="section-badge">
                <i data-lucide="cloud"></i>
                <span>Deployment model</span>
            </div>
            <h2 class="section-title">Your Infrastructure, Not a Shared Cloud</h2>
            <p class="section-subtitle">Licensed software, deployed into your cloud account or your data center. Your workloads never cross a vendor boundary, your security team keeps the keys, and no shared cloud sits between you and your customers.</p>
        </div>

        <div class="fit-grid">
            <div class="fit">
                <i data-lucide="cloud"></i>
                <h3>Your cloud account or your data center</h3>
                <p>The API, the Scheduler, and every node run in your AWS, GCP, or Azure account, or on bare metal in your data center. Nothing needs KVM, so cloud VMs without nested virtualization are fine, and workloads, checkpoints, and credentials never leave your trust boundary.</p>
            </div>
            <div class="fit">
                <i data-lucide="shield-half"></i>
                <h3>No shared cloud, by design</h3>
                <p>Your code never runs on kernels we operate. Cross-tenant isolation stays where your auditor wants it: on your hypervisor, under your control, with the Scheduler packing density inside each boundary.</p>
            </div>
            <div class="fit">
                <i data-lucide="plug"></i>
                <h3>No operational dependency on us</h3>
                <p>Nothing in your stack calls a service we operate: no hosted control plane, no license server, no telemetry endpoint. An outage of ours cannot become an outage of yours, and offboarding requires no data export, because we hold nothing of yours.</p>
            </div>
            <div class="fit">
                <i data-lucide="layers"></i>
                <h3>An open-source exit path</h3>
                <p>Drop the commercial layers and the complete Apache-2.0 core remains yours: the sandbox, every SDK, the CLI, the OCI runtime, and the MCP server. The confinement your platform rests on is not ours to take away.</p>
            </div>
        </div>
    </div>
</section>

<section class="section">
    <div class="section-container">
        <div class="section-header">
            <div class="section-badge">
                <i data-lucide="users-round"></i>
                <span>Who this is for</span>
            </div>
            <h2 class="section-title">Teams Running Sandboxes as a Fleet</h2>
            <p class="section-subtitle">Built for teams whose sandbox count has outgrown one machine. For a single sandbox on a single host, the open-source project is the whole answer.</p>
        </div>

        <div class="fit-grid">
            <div class="fit">
                <i data-lucide="bot"></i>
                <h3>AI agent platforms</h3>
                <p>You run a sandbox per session, sessions outlive a request, and the memory bill is dominated by sandboxes that are doing nothing.</p>
            </div>
            <div class="fit">
                <i data-lucide="code-xml"></i>
                <h3>Code execution products</h3>
                <p>Notebook backends, interpreters, and evaluation harnesses that need an execution API with tenancy, quotas, and per-key accounting.</p>
            </div>
            <div class="fit">
                <i data-lucide="server"></i>
                <h3>Developer platforms</h3>
                <p>Build and CI services where jobs come from outside your trust boundary and per-job VMs are the line item you are trying to remove.</p>
            </div>
            <div class="fit">
                <i data-lucide="shield"></i>
                <h3>Security engineering</h3>
                <p>You are approving untrusted execution on shared infrastructure and need a boundary you can describe precisely to an auditor, with evidence rather than assertions to hand them.</p>
            </div>
        </div>
    </div>
</section>

<section class="cta-band">
    <div class="cta-band-inner" style="max-width: 940px;">
        <h2>Evaluate It Against Your Workload</h2>
        <p>When sandboxes become a fleet, the API and the Scheduler turn them into infrastructure you can operate: many tenants, many machines, and a memory bill that tracks work done rather than sessions held.</p>

        <div class="cta-steps">
            <div class="cta-step">
                <span class="n">01</span>
                <h3>A technical call</h3>
                <p>A thirty-minute engineering discussion with the CEO, not a sales pitch. Bring the workload.</p>
            </div>
            <div class="cta-step">
                <span class="n">02</span>
                <h3>Sized against your numbers</h3>
                <p>Sessions, concurrency, and idle profile, measured rather than modelled.</p>
            </div>
            <div class="cta-step">
                <span class="n">03</span>
                <h3>A pilot on your infrastructure</h3>
                <p>Running against real traffic before anything is signed.</p>
            </div>
        </div>

        <div class="button-group">
            <a href="https://calendar.app.google/nc1upkqQoUeoukdD9" target="_blank" rel="noopener noreferrer" class="btn btn-primary">
                <i data-lucide="calendar"></i>
                Book a Technical Call
            </a>
            <a href="mailto:contact@multikernel.io" class="btn btn-secondary">
                <i data-lucide="mail"></i>
                contact@multikernel.io
            </a>
        </div>
    </div>
</section>