Anthropic, OpenAI and Cursor: The Eight Levels of Agentic Engineering Maturity

Habr AI has published a translation of an article on the eight levels of agentic engineering, a practice that turns an LLM from an autocomplete assistant into a nearly autonomous team of developers. The text's main point: a leap in model quality does not by itself guarantee higher productivity if the team has not built up context, rules, tools and feedback.

From suggestions to agents

The author calls the first two levels familiar: tab complete and the agent IDE. At this stage AI speeds up local tasks: it completes code fragments, helps with edits across several files and builds a plan from an idea. But the real break comes at the third level, where context engineering takes center stage. It is no longer about a clever prompt but about discipline: which files, rules and tool descriptions the model receives, what sits in the session history and how much needless noise eats up the context window. The less junk, the more stable the result.

"Every token must earn its place in the prompt."

The fourth level is compounding engineering: the team does not just use the model but turns successful discoveries into a system. If an agent makes a mistake, the lessons are recorded in rules files, documentation and working patterns so the next session does not repeat the same errors.

The fifth level adds action tools: MCP, skills, and access to APIs, databases, CI and the browser. From this point the LLM stops being merely a conversation partner about code and starts to actually change the codebase, test it and take part in review.

Where the payoff grows

The author considers the sixth level the point where AI coding becomes truly production-grade. What matters here is not only context but the whole environment around the agent: tests, linters, typing, logs, browser checks and other feedback loops. They let the model do more than generate a patch: it can notice an error, check itself and make another iteration without human involvement.

The article calls this harness engineering: designing a runtime in which the agent can see the consequences of its own changes and run into hard constraints rather than vague instructions.

• rules files and documentation that set the context
• CLI or MCP tools for access to data, tests and the interface
• automatic backpressure: types, linters, hooks, CI
• separation of roles between executor and reviewer, so the agent does not check itself

The seventh level grows out of this: background agents. If a model can build a plan, navigate the repository and validate its result on its own, it no longer needs to be kept in an interactive tab. The agent can work asynchronously: explore the codebase, write a feature, run checks, open a PR and come back only with questions or a result. For a team this changes the way of working itself: the developer juggles fewer tasks by hand and increasingly acts as an orchestrator who sets intent, constraints and priorities.

Where the market is heading

What comes next still looks more like the leading edge than everyday practice. The eighth level is autonomous agent teams, in which several LLMs coordinate directly with each other rather than through a single central operator. The text cites examples from Anthropic and Cursor: parallel agents have already been used to write a C compiler, build a browser and carry out large codebase migrations.

But with scale, old development problems surface immediately: regressions, conflicts, hangs, excessive caution and rising compute costs. The author therefore offers a sober conclusion: for most teams it is now more important to reach at least a mature seventh level than to dream of fully independent AI departments. That means building clean context, accumulating rules, good skills, reliable verification loops and background orchestration. This, in the author's view, is where the nearest practical gain lies. And this is where the gap between a strong and a weak AI team becomes especially visible: some speed up releases, others drown in the chaos they themselves automated.

What this means

The Habr AI article is useful because it turns the conversation about "smart models" into one about engineering maturity. The AI coding market is moving not toward a magic button but toward systems in which models get the right context, working tools and strict verification loops. The winners will not be those who simply have a newer model, but those who build a working pipeline around it faster.