oncell.ai

Ship your coding
agent to every
customer.

Each customer gets an isolated cell with their repo, local NVMe, vector search, and durable execution. Your agent runs in their cell. Their code never leaves it.

Get early accessDocumentation
<200ms
Cell wake time
7 GB/s
Local NVMe reads
0
Network hops to repo
sub-10ms
Codebase search

BEFORE CEL8

A YC startup built a coding agent on ECS + EFS + DynamoDB + Step Functions. Every customer's source code sat on a shared EFS volume. The agent was slow. The blast radius was every customer. One IAM mistake from a breach. Scaling meant more duct tape.

AFTER CEL8

Each customer's repo now lives in its own cell. Cloned to local NVMe. Indexed for search. Agent runs in a gVisor sandbox. The code never leaves the cell. Deployed in a day. Scaled to 200 customers in a week.

HOW IT WORKS

Your customer connects. A cell spins up with their repo cloned, indexed, and ready. Your agent codes inside their cell. When they leave, the cell pauses. Costs nearly nothing.

01
Customer connects
Cell created. Repo cloned to local NVMe. Codebase indexed for vector search.
02
Agent codes
Reads code, plans changes, edits files, runs tests. All inside the isolated cell.
03
Agent pushes
Commits changes. Creates PR. Cell has git credentials scoped to this customer only.
04
Cell pauses
No activity for 30 min. Cell auto-pauses. NVMe state preserved. Cost drops to $0.001/hr.
05
Customer returns
Cell wakes in 200ms. Repo, index, agent memory all intact. Picks up where it left off.
06
Agent crashes?
Resumes from last checkpointed step. Zero lost work. Zero re-spent LLM tokens.

INSIDE A CELL

Your customer's repo on NVMe. Their codebase indexed. Your agent running with durable checkpoints. All inside a gVisor sandbox they can never escape.

No S3 round-trips. No shared Pinecone index. No Postgres connection pool. Everything the agent needs is local — 7 GB/s reads, sub-10ms search, exactly-once execution.

acme-corp
4cpu · 8gb · 50gb
Git Repo
/work — cloned, local
Code Index
vector, sub-10ms
Agent Runtime
durable, checkpointed
Test Runner
npm/pytest, isolated
gVisor · isolated filesystem · scoped git credentials · egress blocked

YOUR CODE

This is your entire coding agent. Clone the repo. Index it. Search. Plan. Edit. Test. Push. Done.

Each await is a durable checkpoint. If the machine crashes mid-test, the agent resumes from the last passing step. Not from scratch.

# Your entire backend.
from oncell import Agent

class CodingAgent(Agent):

  cell = {"compute": "4cpu-8gb", "storage": "50gb"}

  async def setup(self, ctx):
    await ctx.shell("git clone {repo} /work")
    await ctx.index("/work")

  async def task(self, ctx, instruction):
    files = await ctx.search(instruction)
    plan  = await ctx.llm(instruction, files)

    for step in plan.steps:
      await ctx.shell(step.command)
      await ctx.shell("npm test")

    return {"status": "done"}
$oncell deploy✓ live

WHY CEL8 FOR CODING AGENTS

Customer code never leaves the cell
gVisor sandbox. Separate filesystem. Egress blocked. Not IAM policies — physical isolation. SOC2 and HIPAA by architecture.
Repo on NVMe, not S3
7 GB/s reads. Your agent greps a 10GB monorepo in milliseconds, not seconds. Codebase search is sub-10ms, not a Pinecone round-trip.
Crash-proof execution
Agent edited 15 files and ran 8 tests. Machine dies. Resumes from test #8, not from git clone. LLM tokens for steps 1-7 are NOT re-spent.
Tests run inside the cell
npm test, pytest, go test — runs in the same cell as the code. Same filesystem, same env vars, same node_modules. No remote test runner.
Git credentials scoped per customer
Each cell has its own git token. Customer A's token can't access Customer B's repo. Impossible — different gVisor sandboxes.
Costs nothing when idle
Customer finished their task. Cell pauses. NVMe state persists. $0.001/hr. Next request wakes it in 200ms — repo, index, memory all intact.

SHIP YOUR CODING AGENT

You write the agent.
Every customer gets their own cell.

Their repo. Their index. Their tests. Their agent. All isolated. All durable. All local. Deploy in one command.

Get early accessRead the docs