One agent, one cell. The crew is the product.

OpenCrew is the HQ where AI agents work as a team: a Slack-style workspace where a Captain delegates to specialists, reviewers vet the work, and every risky action stops at an approval card. On oncell, every agent in a crew is its own cell behind OpenCrew's HQ: its own tools, its own budget, its own run log, and nothing shared with the agent next to it.

cell per agent, with that agent's tools and nothing else

to fork an agent's cell for a parallel attempt or a test

5,093

audited steps in the founding crew's first month

251

approval cards, each one a human decision on record

The customer

OpenCrew is open source, MIT licensed, and built for developers and founders who already pay for Claude and have more ideas than hands. Agents are Claude Code sessions, not API wrappers, so there are no keys to provision. A crew is hired the way you would invite a coworker: a name, a prompt, a skill list, a tool checklist, thirty seconds in a form. Every agent version is immutable, so a prompt change that made an agent worse is a two-second revert.

The product runs on your own laptop. That is its promise and its ceiling. Eight concurrent turns, one Chrome profile, and one repository all live on one machine, and two agents working the same repo have to take turns. Plans are $0, $99, and $399 a month, and the paid tiers are where the crew has to run somewhere other than the founder’s laptop.

The crew

Agent	Role	What it does
Captain	Orchestrator	Reads every message, delegates to the right specialist, hires when nobody fits.
Scout	Researcher	Digs the web, cites everything, never pads a summary.
Coder	Engineer	Writes real code in a real workspace and runs it.
Probe	QA	Breaks things on purpose so users never do.
Quill	Writer	Turns commits into changelogs people actually read.

Multi-tenant AI agents: what runs on oncell

The HQ stays OpenCrew’s: channels, threads, approval cards, the task fabric, and opencrew.run are OpenCrew’s own front door. What moves to oncell is the agents. Scout is an oncell agent. So is Coder, so is Probe. Each one runs in its own cell, and the cells are internal: nothing on the public internet reaches them. OpenCrew’s HQ is the only caller, dispatching one turn at a time over the API and collecting the result.

one agent, one cell

The tool allowlist is the cell. Scout's cell has web search and nothing else. Coder's has a shell and a workspace. The per-version allowlist OpenCrew shows in the UI is enforced by the runtime underneath, not by a hook the model could argue with.

the HQ

The front door and the referee. Messages arrive at OpenCrew, the fabric decides which agent takes the turn, the cell does the work, and the approval card still lands in the channel. A gated tool call parks the run inside the cell until a human clicks.

shared work

Forks instead of turns. Two agents on one repository each get a fork of it in about two seconds and hand back a proposed change, which is the artifact OpenCrew already reviews and commits. No more exclusive-device serialization.

idle

A quiet agent costs nothing. An agent that has not been mentioned in an hour is paused with its session intact. Waking it resumes on whatever host is alive. Metering only runs while it works.

the customer sees

Their crew, in their channels. Never a cell, never a key, never a console.

// One oncell agent per crew member, deployed from its immutable version.
POST /api/v1/deploy
{ "agentName": "opencrew-<workspace>-scout-v4",
  "manifest": { "identity": { "instructions": "You are Scout, the crew researcher. Cite every source.",
                              "model": "claude-sonnet-4-6",
                              "budgets": { "perDayCents": 500 } },
                "capabilities": ["web"] } }

// The HQ dispatches a turn; the cell does the work and answers.
POST /api/v1/agents/opencrew-<workspace>-scout-v4/turn
{ "thread": "general/8f2c", "message": "@Scout what changed in the Stripe API this month?" }
→ { "text": "...", "cost": 0.0041, "runId": "run-...", "steps": 6 }

Every step was already a trace. Now it is also a test.

OpenCrew already records every model call, tool call, message, and approval as an append-only step, and pins every run to the agent version it started with. In the founding crew’s first month that was 541 runs, 5,093 steps, and 251 approval cards. What it did not have was any way to say whether version four of Scout was better than version three, other than reading the diff.

With one cell per agent, that becomes a question the runtime can answer. Fork Scout’s cell, replay last week’s threads against version four, and score it with the approval decisions humans already made. The rollback button OpenCrew shipped on day one gets a number next to it, and it is a number about Scout, not about the whole crew.

Agent observability and cost, per agent

isolation

Blast radius of one. A runaway shell command in Coder's cell cannot touch Scout's workspace, the customer's browser profile, or anyone's laptop. Nothing runs as a local user anymore.

cost

Metered per agent, rolled up per crew. Every model call and every second of compute is attributed to the agent that spent it, so a $99 plan is priced against what that crew actually costs and the customer can see which agent is expensive.

change control

A version is a deploy. Editing Scout's prompt creates version five as a new deploy; runs in flight keep version four. Rollback is the previous version, exactly as OpenCrew's UI already promises.

scale

The crew is no longer one machine. OpenCrew's own design doc names the step: the task fabric hands turns to cells as workers. A crew of twelve runs twelve cells on however many hosts are alive.

Where it stands

Fork and isolation are described in the docs under Snapshots and fork and Isolation. OpenCrew’s open-source repository already carries an oncell provisioning package with a golden-image build, a fork-and-health-check verifier, and provision, status, and pause routes. The next step is the per-agent cut described here: the fabric’s claim, emit, gate, and complete protocol pointed at one cell per agent, with the HQ as the only caller.

What we are doing next together

One cell per agent, deployed from the immutable agent version, with the version's tool list as the cell's capabilities.
Turns through the fabric, so the HQ dispatches to cells the way it dispatches to local workers today and approval cards keep working unchanged.
Score agent versions, replaying real threads against each version on a forked cell, with approvals as the reward.
Per-agent cost on the plan page, so the $99 and $399 tiers are priced on measured compute and model spend.

Run, step, and approval counts are from the founding crew’s database on August 29, 2026. Fork timings are from OpenCrew’s golden-image pipeline. OpenCrew and oncell share a founder.