Publication

The five levels of agent systems

Everything is called an “agent”, from an assistant that calls an to a system that runs a business. Omniatix™ proposes five levels, each defined by a capability the one below it lacks, and a thesis: a solves level 1; level 3, governing the whole system as one unit, calls for an operating system.

The problem

Everything is called an “agent”

Today the same word names very different things:

  • An assistant that calls an API when asked to.
  • A chain of instructions to a model, with access to tools.
  • A team of model instances that work together on a task.
  • A system that runs for months, with its versions, its caps, its rules and the people who step in.

They are not the same. Calling all of them an “agent” is like calling both a calculator and a data center a “computer”: it is correct and it helps no one.

We need a ladder. Not for academic precision, but to answer three practical questions: what you are building, what you are buying and what it actually does.

The five levels

A ladder of five levels

Each level adds a capability the one below it does not have. Moving up a level is not adding features: it changes what the system has to solve.

The ladder of agent systems, according to OmniatixFive levels, from bottom to top: task agents, autonomous systems, multi-agent systems governed as one unit, ecosystems, and systems that redesign their own architecture. GrailAOS is marked at level 3, which it meets by Omniatix's criteria. Levels 4 and 5, dotted, are the industry's horizon.LEVEL 5 · STRUCTURAL CHANGERedesign themselvesLEVEL 4 · COEVOLUTIONEcosystemsLEVEL 3 · GOVERNING THE WHOLEGoverned as one unitLEVEL 2 · LIFECYCLEAutonomous systemsLEVEL 1 · ACTIONTask agentsGrailAOS: at this level

The diagram as text

  1. Level 1 · Task agents. Action. A reflex.
  2. Level 2 · Autonomous systems. Lifecycle. A cell.
  3. Level 3 · Multi-agent systems governed as one unit. Governing the whole. An organism. GrailAOS: at this level.
  4. Level 4 · Ecosystems. Coevolution. An ecosystem. Horizon.
  5. Level 5 · Systems that redesign their own architecture. Structural change. Evolution. Horizon.
  1. Level 1Task agents

    Defining capability
    Action
    Analogy
    A reflex

    It receives an instruction, chooses tools, carries out the steps and returns a result. When the task ends, the agent ends.

    What it lacks: It does not know it ran before and keeps no state from one run to the next: if it fails, it fails, and if it succeeds, it forgets.

  2. Level 2Autonomous systems

    Defining capability
    Lifecycle
    Analogy
    A cell

    It persists over time: it keeps state between runs, runs on its own, on a schedule or when an event happens, and can be started, stopped and watched while it runs.

    What it lacks: Each instance is on its own: the parts do not coordinate, nobody bounds the resources of the whole and nobody sees the health of the whole. If one part consumes too much, nobody stops it in time.

  3. Level 3Multi-agent systems governed as one unit

    Defining capability
    Governing the whole
    Analogy
    An organism

    Several agents and workflows governed as a single unit: versions with and ; shared resources and caps; rules enforced across the whole system; the health and observability of the whole; people in the loop; and several agents and steps that form a single workflow.

    What it lacks: It is a closed system: it governs its pieces, but it does not interact with other systems like it that belong to other owners, and people design its architecture.

  4. Level 4Ecosystems

    Defining capability
    Coevolution
    Analogy
    An ecosystem

    Many systems, each with its own owner, that interact and adapt to one another without central control.

    What it lacks: A person still designs the architecture of each system: each system changes how it works, not how it is built.

  5. Level 5Systems that redesign their own architecture

    Defining capability
    Structural change
    Analogy
    Evolution

    They do more than adjust how they work: they change their own structure when the one they have is not enough for the problem.

    What it requires: Advances in safety and in formal verification before these systems can be deployed responsibly.

Levels 4 and 5 are the industry's horizon: we describe them to complete the ladder, without claiming them for GrailAOS or for anyone else.

To place the upper levels, biology gives a clearer picture than computing, which is why each level comes with an analogy.

Why biology is a good lens

The problems that show up as you climb the ladder, such as allocating scarce resources or coordinating without central control, are the ones living things had to solve. The analogies help you find your bearings; they do not describe how any system is built.

Where the industry stands

Which level each category solves

In April 2026, the internal work this version is based on placed almost the whole industry at level 1. We measured again with sources, each one dated, and that is not the case: several categories already keep state between runs and run on their own over time.

Each category is measured with a well-known product in that category, according to its official sources; each one has pieces of level 3, whole or in part. This is not a quality ranking: it says which level each category solves according to those sources, not how well.

