create · autonomous development
create is the delivery capability. Ten specialized agents plan, build, test, and review code. You set direction. Everything else runs.
Every session starts the same way.
How it works
Every feature follows the same five-phase sequence. Gates are mechanical: a phase does not close until the criteria pass. No exceptions.
Alex writes the ADR and Bea scopes the work. Acceptance criteria exist before a line of code does.
Tessa's tests define the target. Bob writes the code to pass them, and nothing more.
The 2,000+ test suite runs across the fleet. The gate stays red until every test passes. No workarounds, no waivers.
Lint, eval, and Quinn review before anything closes. Sentinel checks for security violations.
Stewart closes the ticket and commits the work. You sequence what comes next off the backlog.
Nothing moves to the next phase until the gate passes. Nothing reaches done without clearing all five.
The roster
Every agent has a bounded role and a defined authority ceiling. No agent approves its own work, claims outside its role, or skips review. The names are a shorthand for keeping the wheel: a ticket to Bob means build, to Quinn means review.
Writes the ADR. Decides the shape of the work before it starts.
Turns intent into scoped tickets with verifiable acceptance criteria, and owns the docs.
Writes the code to pass the tests. Nothing speculative, nothing extra.
Writes tests first. The suite is the target the build aims at.
Reviews every change before it can close. Reuse, clarity, correctness.
Audits for vulnerabilities and policy violations at the review gate.
Assesses whether work is actually complete, not just present.
Reproduces, isolates, and fixes. Tracks down what broke and why.
Improves structure without changing behavior, under green tests.
Triages, sequences, commits, and closes. Keeps the backlog honest.
Proven at scale
Every number below comes from the live ticket archive and git history (1,604 accepted changes across 8 repositories, April 1 through July 11, 2026), graded against Addy Osmani's agentic-autonomy framework. create lands as a real Level 5 system: managed by exception, not managed by hand.
Median lead time from filed to verified-merged is 25 hours (queue time included by design). Median agent-active cycle time is 5.2 hours.
10% of all throughput is defect-repair on the system's own output: filed, dispatched, and verified by the same pipeline that shipped the original change.
28 reverts executed in 60 days against 352 merges, zero lost work. Every agent works in an isolated, detached worktree.
33% of all tickets receive automated review feedback and get caught and corrected before a human would ever have seen them, across 7 independent gates.
Source: internal GTM grading report, 2026-07-11 · 1,604-item ticket archive, live backlog API, 60-day git history. One closed, audited window.
Set in order, struck once
How it holds together
Software projects fail the same three ways: scope drift, knowledge lost at handoffs, and slow velocity despite good tooling. These four constraints are a direct response to all three.
Constraint 01
Ticket to ship, nothing skipped
create is the delivery engine. Tickets move through defined states with mechanical gates at every transition. No manual approvals, no social pressure. The schema refuses illegal moves outright, and a reconciliation layer catches what no schema can prevent: a stale claim held by a dead session is checked against live heartbeats and released automatically, never left to rot on the board.
Constraint 02
2,000+ tests. The gate doesn't negotiate.
Tests are written before code. RED to GREEN to REFACTOR, enforced by a suite that exceeds 2,000 tests and runs on every cycle. The gate will not open on a red suite for velocity, for deadlines, or for anyone. Validation spans every language the stack touches: TypeScript, Python, and Rust. One pipeline, consistent enforcement.
Constraint 03
Institutional knowledge doesn't reset
Session scratchpads, decision traces, and phase handoffs persist across context limits through remember, the Lexenne memory layer. Agents do not start cold. The system accumulates context across every session and handoff, closing the knowledge gap that breaks projects at scale.
Constraint 04
Agents handle mechanics. You decide what matters.
The repetitive mechanics of delivery, writing tests, sequencing the backlog, reviewing code, are automated. The decisions that actually matter stay with you. The automation is the point, and the human in the loop is by design, not by limitation.
The second layer
The pipeline runs when you hand it a ticket. A Loop is the layer above it: a long-running agent that watches the system, finds work worth doing, and brings it back through the same gates. Every Loop runs on five moves, and earns autonomy one rung at a time, from notify, to propose, to act.
Evelyn watches the pipeline and asks the hard question every gate avoids: is this actually done, or does it just look done? She sweeps the archive for false dones, files the remediation tickets herself, and clears routine reviews so a human only ever sees the exceptions.
Doug goes looking for the work nobody filed: the stale dependency, the flaky test, the quiet regression. He runs discovery on his own schedule and proposes a fix as a ticket, never commits one unattended.
A Loop only climbs to act once it has earned trust at notify and propose. That is the whole design.
The pair
create reads its context from remember and writes every decision back. Explore the memory it runs on, or reach out about putting create to work in your own development.