After Self-Healing: Why Agents Need Autonomy Levels L6 and L7

I had a free week. Not quite as planned, though.

Early in the week I kicked off a large research task and burned through almost all my limits very fast — about 90% of the weekly budget gone in two days. In ordinary logic that looks like a problem: work stalls, the usual rhythm breaks, Arcanada seems to go on pause. But it turned out the other way around. When your ability to just keep doing things suddenly runs out, you get a rare space to think. Not to close another task. Not to polish another workflow. Not to chase the next agent. But to stop and look from above: what am I actually building, where is it heading, and why do some services already behave more complexly than I described in my own earlier methodology?

And at some point I noticed a strange thing. Some of my agents already perform functions that fit poorly into fifth-level autonomy. Formally, L5 is full autonomy within a task: the agent works on its own, recovers on its own, optimizes itself, picks cheaper or higher-quality routes, learns from evaluations. But in real work I increasingly see another layer: the agent doesn't just solve a task — it starts building other agents, roles, checks, routes, and infrastructure loops around itself.

So it stops being merely an autonomous executor. It becomes an organizer of autonomy.

In the previous article I took the telecom L0–L5 autonomy scale and mapped it onto AI agents. It was a good starting point: TM Forum really does use a scale of autonomous-network levels — from L0, manual operations, to L5, fully autonomous networks. But the deeper I work with agent systems, the clearer it gets: for AI agents L5 is not the finish line. It's the finish line only for a single agent. Beyond it begins a completely different story.

Why L5 Is No Longer Enough

In telecom the object of autonomy is the network. The network must detect failures itself, recover itself, optimize traffic itself, hold quality of service itself. So L5 there looks like a natural summit: a fully autonomous network that operates by business intent and operational constraints.

But an AI agent is not just a network. An AI agent can be a developer, a tester, an analyst, an architect, a reviewer, an infrastructure operator, a researcher, a manager of other agents. And that's where the difference begins.

If an agent can recover itself after a crash — that's L4. If an agent can improve its own work, choose models, change prompts, optimize cost and quality — that's L5. But if an agent realizes that a recurring class of tasks needs a separate specialized agent, creates it, describes its role, hands it tools, wires in checks, runs it in a sandbox, evaluates quality, and then plugs it into the working loop — that's no longer L5.

That's another level. That's not self-healing. That's self-assembly.

What Already Exists in the Research

I don't want to present this idea as a fantasy out of thin air — the scientific and engineering groundwork has been accumulating for a long time.

Back in 2001 IBM described autonomic computing — self-managing computing systems with the properties of self-configuring, self-healing, self-optimizing, and self-protecting.

Reflexion demonstrated an idea important for agent systems: an agent can improve its behavior not by fine-tuning model weights, but through verbal reflection, feedback, and episodic memory. Experience becomes not mysticism but a working artifact of the system.

AutoGen showed another layer: several LLM agents can be assembled into a conversational system where they interact with each other, use tools, take human input, and execute complex workflows.

And AutoAgents came even closer to what I'm talking about here: the framework proposes not just using predefined agents, but dynamically generating specialized roles for a given task and coordinating them as a team.

So the direction is already visible. But what I'm missing is a practical scale. Not a scale of "how smart the model is," not "how pretty the chat is," not "how many agents are in the workflow" — but a scale of the operational autonomy of an agent system. What exactly can the system do without a human? Where is the human still an operator? Where are they already an architect? Where do they become the author of the system's constitution?

And here I propose extending the earlier scale — not to a "seventh level" in the everyday sense, but to an eight-level one: from L0 to L7.

Eight Levels of Autonomy

Counting from zero, you get eight levels: L0, L1, L2, L3, L4, L5, L6, L7. The zeroth level isn't decorative — it shows the starting state, in which there's no autonomy at all. I described L0–L5 in the previous article; here I add the two top ones: L6 — orchestrator autonomy and L7 — ecosystem autonomy. But to make the jump to them visible, I'll walk briefly through the whole scale.

