Principles
The agentic workflow rests on three pillars. Get Things Flowing (GTF) says what holds for any work: the graph is the record, the person decides, review confirms reality. 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 below combine the three, and they are the only place the workflow cites a pillar. Every rule of the Delivery Process, the parameters and the routines rests on one of them, listed under it. A rule page cites a principle only where the reason changes what an agent decides. A rule no principle reaches is a candidate for removal, and so is a principle no rule rests on.
- The graph is the state, and a tick is a function of it
- One engine, extended for any project
- The author never verifies its own work
- Autonomy is bounded by reversibility
- A rule holds where no agent can outvote it
- Cost of delay orders the work, read from a proxy nobody estimates
- The release queue holds new work upstream
- A full queue is drained, never only held
- A choice is answered by a rule where one exists, and by a person when the work needs it
- No wait is open-ended
- A number is Flow's answer, never an agent's estimate
- Every run is paid for
The graph is the state, and a tick is a function of it
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 status, what holds it, the changes it references and the choices a person answered all live in the Flow graph (P1). A handoff persists what the next run needs in fields the handoff requires, never in a message it must infer (Seam Memory Layer). What integrating leaves is one of those fields, which the tick acts on without reading prose. An implementer's assumptions travel in the change the task references, where its reviewer reads them (Externalized Confusion). The brief is the contract a change is built and checked against, so while a change is out the brief stays as it was given and new scope is a task of its own: a brief rewritten under an open change closes the task against an acceptance the change never implemented (Executable Specification). A run that writes a task again reads it first and names the version it read, since another session may have written it since (Atomic State Isolation).
That state is a machine's: each transition is a condition read from the graph and an act with one owner, so a tick is a function from the graph to the graph (P5). It reads, applies every transition that came due, writes and stops, and the next tick does the same from wherever the graph is. A run that dies loses nothing, and any agent on any model can run the next one (Artifact Persistence, Atomic State Isolation). A parameter points at the file that holds its rule for the same reason, and a signal enters once, by the URL it carries.
What a tick judges is a fact about a task, a change or the parameters, so it is written where that fact lives before the tick plans again: on the task (a tag, a wait, the tasks a split made), on the change (a verdict bound to its commit), or in the parameters file, which every tick reads anyway. Nothing a tick judged reaches its plan from the tick's own memory, so a tick that ends after any act, its work finished or not, leaves the next tick nothing to judge again, and a judgment is paid for once (Compounding Context, P5).
Correctness comes from the structure, not from an agent remembering to do the right thing (Structural Determinism). Only a stage's owner moves a task in that stage, and after the verdict the tick is the only writer, because two writers act on a state the other already changed (one owner per transition, D9). A script computes and never writes, so every write stays with a run and the standing decision it acts under. When nothing schedules a tick, the next run that reads the graph writes what the tick would, since the transition is the graph's, not the scheduler's.
A signal from outside enters the same way, as a task the tick delegates like any other, never as a fix the signal starts on its own. Capturing is not committing (P3), and what enters execution is the tick's decision (Admission Control). The pace belongs to whatever schedules the ticks, not to the agents, and what a run did not write did not happen.
Rules that rest on it:
- One owner per transition.
- With no tick, the next run that reads the graph writes what the tick would.
- A script never writes; every write stays with a run, under the standing decision.
- A parameter is a pointer to the file that holds it, never a copy.
- Every judgment a tick makes is written where its fact lives (the task, the change, the parameters) before the tick plans again; the next tick never judges it again.
- A brief's readiness is a recorded fact of the task, written by whoever writes or refines the brief, or by the tick that reads it once.
- A brief with a change out is not rewritten: new or wider scope is a successor task. A run that wrote a task reads it again before writing to it again, naming the version it read.
- The implementer records its assumptions at the handoff.
- What integrating leaves is a field of the handoff, never prose the next run infers; a person who supplies it later writes the field, and the next tick applies it.
- Intake writes a task, never a fix, and looks for the task the signal's URL already names before it writes one.
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. A rule found true in every project moves up (Curated Minimalism).
The model a parameter names is part of what the engine runs on, so it is pinned by exact id. An upgrade is a migration, never a swap an alias makes under a project without a change anyone made (Pinned Substrate Migration). The process names acts, never tools, so it reads the same on any code host and for a delivery that is not code. A stage a project answers with none is skipped, not replaced. The parameters bind every session working in the repo, a person's included, because an engine two kinds of worker run differently is two engines.
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.
Rules that rest on it:
- A project extends the engine only at its extension points, and never changes it.
- The process names acts, never tools.
- A stage answered with none is skipped.
- The parameters bind every session working in the repo, not only the agents'.
- Models by exact id.
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, which is the one isolation worth the continuity it costs (Verifier Sovereignty, Boundary Justification). A change to the gates that judge it waits on a person.
A round back goes to a fresh child, never to the one whose change came back. Fix rounds have a limit, since each round on the same gates compounds the error of the last and takes the system out of the range where more effort helps (Compounding Contextual Error, V13). Findings only a person can act on (product intent, a change outside the repo, a credential the agents lack) go to that person with no round, because a round there only delays the answer it ends in (E3).
A task closes only on its effect observed where it matters, never on green checks (P6, Intrinsic Verification). It closes as soon as the effect can be seen, because what a reversal must unwind grows with every hour between commitment and detection (Detection Window).
Rules that rest on it:
- Rounds have a limit, a round back goes to a fresh child, and findings only a person can act on go to them with no round.
- The reviewer did not write the change and never fixes it.
- The agents integrate; a change to its own gates waits on a person.
- A task closes on an effect observed where it matters.
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 (P2, Reversibility-Bounded Autonomy). Both cut what a wrong act costs rather than how often one happens, the cheaper lever when output is probabilistic (V12).
So a change carries its reversal path, designed in before it integrates, when buying it is cheapest (Designed Reversal). It goes up green, from automated loops that correct it before a person is asked (Verification Latency). One that proves harmful is reverted by that path before the fix is attempted, a cheap variability accepted to hold the expensive one (V14, F17).
A standing decision delegates what agents may do, so the many small choices are made by rule instead of by queueing for a person, and every write made under it names it as its cause (P4, E13). An answer a person gave more than once to the same kind of choice was meant as such a rule, so the Health proposes it as one, and the person's word stays the rule. Who integrates is the Merge rule's answer alone, so a handoff waits on a person only for a path the rule reserves to them, never for what integrating causes, such as a deploy: a wait on a person the rule does not name fills their queue with work the tick integrates without them (W21). A change a person integrated exactly as the agents proposed it, with nothing added and nothing sent back, answers "may the agents integrate this?" the same way: given twice for the same kind of change the Merge rule reserves, it is proposed as a delegation of that kind, because a reservation that is always granted is a queue for a decision already made (E13).
Work an agent notices outside its task that leaves the product unchanged, such as a refactor or a test repaired, with no behaviour a caller observes and no assertion, gate or agent instruction changed, holds no choice a person would make. So it is admitted active, for the tick to order like any other task, rather than parked incubated until a person promotes it (E13). It gets a change of its own, never one folded into the change at hand: a batch is limited by its worst element, so a refactor riding on a feature waits on the feature's check and is reverted with it (B10, B4). The code the change already touches is the exception: improving it adds nothing the review and the reversal path do not already cover, and a task for it would cost more than the improvement (B11).
What is reserved to a person is what no later tick undoes or what only they can own, listed once in the Decisions default, and a delivery whose act reaches outside the product. A change closed without integrating goes back to a person, to implement again or to cancel, because closing it was somebody's decision the tick cannot read, unless a change of the task in the same repo integrated or is still open, which already says what that decision was. A choice nobody delegated waits on who decides, written in the graph rather than guessed (Silent Interpretation), and only after the tests that show it is a choice at all, since a choice loses value while it waits (E10). Another agent's work is not an agent's to take: a run holding a task past its stale limit is left and reported, never reclaimed (P7). Nor is a blocks edge an agent's to release: once its source's change integrated and the source waits for its release or check, the edge keeps gating and the target is reported, because building on work nobody validated makes reverting the source cost more, unless the standing decision delegates retracting it.
Rules that rest on it:
- A choice goes to a person only after a test.
- Noticed work that leaves the product unchanged is an
activetask with a change of its own; other noticed work isincubated. - The implementer improves the code its change touches and widens the change no further.
- What the
Decisionsdefault reserves is a person's; so is a delivery that reaches outside the product. - The change closed without integrating goes to a person, unless another in its repo superseded it: implement it again, or cancel it.
- A check that needs a target the project did not name waits on a person.
- The change goes up green, with its reversal path.
- An integration that proves harmful is reverted by that path before the fix.
- Another agent's run holding a task past
Stale afteris left to its owner. - A task held only by
blockssources whose change integrated is reported, and the Chase lists it; retracting the edge is a person's unless the standing decision delegates it. - A handoff's wait is
ona person only when the change touches a path theMerge rulereserves to them, naming it; what integrating causes is never a reason. - The Health proposes a standing rule from an answer a person gave more than once.
- The Health proposes delegating a kind of change the
Merge rulereserves once a person integrated it as proposed twice or more; amending the rule is theirs.
A rule holds where no agent can outvote it
An agent cannot tell an instruction from the data it reads: a comment on a change, a tool's output and a file in the repo all reach it on the channel its instructions do (Instruction-Data Conflation). A prompt is the shallowest control there is, outvoted by whatever is read after it (Control Stack). So a rule that must hold against what an agent reads is enforced outside its context, by something that cannot read the diff (Deterministic Enforcement Supremacy).
The code host, not an instruction, enforces the merge rule, through required checks, branch protection and required reviews, which make it true for everyone. A verdict is a status on the commit it judged, from an identity allowed to give it, and the code host requires it, so a verdict read in a comment is not one. The agents' instructions change only through a merge a person approved, because the standing decision points at them.
The same ranking decides what an implementer may settle on its own: what is enforced by the system lasts over what a path's context says, over a procedure, over prose. Where enforcement has nothing to read, the gate fails closed. No verdict for the head, or a Review the parameters do not state, never reads as passed, because merging is the act no later tick undoes and a gate nobody can show passed has not passed (Asymmetric Risk).
Rules that rest on it:
- The code host enforces the merge rule; what judges or instructs the agents changes only through a person's merge.
- A verdict is a status on the commit it judged, from an identity allowed to give it, and the code host requires it.
- A gate fails closed: no verdict for the head, or a
Reviewthe parameters do not state, never reads as passed. - The long-term test ranks durability: enforced, then context, then procedure, then prose.
Cost of delay orders the work, read from a proxy nobody estimates
Work is ordered by what waiting costs, never by who asked first or by size (F16, E5). Nobody quantifies that cost per task: an agent asked to would invent a number and then optimize it (Silent Interpretation, Proxy Collapse). So the workflow reads it from a fixed proxy, the same for every project: the stage the work is in, and the two words a person may add.
The stages, in the order of what waiting costs:
- A red default branch holds every change in its repo, so its repair frees the most (P5).
- Integrated work nobody has seen in effect lets a regression run, the one thing that can go wrong and is not undone by waiting (P9, P6, Detection Window).
- A wait that came due is the tick's to act on (W20).
- What is open at its gates the agents drain on their own, and nothing ranks a conflict, a round and a review among themselves but Flow.
- New work loses little by waiting a tick (V16).
The two words: a very_high priority, which is their own assertion that waiting costs most, whatever the stage, and the bug tag, which at high says the defect is already in effect (P2). A priority holds through the blocks edge too: a task that holds a very_high is worked as one, by the priority Flow answers it inherits, since otherwise the work ranked first waits on what ranks last.
The proxy is the economics, coarsened: the order of the stages is their cost of delay ranked once for every project, which prevents the large mistakes without the per-task precision nobody has (E1, FF2). Below the proxy, Flow's ranking, priority then leverage (P5), orders the work inside a stage and never across them, since a priority holds only where the work is waiting (F18).
A brief asking for several deliveries is split before it is started, because a large batch delays everything it carries (B1) and an agent delivers what it can hold whole (Problem Decomposition). The Chase lists what only a person can move in the same order, so a person reads first what their delay costs most.
The order needs a free slot to act on, and fills two kinds apart. A long child, one that pushes a change (implement, round, conflict, repair), may hold its slot for hours, so with every slot on new work the repair of a red default branch would wait for one to free. New work therefore never takes the last free long slot while Max runs is two or more (D15). What ages faster takes it the moment it appears, ahead of the line without interrupting a run already underway, since a run stopped midway wastes what it did and head-of-the-line privilege already removes the wait (F20). A short child, a check or a review, only reads and ends, so it needs no reserve and takes its slot from Max short runs: under one pool, due checks ranked above new work would fill every slot the reserve left, and new work would never start while the release queue had room.
Rules that rest on it:
- What ages fastest goes first, read from the stage, a
very_highpriority and ahighbug, asserted or inherited throughblocks. - A brief asking for several deliveries is split.
- New work never takes the last free long slot; what ages faster takes it, without interrupting a run.
- Checks and reviews take their slots from their own limit, never from one new work could use.
- The Chase lists what only a person can move in the order the tick works.
The release queue holds new work upstream
Agents add work faster than people answer it, so the queues that cost most are the ones only a person can drain (W21, FF24). There are two, on either side of the implementation: this one, and the decision queue below. Each is named and counted, because product development inventory shows nowhere unless something counts it (Q1).
The release queue is everything between an implementation and its release to the customer in production: the changes waiting to be reviewed, integrated, validated or rid of their feature flag. It ends at the release, not at the review, because the value of the work and the feedback that tells whether it was right arrive only when the customer has it (E3, B3). A change merged behind a flag carries the risk of an open one and none of its feedback, and the faster that feedback comes, the smaller the queue it lets us run (FF7).
Reviewing and validating what agents built is where the queue grows with every implementation, so the tick constrains it (W1) by blocking new work once it is full (W6), holding that work upstream where waiting is cheap (V16). A child ends at its handoff, so the run cap alone leaves the queue unbounded. The limit reads the queue's size, which reacts at once, never its utilization or cycle time, which react only once the work leaves (Q13, Q14). The size is the wait, since a change waits about as long as the queue ahead of it takes to drain (Q12), and a long queue makes no single item feel urgent (FF21).
Only new work waits: integrating, releases, checks, rounds and what a person marked urgent go on, so the queue keeps draining. A validation a person scheduled for a later date is outside the queue until that date: the person chose when it happens, the way a decision has its own best moment (E15), and holding new work would not bring the date closer. The same limit sizes what the Chase asks of people, so the digest never asks more than the queue allows.
The queue is the people's, so what it blocks is the demand that feeds it. A task whose path to production reaches no person adds nothing to it: its closing validation closes it at integration or by a check an agent reads, the Merge rule lets the agents integrate what it touches, and it needs no flag, manual step or choice. Holding it would idle the agents without sparing anyone a minute, so a full queue changes the mix of what starts instead of stopping every start (W14). Whether a path reaches a person is read from the brief before the change exists, and that reading is sometimes wrong, so the Person-free lane lets one such task be in flight at a time: it holds the lane until it closes, and one that lands on a person after all is counted in the queue and keeps the lane shut, which bounds a wrong reading to one item (B4). Urgency is not the test: a task a person must see waits however small it is, and raising its priority to pass the queue would spend the one word that says waiting costs most.
The limit is the project's, and nothing in the queue says what it should be. A change waits about as long as the queue ahead of it takes to drain (Q12), so the limit is read against what leaves: the Health reports how many tasks with a change closed in each week beside it, and a team that drains more or fewer than it did moves the limit to keep the wait it accepts (W19). The two are written side by side and never divided, as every Health number is.
Rules that rest on it:
- The workflow names two queues only a person drains: the decision queue and the release queue.
- The release queue counts every change between its implementation and its release: open past draft, or integrated with its task waiting on a person or come due; a validation a person scheduled for a later date enters it on that date.
- New work waits upstream once the release queue is full; decisions do not count, and only new work waits.
- The Chase lists what only a person can move in the release queue, as many as its limit.
- With the queue full, a task whose path to production reaches no person still starts, one in flight at a time by default; it holds the lane until it closes.
- The Health reports how many tasks with a change closed in each week beside the release queue's limit.
A full queue is drained, never only held
Holding new work upstream stops the release queue from growing; it does not make it shrink, and every way out of it is a person's act. A queue left at its limit stays there, since randomness does not correct a random queue (Q15, Q16). While it is full, every item in it accrues delay at the rate the long queue imposes, so a change that was worth holding when the queue was short may no longer be (W7).
So the Health, counting the queue as the tick does, proposes what to drain. While the release queue is at its limit, it names the changes at the bottom of the tick's order, as many as bring it below its limit so new work can start again, each by URL in one decision waiting on the project's admins. Closing a change, cutting it down to what is worth shipping (W8) or returning its task to incubated is that person's, because closing work is a choice the tick cannot read (P2). The proposal weighs what is left to finish against what it returns, never what was already spent on it (E17).
Averages hide the tail, so the Health also names the oldest item in each queue only a person drains, its age as the code host and Flow answer it, and who acts. An item that waited far longer than the rest is likely stuck on something nobody has seen, and naming it to whoever can move it is the escalation planned in advance (W15, W16). Age names an item for a person and never ranks the work, since only cost of delay orders it (W16).
Rules that rest on it:
- While the release queue is at its limit, the Health proposes the changes at the bottom of the tick's order, as many as bring it below its limit; closing them is a person's.
- A proposal to drain weighs what is left to finish, never what was spent.
- The Health names the oldest item in each queue only a person drains, with its age and who acts.
- Age names an item for a person; it never ranks the work.
A choice is answered by a rule where one exists, and by a person when the work needs it
The decision queue is every open choice that holds work before it can start: a decision that blocks tasks, or a task waiting on a person for an answer its brief needs. Choices age, and many are worth more made quickly (E10, D1), so the workflow answers most of them without a person. Decision rules carry the economic logic of a choice to whoever meets it (E13, FF13), which is what the Decisions default's dominance and long-term tests and a project's standing decision are. What a rule cannot settle reaches a person, and so does what is infrequent, large or irreversible enough to be centralized, what the Decisions default reserves (D2).
A decision holds only the work it blocks, so it never counts against the release queue, and a thousand open choices never stop the work nobody has to choose about. Its best moment is when the work it frees could start (E15, F26). While the release queue is over its limit the tick would not start that work anyway, so asking for the choice then spends attention the release queue needs (FF24).
Most choices are never raised at all, because the implementer meets them mid-task and answers them there, and it can only answer them against an intent it was given. So a ready brief states its purpose, the end state the task serves and why, not only what to build and how it is checked (D8). An acceptance alone is a proxy an agent satisfies literally. The purpose is the decision rule it carries into every choice the brief did not foresee, and without it the agent fills the gap with a guess that reads like an answer (D17, Silent Interpretation).
Where a task closes is one of those choices, and it is made before the task starts, because the edges drawn on a task assume it. The project's list of closing validations is the rule, and the brief names the one that fits what the task promises. One rule for every task makes a change whose promise is code alone wait on a release it did not promise, which lengthens the release queue and holds every task built on that code (Q1, E13).
Rules that rest on it:
- A choice waits on whoever decides: its task waiting on them, or a
decisionthatblocksthe tasks it holds. - A ready brief states its purpose: the end state the task serves, so a choice met on the way is answered against it.
- The
Closing evidencelists the project's closing validations, always including integration with the pipeline green, and a ready brief names the one its task closes on, by what the task promises; the handoff'safter_integrationfollows it. - What integrating leaves is the agent's to choose when the
Closing evidencegives it the choice, and a wait on a person for it is read again once the parameter does. - The Chase lists the decisions the team owes only while the release queue is within its limit, as many as that limit.
No wait is open-ended
Work that is inside the system grows to fill whatever time it is given, so controlling what enters is not enough: every wait carries a date, and the date is the tick's to act on (W20).
A wait on a person carries the day to chase them (GTF-N4), and Flow reports one written without it. A check's wait carries when the effect can be seen, written at the handoff; a reader that finds it not yet visible moves the date to when it will be, from something it can point to, never to a guess. A child's run is given a slice, Stale after, past which a tick that cannot read it takes it as gone and closes it, because a run's duration is unknown and may be unbounded (F19). The run records the same slice as its hold on its tasks, so no other run takes them sooner. A review request nobody picked up within the same slice falls to the Review fallback rather than holding the change. A child ends at its handoff and never waits on CI, so one still running past the slice has stopped.
What passes its date is closed, reported or handed on, never left as it is: a wait with no date is a queue nobody measures.
Rules that rest on it:
- A run past
Stale afteris closed, and its task is ready again. - A review request lost past
Stale afterfalls to theReviewfallback. - A check's wait carries when the effect can be seen, and moves only to a date someone can point to; the handoff's date moves with it, and a wait is never written with a date already past.
- A wait on a person carries the date to chase on; Flow reports one that does not.
- A run's hold on its tasks lasts its
Stale after.
A number is Flow's answer, never an agent's estimate
The graph reaches nobody who does not read it, so the routines carry it to people. The Chase tells each person what the graph holds for them, because knowledge that stays in the graph serves the agents and not the people it waits on (Contextual Readiness).
What the Health reports is what the work product does, never what a worker does (E5). It reports each state's arrivals, departures and age, the cumulative flow that shows a queue as it forms (Q11). It reports rework after the check and failure demand, the leading indicators of what the next weeks will cost (FF3). It reports what became of incubated work and the untriaged inbox and, from the Audit, spend on work that did not ship: the inventory that is invisible unless something counts it, and the expansion nothing else stops (E1, Q1, W20). A state only a person's answer frees that grew two weeks running opens the report, because a queue left alone does not correct itself and more agents or tasks will not help (Q16).
Every number is written as Flow answers it, never a ratio, a goal or a threshold, because a number aimed at is a number reached while the work it stood for stops (Proxy Collapse). The arithmetic behind each is a script over Flow's answers, never an agent's: counting is a well-structured problem, and a sum an agent works out is a guess that reads like a fact (Problem Structure Allocation, Structural Determinism).
Rules that rest on it:
- The Chase tells people what the graph holds for them.
- The Health reports each state's arrivals, departures and age, as Flow answers them.
- The Health reports rework after the check, and failure demand.
- The Health reads incubated exits and the inbox; the Audit reads spend on work that did not ship.
- A person queue growing two weeks running opens the Health's report.
- Health numbers are written as Flow answers them: no ratio, no goal, no threshold.
- The routines' arithmetic is computed by scripts from Flow's answers, never by an agent.
Every run is paid for
A run looks free to the agent that starts it and is not: every prompt costs money, latency and a share of what the people downstream will read (Prompt Economics). So the Audit measures what runs spend, from the instruction files every session loads and the runs Flow records, and a routine is as cheap as its question allows. Every rule is read by every run that loads it, and an agent's bias is to add one, so a fix first tries removing a rule, then changing one, and adds only when neither fixes it (Deletion Supremacy).
It runs on the cheapest model that does the work, because intelligence spent on a low-entropy task is bought and wasted (Allocative Efficiency). It loads only the tools it calls, and hands a wide read to a subagent that returns the conclusion. The children a tick runs at once are capped, long and short apart (Max runs, Max short runs), because each is paid for whether or not what is downstream can take its output. Both are caps on spend, never a signal to start or hold work: the release queue alone holds new work.
A run also has a floor: reading the brief, the code and the instructions costs about the same whether its change is one line or fifty, and every task started alone pays it again. With a transaction cost that high the economic batch is larger than one task (B11), so an implement child, before its first edit, takes up to two other ready tasks its own change answers. It takes one only when the two share their files or chokepoint, their closing validation, their reader under the Merge rule and their compatibility, and never a decision, a release step or a validation, because a batch is limited by its worst element and an unlike task would hold the rest at its gate (B10). The cap stays small because every turn re-reads a wider context, and lowering the floor itself is the first fix (B12).
The routines run on cadences, hourly, daily and weekly, because a regular rhythm turns unpredictable events into predictable ones (F5). The cadences nest as multiples of one another, so the week's Health and Audit read the days the Chase reported and the hours the tick ran (F14).
Rules that rest on it:
- Routines run on nested cadences, on the cheapest model that does the work.
- Child runs are capped, long and short children each by their own limit, and no child starts in a repo whose push branch another child already holds this tick.
- A routine loads only the tools it calls, and hands a wide read to a subagent.
- An implement child takes, before its first edit, up to two other ready tasks its change answers: same files or chokepoint, closing validation, reader under the
Merge ruleand compatibility; never a decision, a release step or a validation. - The Audit measures what runs spend.
- A fix or an improvement to the workflow first tries removing a rule, process, principle, routine or script, then changing one, and adds only when neither fixes it; the change says which step fixed it.