The Agentic OS Maturity Model: 5 Stages

Most teams can't answer a simple question: how far along are we, really, with AI? They know they're "using it." They can't tell whether that means a few people paste things into a chatbot or whether they've built something that genuinely runs work. Without that answer, every decision about what to do next is a guess.

Here's a maturity model to fix that. Five stages, from scattered prompting to a real Agentic OS. To make it concrete, we'll follow one hypothetical company, a 50-person B2B SaaS, as it climbs. Find the stage that sounds like you, and the next move becomes obvious.

Stage 1: Ad hoc

Individuals use AI on their own, unofficially. There's no shared approach, no standards, and no record of what works. The value is real but invisible and entirely dependent on which person happens to be clever with the tools.

At our 50-person SaaS, that looks like two support reps quietly using a chatbot to draft replies, and the head of sales pasting call notes in to summarize them. None of it is shared, and none of it is official.

You're here if: AI use is personal and private, and if your best AI user left, the capability would leave with them.

Next move: Start sharing what works. Collect the prompts and use cases that are actually paying off and make them visible to the team. You're turning private tricks into shared practice.

Stage 2: Assisted

The team has standardized some prompts and tools. There's a shared sense of where AI helps, maybe a library of go-to prompts. But it's still a human doing the work with AI assistance at the keyboard. Nothing runs without a person actively driving it.

The SaaS company now keeps a shared doc of approved prompts and a couple of sanctioned tools. Support reps draft replies twice as fast, but a person still reads, edits, and sends every single one.

You're here if: AI makes your people faster, but every bit of output still requires a human in the loop on every step. It's a power tool, not a worker.

Next move: Find one well-defined, repetitive workflow and ask what it would take for an agent to own it end to end, not just assist. That question moves you toward the next stage.

Stage 3: Automated

You've deployed your first real agents. Specific workflows run with the agent doing the bulk of the work and a human checking or approving. This is a genuine leap, and it's where most teams that take AI seriously currently top out.

Our company puts its first agent on ticket triage. It reads every inbound ticket, categorizes it, and drafts a reply for the routine majority. A support rep skims and approves before anything goes out. The agent does the volume, the human owns the send.

You're here if: At least one workflow runs mostly without human labor, and you'd notice if the agent stopped. But each agent is a standalone thing, built and managed on its own.

Next move: Stop building agents one-off. Start defining them properly, with real job descriptions, scoped access, and named owners, so the next one isn't built from scratch. And put a review loop on the ones you have.

Stage 4: Orchestrated

Multiple agents work together, with handoffs between them and a deliberate division of labor. One agent's output is another's input. There's a shared context layer, defined boundaries, and a sense of the agents as a team rather than a collection of separate tools.

Now the SaaS company's triage agent hands billing questions to a dedicated billing agent, routes anything angry or high-value to a human queue, and shares one context layer about the product, pricing, and policies with all of them. You're managing a system, not a pile of scripts.

You're here if: Agents pass work to each other, you've thought about the org chart of your agents, and you can reason about the whole system rather than each piece in isolation.

Next move: Harden the governance. Make sure every agent has a clear answer to who's accountable when it's wrong, that human gates match the stakes, and that the whole system is observable. Orchestration without governance is just a faster way to cause a coordinated mess.

Stage 5: Agentic OS

Agents are a managed part of how the organization operates. There's onboarding for new agents, performance review on a cadence, clear ownership and accountability, governance matched to stakes, and a deliberate split between the work agents own and the judgment humans keep.

When our SaaS company decides to add an agent for renewal outreach, it looks like any other hire: a role definition, scoped access to the CRM, a named owner on the success team, a human gate on anything touching price, and a monthly review already on the calendar. New capability, same playbook.

You're here if: Running agents feels like running an org, not maintaining software. The system is trustworthy because it's governed, not because you got lucky.

Next move: Keep widening the 70 as trust is earned, and keep the 30 sharp. This is the steady state the 70/30 Method is built around: aggressive automation with senior judgment wrapped around the parts that matter.

What to do with this

Most teams are at Stage 1 or 2 and assume they're further along. The point of naming the stages isn't to feel behind. It's that each stage has a clear, single next move, and trying to skip stages is how AI projects end up in the ditch. You don't jump from ad hoc prompting to an Agentic OS. You climb.

If you want an honest read on which stage you're actually in and a concrete plan for the next one, that's the kind of work I do with clients. Let's talk.