L0 — Manual Work

The system does nothing on its own. A human reads, thinks, copies, pastes, runs commands, checks the result, fixes errors. In the AI world this is ordinary work with ChatGPT or Claude: you wrote a prompt, got an answer, moved it into code yourself, ran the tests yourself, fixed it yourself, decided the next step yourself. The model can be very smart, but the process isn't autonomous — the loop is closed by the human.

L1 — Assisted Automation

The system can run a pre-configured operation: a cron, a script, a simple bot, a scheduled summary, a report generator on a timer. If all is well — it ran. If something went wrong — it crashed, wrote a log, or, worse, wrote nothing. For an agent this is the "useful toy" level: it already saves time, but doesn't understand its own state.

L2 — Partial Autonomy

A narrow closed loop appears. The system can check its health, classify known errors, do a safe retry, write a status, send a signal to monitoring. This isn't intelligence yet, but it's the beginning of autonomy: the agent doesn't just "start up and die," it understands simple states — alive, not alive, token expired, API didn't respond, database unavailable, task done, task failed. Many of Arcanada's services lived in this zone for a long time. A boring level, but without it everything else is theater.

L3 — Conditional Autonomy

The system begins to adapt — not just execute static rules, but change behavior by policy. Traces, structured logs, eval scores, heartbeats, startup checks, smoke tests, secret and model-availability checks, conditional routing appear. The human no longer approves every action — they set policy: simple tasks to a cheap model, hard ones to a strong one; eval drops — stop the rollout; provider down — fail over; cost above the limit — don't continue. This is already a real operational agent, but it doesn't heal itself deeply yet.

L4 — Self-Healing

The agent can not only detect a problem but recover: restart a crashed component, roll back a bad deploy, switch to a backup provider, resume a task from a checkpoint, tell a transient error from a permanent one, stop an infinite retry loop. For AI agents a special thing appears here — hard financial circuit breakers. In an ordinary service an infinite retry loop burns CPU. In an LLM agent it burns money. So L4 for AI is self-healing plus cost circuit breakers: every model call has a limit, every task a budget, every agent a ceiling, every workflow a kill switch. Without that, autonomy turns into a financially dangerous illusion.

L5 — Self-Optimization

At L5 the agent doesn't just survive — it gets better. It analyzes results, improves prompts, picks models, compares providers, compresses context, cleans memory, builds an eval dataset, runs A/B tests, lowers cost without losing quality, and raises quality without pointlessly growing cost. At this level the agent already looks almost like an independent worker: got the task, understood the context, did the work, checked itself, fixed errors, saved the lessons, did better next time.

This is where the classic L0–L5 scale ends. And this is exactly where it gets most interesting. Because L5 answers the question "how can the agent do its job better?", while the next level answers a different one: "what new agents need to be created so this class of work is never done by hand again?"

L6 — Orchestrator Autonomy

L6 is the level where it's not the executor that becomes autonomous, but the orchestrator. The orchestrator doesn't just call pre-existing agents — it can create new ones. Not in a mystical sense, but a very engineering one: it sees a recurring task, understands that it needs a separate role, describes the agent's purpose, assigns tools, restricts permissions, allocates memory, formulates quality criteria, runs tests, checks against historical cases, compares with a baseline, plugs it into the workflow, watches the results, and turns it off or rebuilds it if the agent can't cope.

That's L6. Not an agent that works well — but an agent that builds other agents. At L5 the system asks: "how can I do the task better?" At L6: "what new working unit should exist in the ecosystem so that tasks like this are always solved better?"

This is a fundamental jump. Here the agent system starts producing its own organs — not just using the hands the developer gave it, but growing new hands for new tasks.

How L6 Differs from an Ordinary Multi-Agent Workflow

It's important not to confuse the two. If a human built five agents by hand, wrote their roles, and wired them into a pipeline — that's not L6 yet. It could be L2, L3, L4, or L5, depending on the quality of the system. L6 begins only where the orchestrator itself can see a missing role, design it, create the agent, give it tools, restrict permissions, check quality, embed it in the process, watch the consequences, and roll the decision back.

