An 'agentic' system is any system that can 'do' something, there is often a lot of confusion around what we exactly mean with 'agentic' systems. The term 'agentic' come from the Latin word 'agere' (meaning "to do," or "to act). It includes the noun 'agent' (agens, "one who acts").

In Computer Science, tool use is the defining feature of an agentic system. Researchers during the ‘80s and ‘90s used the word “agent” to describe an AI system that could “act” (using tools). In 1995, Russell and Norvig wrote in their massively popular Artificial Intelligence: A Modern Approach, where they classify Agents are a class of AI systems that can take actions with varying degrees of autonomy, and use tools, in order to pursue goals.

'Using tools' can in practice still be very general and abstract. Often this is not meant in the sense of a robot physically handling a tool, but an AI system using some other computer system (like a calculator, a webbrowser, or any other kind of software) as a software tool.

But when do we say an AI system is 'using a tool', and when do we say that the 'tool' is part of the AI system? This can sometimes be a bit of a semantic discussion, and practice typically comes down to whether what the AI system is using to 'do' is a piece of software that has been custom created for this AI system (in which case we might also consider it part of this AI system), or if it is using general software that is used by many different users, and was not specifically designed with the current AI system or usecase in mind.

Eventhough the theoretical Computer Science framework was already largely there, how general the tools were that an agent was capable of using, remained limited by the capabilities of the available AI systems at the time. It has taken decades for machine learning to develop to the point where AI could finally start to use the same software that is used by humans. Software that no longer needs to be specifically designed to be used by a specific AI system (and might then for all practical purposes be considered an extension of that AI system).

This, letting AI systems use general software as tools, is what we mean these days as the defining feature of Agentic AI systems.

Limits and Challenges

Letting an AI system (that can make mistakes) use tools, so it can now make mistakes while operating on a sensitive system sounds like it can potentially cause trouble. '

Whether the tools it uses are software running on a personal computer, or the software within a larger enterprise organisation, important is to make sure that these systems will not make accidental mistakes that can overwrite data with incorrect information, delete important data, uninstall important software, or install malevolent software.

Because of this, it often helps to break down what it is that such a system exactly can do. And instead of giving an AI system access to all the software on a system, trying to set up more limited workflows.

Different Degrees of Autonomy

Now, let's talk about how we build such AI systems that can use general software. There are different degrees of autonomy when using general software as tools. One system might only be able to perform very specific actions in response to very narrowly defined isntructions. While a more general system might be able to figure out how to use the software based on more general instructions.

But when do we call something an 'Agent'? The boundary between a 'deterministic workflow', an 'LLM-augmented workflow', an 'LLM-Agent' and an 'Autonomous LLM-Agent' often gets murky. I will try to split up how I am using these terms throughout this blog, and which different industry definitions they refer to.

Tool-Augmented LLM (or LLM-Augmented Workflow)

When we include LLMs as part of a workflow, we can create workflows that allow us to process much more general inputs. If we think about these structures as essentially being workflows, we can refer to them as LLM-Augmented workflows.

Alternatively we might think of them as Tool-Augmented LLMs. This is Anthropic's "augmented LLM" definition of an 'agentic system' = LLM + retrieval + meory + tools.

Since LLM + Tools also meets the definitions used throughout the ‘80s and ‘90s, where an “agent” is described as an AI system that could “do” something. An LLM-Augmented Workflow if often equated with an 'AI Agent'.

The Agentic Loop

The spectrum from 'workflow' to 'agent' is the degree of autonomy that we delegate to a system to pursue a goal.

As far back as 1948, Norbert Wiener’s introduced the idea of a feedback loop in his book Cybernetics: Or Control and Communication in the Animal and the Machine. Such a feedback loop enables an entity to sense their environment, process information and adjust behavior accordingly, in order to persue a goal.

This theoretical framework is still very close to how we think about AI agents and their architecture today. By including a loop in an 'LLM-Augmented Workflow', we allow such a system to continue running until it is satisfied that it has achieved its goal and exits the loop.

This is the definition that most of the AI-engineering community converged on in 2025: "An LLM agent runs tools in a loop to achieve a goal." Essentially this is an LLM-Augmented Workflow run in a loop. And the distinction between these two, and which one is called an agent, is often where most of the confusion comes from.

Some groups insist that Agentic tool use is the defining feature of an agent. While other groups focus on the loop-based persuing of a goal as the defining feature.

Classification of Different degrees of Autonomy

When classifying these kinds of workflows (with or without agentic loops), we can distinguish them into different types:

• linear workflows or pipelines (where each stap linearly follows the next). Where there is a clearly defined path that the system takes of one action that is performed after another. We can include loops, to enforce retries when part of the workflow fails, and force the output of the pipeline to be agentic (in the sence that we can try to ensure some action will be taken by the system).
• graph based workflows. Where (depending on the input) the system itself routes though one of various processes, follownig a more complicated process logic where it makes decisions on how to go through the process.

The path that a static agentic system will take through a process might not be determined in advance (and depend on the input). But the process that the system is following is static and fixed in advance. In this section we will first constrain ourselves to designing these kinds of static agentic systems, either linear or graph based, by hand - following an engineering approach.

In later sections we will generalize this to:

• following a machine learning approach to itteratively change the design of such a system, guided by how well it scores on evaluation sets.
• dynamic agentic systems, that themselves define the process they will follow in order to complete a task

The rest of this section will be mainly focussed on the design and evaluation of such 'static' agentic systems. Starting from linear systems, to linear systems with loops, to graph-based systems. We will touch through various section upon the engineering best practices surrounding them.