The structure follows three habits good engineers already have: DRY (don’t repeat yourself), separation of concerns, and using each tool’s best native features rather than the lowest common denominator.
1. Persona-Agents
A library of specialist agents, like a real team: an architect, a tester, a security reviewer. Each brings focused expertise to a shared goal.
2. Stages
A library of stage definitions. Each says what work must be done and which artefacts must exist when it is finished.
3. Knowledge
A library of reference material the agents use to generate their outputs and to check themselves.
4. Orchestrator
Uses AI to compose stages into an adaptive workflow, then tracks and manages the run. (Lesson 4.)
5. Package manager
Turns the above into tool-specific artefacts, for example for Kiro or Claude Code. (Lesson 5.)
Two kinds of checks
Compartment 2 (the checks) can hold two very different kinds of rule. Knowing which is which is the key to safe autonomy.
Written as LLM instructions
For judgement calls that are not a strict pass/fail, such as most code review guidance (“functions should be easy to read”).
Catch: when the same model writes and grades the work, it can satisfy the letter of a check but not its intent. So a stage with only these checks never approves itself; a human still validates the output.
Written as executables
Scripts, linters, tests, static analysis. For rules with zero tolerance, such as “no code path deletes a CloudFormation stack in production” or “no API endpoint is exposed without authentication”.
Payoff: the more of your rules live here, the more stages can finish (self-halt) without a person.
For each rule your team cares about, ask: is it a judgement call (inferential) or can a script decide it (computational)? Move the scriptable ones first.
Want the original wording? Read Section 3 of the specification.