So L6 isn't "many agents." L6 is the autonomous design of an agent team. A real orchestrator agent isn't a task manager — it's a constructor of an organization.

L7 — Ecosystem Autonomy

L7 is another jump. At L6 the orchestrator is autonomous. At L7 the entire ecosystem becomes autonomous. This is no longer a story about one smart agent, or even one chief manager — it's a system that can develop itself as infrastructure.

An L7 ecosystem can watch the health of all agents, see bottlenecks, propose new infrastructure, create new services and roles, convene councils of agents, explore new directions, compare architectural decisions, build eval datasets, maintain internal documentation, update its own rules, plan its development, reallocate resources, and build tools for itself.

This is no longer task autonomy. It's development autonomy. At L5 the agent does the work. At L6 the orchestrator builds agents. At L7 the ecosystem builds its own future form.

And this is where Arcanada becomes not a set of services, but an organism. Not biological, not conscious, not magical — an operational one. With memory, roles, organs, an immune system, internal councils, rules, a history of decisions, mechanisms for growth, and mechanisms for prohibition.

A Council of Agents

One of the central mechanisms of L7 is the council. Because the higher the autonomy, the more dangerous a single agent's decision becomes. One agent can be persuasive and wrong: it can nicely explain a bad architecture, optimize the wrong metric, miss a risk, make a locally profitable decision that destroys the system a month later.

So at L7 a decision should pass through different roles. The architect looks at structure. The security agent looks at permissions and threats. The finance agent looks at cost. The reliability agent looks at failure modes. The product agent looks at user value. The research agent looks for alternatives. The critic agent attacks the decision. The ops agent checks whether it can be operated safely. This isn't democracy for democracy's sake — it's a way to reduce the blindness of a single agent.

Research on generative agents (Stanford and Google) already showed that agents with memory, planning, reflection, and interaction can produce complex group behavior. But for a production system what matters is not the "magic of behavior" itself, but a governable form of discussion: artifacts, logs, arguments, objections, decision records, a rollback plan. At L7 the council must leave a trace — what decision was made, who objected, why the objection was rejected, what data was used, what risk was deemed acceptable, what rollback was provided, what budget was allocated, when the decision will be revisited. Without that, a council turns into theater. With it — into a system of governance.

The Human Doesn't Disappear

The most common mistake in conversations about autonomy is thinking that the higher the level, the less the human is needed. In fact the human doesn't disappear. They change layers.

• At L0 the human is an executor.
• At L1 — a launcher.
• At L2 — an observer.
• At L3 — the author of policy.
• At L4 — an engineer of recovery mechanisms.
• At L5 — the owner of goals and eval criteria.
• At L6 — the architect of boundaries: which agents may be created, which permissions may be granted, which tests are mandatory, which actions require approval.
• At L7 — the author of the ecosystem's constitution: mission, forbidden actions, budget limits, legal and ethical constraints, risk levels, agent rights, escalation criteria, stop conditions.

So the human stops being a mouse operator and becomes a legislator. And that's the right direction: not to "remove the human from the system," but to raise them to the level where they're actually needed.

Why L6 and L7 Are Not AGI

It's very easy to start calling all of this AGI. But that's the wrong language. L6 doesn't require consciousness, L7 doesn't require a soul. The orchestrator doesn't need to "understand life" — it needs to do concrete things: notice repeatable work, create a specialized executor, set permissions, give tools, check quality, embed it in the process, stop on errors. An L7 ecosystem doesn't need to be alive in the human sense either — it needs observability, memory, evals, governance, planning, a research loop, decision records, rollback, a sandbox, permission boundaries, cost control.

This isn't AGI. It's an autonomous engineering organization built out of agents. And in a sense that's even more interesting: AGI is a foggy word, while L6 and L7 can be designed.

The Main Danger of the Upper Levels

