From d012b7712baf48d4550d2ce5a3f35265564ed770 Mon Sep 17 00:00:00 2001 From: Jannes Stubbemann Date: Fri, 3 Jul 2026 10:38:27 +0200 Subject: [PATCH] feat(site): Mitos vs CubeSandbox comparison page Adds CubeSandbox (Tencent, open-sourced April 2026) to competitors.ts, which generates /compare/cubesandbox and lists it on /alternatives. Positioning per .agents/product-marketing.md frame rules: lead with the fleet-from-a-running-machine outcome; concede the Apache-2.0 and own-kernel ties in one line; their figures labeled as theirs (sub-60 ms cold start, hundred-millisecond CubeCoW clone); wins are live fork vs snapshot clone, Kubernetes-native CRDs vs a standalone Redis-backed control plane, and Firecracker pedigree plus reproducible benchmarks vs vendor charts. Co-Authored-By: Claude Fable 5 Signed-off-by: Jannes Stubbemann --- src/data/competitors.ts | 47 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 47 insertions(+) diff --git a/src/data/competitors.ts b/src/data/competitors.ts index 358306d..67d1530 100644 --- a/src/data/competitors.ts +++ b/src/data/competitors.ts @@ -289,6 +289,53 @@ export const competitors: Competitor[] = [ { q: 'Which is faster?', a: 'Mitos publishes about 27 ms to activate a warm fork, against the hundreds of milliseconds CodeSandbox publishes for live fork and memory resume. Both are self-reported on different hardware, so treat it as context, not a head-to-head benchmark.' }, ], }, + + { + slug: 'cubesandbox', + name: 'CubeSandbox', + blurb: 'Tencent’s Apache-2.0 microVM sandbox with fast cold starts. Clones from saved snapshots, not a running machine, and runs its own control plane beside Kubernetes.', + title: 'Mitos vs CubeSandbox: live fork vs snapshot clones', + description: + 'Mitos vs CubeSandbox for AI agents: Mitos forks a running microVM into a fleet and is Kubernetes-native; CubeSandbox clones saved snapshots on its own control plane.', + h1: 'Mitos vs CubeSandbox', + lede: + 'Mitos forks a running agent into a fleet of warm daughters, as Kubernetes-native CRDs. CubeSandbox starts sandboxes fast and clones them from saved snapshots, on a separate control plane of its own.', + verdict: + 'Both run agents in Apache-2.0 microVMs with their own kernel, so license and the isolation boundary tie. The difference is the fleet and where it lives: Mitos forks one running machine, memory and processes, into many warm daughters, declared as CRDs inside the Kubernetes cluster you already run. CubeSandbox clones from saved snapshots and ships its own scheduler, node agents, and Redis state store that you operate beside Kubernetes.', + rows: [ + row('Fork a running VM (memory + processes)', { s: 'n', t: 'snapshot clone' }, MITOS.liveFork), + row('Kubernetes-native (CRDs, kubectl, GitOps)', { s: 'n', t: 'own control plane' }, { s: 'y', t: 'mitos.run/v1 CRDs' }), + row('microVM isolation (own kernel)', { s: 'y', t: 'RustVMM + KVM' }, MITOS.isolation), + row('Open source license', { s: 'y', t: 'Apache 2.0' }, MITOS.license), + row('Sandbox create speed', { s: 'y', t: 'sub-60 ms cold start (their figure)' }, { s: 'y', t: '~27 ms fork (ours)' }), + row('Benchmarks reproducible from the repo', { s: 'n', t: 'vendor charts' }, { s: 'y', t: 'scripts in repo' }), + row('Fully managed cloud', { s: 'n', t: 'self-host only' }, MITOS.managed), + ], + sections: [ + { + h: 'A fleet from one running machine', + body: 'Mitos copies a running machine’s live memory and processes into many daughters at once, each resuming warm with fresh uniqueness, entropy reseeded and identity regenerated per daughter. CubeSandbox’s CubeCoW engine snapshots, clones, and rolls back from saved state at hundred-millisecond granularity (their figure), a save-and-restore workflow rather than a fork of the machine that is running right now.', + }, + { + h: 'Inside your Kubernetes, not beside it', + body: 'Mitos is a set of CRDs in your existing cluster: sandboxes and pools are declared like any other resource, drive through kubectl, and fit GitOps as YAML. CubeSandbox brings its own scheduler, node agents, API gateway, and a Redis state store, a second control plane your team operates and secures in parallel with Kubernetes.', + }, + { + h: 'A proven hypervisor and numbers you can rerun', + body: 'Mitos runs every fork on Firecracker, the microVM hypervisor hardened by years of production use at AWS scale, and every latency figure we publish comes with the benchmark script to reproduce it from the open repo. CubeSandbox is built on its own new RustVMM-based hypervisor, and its published charts compare against Docker and a traditional VM without a public harness to rerun them.', + }, + ], + mitosWins: [ + 'Fork one running machine into a warm fleet; CubeSandbox clones from saved snapshots.', + 'Kubernetes-native CRDs in the cluster you already run, not a second control plane with its own state store.', + 'Firecracker’s production pedigree plus benchmark numbers you can rerun from the repo.', + ], + faqs: [ + { q: 'Does CubeSandbox fork a running sandbox?', a: 'No. CubeSandbox snapshots, clones, and rolls back from saved state via its CubeCoW engine. Mitos forks the running machine itself, live memory and processes, into many warm daughters at once.' }, + { q: 'Is CubeSandbox Kubernetes-native?', a: 'No. CubeSandbox ships its own scheduler, node agents, and Redis state store as a standalone control plane. Mitos is CRDs inside your existing Kubernetes cluster, so kubectl, RBAC, and GitOps just apply.' }, + { q: 'Are Mitos and CubeSandbox both open source?', a: 'Yes, both Apache 2.0. Mitos runs on Firecracker with reproducible benchmarks and offers a managed cloud on the same engine; CubeSandbox is self-host only on its own new RustVMM-based hypervisor.' }, + ], + }, ]; export const getCompetitor = (slug: string) => competitors.find((c) => c.slug === slug);