Principles
The agentic workflow rests on three pillars. The product development principles say what the work is worth and why flow beats utilization. The agentic development principles say how AI agents behave: context resets, output is probabilistic, and a proxy optimized hard enough stops tracking the goal. The workflow's own principles combine the two into a design. Every rule of the Delivery Process, the parameters and the routines applies one of them.
The Workflow's Own Principles
The graph is the only memory
An agent's context ends with its run, so whatever a run does not write outside its conversation is lost (Compounding Context). The workflow therefore keeps nothing in a conversation: a task's state, what holds it, the changes it references, the assumptions an implementer made and the choices a person answered all live in the Flow graph. A run reads the graph, acts, writes the result and stops. A run that dies loses nothing, any agent on any model can run the next one, and context compounds instead of being rebuilt by every run (Artifact Persistence, Atomic State Isolation). What a run did not write did not happen.
The graph is a state machine
A task's state is its status, what holds it and the changes it references. Each transition is a condition read from that state and an act with one owner, so a tick is a function from the graph to the graph: it reads, applies every transition that came due, writes and stops, and the next tick does the same from wherever the graph is. Correctness comes from the structure, not from an agent remembering to do the right thing (Structural Determinism). This is why only a stage's owner moves a task in that stage and why, after the verdict, the tick is the only writer (one owner per transition, D9): two writers act on a state the other already changed. It is also why the pace belongs to whatever schedules the ticks, not to the agents.
One engine, extended for any project
The states, stages, owners and transitions are the same for every project. A project extends them only at defined extension points: an extension answers a question the engine asks and never changes the engine, and a point left empty takes its default. Shared handoffs keep the cost of a new project or a new agent flat instead of growing with every pair (Protocol Standardization). A rule lives at the most general level where it holds, Get Things Flowing for any work, this workflow for software delivery, the ttoss skills for how an agent carries it out and the parameters for one product, and a rule found true in every project moves up (Curated Minimalism). So any project, delivering code or anything else, adopts the workflow by answering its parameters, and an improvement to the engine reaches every project at its next run.
The author never verifies its own work
An agent that judges its own change optimizes the check instead of the goal (Proxy Collapse). The reviewer runs in a fresh context, did not write the change and never fixes it; a change to the gates that judge it waits on a person (Verifier Sovereignty); fix rounds have a limit; and a task closes only on its effect observed where it matters, never on green checks (Intrinsic Verification, FF3).
Autonomy is bounded by reversibility
Agents act alone where an act can be undone and its failure is seen in time; a person decides the rest (Reversibility-Bounded Autonomy). A standing decision delegates what agents may do, so the many small choices are made by rule instead of by queueing for a person (E13). A choice nobody delegated waits on who decides, written in the graph rather than guessed (Silent Interpretation), and the code host, not an instruction, enforces the merge rule (Deterministic Enforcement Supremacy).
How Each Rule Applies Them
The pages the agents read cite a principle only where the reason changes what an agent decides; this table carries the rest, for whoever changes a rule. A rule that cannot cite one is a candidate for removal.
| The workflow says | Because |
|---|---|
| The graph is the only memory; a tick that dies loses nothing | Compounding Context, Atomic State Isolation |
| One engine, extended at defined points | Protocol Standardization |
| A rule lives at the most general level where it holds | Curated Minimalism |
| One owner per transition | D9 |
| Rounds have a limit | Proxy Collapse, Compounding Contextual Error |
| What ages fastest goes first, read from the stage | F17, E5 |
| Intake writes a task, never a fix | Admission Control |
| A choice goes to a person only after a test | E10, E13, Silent Interpretation |
| A brief asking for several deliveries is split | Problem Decomposition, B1 |
| The implementer records its assumptions at the handoff | Externalized Confusion, Seam Memory Layer |
| The change goes up green, with its reversal path | Verification Latency, Designed Reversal |
| The reviewer did not write the change and never fixes it | Verifier Sovereignty, Boundary Justification |
| The agents integrate; a change to its own gates waits on a person | Reversibility-Bounded Autonomy, Verifier Sovereignty |
| A task closes on an effect observed where it matters | Detection Window, Intrinsic Verification, FF3 |
| The code host enforces the merge rule; instructions change only through a person's merge | Deterministic Enforcement Supremacy, Control Stack |
| Models by exact id | Pinned Substrate Migration |
| Child runs are capped; a stale one is closed | W1, F19 |
| Routines run on nested cadences, on the cheapest model that does the work | F5, F14, Allocative Efficiency |
| The Chase tells people what the graph holds for them | Contextual Readiness |
| The Chase reports time in each state, computed by Flow | E5, E3, Q11 |
| The Audit measures what runs spend | Prompt Economics |