Tests come first. That's the whole point!

Code first. Otherwise what are you even testing?

Two people in a tug of war over a lifecycle Two people lean back and pull on a paper banner of lifecycle stages until it tears in the middle. The left half reads Design, Test, Code. The right half reads Design, Code, Test. On the floor between them, ignored by both, sits a cardboard box labeled package. package Design → Test → Code Test → Code Design → Code → Test Code → Test

No two teams have ever agreed on a development lifecycle.

So this one is built to be tailored. Change the stages, change who holds them, and everything it builds still ends the same way: with its standard's own signed document, a Descriptor for an agent and a process document for a process.

Read the stages Get the code

Every stage says who holds it and how you know it's done.

This reference runs through twenty-four stages, from the first idea to the last day. Each names its role, what it's given, what it hands back, and how you know it's done. Here's one.

Test

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
Why here
Tests come before the program, from the statement, so a test can't pass by agreeing with a mistake. (Yes, people argue about this.)

Cut it to fit the way you work.

Add the stages you need, drop the ones you don't, and name them whatever you like. Put your own agent, a vendor's or a person in any role.

  • RequirementsWishlistnew name
  • Testas written
  • Codeyour own agent
  • Legal reviewadded
  • Packageon-ramp
  • Releaseon-ramp
  • Evaldropped

Join the lifecycle where you are.

Everybody starts from something: an idea, a prototype, working code, a package. Find the furthest one you have, and start at the stage right after it.

  1. If you already have an idea,start at Requirements
  2. If you already have a prototype,start at Test, then Code
  3. If you already use a coding agent,start at Requirements, then hand it the Code stage
  4. If you already have working code,start at Package on-ramp
  5. If you already have a package or an image,start at Release on-ramp, then Deploy goes live
  6. If you already have a remote agent with an A2A endpoint,register it; add what it refuses and records
  7. If you already have an agent connected to a network through a node,it's already on; finish its Descriptor
  8. If you already have agents running on a platform,start at Run and Change

See every asset, and which ones are required

Everyone agrees on the ending.

However your lifecycle runs, every agent ends with a signed Descriptor and a registration. An agent a platform runs also arrives as an Agent Package: the declaration, the parts, a manifest and a digest.

Our package maker is the easy on-ramp to the mesh. Any other tool works, as long as the package is valid.

A platform checks every package before it installs or updates anything, so every agent it runs meets the same gate, whoever built it.

seven stages twenty-four stages two stages and a lot of hope package

Any agent can hold a role, and so can you.

Every stage names a role, not a product. The roles are written down at agentroles.ai, so anyone can build an agent to one, and a person can hold any of them. The coding agent you already use can hold the code writer role through a hand-off, and here is the contract to give it. A tool that already checks software can hold a checking role the same way, and here is what it signs.

Start from working code, not a blank page.

Reference agents for eleven roles are open source under Apache-2.0, at github.com/CommonAgent/adlc.

Run them, read them, or swap in your own.

CommonAgent/adlc
$ git clone https://github.com/CommonAgent/adlc
$ cd adlc/agents/test-writer
# eleven agents, one folder each:
spec-writer  test-writer  code-writer
package-maker  deployment-manager
conformance-checker  publisher  catalog
documenter  incident-recorder
solution-planner

Copy a process instead of writing one.

Here are three examples, in the open format at agentprocesses.ai. Copy one, put your own holders in it, and run it.

Make a new agent

A request in words becomes a deployed agent, with the owner's yes at three gates.

agentprocesses.ai/make-a-new-agent

Record an incident

Notice it, gather the records, write it down with every gap named, then decide.

agentprocesses.ai/record-an-incident

Retire an agent

Take the listing down, get the owner's yes, remove it, close its AgentDoc.

agentprocesses.ai/retire-an-agent

Here is the whole map.

Open any stage for its role, its handoffs and its check.

Define

Make

Ship

Prove

Use

Run

Change

Beside the stages sits the ledger, where the debts a change leaves behind are written down.

Read the stages See the handoffs