An AgenticLevel archetype
The Deliberate
The Deliberate does not trust — it verifies; every advance the fleet makes passes through a gate before it becomes true.
Discover if you're a The DeliberateThe Deliberate is the type that conducts a fleet the way a mason builds in stone: nothing an agent produces counts as fact until it has been exercised, tested, and signed off. It leads through disciplined doubt — not the doubt that freezes, but the doubt that installs a gate at every joint of the work. Where other types bet on the speed of generation, this one bets on the certainty of what survives the check.
How it conducts
It runs the fleet in short, closed loops: instruct, take the agent's output, and immediately put it on trial — run the test, exercise the real flow, read the diff with a reviewer's eye before letting the change touch anything that already works. It prefers explicit checking modalities over implicit trust, and treats 'the tests pass' as a precondition, not a celebration. It hands work to agents in slices that fit inside a single verification gate, so no leap is ever too large to audit. The result is a fleet that moves in firm, reversible steps, with clean craft and a trail of sign-offs anyone can reconstruct after the fact.
Its superpower
It errs rarely, and it knows why. Because every advance crosses a gate before it counts, the Deliberate accumulates little hidden debt and almost no production surprises. The fleet inherits the conductor's discipline: the code that ships is lean, exercised, and defensible, and confidence in it is earned rather than assumed.
Its frontier
The type's frontier is the very thing that makes it strong: the gate. When every change must pass the trial, cheap exploration suffers — throwaway prototypes arrive heavy with rigor, and the fleet can idle waiting on the conductor's sign-off instead of racing ahead in parallel. Verification becomes a bottleneck when it is applied with equal severity to the irreversible and to what could simply be discarded tomorrow.
Sub-archetypes
No green test, no 'done.'
Within the Deliberate, you're the wing where verification becomes near-religion: every agent edit is chased by a check, every claim of 'it works' demands executable proof. You don't trust the code — you trust the test that exercises it. It's how you sleep soundly with a whole fleet touching the system.
A clean diff is an honest system.
You're the wing of the Deliberate that treats craft as verification: to you, messy code is a bug waiting to be born. You conduct the fleet demanding lean commits, no stray files, names that tell the truth, and zero 'I'll fix it later.' The tidiness isn't aesthetic — it's your guarantee that the next reader, human or agent, won't stumble in the dark.
Wings & blends
It blends with wings from other forms without ever losing the gate: an exploratory lean loosens the rigor where work is disposable and keeps it where work is irreversible; a scaling wing teaches the conductor to parallelize verification instead of serializing it; a speed wing shortens the loop between editing and proving. The axis stays the same — work is only true once it has been signed off.
Computed from your real transcripts · auditable
What defines this type is not a taste for quality — it is the structural pattern of verifying right after editing (verify_after_edit), of operating through explicit checking modalities, and of holding craft clean change after change. These are measurable in the trace: the closeness between an edit and the proof that validates it, the fraction of work that clears a gate before being accepted, the low rework rate. Nothing of temperament; everything of observable discipline.