
"Are you using AI yet?" is the wrong question for me. Almost everyone uses some form of AI today, often without consciously noticing it. What gets interesting is the question: at what stage? Between "I type a question into a chat" and what I run today — several agents with fixed roles that review each other before anything goes live — lie several clearly distinguishable steps. I looked at how different organizations describe these steps, built my own practical stage model out of it, and mapped it onto my own agent pipelines, above all the ones for ketovavaria.de. What emerged: the question of "which stage" is actually two questions. How much work do the agents take over? And how much are they allowed to decide on their own?
- How four different stage models — from OpenAI, Gartner/Microsoft, assecor, and MIT Media Lab — describe the same development from different angles
- My own six-stage model for practical AI use, with concrete examples from my own agent pipelines
- Why higher stages aren't automatically the goal, but depend on risk and governance
- Where I stand myself — and why I deliberately don't go further on autonomy
Four models, one basic idea
Anyone searching for "stages of AI use" quickly finds several models that, at first glance, have little in common. They measure different things — the system, the organization, the person, the autonomy — but describe the same basic movement: AI takes over progressively more, and responsibility doesn't disappear in the process, it shifts.
OpenAI: five stages by task size
According to a Bloomberg report from July 2024, OpenAI internally used a five-level scale: Chatbots (level 1, conversation), Reasoners (level 2, PhD-level problem-solving without tools), Agents (level 3, AI acts on a user's behalf), Innovators (level 4, AI contributes to new inventions), and Organizations (level 5, AI does the work of an entire organization). Important for context: OpenAI never officially published this scale. It comes from an internal meeting and was confirmed to Bloomberg by a spokesperson. There is no published test and no benchmark threshold that assigns a model to a level. The scale doesn't measure how intelligent a system is, but what kind of work you'd trust it with — it's closer to an org chart than an IQ test.
OpenAI's internally communicated five-level scale, never officially published
Gartner and Microsoft: organizational maturity
While OpenAI's model describes the capability of the AI system itself, Gartner and Microsoft ask how mature an entire organization is in dealing with AI. Gartner's model distinguishes five stages: Foundational (uncoordinated experimentation), Emerging (first pilot projects), Operational (AI embedded in individual processes), Scaled (AI across multiple functions with measurable ROI), and Transformational (AI changes decision-making and the business model). Microsoft's Agentic AI Adoption Maturity Model for enterprises uses a comparable five-stage scale (level 100 to 500) across five capability pillars: AI strategy, business value, governance, technology, and culture. Neither model evaluates a single AI system — they evaluate the organizational foundation around it: governance, data infrastructure, processes, culture.
Gartner's organizational maturity model, from uncoordinated experimentation to transformation
assecor: learning stages for people and teams
A German-language model I find especially practical comes from the consultancy assecor. It describes seven learning stages — not for the AI system, but for the people working with it: from unconscious use through conscious individual tasks, a first fixed assistant, connecting to data sources, reusable skills and automatic trigger events, all the way to agents reviewing other agents. The crucial difference from the other models: the technology isn't at the center here, the user's learning task at each stage is. An AI can technically already be wired up to stage five while the team is still practicing stage two — and that exact gap, assecor writes, is one of the most common reasons AI projects stall.
assecor's seven learning stages, from unconscious use to mutual agent review
MIT Media Lab: autonomy levels modeled on self-driving cars
The fourth model was proposed by MIT Media Lab researchers in 2026. They transfer the well-known SAE levels for self-driving cars onto AI agents: A1 Directed (AI acts only under direct human approval of every single action), A2 Delegated (AI gets a bounded goal and works several steps without checking back, but within fixed limits like budget or time), A3 Adaptive (AI adapts its plan to changing circumstances and only escalates genuine exceptions), A4 Self-Governing (AI operates without ongoing supervision within a clearly defined scope), and A5 Independent (AI acts independently across organizational boundaries). The authors' central thesis: as autonomy increases, human control doesn't disappear — it moves from the individual action toward policy, certification, and institution. And: more capability shouldn't automatically lead to more authority. A system should only move up a level once the control mechanisms around it are ready for it.
MIT Media Lab's A1–A5 autonomy model, modeled on the SAE levels for self-driving cars
| Model | Perspective | Stages | Core question |
|---|---|---|---|
| OpenAI (internal, 2024) | System capability | 5 (Chatbots → Organizations) | What kind of work would you trust the system with? |
| Gartner / Microsoft | Organizational maturity | 5 (Foundational → Transformational) | How mature is the organization around it? |
| assecor | Learning progress of people/teams | 7 (unconscious → agents review agents) | What does the person need to learn? |
| MIT Media Lab | Agent's autonomy level | 5 (A1 Directed → A5 Independent) | How much ongoing supervision is still needed? |
My own stage model: from the single request to the reviewed pipeline
None of these four models, on its own, describes what actually happened in my case. OpenAI and Gartner/Microsoft look at the system or at the organization, not at the daily work with a concrete pipeline. assecor comes closest: its learning stages largely match my own path, so they form the backbone of my model. Two things are missing there, though — the division of labor between multiple agents, which is its own stage for me, and an answer to the question of how much an agent is allowed to decide on its own. That second axis comes from the MIT model. That's why, for each of my six stages, I also note the approximate MIT autonomy level at which the work actually runs in practice. As it turns out, it rises much more slowly than the stage itself.
The six stages of AI use — from the single request to a pipeline where agents review each other
One question, one answer, no stored context. That's how I started myself: having texts checked, having phrasing suggested, having code snippets explained. The AI doesn't act here, it informs. I re-evaluate every answer; nothing continues automatically. On the MIT scale, this stage doesn't even appear yet, since even A1 presupposes that the AI itself carries out an action. In the other models it corresponds to OpenAI's level 1 (Chatbots) and assecor's stage 2 (conscious individual tasks). OpenAI describes what the system can do; assecor describes what the person needs to learn: to use the answer deliberately and know its limits.
The difference from the first stage is subtle but decisive: I define purpose, tone, and working rules once, instead of re-explaining them with every request. For me, that was the first step toward a social-media text agent for ketovavaria.de that knows from the start that Instagram captions should be image-forward with three to five hashtags, and X posts shorter with at most two. The agent proposes, I decide on every single publication. That's assecor's stage 3 (first fixed assistant) and, by MIT's definition, A1 Directed: the AI only acts under direct approval of every single action.
From here on, the AI no longer works only with what I write into the prompt — it works with real systems: the blog system's database, the FTP access, Docker containers, the Instagram Graph API. A concrete turning point for me was the moment an agent first independently pulled a blog post via the blog system's REST API, extracted its featured image, and automatically inserted it as a link preview into a social-media post. Before that, I had to piece that together by hand. The boundaries here are explicitly set: defined access, defined actions, clearly limited permissions. Within those limits, the agent works several steps without checking back. That's A2 Delegated under MIT, and simultaneously assecor's stage 4 (connection to data sources).
The real shift doesn't come from more autonomy per agent, but from dividing the work across multiple agents. At ketovavaria.de, that's everyday reality today: a social agent writes platform-appropriate copy, a designer agent delivers the matching image, a coordinator agent combines both into a preview, a developer agent builds and repairs the technical pipeline. None of these agents is allowed to publish alone. Each works within its own area at A2 level — multi-step, but within fixed limits. Hints of A3 only show up in small technical sub-tasks — for instance, when an agent retries a publish attempt because a platform reports an image as "not yet fully processed." Whether a post gets published at all remains untouched by that: that decision stays with me. This stage doesn't exist in assecor's model; it's my own addition.
A systemd timer at ketovavaria.de triggers a publishing run every five minutes, without me kicking it off by hand. That's assecor's stage 6 (automatic trigger events). What matters, though, is what was deliberately NOT automated: a post only goes live if three conditions are met at the same time. I previously set its status to "approved," a global live switch is active, and the program runs with an explicit live flag. The timer determines the timing, not the decision. So the run is automatic, not the approval. That's exactly the difference from stage 2: there, I approved every single action (A1); here, I only approve the content, and the system handles the actual publishing run without me. Under MIT, that's A2. Deliberately not higher: the system neither adapts on its own what gets published (A3), nor does it run unsupervised content-wise (A4). The same logic applies to my weekly Ketovavaria reports: they're published on schedule, but never without prior content review by me.
The highest stage I currently use corresponds to assecor's stage 7: one agent reviews another agent's work before I even look at it. For me, this runs as a fixed sequence, for instance for a handbook chapter. First, a writer agent drafts it. Then a reviewer agent checks it sentence by sentence against the original sources and only gives a PASS after its own corrections. After that, a tester agent tests the chapter on a staging environment. A chapter only goes live after passing the test; my own content sign-off is deliberately kept separate from that — the agents' PASS doesn't replace it. A second example: before a revised article draft is shown to me, a separate review agent checks it for logical breaks, unsupported claims, and inconsistent phrasing — independent of the agent that wrote the draft. The review itself corresponds to A3 Adaptive: it runs on its own and escalates unclear cases to me. This autonomy applies to reviewing, not to publishing. For the criteria the reviewer agent judges by, I use the LLM-as-judge pattern known from practice: a test case consists of a fixed set of known examples, a set of named evaluation criteria (for me, e.g. source fidelity, logical consistency, evidence), a scale per criterion, and a hard rule for when a case fails overall — if any single criterion falls below a threshold, the overall verdict is automatically "fail." Every recurring review task gets three to five known test cases with an expected result, which a new draft automatically runs against before the reviewer agent renders its own free-form judgment. That's the specification for the next step — implementation in the running pipeline isn't done yet.
Placed side by side, what the model actually shows is this: the stages rise considerably faster than the autonomy.
| My stage | assecor | MIT autonomy | What I decide myself |
|---|---|---|---|
| 1 · Single request | Stage 2 | below A1 | I re-evaluate every answer |
| 2 · Fixed assistant | Stage 3 | A1 | Every single action |
| 3 · Tool connection | Stage 4 | A2 | Access, actions, and permissions of the agent |
| 4 · Multiple agents | – (my addition) | A2, occasionally A3 | Whether a post gets published |
| 5 · Automatic runs with approval gates | Stage 6 | A2 | Approval of every single post |
| 6 · Agents review agents | Stage 7 | A3 (for the review) | Unclear cases and my own sign-off |
assecor's stage 1 (unconscious use) and stage 5 (reusable skills) have no stage of their own in my model.
Why I deliberately don't climb higher on autonomy
In my own model, I've reached the top stage. On autonomy, though, I deliberately stop at A2 once publishing is involved. The MIT Media Lab paper puts this stance most clearly, as a guiding principle: no agent should operate at a higher autonomy level than the governance environment around it can safely support. For me, concretely, that means: I won't automate the approval gates from stage 5, even though it would be technically possible. The reason isn't that I fundamentally distrust the texts. The reason is that a false statement once published — a fabricated quote, a wrong number, a misleading phrasing about health or finances — can't be fully taken back. This is exactly where the difference between A2 and A4 in the MIT model lies: at A4, the system operates without ongoing supervision and handles exceptions within its scope on its own; human control then lives only in the rules set in advance. At A2, I still decide on every single post. For drafts, internal research, and pipeline repairs, on the other hand, I deliberately use A3 behavior, because a mistake there stays correctable before it reaches anyone.
Whether I should even take this step is something I check against a governance checklist for enterprise AI agents that proposes five questions: Ownership, Access, Authority, Intervention, Evidence. Four of those are clearly answered for me — the weakest is Evidence: the complete traceability of every single approval decision. A parallel IETF draft for a standardized agent protocol format (Agent Audit Trail) provides the target structure for exactly that: every entry with a unique ID, timestamp, acting agent, the authorizing party, the decision with its reasoning, and the actual outcome — crucially, a note on whether the entry was written before or after the action, because only a before-the-fact entry actually proves an approval check ran before something happened. For my social-media pipeline, that would concretely mean: extending the existing results log with an approval ID, the time of approval, and this before/after marker — specified, but not yet implemented.
Conclusion
The four models measure different things — system capability, organizational maturity, human learning progress, degree of autonomy — but describe the same movement: AI takes over progressively more, and with every stage, what you need to watch shifts, not whether you still need to watch. So to the opening question of which stage I'm on, I have a two-part answer. In my own model, I'm at stage 6: agents write, review, and test before I even look. On the MIT scale, I deliberately stay at A2 when it comes to publishing. Organizationally, by assecor's own six-stage maturity model for enterprises (Experimental Early Phase to Transformative End Phase), I'd place ketovavaria.de at "Operationally Embedded": AI is a fixed part of regular operations, an initial scale-out across multiple channels and reports has happened, systematic expansion into further areas is still ahead. The most important insight from this path: how much work the agents take over, and how much they're allowed to decide on their own, are two separate dials. The first can go a long way up without the second following. Governance and autonomy have to grow together, and wherever a wrong decision can no longer be corrected, the approval stays with me, no matter how good the pipeline underneath has become by then. What I'm still missing for the next step is, above all, complete traceability of every single approval decision, before I even think about more autonomy.
- Bloomberg (July 2024) / Tom's Guide / The Verge – coverage of OpenAI's internally communicated five-level AI scale (Chatbots, Reasoners, Agents, Innovators, Organizations); never officially published by OpenAI
- Gartner: "AI Maturity Model and AI Roadmap Toolkit" – five-stage organizational maturity model (Foundational through Transformational)
- Microsoft Learn: "Agentic AI Adoption Maturity Model" – five-stage maturity model for enterprises (level 100–500) across five capability pillars
- assecor: "Building AI competency: the learning stages in the enterprise" – seven-stage learning model for people and teams working with AI
- Raskar, Chaddha, Reddy, Todkar (MIT Media Lab, 2026): "From Autonomous Cars to Autonomous Agents: The Five Levels of AI Agent Autonomy" – A1–A5 autonomy model for AI agents, modeled on the SAE levels for self-driving cars
- Internal pipeline documentation for the social-media and handbook workflows of ketovavaria.de, as of November 2026
- Microsoft Learn: "Review the agent evaluation checklist" – structure for test cases (prompt, assertion, acceptance criterion, evaluation method) in agent evaluation
- V-Soft Consulting (Prasanna Simhadri, October 2026): "AI Governance Readiness: What Enterprises Need Before Scaling AI Agents" – five-question checklist (Ownership, Access, Authority, Intervention, Evidence) before a higher autonomy level
- assecor: "AI maturity and the AI maturity model" – six-stage organizational maturity model (Experimental Early Phase through Transformative End Phase)
- IETF draft (Datatracker, 2026): "Agent Audit Trail: A Standard Logging Format for Autonomous AI Systems" – logging format for AI agent actions with before/after timestamp distinction