Ask any vendor what level of agentic AI their product delivers and you'll get an answer somewhere between "transformative" and "fully autonomous." Ask the same question of the engineering team actually deploying it and you'll hear something closer to "we've got a chatbot that sometimes calls an API."

That gap — between marketing narrative and operational reality — is where most businesses live right now. And it's widening.

Ashpreet Bedi, the founder of Agno (formerly Phidata), recently proposed a useful framework: five levels of agentic software, each building on the last. The levels themselves aren't new — but they're a good way to force an honest conversation about where you actually sit.

The five levels

Bedi's framework maps the progression from basic tool use to autonomous systems.

Level 1: Agent with tools and instructions. An LLM that can actually do something — read files, call APIs, run commands. Without tools, it's just a reasoning engine with no hands. Most "AI agents" in production today are level one. They follow explicit instructions and use predefined tools. A lot of value lives here already.

Level 2: Agent with knowledge and retrieval. Level one is stateless. Every conversation starts from scratch. Level two fixes that by giving the agent access to your domain knowledge — specifications, runbooks, meeting notes, architecture decisions — and the ability to persist and retrieve context across sessions. The agent doesn't just respond; it responds with your organisation's context. But it's still fetching and following. You ask, it retrieves, it acts.

Level 3: Agent with reasoning and judgement. This is where most businesses claim to be. Very few actually are. A level-three agent doesn't just retrieve relevant context — it reasons across it. It handles ambiguity, connects patterns across data sources, plans multi-step approaches, and makes judgement calls when the instructions don't cover the situation. The difference between two and three is the difference between a system that looks things up and one that figures things out.

Level 4: Multi-agent teams. Multiple specialised agents working together, delegating tasks, sharing results. Think of it as a software team where each member has a specific role — one researches, one writes, one reviews, one deploys. The coordination layer is what makes this hard, not the individual agents.

Level 5: Agentic systems. Fully autonomous systems with real decision-making authority across complex workflows. No human in the loop for routine operations. Self-directing, self-correcting, operating at scale. This is what the vendor slides show. Almost nobody is here.

The honest self-assessment

If your "agent" is a chatbot with some API integrations and a system prompt — that's level one. Most of what passes for agentic AI in production is exactly this, and when it's well-built, it works.

If your agent can pull from a knowledge base and retrieve previous interactions — you're approaching level two. If it persists context across sessions and draws on organisational knowledge without being explicitly told where to look, you're solidly there.

Level three is where most self-assessments fall apart. Your agent is supposed to be reasoning across multiple data sources, handling ambiguous requests, and adapting its approach based on historical outcomes. Be honest: is that what's happening, or is it just a well-written prompt chain?

Level four requires orchestration infrastructure that most companies haven't built. Level five? You probably don't need this article.

Why jumping levels is counterproductive

The instinct is understandable. The board has seen the demos. Competitors are making claims. The pressure to leapfrog straight to multi-agent systems or fully autonomous workflows is real — especially when the structural case for AI investment is this strong.

But the readiness data tells a different story: 85% of enterprises say they want AI agents, but 76% lack the infrastructure to support them. Gartner predicts that over 40% of agentic AI projects will be cancelled by the end of 2027 — not because the models fail, but because organisations can't operationalise them. Identity, permissions, auditability, governance — the boring stuff that never makes it into the demo.

And the vendor landscape isn't helping. Gartner estimates only about 130 of the thousands of agentic AI vendors are the real thing. The rest are engaged in what analysts are calling "agent washing" — rebranding existing chatbots, RPA tools, and assistants with agentic language without any substantive change in capability.

Skipping levels means building on foundations that don't exist. And the maths of reliability makes this worse — each nine of reliability costs the same effort as the last, so rushing to multi-agent systems multiplies both the capability gap and the reliability gap. Your level-four multi-agent system needs the knowledge infrastructure of level two and the reasoning capabilities of level three. Without them, you get something that looks impressive in a demo and falls over in production.

The gap between the brochure and the build

McKinsey reports that 39% of organisations are experimenting with AI agents, but only 23% have begun scaling them within even a single business function. Only 6% have fully implemented agentic AI. Meanwhile, nearly every enterprise software vendor has "agentic" somewhere in their marketing.

This isn't unusual for technology adoption cycles — the gap between early experimentation and scaled deployment is always larger than anyone admits. But with agentic AI, the marketing has dramatically outpaced the engineering. Vendors are selling level five while most buyers are still building level one.

The businesses making real progress have accepted this. They're building solid level-one and level-two systems, proving value in constrained domains — IT operations, customer support, finance reconciliation — and only adding complexity when the simpler approach has clearly hit its limits.

Software maturity is not business readiness

The part most frameworks miss — including Bedi's — is that agent capability is only one axis. Organisational readiness is another. And they don't move in lockstep.

You can buy a level-four tool and still operate like a level-one business. It happens all the time. The tool can orchestrate multiple agents, handle complex workflows, coordinate across systems — but if you haven't defined which decisions can be delegated, what evidence an agent may use, how exceptions get escalated, who owns the outcome, and what audit trail must exist afterward, you haven't got an agent system. You've got an expensive liability.

In practice, many of the failures blamed on the model are really failures of operating design. The agent did exactly what it was capable of doing. The organisation just hadn't done the work to make that capability safe. Nobody had drawn the line between "the agent can decide this" and "a human needs to decide this." Nobody had specified what a good outcome actually looks like, in terms the agent could evaluate.

This is the hard part that doesn't fit on a maturity slide. Getting the agent to act is a solved problem. Making the decision boundary explicit enough that action is safe — that's the work most companies haven't started.

What to actually do with this

Be honest about where you are. Not where your vendor deck says you are, not where your board presentation implies you are — where you actually are. For most organisations, that's level one, possibly approaching level two.

The persistent knowledge layer of level two — your organisational memory, your domain knowledge base, your session continuity — is where most of the early value sits. Get that right before chasing multi-agent orchestration. And ignore the FOMO. The fact that a competitor announced an "autonomous AI agent" doesn't mean they have one. It means their marketing team had a good quarter.

But beyond the technical levels, do the organisational work too. Define the decision rights. Map the escalation paths. Specify what "good" looks like in terms an agent can be measured against. That groundwork is less visible than deploying a new model, but it's the difference between a system that runs and one that runs safely.

Before asking how autonomous your agents are, ask how explicit your business is about decisions. Most companies don't have an agent problem. They have a judgement-design problem.