The ladder as a lens

Which level each category solves

This is not a quality ranking: it says which level each one solves, not how well.

By our criteria, each category sits at the level where the official sources of the product that measures it say “Yes” to every criterion of that level and of the levels below; GrailAOS, by the same rule, from the status of its statements. Where the levels come from

How we measure it

A category is at a level when the sources of the product that measures it back every criterion of that level and of the levels below with a “Yes”; the product counts together with its vendor's platform. Partial is not enough, and what it has from the levels above is shown alongside. The level 3 criteria are Omniatix's and reflect how we think about that level: with other criteria, the result may change.

  • Category: Visual builder for appsLevel 2+1 from level 3

  • Category: Process automation with AILevel 2

  • Category: Code-based agent frameworkLevel 2+2 from level 3

  • Category: Agent platform from a model providerLevel 1+1 from level 2+1 from level 3

  • Category: Conversational platformLevel 2+1 from level 3

  • GrailAOSCategory: Agent Operating SystemLevel 3

    • Runs todayLevel 3, by the same rule as the others
    See why: GrailAOS

    Limit Under other criteria, the result may change, and each piece has its limits: parallel branches run on a single server.

    The level 3 pieces, with their status

    • Runs todayVersions with canary and rollback
    • Runs todayShared resources and caps

      Limit The turn in progress always finishes; usage notifications are off by default and, like the billed-amount cap, need billing turned on.

    • Runs todayRules enforced across the whole system
    • Runs todayHealth and observability of the whole
    • Runs todayPeople in the loop
    • Runs todaySeveral agents as one unit

    Measured by the same rule as the others: what counts is what runs today, according to the status of its statements. It meets all six level 3 pieces, and each one carries its status. The pieces, one by one

The thesis

Why an operating system

A framework solves level 1 well: it gives developers the pieces for an agent to use tools. With a platform that hosts it, it adds level 2. Level 3 is something else.

You do not reach level 3 by adding features to a framework, just as you do not reach an operating system by adding features to a library. Programs needed an operating system, such as Unix, to become a governed computing environment; an agent system that runs a business needs the same.

The difference shows piece by piece. On one side, what a framework alone gives you; on the other, what an operating system governs. With their vendor's platform, some frameworks already have whole pieces of the operating system, and the industry lens says how many: what level 3 asks for is having all of them, governed together. Under each piece, what runs today in GrailAOS, with its status.

How to read the labels

Runs today
Implemented and tested; if it ships turned off, the limit says how to turn it on. If the statement is not a capability, such as the license, the trademarks or a design principle, it means the statement is true today.
Partial
Runs, with gaps in the implementation: the limit says which ones.
Available on request
Does not run today: Omniatix implements it if a customer asks for it, with no timeline.
Coming soon
Omniatix has announced it and it is not available yet. No date.
Vision
The purpose GrailAOS is designed for. It is not a current capability: what already runs carries its own label.

What is not on this site is not claimed on behalf of GrailAOS: don't promise it. For other capabilities, ask Omniatix.

  1. Versions with canary and rollback

    Every change ships as a version: first to part of the traffic, and it can be rolled back without rebuilding anything.

    With a framework alone
    Versioning and publishing each agent is the team's job, with its own tools.
    With an operating system
    A that publishes each version of the solution, with canary and rollback.

    In GrailAOS, today

    • Runs todaySolution versions without rebuilding, with preview, canary and rollback
  2. Shared resources and caps

    Usage is measured, and the caps, for the account or for a solution, are checked before each turn.

    With a framework alone
    A budget the team sets up and watches on its own.
    With an operating system
    A budget the system enforces by itself, before the money is spent.

    In GrailAOS, today

    • Runs todayUsage measured at real cost and caps checked before each turn

      Limit The turn in progress always finishes; usage notifications are off by default and, like the billed-amount cap, need billing turned on.

  3. Rules enforced across the whole system

    The rules apply to the whole solution: they are verified before it runs, and the runtime enforces its guards while it runs.

    With a framework alone
    Validations the team adds wherever it needs them.
    With an operating system
    The same rules for every part, without the team having to repeat them in each one.

    In GrailAOS, today

    • Runs todayThe verifies the whole solution before anything runs
    • PartialThe notice of what the runtime does not execute

      Limit The check covers a fixed set of cases.

    • Runs todayRuntime guards: isolated , integrations with no access to private networks and the contact's identity
  4. Health and observability of the whole

    You see the state of the whole system, not that of each agent separately, and someone finds out when something fails.

    With a framework alone
    Logs the team gathers and reviews on its own, unless it adds a platform.
    With an operating system
    The health and observability of the whole, with alerts to whoever operates it.

    In GrailAOS, today

    • Runs todayRuntime health and the of each solution
    • Runs todayOne per turn and email alerts to whoever operates it
    • PartialTraces in

      Limit OpenTelemetry sends one span per agent turn: workflow runs are not sent.

  5. People in the loop

    A person steps in when needed and replies from within the same system, without leaving it.

    With a framework alone
    A pause for someone to approve; each team builds the inbox where a person replies.
    With an operating system
    People in the loop as part of the system: they step in when needed and the system keeps going.

    In GrailAOS, today

    • Runs todayHandoff to a person, who replies from the console, and back to the agent
    • Runs todayA person's approval as a step in a workflow
  6. Several agents as one unit

    Several agents and steps form a single workflow: in parallel, in a loop, with subworkflows and with a person who approves as one more step.

    With a framework alone
    A graph of agents the team programs; governing it together with the other pieces is up to the team.
    With an operating system
    Several agents and steps that form a single workflow, governed with the other pieces as one unit.

    In GrailAOS, today

    • Runs todayDelegation between agents of the same solution
    • Runs todayConversational workflows
    • Runs todayWorkflows that run on their own, with list iteration, parallel branches, subworkflows and a person's approval as one more step

