The Agentic Maturity Model
The Agentic Maturity Model has six levels: L0 ad-hoc prompting, L1 persistent instruction files, L2 reusable skills, L3 closed-loop workflows, L4 durable memory plus evaluation, and L5 governed agentic execution systems. Each level fixes the failure mode the previous level exposes, and skipping levels builds on sand.
Key takeaways
- Most teams believe they are at L3 and are actually at L1: instruction files exist, but nothing verifies work before acceptance.
- The jump that changes economics is L2 to L3: from better inputs to checked outputs.
- L4 before L3 is the classic mistake: memory amplifies whatever exists, including unverified errors.
- L5 is what passes audit: permissions, logs, and human gates around everything below.
- The level question is a diagnostic, not a grade: it names your next build.
The six levels
| Level | Name | What exists | What catches the agent's errors |
|---|---|---|---|
| L0 | Ad-hoc prompting | Individual prompts, individual results | Nothing |
| L1 | Persistent instruction files | AGENTS.md / CLAUDE.md with verified commands and constraints | Nothing, but errors from guessed context stop |
| L2 | Reusable skills | A maintained skills directory; procedures standardized across operators | Nothing structural; quality variance drops |
| L3 | Closed-loop workflows | Loops with verification and recovery around real work | The loop: evidence-checked completion |
| L4 | Durable memory + evaluation | Dated memory with staleness handling; benchmarks and eval suites | The loop, plus regression: mistakes don't repeat |
| L5 | Governed execution systems | Permissions, audit logs, human gates, review cadences | All of the above, auditable |
The diagnostic question that locates any team in one pass: what happens when the agent is wrong? Nothing catches it: you are at L0 to L2 (the difference among those three is input quality, not error capture). A loop catches it: L3. It is caught and remembered so it doesn't recur: L4. Caught, remembered, and you can show an auditor the log: L5.
What each transition buys
L0 to L1 eliminates guessed context: the wrong-port, wrong-command, wrong-convention class of failure. Cheapest transition, largest error-rate drop per hour invested.
L1 to L2 eliminates operator variance: ten engineers stop producing ten quality levels. This is where team economics start, and where review of agent behavior becomes possible at all (you can review a skill; you cannot review ten people's ad-hoc prompting).
L2 to L3 is the transition that changes what agents are for. Below it, agents produce drafts a human must check; above it, agents produce verified work. Every claim about "delegating to agents" is really a claim about being at L3.
L3 to L4 makes the system compound: evaluation proves quality is holding, memory stops repeated mistakes. Note the ordering dependency, because it is the classic skipped step: memory before verification (L4 tooling at L2 maturity) accumulates unverified claims and amplifies them. The Memory Safety Model exists largely because teams take this shortcut.
L4 to L5 makes it deployable where auditors live: governance around everything below. For enterprise teams this is the difference between a pilot and a production system.
Using the model
Be suspicious of self-assessment one level up: most teams that say L3 have loops that assert success rather than verify it (run the false-success test: does anything refuse to accept bad work?). Locate honestly, then build the next level, not the most interesting one. The build order is the execution stack's build order for the same reason: each layer's value depends on the layers below.
A self-assessment worksheet version of this model ships as part of the governance checklist; the level question is also where an agent-reliability audit starts.
Frequently asked questions
What is the Agentic Maturity Model?
A six-level model of agent practice: L0 prompting, L1 instruction files, L2 skills, L3 closed loops, L4 memory plus evaluation, L5 governed execution systems.
How do I know my team's level?
Ask what happens when the agent is wrong. Nothing catches it: L0-L2. A loop catches it: L3. It's caught and remembered: L4. It's caught, remembered, and auditable: L5.
Can you skip levels?
You can install higher-level tooling anytime, but each level's value depends on the ones below. Memory (L4) without verification (L3) accumulates unverified claims; governance (L5) without skills (L2) governs improvisation.
Summary
- Topic
- The Agentic Maturity Model (L0 to L5)
- Definition
- Six levels: ad-hoc prompting, instruction files, skills, closed loops, memory+evaluation, governed systems
- Best used for
- Assessing a team's agent practice and choosing the next investment
- Related concepts
- agentic execution system, closed-loop workflow, governance
- Common mistakes
- Adding memory before verification; claiming L3 while accepting unverified output
- Recommendation
- Locate your level by asking what catches the agent's errors; build the next level, not the coolest one