The pitch sounds almost contrarian in an age when serverless computing has become gospel: buy your own hardware, run full Linux virtual machines, and let developers fork entire computing environments the way they'd branch code in Git.
That's the bet Indexable is making. The startup, operating under the brand "ix" and part of Y Combinator's Spring 2026 cohort, launched a developer preview recently with an approach to AI agent infrastructure that zigs where most competitors have zagged. Instead of isolates or lightweight containers—the dominant architectures for executing autonomous AI agents safely—ix is building atop bare metal, with environment forking as a core primitive rather than an afterthought.
It's a technical wager that either positions the company to capture workloads competitors can't handle efficiently, or leaves it struggling to compete on the dimensions—startup latency, global reach, compliance certifications—where established players have already staked ground.
Hardware as Differentiator
Talk to enough infrastructure founders and you'll hear a recurring theme: the hyperscalers have gotten too expensive, too opaque, or both. Indexable's answer involves leasing dedicated AMD EPYC 9555 processors—64-core chips from the Zen 5 "Turin" family—paired with 512GB of DDR5 RAM and local NVMe storage in ZFS configurations. The hardware runs in two U.S. regions: Hillsboro, Oregon and Vint Hill, Virginia.
Economics flow from that choice. The company bills by the second, with pricing as of May 2026 that undercuts typical cloud VM rates—around $0.000008 per vCPU-second, which translates to roughly $20 monthly for a core running flat out. Memory runs $0.000003 per GiB-second; disk storage $0.000002 per TiB-second. More crucially for teams running agents that generate substantial network traffic, there are no egress fees. Each VM gets up to 25Gbps throughput.
But raw pricing isn't the real story, or at least not all of it. What bare metal enables here is architectural. Indexable built a custom hypervisor using rust-vmm and KVM, with copy-on-write fork and snapshot primitives designed in from the ground up. The system uses what the company calls a content-addressed virtual filesystem (VCFS) that deduplicates blocks not just across snapshots of a single machine, but across all container image layers and even separate tenant environments.
Fork a VM and you pay only for the blocks that diverge. Snapshot it—capturing running processes, memory, filesystem state, even database contents—and storage is free, at least initially. It's a model that feels borrowed from version control systems, transposed onto infrastructure.
Git for Compute Environments
The technical primitive at the heart of ix is deceptively straightforward: ix vm fork creates an instant, copy-on-write duplicate of a running environment. ix vm snapshot freezes the full state as an immutable artifact. Documentation suggests ~1 second boot times for cached images, pending published benchmarks, though detailed latency distributions remain on the "to be published" list.
What makes this interesting for AI builders—particularly those working on autonomous coding agents or reinforcement learning systems—is alignment with emerging workflow patterns. Recent research, including a paper published on arXiv in early May proposing Git-like execution traces for meta-agent systems, claims dramatic performance gains: 5× faster fork operations than Docker, 95% prompt-cache reuse on replay. The architecture describes checkpoint-every-tool-call patterns, where agent systems fork execution paths, evaluate against copies, then merge or discard results.
It's speculative, perhaps. But system designers building production agent platforms are converging on similar ideas independently—which suggests ix might be early to a paradigm shift rather than betting on an architectural dead end.
Andrew Gazelka, the founder (who previously worked at xAI and maintains a Rust-based Minecraft engine called Hyperion), describes the philosophy as "primitives over prebaked stacks." Rather than ship an opinionated agent orchestration platform, Indexable exposes low-level APIs for VMs, forks, and snapshots via TypeScript and Python SDKs, plus a CLI. Teams building coding agents or browser automation assemble their own stacks.
That's a strength if you want control. It's also a burden if you just want something that works out of the box.
The Competition, Growing Dense
The timing drops Indexable into a market that has gotten crowded fast. Cloudflare opened beta access to Dynamic Workers in March, promising sub-10ms startup times through V8 isolates—"100× faster" than containers, the company claimed. Follow-on products like Dynamic Workflows and Artifacts add durable execution and versioned storage, targeting the exact long-running agent sessions where ix hopes to compete.
E2B, meanwhile, has carved out position with Firecracker-based microVMs that boot in under 200ms. The company lists production case studies with Perplexity, Hugging Face's Open R1 project, and Groq's compound AI systems. E2B also offers a first-party Desktop variant for GUI agents—something Indexable's documentation candidly acknowledges as "more turnkey today." With ix, teams need to cobble together their own Xvfb/noVNC stacks.
Beyond those two, a cluster of other entrants spans the spectrum: Podflare with hardware-isolated sandboxes, Runloop and InstaVM offering persistent environments, ZeroCore focusing on security-first execution. The market appears to be segmenting along technical fault lines—isolates versus microVMs versus full VMs, cold-start latency, whether the focus is ephemeral security or persistent productivity tooling.
Where does a four-person startup fit? Somewhere in the middle, betting that a meaningful slice of agent builders will prize full Linux semantics, deterministic fork behavior, and cost structures that make per-second billing viable at real scale.
Unusual Candor About Gaps
What distinguishes Indexable's entry, aside from the technical architecture, is transparency about what doesn't exist yet. The reliability documentation—updated in May—lists explicit gaps: no cross-host snapshot replication, no automatic VM restart after host failure, no SOC 2 or HIPAA certifications in progress as of this spring. The system uses kernel same-page merging (KSM) by default across tenant VMs, with an opt-out mechanism and a clear warning about potential side-channel vulnerabilities.
For enterprise buyers evaluating platforms against upcoming EU AI Act compliance requirements—main provisions take effect in August—these aren't minor footnotes. The company offers dedicated metal and source access under NDA for larger customers, and documentation promises that in a shutdown scenario, Indexable will open-source its VMM and filesystem code. But automated failover and completed security audits are roadmap commitments, not current capabilities.
This level of candor is... atypical. Most developer tools companies at this stage would sand down rough edges in public materials, focusing on strengths while downplaying limitations. Indexable's documentation reads more like internal engineering wikis—performance numbers flagged as "owed," fsync semantics detailed for database users concerned about durability, even a note about discrepancies between the Y Combinator directory (three people) and actual headcount (four).
It's either refreshing or a liability, depending on your perspective. Or both.
An Experiment Still Running
Agent sandboxes are emerging as a distinct infrastructure category this year, driven by production deployments like Pinterest's orchestration systems and Anthropic's multi-agent architectures. The split between stateless function execution and stateful, long-running agent sessions is forcing infrastructure providers to choose lanes.
Indexable's lane is full environments, deterministic semantics, bare-metal economics. The trade-off is maturity. Cloudflare brings global distribution and enterprise SLAs; E2B has case studies and compliance work underway. Indexable offers raw primitives and transparent documentation of what's still unfinished.
For teams building reinforcement learning pipelines that fork environments thousands of times per experiment, or autonomous coding agents requiring full filesystem semantics, that trade-off might pencil. For others, the gaps will matter more than the capabilities.
The market will sort this out over the next year or so, as agent workloads shift from prototype to production and the real costs of isolation, latency, and state management become line items on engineering budgets. What's notable is that a four-person team has positioned itself to compete where Cloudflare ships product updates monthly and venture-backed players are raising Series rounds.
The infrastructure layer for AI agents is still being figured out in real time. That multiple architectural approaches are attracting serious funding and engineering talent suggests the ultimate winners will be determined by workload characteristics we're only beginning to understand. Indexable's fork-first, bare-metal bet is one data point in that experiment.
Whether it's the right bet remains an open question.
