In development · private beta
SessionFleet runs coding agents in isolated lanes, applies your team’s policies, and binds a review by a different model family to the exact change it approved. Today that runs one direction: Claude Code builds, Codex reviews.
coordinator · holds the lease · 5 lanes allocated
| Lane | Claim | Gate | |
|---|---|---|---|
| lane-1 | capability-pages | docs/capability-pages | building |
| lane-2 | tier1-review | feat/tier1-review | gate passed |
| lane-3 | context-meter | feat/context-meter | gate failed · R2 |
| lane-4 | vocab-drift | docs/vocab-drift | blocked on R1 |
| lane-5 | currency-codex | feat/currency-codex | unclaimed |
That is the system we run our own development on today. What installs right now is the readiness layer below — the runner, the board and the review gate reach the beta once they are proven here first.
Running many agents is becoming a runtime feature. Claude Code’s own product page describes an agent view for managing sessions, and workflows that execute “across 10s to 100s of parallel subagents, and checking its work before anything reaches you” (claude.com/product/claude-code, retrieved September 2026). Read that last clause again: its work. The open question is the one a vendor cannot answer about itself — checked by whom, against whose policy, and with what evidence you can audit afterwards.
The reviewer shares the author’s blind spots
A model reviewing its own family’s output scores it higher and misses the same things. LLM-as-judge studies (June 2026) measure self-preference from −38% to +90% across datasets, and find same-family bias alongside it. The review still looks rigorous, which is what makes it expensive.
Policy lives in one vendor’s product
Permissions, sandbox posture, merge authority and what counts as reviewed are your decisions, not your runtime’s. When they are settings inside one agent, they do not travel to the next one your team adopts.
The evidence dies with the session
A verdict that lives in a chat log cannot be re-checked against the commit it approved. When the session ends the reasoning goes with it, and the next person inherits a merge nobody can audit.
The bottleneck stops being how fast an agent writes. It becomes whether you can trust what came back — and prove it later.
SessionFleet ships as two plugins from one repository — one for Claude Code, one for Codex. We publish what an install actually contains, and what it does not, because a control plane that overstates itself is the exact thing it exists to prevent.
Today — the readiness layer
Four skills and a sensitive-path guard. Scaffold a project profile, run the readiness checks, review a plan against platform constraints, and route around a missing tool without ever installing one silently.
Today — governance you own
Permissions, sandbox, credentials and sensitive paths live in your config, never in the plugin. SessionFleet ships mechanisms; your team supplies policy. Nothing is enabled on your behalf.
Next — the runner and the board
The coordinator, the lane runner, the run record and the fleet view are running on our own development now. They reach the beta once they have been proven on our backlog first.
Next — cross-family review, installed
The review packet, the risk tiering and the evidence gate are built and in daily use here. Packaging them so a consuming repo gets the same gate is the work between here and beta.
A capability appears here as “Today” only once it installs. Everything else says Next, however well it works for us.
Three mechanisms, in the order a change moves through them.
01
A coordinator allocates work to lanes. Each lane is one claim, one branch, one worktree, one pull request, so no two agents share a checkout. How many run at once is your policy, not ours — the shipped default is one, and we run five on our own development as a deliberate test boundary rather than a recommendation. Lanes stay attachable: you can watch one or take it over mid-flight, because a background lane is one nobody can rescue.
02
Today one direction is built: Claude builds, Codex reviews. The reverse — Codex building and Claude reviewing — is designed and not yet running, and we would rather say so than imply symmetry we have not shipped. The decorrelation is the asset either way: a reviewer from a different model family does not share the author’s blind spots. Risk is tiered by path and posture, the strictest wins, and security, permissions and merge-boundary paths can never be downgraded to save tokens.
03
Sessions end. The work should not. State lives in the repository and in run records rather than in a conversation, so a successor can reconstruct what is in flight from git and the pull requests alone — and the handoff carries the mechanism, not just the status.
We hold ourselves to a rule that a capability is not claimed until an eval proves it. That applies to this page too: each figure below is checked against the repository record that produced it, and each carries the scope of that record rather than a rounded-up headline.
On our fixture, a different model family found what the same one missed.
On a committed paired fixture, the cross-family arm surfaced a finding the same-family arm did not, on 3 of 3 targets, with the threshold declared before the corpus was generated. Directional evidence for the mechanism — not a catch rate.
The gates find real defects, not style notes.
In one development epoch: 29 review rounds dispatched, 28 returned a failing verdict, and not one finding was cosmetic.
Passing your own tests is not the same as being reviewed.
On one change, all 8 constructed mutants were killed by their named assertion — and the opposite-family gate still returned 6 blockers on the same commit.
The work survives the session that started it.
A successor coordinator has rebuilt working state from git and the pull requests alone, with no conversational context carried over.
Every phase ships one capability, is proven on SessionFleet’s own backlog first, and only then is offered to anyone else. We run the next sprint using the capability we just built. The practical effect is the part worth caring about: you never receive an unproven capability, and when something does not work yet, we have already found out.
Ordered, not dated. A milestone gets a date here when the measurement behind it exists — not before.
Today
Readiness and guardrails
Next
The runner and the board
Then
Cross-family review, installed
The end state
A fleet your team runs
Both runtimes change weekly. We track each one independently — primitives, releases and security posture — because a fact verified on one runtime is not evidence about the other. Each record carries the evidence behind it and the commit it was generated from.
Claude Code
Primitives, releases and security posture, each dated and sourced. Features and best practices are still being gathered.
Open the Claude Code referenceCodex
The same surface, built and verified in a separate lane — never inferred from the Claude Code side.
Open the Codex referenceA section stays visibly empty until a record has actually been measured for it. An empty page here means we have not made the measurement, not that the answer is zero.
SessionFleet ships no credentials. A check on every change scans the shipped payload’s direct dependencies and imports for credential, telemetry and MCP defaults — that is the scope it covers, and transitive dependencies are a named follow-up rather than something we claim today. The Claude Code and Codex CLIs authenticate as they already do on your machine; that stays between you and them.
Lanes and self-healing open pull requests; they never push to your protected branch, never relax a permission, and never enable MCP, telemetry or credentials on their own. A coordinator may merge only under the conditions your merge-authority policy sets, and that policy is yours.
SessionFleet adds no telemetry, no prompt logging and no upload channel of its own, and runs no server in between. Cross-family review does send your diff to the reviewing CLI — and because the reviewer is deliberately a different model family from the author, that is generally a SECOND provider receiving your code, not the one already running your agent. Which CLI reviews, and therefore which vendor sees the diff, is set by your configuration.
The opposite is the point. It ships as two plugins, one for Claude Code and one for Codex, from a single repository. Cross-family review only works because two families are involved — it is a layer no single vendor would ship.
Those are agents. SessionFleet is not another agent runtime — it is the layer above one: allocation, isolation, independent review and merge authority. We coordinate; we do not replace your editor.
In your repository, and in the plugin data directory the runtime gives it. Nothing is written to the plugin root, because that is wiped on update. SessionFleet itself sends none of it anywhere — but see the question above: review does pass your diff to the reviewing CLI, so this is a statement about the state SessionFleet keeps, not a claim that no data reaches a vendor.
SessionFleet is in private beta. We are working with a small number of teams already running Claude Code or Codex who want governed delivery rather than more agents. If that is you, get in touch.
Worth including: