Agents change the executor, not the stations

Every delivery methodology you run — TOGAF, BABOK, ISTQB, Scrum, SAFe, ITIL — shares one assumption nobody wrote down: the executor has judgement and a career. They notice when a requirement is wrong, they remember last quarter’s incident, and they are accountable if the release fails. An agent has none of the three. That does not change what governance is. It changes where it has to live.

Last time we argued that agentic coding stops at the pull request because the lifecycle around it was never built for agents. This post draws that lifecycle on one page, so the rest of the series has a map to point at.

Six stations, one loop

Strip the frameworks away and enterprise delivery has six stations: intent → backlog → build → verify → release → operate, with operate feeding back into intent. Every methodology is a way of running some of those stations. TOGAF and ArchiMate govern how intent becomes architecture. BABOK and IREB turn intent into backlog. Scrum and SAFe run build and verify. ISTQB formalises verify. ITIL owns release and operate.

Over the stations sits a second layer that no single framework owns: traceability, separation of duties, auditability, security, observability. That layer is what a regulator, an auditor or a security review actually asks about. It is also the layer agentic coding tools know least about.

Agents change the executor at build and verify. They do not change the stations, and they do not touch the overlay. Which is exactly the problem.

The agent is the software — except in your audit

The most radical answer to that problem comes from the research side. Cao (2026, preprint) argues that decision logic will be generated at runtime, code becomes an ephemeral instrument, and the agent itself is the software. On complexity scaling the argument is strong. On change control it collapses.

Try the thought experiment: an incident at 03:00, and the post-mortem asks what changed. The answer is “the agent decided”. Would your auditor accept that as a change record? Would your security team accept it as forensics?

We accept Cao’s diagnosis and reject the prescription for enterprises. Code stays the durable, reviewable artefact. Agents are the workforce that produces it.

Traceability is the product

In a regulated environment the chain is the deliverable: business requirement → technical requirement → task → commit → test result → release note, with typed links between them — derived-from, implemented-by, realised-in. The code is evidence for the chain, not the other way round.

A practical test. Pick any function in a system you own and ask: which requirement introduced this? If the answer takes a week and three people, the platform that produced it is not enterprise-grade, whatever its benchmark score. An agentic platform that cannot answer the question is not either.

What Scrum gets right for agents, and what it does not

Some of the existing practice transfers directly: an ordered backlog, small bounded increments, an explicit definition of done, review before acceptance, one owner of priority. Some does not: time-boxed sprints, ceremonies and velocity are human-cadence constructs, built around people who need rhythm and a meeting to synchronise. Agents work event-driven and in parallel. The cadence that matters is the release window. Adapt the artefacts and roles, not the ceremonies — and give SAFe and stage-gates the same treatment.

Drop the ceremonies, keep the signatures

Stage gates were not invented out of bureaucratic instinct. PRINCE2 stage boundaries, V-model phase exits, RUP milestones all exist for one reason: change after a phase is expensive, and someone has to be accountable for letting the work through. Agile diluted the gates because human re-planning cost more than the gate was worth.

With agents, the economics flip. The work between gates is cheap to redo. A requirement set can be re-challenged overnight; an epic can be decomposed again before lunch. What becomes scarce is the accountable act: a named person reading what the agents produced and signing that it is right.

So our rule is short. Humans sign the phase transitions — we call it the sign-off gate. Agents work inside the phases. The ceremonies that existed to coordinate humans can go; the signatures that existed to hold someone accountable cannot.

Where this leads

If you accept the map, the gap in Post 1 has a shape. It is not “agents cannot code”. It is that nothing in the lifecycle tells an agent what intent means, verifies its work against a contract, keeps the chain of evidence intact, or gives a human a defined place to sign. Those four are design problems, and the next two posts are our design.

Two questions for the comments. Which station in your organisation has no written exit criterion? And who signed your last requirement set — would they know if it had changed since?

References

• Cao, Z. (2026). Agentic Software: How AI Agents Are Restructuring the Software Paradigm. Single-author preprint, arXiv:2606.05608, 11 Jun 2026. arxiv.org/pdf/2606.05608. Section references used in the series check out: §3.2 (human as bottleneck), §4.3 and Table 2 (intent architect, four capabilities), §6.3 Stage III, §6.4 Stage IV from 2028, §7.1 “human-in-the-loop, agent-in-the-driver’s-seat”. The author is affiliated with an investment firm, not a research institution — keep using it as a foil, never as an authority.

• Deng, G. et al. (2026). EvoClaw — as in Post 1, for the lifecycle-gap callback.

• TOGAF, ArchiMate, BABOK, IREB, ISTQB, Scrum, SAFe, ITIL, PRINCE2 — named as standards; no citation needed beyond a link to each body’s site if marketing wants them clickable.