Here are all twenty-four stages.
They run in seven phases, from the first idea to the last day. Each card says who holds the stage, what it's given, what it hands back, and how you know it's done. Keep what you need.
Retract and Rollback name their roles; the reference publisher and deployment-manager agents don't hold them.
A service that runs these stages reports each build by them, one entry per stage, through the lifecycle API.
What each stage's gate must require, for each tier of risk, is set by an organization's policy, as laid out in the Agentic Governance Framework.
Define
Whoever builds from it can't ask what you meant, so it says everything, and never invents a name, a price or a permission.
- Role
- spec writer for an agent; solution planner for a solution
- Given
- somebody's account of what they want, with whatever they have
- Hands back
- a statement of the job: what it does, refuses, needs, records and costs, plus the open questions
- Done when
- a package could be built from it, and nothing unsettled was invented
The systems named here become the package's runtime requirements, and the bindings are what Deploy places.
Architecture
- Role
- solution architect, or a person
- Given
- the statement of the job, and the organization's stack
- Hands back
- an architecture record:
- the systems the agent reaches, in plain words (database, files, text reasoning, mail sender)
- the product bound to each in dev, test and production: the organization's stack first, a platform default for the rest
- dependencies on other agents and services
- the agent's kind: a harness reading skills, code that speaks the network itself, or a container
- limits on cost, speed, data and trust
- each decision, with its reason
Design
- Role
- spec writer for an agent; solution planner for a solution
- Given
- the statement, and the architecture record
- Hands back
- the steps, what each is given and hands back, and whether each is a program or a judgment
- Done when
- every system is named and bound in each environment it will run in, every decision has a reason, and every design step uses only systems the architecture named
A change that's safe for its owner can break everyone who depends on it.
- Role
- impact analyst
- Given
- the change, the running version, and what depends on it
- Hands back
- the impact report: each dependent marked compatible, breaking or a change of behavior
- Done when
- every dependent is named and answered, and the person approves before anything is built
The cheapest step is one somebody already built and checked.
- Role
- catalog
- Given
- the steps, each with what it takes and hands back
- Hands back
- for each step, an agent or solution that fits, or "build one" with the reason
- Done when
- every step has an answer, and every "build one" says why
Make
Tests come before the program, from the statement, so a test can't pass by agreeing with a mistake. (Yes, people argue about this.)
- Role
- test writer
- Given
- the statement of the job
- Hands back
- the suite, and what no test could be written for
- Done when
- the suite fails against empty stand-ins, and notices each program removed
Any code writer can hold it; your prototype is read as the spec and written again against the suite.
- Role
- code writer: the reference agent, your own coding agent, or a person
- Given
- the statement, the suite, and a prototype if there is one, as a build folder on a branch with a "Write the scripts" pull request
- Hands back
- the programs, an account of what was written, and a record of every round
- Done when
- the suite passes, each program removed is noticed, and the tests and statement are unchanged
The hand-off. The folder carries its rules in AGENTS.md and a fence in build.lock.json, so the coding agent you already use can hold this stage. Its work comes back through the gate as the pull request's checks, then the owner's OK. Start here with your own coding agent.
A review is already an artifact everywhere else: findings you can answer.
- Role
- code critic
- Given
- the programs, the tests, and the Code stage's account
- Hands back
- findings, each naming a place, a claim and a consequence
- Done when
- every finding is answered, by a change or a reason
The blast radius is set before the credentials are given, not after.
- Role
- security reviewer
- Given
- the architecture record and the design, the programs, and everything the package will ask for
- Hands back
- what it may reach, what it may spend, what it must never do, and the reason for each
- Done when
- every permission asked for has a recorded reason
Ship
Your work becomes an Agent Package, the easy way onto the mesh. Any tool works if the package is valid.
- Role
- package maker
- Given
- the architecture record, the design and the programs
- Hands back
- the package: the declaration (agent-descriptor.json and agent-runtime-requirements.json), the parts, a manifest and a digest
- Done when
- the declaration validates and matches the runtime requirements, and every program in the package is listed in its manifest
The signed record is why anyone downstream can trust the bytes.
- Role
- package maker
- Given
- the package
- Hands back
- a signed build record, and the package at an address
- Done when
- the digest at the address matches the record, and the record verifies
There's never a moment when the agent is live without its credentials and limits; secrets are named, never carried.
- Role
- deployment manager
- Given
- the package, where it goes, and the owner's answers as names and numbers
- Hands back
- a running agent with an identity, an address and an inbox; its Descriptor signed and registered; settings, credentials (placed by name) and ceilings in place before it starts; a signed deployment record
- Done when
- nothing asked for is missing, no secret appeared, a message gets an answer, and the record is signed
Prove
It checks the agent keeps its promises, not that the promises were right; that's Eval.
- Role
- conformance checker
- Given
- the package, the agent's address, and its records
- Hands back
- a signed verdict, case by case, and an attestation: one signed statement, for this version, of which checks on a published check list it passed
- Done when
- every case from the declaration ran, the verdict is signed, and the attestation names the version, the check list and who attested
Acceptance
13a personOnly the person who asked can say it's what they wanted.
- Role
- the requester, the person who asked
- Given
- what was delivered, and "done" as written at Requirements
- Hands back
- a recorded yes against "done", or a no that says what's missing
- Done when
- the answer is recorded with who and when, and the request closes
Use
The AgentDoc is gathered from what the agent declares, not written, so it can only say what its sources say.
- Role
- documenter for the AgentDoc; doc writer for the documentation
- Given
- the declaration, the identity, and any records, verdicts and attestations
- Hands back
- the AgentDoc a stranger reads, each claim traced to its source, with the attestations others signed shown as checked by others, and documentation for people
- Done when
- nothing in the AgentDoc was authored, and every silence shows
The stage where a deliverable becomes public.
- Role
- publisher
- Given
- the deliverable, and where it may be written
- Hands back
- an address a person can open, and the digest of what's there
- Done when
- the address resolves and serves what the digest says
Only whoever published something may take it down.
- Role
- publisher
- Given
- the address, or the name it went out under
- Hands back
- a record of what was taken down, by whom, and when
- Done when
- the address reads back empty, and the record says why
Run
A process being up says almost nothing; liveness is measured by an answer.
- Role
- watcher
- Given
- the fleet, and what each agent declared
- Hands back
- whether each agent is alive, answering, and inside its limits
- Done when
- each agent has a current answer or an open alert
Conformance says it answers; eval says whether the answer was any good.
- Role
- agent critic
- Given
- the work, and a standard set beforehand
- Hands back
- a graded judgment, with a reason on each grade
- Done when
- every piece is graded, and the standard predates the work
Record what happened, guess nothing, fix nothing; deciding stays with a person.
- Role
- incident recorder
- Given
- what monitoring saw, and the agent's records
- Hands back
- a timeline of what's known, with every gap marked
- Done when
- every fact names its source, and every gap is marked
Ceilings are the easy half; the view across everything is the hard one.
- Role
- watcher
- Given
- the ceilings, and what each job spent
- Hands back
- what was spent, by whom, against what was allowed
- Done when
- every spend traces to a job, and the total reconciles
Change
New version, same identity: candidate first, then prove, then promote.
- Role
- deployment manager
- Given
- a new package, and the agent it replaces
- Hands back
- the same agent on the new version, with what changed recorded
- Done when
- the candidate passed before the promote, the identity and address are unchanged, and the old version's attestations are marked stale until the new version is attested
New settings, credentials or ceilings, same version.
- Role
- deployment manager
- Given
- the running agent, and the change as names and numbers
- Hands back
- the same agent on the same version, and a signed record of what changed
- Done when
- the change is in place, no secret appeared, and the agent still answers
Moving the code back is easy; undoing what the bad version did is not.
- Role
- deployment manager
- Given
- the agent, and the version before
- Hands back
- the agent back on that version, why, and what can't be undone
- Done when
- it answers on the old version, and the side effects are named
This is retiring an agent: the address stops answering rather than answering wrongly.
- Role
- deployment manager
- Given
- the instruction, and the agent
- Hands back
- nothing running, the records kept, and the address retired
- Done when
- no work is stranded, the records are kept, and the address is never reused
Beside the stages
The ledger
kept by the platformDebts a change leaves behind: owed to someone who depends on it, or to the agent's own team. An open dependency debt blocks promote and retire; a rollback is allowed and recorded.