We keep talking about AI agents, but can we ever know what they’re?

Imagine you do two things on a Monday morning.

First, you ask a chatbot to summarize your latest emails. Next, you ask an AI tool to work out why your top competitor grew so fast last quarter. The AI silently gets to work. It scours financial reports, news articles and social media sentiment. It cross-references that data along with your internal sales numbers, drafts a technique outlining three potential reasons for the competitor’s success and schedules a 30-minute meeting along with your team to present its findings.

We’re calling each of those “AI agents,” but they represent worlds of difference in intelligence, capability and the extent of trust we place in them. This ambiguity creates a fog that makes it difficult to construct, evaluate, and safely govern these powerful latest tools. If we will not agree on what we’re constructing, how can we all know after we’ve succeeded?

This post won’t attempt to sell you on one more definitive framework. Instead, consider it as a survey of the present landscape of agent autonomy, a map to assist us all navigate the terrain together.

What are we even talking about? Defining an “AI agent”

Before we will measure an agent’s autonomy, we want to agree on what an “agent” actually is. The most generally accepted start line comes from the foundational textbook on AI, Stuart Russell and Peter Norvig’s “Artificial Intelligence: A Modern Approach.” 

They define an agent as anything that will be viewed as perceiving its environment through sensors and acting upon that environment through actuators. A thermostat is an easy agent: Its sensor perceives the room temperature, and its actuator acts by turning the warmth on or off.

ReAct Model for AI Agents (Credit: Confluent)

That classic definition provides a solid mental model. For today’s technology, we will translate it into 4 key components that make up a contemporary AI agent:

1. Perception (the “senses”): This is how an agent takes in details about its digital or physical environment. It’s the input stream that enables the agent to know the present state of the world relevant to its task.

2. Reasoning engine (the “brain”): This is the core logic that processes the perceptions and decides what to do next. For modern agents, this is often powered by a big language model (LLM). The engine is chargeable for planning, breaking down large goals into smaller steps, handling errors and selecting the fitting tools for the job.

3. Action (the “hands”): This is how an agent affects its environment to maneuver closer to its goal. The ability to take motion via tools is what gives an agent its power.

4. Goal/objective: This is the overarching task or purpose that guides the entire agent’s actions. It is the “why” that turns a group of tools right into a purposeful system. The goal will be easy (“Find one of the best price for this book”) or complex (“Launch the marketing campaign for our latest product”)

Putting all of it together, a real agent is a full-body system. The reasoning engine is the brain, however it’s useless without the senses (perception) to know the world and the hands (actions) to vary it. This complete system, all guided by a central goal, is what creates real agency.

With these components in mind, the excellence we made earlier becomes clear. An ordinary chatbot is not a real agent. It perceives your query and acts by providing a solution, however it lacks an overarching goal and the power to make use of external tools to perform it.

An agent, then again, is software that has agency. 

It has the capability to act independently and dynamically toward a goal. And it’s this capability that makes a discussion in regards to the levels of autonomy so necessary.

Learning from the past: How we learned to categorise autonomy

The dizzying pace of AI could make it feel like we’re navigating uncharted territory. But with regards to classifying autonomy, we’re not ranging from scratch. Other industries have been working on this problem for a long time, and their playbooks offer powerful lessons for the world of AI agents.

The core challenge is at all times the identical: How do you create a transparent, shared language for the gradual handover of responsibility from a human to a machine?

SAE levels of driving automation

Perhaps essentially the most successful framework comes from the automotive industry. The SAE J3016 standard defines six levels of driving automation, from Level 0 (fully manual) to Level 5 (fully autonomous).

The SAE J3016 Levels of Driving Automation (Credit: SAE International)

What makes this model so effective is not its technical detail, but its concentrate on two easy concepts:

1. Dynamic driving task (DDT): This is all the things involved within the real-time act of driving: steering, braking, accelerating and monitoring the road.

2. Operational design domain (ODD): These are the particular conditions under which the system is designed to work. For example, “only on divided highways” or “only in clear weather through the daytime.”

The query for every level is straightforward: Who is doing the DDT, and what’s the ODD? 

At Level 2, the human must supervise in any respect times. At Level 3, the automotive handles the DDT inside its ODD, however the human have to be able to take over. At Level 4, the automotive can handle all the things inside its ODD, and if it encounters an issue, it may safely pull over by itself.

The key insight for AI agents: A strong framework is not in regards to the sophistication of the AI “brain.” It’s about clearly defining the division of responsibility between human and machine under specific, well-defined conditions.

Aviation’s 10 Levels of Automation