The higher the autonomy, the more dangerous the mistake. At L3 a bad policy leads to a bad route. At L4 a bad recovery restores the wrong thing. At L5 a bad metric teaches the agent to optimize cost at the expense of quality, or the reverse. At L6 a bad orchestrator starts creating bad agents. At L7 a bad ecosystem starts reproducing bad decisions as the norm. That's no longer a bug — it's the institutionalization of error.

That's exactly why the upper levels are impossible without governance. Not in the sense of a pretty PDF document, but in the sense of runtime governance: permissions, budgets, logs, audit, roles, sandboxes, approval gates, kill switches, decision records, rollback plans, limits on creating new agents, on data access, on spending.

Modern AI risk-management frameworks — the NIST AI Risk Management Framework and ISO/IEC 42001 — point precisely to the need for systematic management of risks, roles, processes, and continuous improvement of AI systems. For L7 this isn't bureaucracy, it's a skeleton. Without it, an autonomous ecosystem turns into a swarm. And a swarm can be effective, but it's unmanageable.

The Levels Table

A Practical Test

To keep the scale from being philosophy, you can check it with simple questions.

• L0: if the human stops acting, will the system do anything useful?
• L1: can the system run a pre-configured task without manually launching each step?
• L2: can it detect a known error, retry safely, and report status?
• L3: can it change behavior by policy, metrics, and observability?
• L4: can it recover from a failure without a human and without burning the budget?
• L5: can it improve quality, cost, routing, memory, or prompts based on evaluations?
• L6: can it create or reconfigure another agent, giving it a role, tools, tests, and constraints?
• L7: can the whole ecosystem research, deliberate, decide, build infrastructure, change its own structure, and grow under human-set constraints?

If the answer is "yes" — the level is reached. If "almost" — it isn't. "Almost autonomy" usually means the human is still quietly holding the system by hand.

Where Arcanada Fits

For me this scale matters not as an abstract classification, but as a map for building Arcanada. Individual services can move toward L5 for now: self-healing, eval-driven optimization, cost governance, fallback chains, model routing, prompt refinement. But Arcanada as an ecosystem has to move further.

Toward L6 — where Datarim or another orchestrator can not just execute tasks, but create new specialized agents for recurring classes of work. Toward L7 — where the whole ecosystem can sustain itself, explore new directions, convene councils, make architectural decisions, build infrastructure, improve its own rules, and grow without constant manual control of every step.

That's the main shift. First we build agents. Then agents build other agents. Then the system builds itself. Not without control, not without the human, not without boundaries — but inside a given constitution.

Instead of a Conclusion

This would be a convenient place to put a full stop. To say we now have a finished scale: from L0 to L7. From manual work to an autonomous agent ecosystem. From a human-operator to a human-legislator.

But I don't think L7 is the real limit. Rather, it's the limit of the current operational frame. L7 describes autonomy inside a single ecosystem: Arcanada, a company, a product, an infrastructure loop, a research lab. And above that frame, other scales begin to appear.

There's a space of projects — no longer one project or one ecosystem, but many projects between which connections, dependencies, tool exchange, agent transfer, knowledge reuse, architectural competition, and the migration of ideas arise. There's a universe of projects — the level where projects form their own environment: some become infrastructure for others, some agents serve several directions at once, some research results change the trajectory of whole families of systems. And there's a metaverse of the information space, where autonomy can no longer be described only through an agent, an orchestrator, or an ecosystem — there you'll have to talk about the movement of knowledge, the birth of new meanings, the competition of world models, and navigation between project universes.

Maybe levels L8, L9, and beyond will appear there. But I don't want to rush the names yet — L6 and L7 are already complex enough to first build, test, get burned by, describe, redo, and test again.

For now what matters to me is a simple thought. L5 is an autonomous agent. L6 is an agent that builds other agents. L7 is an ecosystem that develops itself. And everything above that is no longer just autonomy of execution. It's the autonomy of developing spaces: spaces of projects, universes of projects, a metaverse of the information space.

And it seems that's where all of this is ultimately heading. But that's the next map. And we still have to explore it.