Contextual Agentic

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.

·7 min read

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.

Two eight-step loops side by side. Left, the agentic SDLC as demoed, inside a dashed outline labelled no shell, controls live in the prompt: goal prompt, agent writes the PRD, agent designs, agent implements, agent tests itself, agent deploys, agent monitors and auto-fixes, iterate. Right, the governed agentic SDLC inside a solid outline labelled deterministic shell: intent plus Context Contract, evidence-backed spec, design inside the Authority Envelope, bounded implementation, evaluation-first testing, Commit Boundary release highlighted in amber, governed operation, learn and re-plan. Amber gate markers sit between governed steps. Below, a table compares traditional, as-demoed and governed loops on cycle time, who writes code, testing, release, authority, evidence and humans.
Figure 1. The same eight stages twice. The demo loop is a composite of how agentic development is commonly pictured. The governed loop is the AI-Native SDLC: same speed, inside a deterministic 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

  1. The Contextual Agentic Enterprise.
  2. AI-Native SDLC Engineer: From Fast Proof of Concept to Governed Production (course).

← All articles

Related