While the SAE’s six levels are great for broad classification, aviation offers a more granular model for systems designed for close human-machine collaboration. The Parasuraman, Sheridan, and Wickens model proposes an in depth 10-level spectrum of automation.

Levels of Automation of Decision and Action Selection for Aviation (Credit: The MITRE Corporation)

This framework is less about full autonomy and more in regards to the nuances of interaction. For example:

• At Level 3, the pc “narrows the choice all the way down to a couple of” for the human to pick from.

• At Level 6, the pc “allows the human a restricted time to veto before it executes” an motion.

• At Level 9, the pc “informs the human provided that it, the pc, decides to.”

The key insight for AI agents: This model is ideal for describing the collaborative “centaur” systems we’re seeing today. Most AI agents won’t be fully autonomous (Level 10) but will exist somewhere on this spectrum, acting as a co-pilot that means, executes with approval or acts with a veto window.

Robotics and unmanned systems

Finally, the world of robotics brings in one other critical dimension: context. The National Institute of Standards and Technology’s (NIST) Autonomy Levels for Unmanned Systems (ALFUS) framework was designed for systems like drones and industrial robots.

The Three-Axis Model for ALFUS (Credit: NIST)

Its foremost contribution is adding context to the definition of autonomy, assessing it along three axes:

1. Human independence: How much human supervision is required?

2. Mission complexity: How difficult or unstructured is the duty?

3. Environmental complexity: How predictable and stable is the environment wherein the agent operates?

The key insight for AI agents: This framework reminds us that autonomy is not a single number. An agent performing a sure bet in a stable, predictable digital environment (like sorting files in a single folder) is fundamentally less autonomous than an agent performing a fancy task across the chaotic, unpredictable environment of the open web, even when the extent of human supervision is similar.

The emerging frameworks for AI agents

Having checked out the teachings from automotive, aviation and robotics, we will now examine the emerging frameworks designed for AI agents. While the sector continues to be latest and no single standard has won out, most proposals fall into three distinct, but often overlapping, categories based on the first query they seek to reply.

Category 1: The “What can it do?” frameworks (capability-focused)

These frameworks classify agents based on their underlying technical architecture and what they’re able to achieving. They provide a roadmap for developers, outlining a progression of increasingly sophisticated technical milestones that usually correspond on to code patterns.

A chief example of this developer-centric approach comes from Hugging Face. Their framework uses a star rating to point out the gradual shift on top of things from human to AI:

Five Levels of AI Agent Autonomy, as proposed by HuggingFace (Credit: Hugging Face)

• Zero stars (easy processor): The AI has no impact on this system’s flow. It simply processes information and its output is displayed, like a print statement. The human is in complete control.

• One star (router): The AI makes a basic decision that directs program flow, like selecting between two predefined paths (if/else). The human still defines how all the things is finished.

• Two stars (tool call): The AI chooses which predefined tool to make use of and what arguments to make use of with it. The human has defined the available tools, however the AI decides the best way to execute them.

• Three stars (multi-step agent): The AI now controls the iteration loop. It decides which tool to make use of, when to make use of it and whether to proceed working on the duty.

• Four stars (fully autonomous): The AI can generate and execute entirely latest code to perform a goal, going beyond the predefined tools it was given.

Strengths: This model is superb for engineers. It’s concrete, maps on to code and clearly benchmarks the transfer of executive control to the AI. 

Weaknesses: It is very technical and fewer intuitive for non-developers trying to know an agent’s real-world impact.

Category 2: The “How can we work together?” frameworks (interaction-focused)

This second category defines autonomy not by the agent’s internal skills, but by the character of its relationship with the human user. The central query is: Who is on top of things, and the way can we collaborate?

This approach often mirrors the nuance we saw within the aviation models. For instance, a framework detailed within the paper Levels of Autonomy for AI Agents defines levels based on the user’s role:

• L1 – user as an operator: The human is in direct control (like an individual using Photoshop with AI-assist features).

• L4 – user as an approver: The agent proposes a full plan or motion, and the human must give a straightforward “yes” or “no” before it proceeds.

• L5 – user as an observer: The agent has full autonomy to pursue a goal and easily reports its progress and results back to the human.

Levels of Autonomy for AI Agents

Strengths: These frameworks are highly intuitive and user-centric. They directly address the critical problems with control, trust, and oversight.

Weaknesses: An agent with easy capabilities and one with highly advanced reasoning could each fall into the “Approver” level, so this approach can sometimes obscure the underlying technical sophistication.

Category 3: The “Who is responsible?” frameworks (governance-focused)

The final category is less concerned with how an agent works and more with what happens when it fails. These frameworks are designed to assist answer crucial questions on law, safety and ethics.

