Most conversations about AI agents treat them as one thing, but there are five distinct stages, each demanding a different level of trust and a different time scale, from seconds to weeks. In a recent episode of the AI DevOps Podcast, returning guest Matthew Renze, an AI researcher and consultant who has trained over half a million developers and IT professionals worldwide, laid out those stages.
For most of the past decade, Renze’s predictions about AI kept sliding further into the future, always a few years away. That changed around late 2025, when he started seeing agents reliably complete around 100 steps on a task, up from the 10 to 20 steps he’d been benchmarking. Capability gains have also accelerated resulting in gains that used to double roughly every seven months are now doubling about every four.
That’s the kind of pace that raises real budget questions, and podcast host Jeffrey Palermo pushed on exactly that before Renze got into specifics: an agent that runs constantly “seems incredibly expensive,” he said, so what are the use cases where it’s not? Renze’s answer was the five-stage framework below.
Renze frames this as a spectrum, and most people are somewhere on it without realizing where.
Stage one is a simple assistant relationship: working with a chatbot one step at a time, answering questions, searching, drafting a document. This is where most people working with AI sit today.
Example tools: ChatGPT, Claude Chat
At stage two, you’re collaborating with a coding agent or coworker agent on individual multi-step tasks. You specify what’s needed, the agent runs a few steps, comes back if it needs more information, and you then review the completed task.
Example tools: GitHub Copilot, Claude Code, OpenAI Codex
Stage three moves into supervising agent workflows: non-sequential, branching processes where a sub-agent handles each node in the graph and hands its work to the next agent in the chain.
Example tools: LangChain / LangGraph, Microsoft Agent Workflows
By stage four, you’re managing a goal through a fully autonomous agent, the kind that runs on its own machine, checks in through chat, and works against a task board with minimal interruption.
Example tools: OpenClaw, Hermes
Stage five, which Renze describes as highly experimental, is leading a mission through an autonomous agency: a multi-agent system organized like a company, with a manager agent delegating to agents in specific roles, all working from a shared mission and shared operating procedures.
Example tools: PaperClip AI
As you move up the stages, the unit of work you can safely hand to AI increases, and so does the time scale, from seconds at stage one to days or weeks at stages four and five.
At Anthropic, roughly 80 to 85 percent of code is now written by AI agents rather than humans, a shift Renze says took hold within about six months of the industry recognizing that coding agents had become capable.
The practical implication for engineering leaders is that whatever agent capability you’re evaluating today will likely be roughly twice as capable in about four months. Renze’s advice is blunt: if you are running a model that is three to six months old, replace it with the current generation and see what changes.
Renze’s approach to ROI is grounded in what a business already does, not what it could hypothetically do. Start with an existing task that already has a known cost profile, a person or team already doing it, and compare that against the cost of running an agent to do the same work. Until the agent’s cost falls below that existing baseline, the automation doesn’t pay for itself yet.
For early-stage or exploratory work, there often isn’t a clean baseline to compare against. In that case, Renze’s approach is closer to a rough estimate of anticipated cost against anticipated value, while acknowledging that some of the value, like market understanding, is real but not directly quantifiable in dollars.
The gap between what simple prompting costs and what a running coding agent costs is bigger than most people assume. Jeffrey pushed on this directly: it isn’t just double the token cost, it can be a factor of 10 or 20. Renze agreed, and pointed to where the real spend shows up: his own research and production workloads can run into the billions of tokens depending on which stage of the agent is running and how many are active at once.
Renze expects token pricing to stay flat or rise in the near term, driven by GPU, fab, and data center capacity constraints that haven’t caught up with demand, particularly in the United States relative to countries investing more aggressively in energy and data center infrastructure. Longer term, his expectation, shared broadly across the industry by his account, is that token costs drop close to zero as efficiency gains compound: better GPU design, new architectures, and algorithmic improvements like lower-bit-precision model weights.
That expectation is part of why some organizations keep spending heavily on tokens now rather than waiting: first-mover advantage compounds, and building a company around the assumption that tokens will eventually be as cheap and unmetered as electricity is itself a bet worth making early.
Jeffrey framed the question in terms every engineering team will recognize: a batch job that starts up, listens for a trigger or runs on a schedule, sits behind a web API, queries a database, and once it’s live gets automated tests, health checks, and IT monitoring, watching memory and uptime. How much of that carries over to an autonomous agent, and how much doesn’t?
Renze described a mixed picture. Principles like high cohesion, low coupling, and a single source of truth hold up well with agents, just as they did before. Other agent behavior, like branching into multiple sub-agents mid-task and merging the results back together, has no clean equivalent in how a single person works, and Renze said he’s still rethinking those cases from first principles rather than assuming an existing pattern applies.
The distinction that matters isn’t whether your team is “using AI.” It’s which of these five stages a given task requires, whether the cost of running an agent at that stage has crossed below what the task already costs your team, and whether you’re rebuilding practices that don’t need to change or rethinking the ones that do.
If you’re not sure which stage your team is ready for, that assessment, matching the task to the right stage and the right level of trust, is exactly where a lot of teams get stuck. One production support team at a digital-first commercial insurance company was losing dozens of developer hours a week to import failures, log investigation, and task refinement, the kind of repetitive work that sits squarely at stage two. Clear Measure led their Cursor rollout: training for developers, team leads, BSAs, and QA, plus dedicated sprint time to rebuild the team’s workflows around the new tooling. Import failure resolution time dropped from about an hour to about 15 minutes. See how we approach AI tooling support for teams making that same jump.
Listen to the full conversation with Matthew Renze on the AI DevOps Podcast.
