feat(site): Mitos vs CubeSandbox comparison page

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);