A whole development team, one specialist at a time.

Ask a single reviewer to check security, concurrency, data persistence, accessibility and test coverage in one pass and you get an average of five shallow passes. Every specialist here reviews through exactly one lens, in its own dispatch, and no reviewer ever sees the whole roster — so no reviewer can quietly assume someone else covered it.

The no-muting rule is the one worth arguing about. Dropping low-confidence findings is the industry default; this pipeline refuses it and asserts the refusal in a test. A missed expensive-to-unwind defect is the costly failure. A low-priority note you skim past is not.

Nothing here is a single prompt with a long system message. Each stage has one job, and the ones that matter most — selection, verification, scoring — are deliberately performed by something that did not do the stage before it.

Changeset

The merge-base diff, with every file classified by technology signal.

Scope

A named roster resolved from team data before anything agentic runs — nineteen of them, composing as a union.

Selection

Two tiers: a deterministic signal floor plus the always-on specialists, then an agentic interest poll for the discretionary candidates.

Pre-checks

Your repo’s own linters and typecheckers run first, and their diagnostics are folded in as leads so the workers stop re-reporting them.

Reviewers

One dispatch per specialist. An oversized diff is chunked hunk-aware and map-reduced — nothing is truncated.

Verifier

An independent pass checking each specialist’s findings against that specialty’s own Verify criteria; a fail drives a bounded re-review.

Consultant

Every finding re-scored 0–100 against an anchored rubric and a false-positive catalog, blind to who found it.

Report

Deduped by defect, ranked, written per model, coalesced, and posted to the pull request.

The full pipeline, scope by scope →

An acceptance contract is atomic criteria, each with a check hint, pinned before the work starts and never edited mid-run to make a gap disappear. Then the loop runs: pick a lane, brief a coder, verify every citation, commit, and put the result in front of a conformance oracle.

• Carry-forward semantics. Only criteria this iteration targeted trust the fresh verdict; the rest keep their prior status. Without it the oracle silently forgets what it already proved.
• Anchor checking. A coder can hallucinate an execution claim, but not a diff anchor — so every cited line is checked against the increment, and a second failure blocks the commit.
• One lane per increment. Lane selection is deterministic signal ranking with zero model calls; only a genuine tie escalates to exactly one dispatch, and a failure there degrades loudly rather than guessing.
• The session commits, never the coder. Each increment is its own commit, so the git history is the rollback trail.

Three of ten recorded runs, and the halt is here because it is the informative one: the gate killed that run twice without ever rejecting the work, because the first gate run’s state was destroyed mid-run by the archiver. Six of the ten reached ready and four halted — two of those on budget, one after burning 13.5M tokens against a 10M ceiling. All ten are in the table behind this link. How convergence is measured →

The composition is registry → team → specialist → specialty, and dispatch is team-first: the first argument is a team, the second is one of its commands. All the Python lives in one generic engine. A team ships a spec, a roster, prompts, and the eval fixture it is judged against — and nothing else.

myteams <team> <command> [args]

myteams devteam review code --base main
myteams devteam plan code
myteams devteam build --contract ~/.myteams/contracts/devteam/feature.json
myteams researchteam research "loop engineering"
myteams teamtester campaign start --spec ./spec.json
myteams registry list

Nine teams ship today. The available surface is the union of what the installed, enabled teams contribute — there is no intermediate grouping layer and no verb-first fan-out.

• devteam — review, conformance, build
• projectteam — planning
• researchteam — verified research
• storyteam — narrative
• cookbookteam — recipe authoring
• brainstormteam — deliberation
• teambuilder — creates and improves teams
• teamtester — the run observatory
• socialteam — generated, not written

How teams compose →

A team is a directory: a spec, a roster of specialists, the prompts they read, and the eval fixture it is judged against. These are the ones that ship.

47 specialists and 252 review lenses across the 9, unevenly spread on purpose: devteam alone carries 23 of the specialists and 187 of the lenses, because reviewing code is the job with the most distinct ways to be wrong.

8 of the 9 produce runs, so they also answer the six shared commands — report, pause, resume, log, findings and insights — against their latest run without being told which one. A card omits what its team does not have: no scope flags, no scope figure; no roster of its own, and it says so.

Open any team →

teamtester runs teams against their own eval fixtures, across models, repeatedly — then reads the results three ways, so a flaky team and a mediocre team come out as different findings instead of one muddled score.

Tier 1

Nine deterministic probes over every run, at zero token cost — completion, run records, session outcome, dispatch hygiene, fan-out, verifier coverage, artifact substance, event delivery, stall. They read the subject run’s own SQLite rather than parsing its prose.

Tier 2

A sampled slice judged 0–10 per criterion with quoted evidence. The judge is always the same high-reasoning Claude model, whatever backend produced the artifact under test.

Tier 3

Campaign-wide defect mining: probe failures, run states and score means pre-compressed by plain GROUP BY, then one tools-disabled dispatch returning findings from a fixed enum — each linked back to the runs that evidence it.

Capacity

Median wall time, median dispatches and total tokens per team-and-model pair, rendered as runs per five-hour window. The campaign cadence comes from that number rather than a guess.

The probes, the tiers and the corpus →

Every team carries an intent contract with at least three weighted excellence criteria and scenarios that are exact command invocations. improve-team runs them, judges each artifact 0–10 per criterion with quoted evidence, proposes edits to the team’s own prompts and rosters, applies the ones you approve, and re-runs to measure whether the edit actually helped.

20.0

socialteam, baseline

68.18

after iteration one

87.27

after iteration two

halted

one criterion at 7 of 8

The 20.0 was not bad writing. The generated authoring objective denied its own child web access, so the team honestly reported that it was blocked and produced nothing. Fixing the tool grant took it to 68.18 — but freshness regressed to 1, because a prose instruction was being overridden. Iteration two moved that window into fixed doctrine and freshness went to 10. The lesson written down afterward: doctrine files bind, method prose gets overridden.

The same machinery creates teams from scratch: eight phases from framing questions through research, design, your approval, materialization, a gate with at most two repair passes, install with a smoke check, and handoff into this loop — a new team is a baseline to be scored, not a finished thing. Nothing is written to the destination before you approve the design. How a team is built and improved →

Everything above this line runs on main today. Everything below is real code you cannot yet rely on — either because it is still on a branch, or because it landed with nothing in the box that uses it. Separated out rather than described in the present tense with a caveat a skimmer never reaches.

Memory in detail →

Real tools over MCP in detail →

A review of the project’s own multi-provider review command returned 95 findings across 10 specialists and 2 models, spanning severity 14 to 92. The top one was a genuine concurrency defect: parallel provider runs each opening a separate backend against the same database file, producing intermittent locking and order-dependent failures.

Three separate findings independently flagged the same defect — provider calls gathered with no timeout, able to hang indefinitely. That is exactly what the merge key exists to collapse into one corroborated row. At the other end, the lowest-severity finding was an import inside a conditional block. The pass runs all the way down.

807

commits since April

125k

lines of Python

106

dated history entries

1

author

The limits, stated rather than implied: there is no precision-and-recall benchmark for this pipeline, so every claim about review quality on this page is qualitative. The published field ceiling on automated bug-finding is around 60% F1 and nobody is above it — this is not claimed to be. It is a single-author system exercised on a small number of codebases, and it has not been stress-tested by many independent authors. The whole record →

Ticked is on main today. An open circle is real code you cannot rely on yet — either still on a branch, or landed with nothing in the box that uses it — and says which.

The same hierarchical browser the platform uses for its own navigation, pointed at this. Every topic is a real URL you can share, and every one says how far along it actually is.