Agentic SDLC: The Demo Loop and the Governed Loop
Every "traditional versus agentic SDLC" picture shows the same eight steps made autonomous, with a human who reviews and steers. It is fast, and it has no shell. Here is the same loop with authority, evidence and the commit decision put back where they can be enforced.
Written as at 30 September 2026.
agentic-aiai-native-sdlcdevsecopsdeterministic-shellevaluation
There is a picture that circulates whenever agentic development comes up. On the left, the traditional software development lifecycle: requirements, design, implementation, testing, code review, deployment, monitoring, feedback, weeks to months per cycle. On the right, the agentic version: goal definition, AI-assisted PRD, agent architecture, autonomous implementation, autonomous testing, agent-driven deployment, continuous monitoring, continuous iteration, hours to days per cycle. Between them, a human who “reviews and steers”.
The picture is right about the speed. It is wrong about almost everything else that matters to an enterprise, and the error is not in any one step. It is that the loop has no shell.
What the demo loop leaves in the prompt
Walk the left-hand loop and ask, at each step, where the control is.
The goal is a prompt, so the constraints are whatever the prompt says. The requirements are generated, so nobody types the claims in them and nobody marks which are observed, which were declared by a stakeholder and which the agent inferred. The design is chosen by the agent, so the limit on what the system may change is implied by the credentials the pipeline happens to hold. The implementation is an unbounded run. The tests are written and passed by the thing under test. The deployment executes with the pipeline’s permissions. The auto-fix patches production because it can. And the loop repeats with the code versioned and nothing else.
Every one of those controls exists, in the sense that a sentence in a system prompt asks for it. None of them is enforced, in the sense that the agent cannot argue its way past it. Controls in the prompt drift with every model update, and a control that drifts is a request.
The governed loop keeps the speed
The right-hand loop has the same eight stages and the same cycle time. What changes is that each control has been moved out of the prompt and into the layer that can enforce it.
It starts with intent and a Context Contract: a human states the purpose and the principal, and what the agent may be shown is declared, versioned and testable before the model sees a token. The specification is still drafted by the agent, but every material claim is typed as observed, declared or inferred, and a human accepts it at a gate where the record is written. The design is still proposed by the agent, but it is proposed inside an Authority Envelope that says what the system may change, with what, up to what limit, and who owns that decision.
Implementation is bounded: a sandbox, a budget, a rung on the autonomy staircase, and typed adapters only. Testing is evaluation-first: the evals exist before the code, fault injection is routine, and each change carries a Minimum Action-Evidence Bundle. Release crosses a Commit Boundary, where deterministic checks of identity, authority, schema and state run against the exact change, a human approves anything consequential, and the Evidence-First Decision Record is written before the effect happens. In operation, the agent may auto-fix only inside its envelope; anything outside escalates to a person, with the evidence attached. And the cycle repeats with the contract and the envelope revised and versioned alongside the code, which is the difference between a system that learns and one that merely changes.
Three gates and one boundary. The gates take minutes, because the authority question was answered at design time rather than argued at release time. That is why the governed loop is not slower than the demo loop, and why it is much faster than the traditional loop with a change board bolted onto an agent.
The shape most estates are actually in
The common shape is neither loop. It is agents generating specs and code in hours upstream, and a change advisory board holding the release for a fortnight downstream, because nobody can say what the agent was allowed to change. The organisation has bought the speed of the demo loop and the delay of the traditional one, and kept the risk of both.
The way out is not to remove the board. It is to give it something to decide with. A Commit Boundary with an Authority Envelope behind it turns “should we let this through?” into “does this change fall inside what we already agreed?”, which is a question a deterministic check can answer in minutes, with a human reserved for the cases that fall outside.
The self-assessment asks eight questions, one per stage, and shows which loop each stage of your delivery is in, with the single gate that would move it. If the release stage comes back in the demo loop, start there. It is the one place every other control can be made to fire.
The demo loop is a good picture of how fast agents can build. The governed loop is a picture of how an enterprise can let them.
References
- The Contextual Agentic Enterprise.
- AI-Native SDLC Engineer: From Fast Proof of Concept to Governed Production (course).
Related
The CAE Stack: Ten Layers, and the Construct That Governs Each One
The stack diagrams that circulate for AI engineering list models, frameworks and vector databases. None has a row for authority, evidence or the point where a proposal becomes an effect. This is the same stack drawn from the enterprise's side.
Evaluation Is Not a Test Phase
Most agentic programmes pick a model, write a prompt, add retrieval, and write the evaluations last — by which point the evaluations can no longer change the design. Reversing the order gives an architect something better than an opinion: gates that show whether a model swap, a prompt change or a new retrieval strategy measurably improved the system.
The Commit Boundary: Where AI Recommendations Become Enterprise Consequences
Controls placed at the start of an agent conversation check the wrong thing. The decisive check evaluates the exact action about to become real, at the moment it becomes real.
Continuity Is Not Permission: The Engineering of Durable Agent Execution
Durable execution keeps a workflow alive across interruption. It does not keep it authorised. Four engineering objections to the architecture, and what actually answers them.
The Agentic AI Playbook: Five Rungs from Model to Governed Enterprise
LLM, RAG, agent, agentic system: every popular diagram stops at four rungs. The enterprise needs a fifth, where authority is checked before anything changes.