It builds agents and processes.

One shape from the first stage

What a build makes is never kept in a private format and converted at the end. The statement of the job is already written in the standard the finished thing will follow, so it is the statement and the design at once. The test writer tests what it declares, the next stage builds what it names, Conformance checks the finished thing against it, and the listing is copied from it.

The stages stay the same for every kind. What each stage hands back changes with the kind.

The two kinds

	An agent	A process
Shaped as	a Common Agent (the Common Agent Specification)	an Agent Processes document (the Agent Processes Specification)
Requirements writes	the Descriptor: what the agent offers, takes, hands back and refuses	the process document: its steps, who holds each, what a run is handed, what passes between steps and where a person signs
Tested by	a suite of tests, written before the scripts	a suite of test cases, written before the wiring and run as test runs
Ships as	an Agent Package, signed	the process document and its test cases, pinned by digest and signed
Proven by	Conformance: the running agent keeps the promises its Descriptor makes	Conformance: the document meets the specification, and every test case passes
Listed as	its AgentDoc and a catalog entry	a process entry in a catalog, copied from the document's header

Stage by stage

Stage	For an agent	For a process
Requirements	the Descriptor, with the questions only the person can answer	the process document, with the questions only the person can answer
Architecture and Design	how the agent is built	who holds each step, and what each step hands the next
Impact	who depends on the agent	who depends on the process: other processes that run it, and agreements pinned to its digest
Source	an agent or a part that already exists	an agent that already holds the step, or a new one made by Make a new agent
Test	the suite, shown to fail against nothing	the test cases: what each run is handed, how each approval is answered, what must be true at the end
Code	the scripts, passing the suite	the wiring: the holders bound, and each handoff fitted to the step that receives it
Review and Security	findings on the code, and what it may reach	findings on the document, and what its steps may reach outside
Package and Release	the Agent Package and its signed build record	the document and its test cases, pinned by digest, with a signed record
Deploy	the agent installed with its credentials and limits	the process filed with the organization's processes and bound to its trigger
Conformance	the agent checked against its declarations	the document checked against the specification, and the suite passed
Acceptance	the person tries it and says yes	the person runs it for real and says yes
Docs and Publish	the AgentDoc, and the catalog entry	the catalog's process entry
Update	a new version, proven before it is promoted	an amendment, a new version whose suite passes before it runs real work
Decommission	the agent's address stops answering	the process stops starting runs, and its listing comes down

A process can need an agent

When Source finds no agent that can hold a step, the process build runs Make a new agent for that step and waits for it. The new agent goes through every stage of its own lifecycle, and the process build carries on once it is installed and proven. One request can therefore make a process and the agents it needs, each checked by its own standard.

Adding a kind

Any other kind of work can go through the same stages if it has three things:

• a standard document that says what the finished thing is, which Requirements writes from the first draft;
• a way to test it that a program can run, written before the thing is built;
• a way to pin it, sign it and list it, so anyone downstream can check that what they were given is what was approved.

The stages, the handoffs and the way a person says yes stay as they are.