What it means

For builders, buyers and investors

The ladder helps you ask better questions.

For builders
Know which level you are at: for level 1 a framework is enough, for level 2 you need a platform that runs it, and level 3 calls for a different architecture.
For buyers
Ask which level the thing you are buying is at, and with what evidence: “multi-agent system” can mean almost anything.
For investors
What helps is knowing which level a product solves today, with what evidence, and what it is missing for the next one.
For the industry
It needs a shared vocabulary: with five levels, the conversation can be precise.

Our position

Where GrailAOS stands

We apply to GrailAOS the same rule we apply to the others in the industry lens, piece by piece and with the status of each one.

  • Runs todayGrailAOS meets level 3 by Omniatix's criteria

    Limit Under other criteria, the result may change, and each piece has its limits: parallel branches run on a single server.

GrailAOS is a , a compiler and a runtime for programming businesses with agents, built with coding agents, and every statement about GrailAOS carries its status.

We do not claim levels 4 and 5: they are the industry's horizon, and level 5 first requires advances in safety and in formal verification.

  • Runs todayA language, a compiler and a runtime: the solution in versioned text documents, verified as a whole before it runs
  • Runs todayBuilt with coding agents

The level 3 pieces, one by one

Measured in the repositories

  • v4.437Specification version implemented by the runtimeSource: GrailAOS runtime repository, main branch. Measured on .
  • 1,385Specified featuresSource: GrailAOS specification master index. Measured on .
  • 564Recorded architecture decisionsSource: GrailAOS specification master index. Measured on .
  • 21,558Tests declared in the runtimeSource: GrailAOS runtime repository, main branch. Measured on .
  • 72.5%Share of attributed to ClaudeSource: GrailAOS specification and runtime repositories, main branch. Measured on .
API An interface that lets another system use a service through requests and responses, without going through a screen.Framework A set of libraries on which an application is programmed in code.Canary A new version that first reaches only part of the users, so it can be seen working before everyone gets it.Rollback Going back to the previous version when the new one is not working well. As a verb, roll back.LLM A large language model, such as Claude, that reads and writes text. This site calls it “the model.”Runtime The engine that runs a program that is already written. In GrailAOS, the one that operates the compiled solution.Compiler In GrailAOS, the piece that checks the whole solution before anything runs and, for each error, says what happened, where and how to fix it.Tenant and multi-tenant A tenant is an account, for example a business, with its data kept apart; multi-tenant means that several of them share the same installation without seeing each other's data.Readiness The check Kubernetes uses to know whether a pod is ready to receive traffic: if it is not, no requests are sent to it.Trace The record of what happened in a turn: what was done, which tools were called, how long it took and how much it cost.OpenTelemetry An open standard for sending traces and metrics to whatever observability tools each company uses.Language In GrailAOS, the way a solution is declared in text documents: its agents, workflows, tools, knowledge, tests and the rest of its pieces.Commit A change saved in the history of the code, with a unique identifier that tells which version something comes from and lets you go back to it.