If you run software programs for a living, you already know the shape of what is coming: a maturity ladder, gates between rungs, a sign-off before the next rung is funded. That instinct is right. What changes with agentic AI is what the gates are made of. A traditional gate was a meeting, a sign-off, a ticket moving one column to the right. An agent never attends a meeting, so every gate has to be an artifact a machine can read and a control that can say no. This guide walks the five levels of my Agentic AI Roadmap, Prompted to Autonomous, and at each level tells you what the agent is allowed to do inside the six stages of Anthropic’s AI-native SDLC, what you are signing off on, and what has to be true before you move up.
First, the two things that changed underneath you
Agentic AI is a governed layer you hand an outcome rather than a script. It takes the goal, plans its own path, calls tools, acts on live systems and checks its own work. An agentic AI SDLC is a lifecycle in which agents execute the work inside each phase and people move to setting intent, approving plans, reviewing outcomes and governing the loop.
The six stages of that lifecycle are intent, specification, plan, build, verify and maintain, and each one ends by committing a file the next stage reads. Your requirements document becomes intent.md, your design document a spec, your work breakdown a plan file; the build produces a diff, verification a pull request with evidence attached, and an incident a record that feeds the next intent. Nothing you managed before has gone away. It has changed from a document a person interprets into a file a control can enforce. The table is the whole guide on one screen.
| Level | What the agent runs unattended | What you sign off on | Exit gate to the next level |
|---|---|---|---|
| 1 Prompted | Nothing; it suggests inside the build stage | A tool licence and a usage policy | A written, repeatable use case with a named owner |
| 2 Piloted | The build loop in one bounded repository | Every diff, through a human reviewer, with rollback | Identity, hooks and a registry exist as standards |
| 3 Governed | Intent through pull request, non-production | Merge, by a person, on the evidence bundle | Evals with thresholds and cost per task measured |
| 4 Assured | Merge within scoped areas, on evidence | Threshold changes and scope expansions | Guardian agents and provable control over drift |
| 5 Autonomous | Maintenance, closing the loop back to intent | The runbook the agent’s highest tier ends at | None; this is the top, and the gate stays |
Step one, Prompted: the tool is in the building
At Level 1 people use copilots one at a time. The agent touches one stage, build, and only through a developer’s hands. Nothing about how a result was produced is captured, so nothing is repeatable. Most of what is called an AI-native lifecycle in vendor decks is this. Your job here is small: license the tool, write the usage policy, and find the one use case a named person will own. You leave Level 1 when that use case is written down in a form someone else could repeat.
Step two, Piloted: one agent, one repository, every diff read
Level 2 is the first real change. A task-specific agent runs the plan, build and verify loop inside one bounded repository and returns a pull request. Your old instincts serve you well here, because the controls are ones you know: a human reviews every diff, rollback is proven before go-live, and the pilot has a scope it may not leave.
It is also where most programs fail. Gartner forecast in 2025 that more than 40 percent of agentic AI projects would be canceled by the end of 2027, and Level 2 is where it happens. The pilot works for one product line, the steering committee asks for five more, and nobody can say how the second gets built.
The next deliverable is the standard the second agent will be cut from: an identity for the agent that is not a developer’s credentials, hooks every repository shares, and a registry that says what is running. When those exist as standards, not one team’s scripts, you are at Level 3.
More on the Agentic AI SDLC
- The Roadmap: My five-level maturity model for enterprise agents, Prompted to Autonomous, with the exit gate at each step.
- The Plays, Sorted: All sixteen AI-native SDLC plays placed on the roadmap, with what to hold back at each level.
- The Definition: What an agentic AI SDLC is, and how it differs from copilots and vibe coding.
- Habits to Unlearn: The ten agile practices to retire when the artifact replaces the ceremony.
- What Breaks: Ten assumptions of the traditional lifecycle that agentic AI breaks.
Step three, Governed: every stage has an artifact and a gate
This is where the lifecycle becomes something you can run a program on. Intent is a committed file with an author, a timestamp and an approval on it, which is the first record an examiner will ask for. Hooks are the enforcement layer, so a rule is checked before the agent acts rather than reviewed after. The agent has its own identity and appears in the registry. Every stage from intent to pull request ends in a named artifact and passes through a gate the agent cannot talk its way past.
With those in place I let the agent run from intent to pull request unattended in non-production. A person still merges, and that is the sign-off to hold onto longest, because merge is where the agent’s work touches something that matters. You leave Level 3 when verification produces a number.
Step four, Assured: merge on evidence, not on a green build
Your old test suite was binary. An agent breaks that, because the same agent gives different answers on different runs and a test asserting an exact value fails while the system is fine. So the test suite becomes an eval suite, a fixed bank of tasks with known-good outcomes, scored against thresholds, and those thresholds are the release gate. Alongside them sit escaped-error rate, drift, and cost per completed task, because an agent loop has a variable cost with no natural ceiling and a build does not.
At this level I let agent pull requests merge without a human, only within scoped areas, only when the evals pass, and only with the evidence attached. Your sign-off changes shape: not each change, but each change to a threshold or a scope.
Step five, Autonomous: maintenance closes the loop
The last stage the agent owns is the one that feeds the first. A deterministic monitor watches production, a breached control band invokes the agent with no person in the invocation path, and the diagnosis comes back as a new intent file in the format a human would have written. Guardian agents contain drift, and root-cause analysis feeds the reference architecture so the defaults improve without a project.
How to place your program
Place yourself by your weakest production agent, not your best pilot, then read across the table. If the agent still runs under a developer’s credentials, you are at Level 2 whatever the demo looked like. If you merge agent pull requests on a green build rather than on evals with thresholds, you are letting a Level 4 permission run on Level 3 controls.
The longer version of the ladder is in my book Agentic AI, and the case for autonomy that is earned rather than granted is in Earned Autonomy.
Which level is your program actually at, and which sign-off are you still giving from the level below?
Go deeper
- Agentic AI Architect: control design for enterprise agents.
- Agentic AI Case Studies: deployment evidence, one teardown at a time.
- Agentic AI P&L: cost, payback, and risk in a CFO’s voice.
- Agentic AI Governance: who owns the harness.
- Agentic AI SDLC: the lifecycle that builds the agents.
- Substack first access: agenticaiarch.substack.com/subscribe
© Dr. Harish Kotadia, Ph.D., All Rights Reserved, 2026.
Dr. Harish Kotadia, Ph.D., is an Enterprise AI Architect with 20+ years of IT consulting experience serving Fortune 100 clients, specializing in agentic AI systems built on Anthropic Claude, AWS Bedrock, and Google Vertex AI.
Disclaimer: This blog post is based on publicly available academic publications, vendor documentation, open standards, and news items from reputed media sources linked above. This post is intended for educational purposes, to help the enterprise agentic AI community build a shared vocabulary from public, authoritative sources.
Views and opinions expressed here are my own and do not represent those of any employer or client, past or present. The analysis presented is my independent interpretation of the published sources linked above and does not constitute legal, financial, or consulting advice of any kind.