Think tanks like Germany’s Stiftung Neue VTrantwortung have analyzed AI agents through the lens of legal liability. Their work goals to categorise agents in a way that helps regulators determine who’s chargeable for an agent’s actions: The user who deployed it, the developer who built it or the corporate that owns the platform it runs on?

This perspective is important for navigating complex regulations just like the EU’s Artificial Intelligence Act, which is able to treat AI systems otherwise based on the extent of risk they pose.

Strengths: This approach is totally essential for real-world deployment. It forces the difficult but obligatory conversations about accountability that construct public trust.

Weaknesses: It’s more of a legal or policy guide than a technical roadmap for developers.

A comprehensive understanding requires all three questions without delay: An agent’s capabilities, how we interact with it and who’s chargeable for the final result..

Identifying the gaps and challenges

Looking on the landscape of autonomy frameworks shows us that no  single model is sufficient since the true challenges lie within the gaps between them, in areas which can be incredibly difficult to define and measure.

What is the “Road” for a digital agent?

The SAE framework for self-driving cars gave us the powerful concept of an ODD, the particular conditions under which a system can operate safely. For a automotive, that is perhaps “divided highways, in clear weather, through the day.” This is an incredible solution for a physical environment, but what’s the ODD for a digital agent?

The “road” for an agent is your entire web. An infinite, chaotic and continuously changing environment. Websites get redesigned overnight, APIs are deprecated and social norms in online communities shift. 

How can we define a “secure” operational boundary for an agent that may browse web sites, access databases and interact with third-party services? Answering that is one in every of the largest unsolved problems. Without a transparent digital ODD, we will not make the identical safety guarantees which can be becoming standard within the automotive world.

This is why, for now, essentially the most effective and reliable agents operate inside well-defined, closed-world scenarios. As I argued in a recent VentureBeat article, forgetting the open-world fantasies and specializing in “bounded problems” is the important thing to real-world success. This means defining a transparent, limited set of tools, data sources and potential actions. 

Beyond easy tool use

Today’s agents are getting superb at executing straightforward plans. If you tell one to “find the worth of this item using Tool A, then book a gathering with Tool B,” it may often succeed. But true autonomy requires far more. 

Many systems today hit a technical wall when faced with tasks that require:

• Long-term reasoning and planning: Agents struggle to create and adapt complex, multi-step plans within the face of uncertainty. They can follow a recipe, but they can not yet invent one from scratch when things go improper.

• Robust self-correction: What happens when an API call fails or an internet site returns an unexpected error? A really autonomous agent needs the resilience to diagnose the issue, form a brand new hypothesis and take a look at a special approach, all and not using a human stepping in.

• Composability: The future likely involves not one agent, but a team of specialised agents working together. Getting them to collaborate reliably, to pass information forwards and backwards, delegate tasks and resolve conflicts is a monumental software engineering challenge that we are only starting to tackle.

The elephant within the room: Alignment and control

This is essentially the most critical challenge of all, because it is not just technical, it’s deeply human. Alignment is the issue of ensuring an agent’s goals and actions are consistent with our intentions and values, even when those values are complex, unspoken or nuanced.

Imagine you give an agent the seemingly harmless goal of “maximizing customer engagement for our latest product.” The agent might appropriately determine that essentially the most effective strategy is to send a dozen notifications a day to each user. The agent has achieved its literal goal perfectly, however it has violated the unspoken, common sense goal of “do not be incredibly annoying.”

This is a failure of alignment.

The core difficulty, which organizations just like the AI Alignment Forum are dedicated to studying, is that it’s incredibly hard to specify fuzzy, complex human preferences within the precise, literal language of code. As agents develop into more powerful, ensuring they usually are not just capable but additionally secure, predictable and aligned with our true intent becomes an important challenge we face.

The future is agentic (and collaborative)

The path forward for AI agents will not be a single leap to a god-like super-intelligence, but a more practical and collaborative journey. The immense challenges of open-world reasoning and ideal alignment mean that the longer term is a team effort.

We will see less of the only, all-powerful agent and more of an “agentic mesh” — a network of specialised agents, each operating inside a bounded domain, working together to tackle complex problems. 

More importantly, they may work with us. The most beneficial and safest applications will keep a human on the loop, casting them as a co-pilot or strategist to enhance our intellect with the speed of machine execution. This “centaur” model will likely be essentially the most effective and responsible path forward.

The frameworks we have explored aren’t just theoretical. They’re practical tools for constructing trust, assigning responsibility and setting clear expectations. They help developers define limits and leaders shape vision, laying the groundwork for AI to develop into a dependable partner in our work and lives.

Sean Falconer is Confluent’s AI entrepreneur in residence.