Part I of 5 · Chapters 1 to 4
What an agent is, and what this report sets out to do
What counts as AI, where a model becomes an agent, and the vocabulary this report fixes before it argues anything.
Chapters (4)
1. Agentic AI is an assembly around a model, not a new kind of model2. An agent starts where the model, not the code, directs the next step3. Six terms and four distinctions this report fixes before it argues4. The plan: tell the methods apart, weigh the evidence, choose by situation1. Agentic AI is an assembly around a model, not a new kind of model
Before asking how agentic systems should be built, a reader needs to know what kind of thing an agentic system is. This chapter places agentic AI on the map of artificial intelligence, and its answer shapes the rest of the report. Agentic AI is not a new family of models. It is a way of assembling software around a model that already exists.
The word “AI” covers at least three families, and they differ in what they are trained to do. Discriminative models learn to separate: given labeled examples, they classify an input or predict a number. A spam filter is one. Reinforcement learning systems learn to act: they try, receive a reward or a penalty, and adjust their behavior inside a bounded environment such as a game. Generative models learn to produce: they model how text, code, images or audio are distributed, and generate new sequences that resemble what they were trained on.
Two terms inside the generative family are often used as if they meant the same thing. Stanford’s Center for Research on Foundation Models, the group that coined the first of them, keeps them apart (Stanford CRFM). A foundation model is defined by its function: a large model trained on broad data, without task-specific labels, that can then be adapted to many tasks. A large language model, or LLM, is defined by how it is made: it predicts the next fragment of a text from the fragments before it. Every LLM in common use is a foundation model. The reverse does not hold, since foundation models also exist for images, audio and molecular biology.
Figure 1.1: The three families of AI, with LLMs nested inside foundation models (Stanford CRFM). An agentic assembly trains nothing new: it wraps software around one existing model (IBM). Diagram drawn by this report.
Agentic AI appears nowhere in that list of families, and Figure 1.1 shows why. Nothing new is trained. An agentic system takes a foundation model and wraps software around it. That software calls the model in a loop, lets it use tools through programming interfaces, and keeps track of the work from one call to the next (IBM). A generative model on its own produces an output and stops. The same model placed inside such an assembly can act on its environment, observe the result, and pursue a goal over many steps (Google Research).
An example makes the difference concrete. Asked to fix a failing test, a language model alone can only write text that looks like a fix. Wrapped in an agentic assembly, it can open the file, change it, run the test, read the error, and try again.
The institutions that classify AI have not drawn this boundary. The European Union’s AI Act gives no legal definition of an “AI agent”. It defines AI systems broadly, as machine-based systems operating with varying degrees of autonomy, and regulates them by level of risk, whatever their internal structure. The NIST AI Risk Management Framework, the reference published by the United States standards agency, has a risk profile for generative systems and none for agents.
The companies that build the models do not agree either. Anthropic, which develops the Claude models, draws a sharp line between workflows and agents. OpenAI, which develops the GPT models, describes a continuous scale of autonomy with no line at all.
This report therefore starts from an engineering position: agentic AI is an assembly built around a foundation model. That position settles what an agent is made of. It leaves open where the model ends and the agent begins, and the two companies just cited give opposite answers. The next chapter sets those answers side by side and chooses one.
2. An agent starts where the model, not the code, directs the next step
If an agent is an assembly around a model, where does the model stop and the agent start? This chapter compares the answers in circulation and picks the one the report will use. The field has no agreed answer, and the choice has consequences: it decides what a team instruments, what it checks, and where it expects failures.
Two answers dominate, and they differ in kind. One draws a line. The other describes a slope.
The line: who directs the next step
Anthropic gives the sharpest version (Building Effective Agents). It does not ask how capable the model is. It asks who controls execution. A system is a workflow when models and tools are orchestrated through code paths written in advance. It is an agent when the model directs its own process, choosing which tools to use and judging its own progress. Anthropic calls both of them agentic systems, so the distinction separates two architectures, not two levels of intelligence.
The test this definition gives is a single question: at each step, does the code or the model decide what comes next? The two answers buy different things. A workflow is consistent, its duration is bounded, and its cost per run can be predicted. An agent adapts to a task nobody specified in full, and pays for that freedom with behavior that varies from run to run and errors that build on one another.
Figure 2.1: The line drawn by Anthropic (Building Effective Agents) and the slope described by OpenAI (OpenAI for Developers 2025). The diagram is drawn by this report, which adopts the line.
The slope: degrees of agenticness
OpenAI describes no threshold (OpenAI for Developers 2025). In its account a system becomes more agentic as it gains capabilities and works over longer horizons. The progression runs through four stages:
- A single prompt and a single response, with no tools.
- Tool use inside one conversational turn.
- A chain of turns carrying out a structured task.
- Open-ended pursuit of a goal over days or weeks.
Seen this way, choosing an architecture is a matter of tuning. The designer moves along a gradient of autonomy and trades cost, latency and quality against each other at each point.
Two further readings, and a silence
Other actors place the boundary in behavior. IBM speaks of “supervised autonomy”: an agent acts toward an objective under limited supervision, where a generative model only produces an output (IBM). Google Research characterizes agentic systems by what they do over time. They interact with an environment across many steps, gather information they did not have at the start, and adjust their strategy from the feedback they receive (Google Research).
Regulators, as the previous chapter noted, stay silent. Neither the AI Act nor the NIST framework defines an agent, and both assess systems by risk.
The choice made in this report
No definition is authoritative, so the report has to choose one and say why. It adopts Anthropic’s line.
The reason is practical. Asking who controls the loop tells a designer what to expect. Where code decides the sequence, each step can be checked in the ordinary way, and an error stays where it occurred. Where the model decides, every decision can vary, and the system needs additional machinery: a way to save its state, filters on what it does, and points where a human can step in. The eight levers of Part II describe that machinery, and the line drawn here is what lets them be read as concrete mechanisms.
The slope is not discarded. Chapter 8 returns to it, because real systems turn out to mix both modes at different scales.
One obstacle remains before the analysis can begin. The field uses pattern, harness, scaffold and framework as if they were one word, and the next chapter fixes what each will mean here.
3. Six terms and four distinctions this report fixes before it argues
A report that compares methodologies has to use its words consistently, and the field does not. This chapter fixes the vocabulary for everything that follows: six terms for how a system is built, and four distinctions that matter while it runs. The need is easy to show. Words such as pattern, architecture, harness, scaffold, framework, and methodology are used as if they were interchangeable. A software vendor who says “framework” usually means a packaged Python library, and an enterprise architect who says the same word means a governance policy. When a team mixes these terms, it loses sight of design trade-offs that separate code, runtime containment, and reasoning.
The definitions come in two groups, and they hold in every later chapter.
Figure 3.1: An editorial allegory by this report for five of the six terms defined below. The blueprint is the pattern, the timber frame the scaffold, the enclosure around it the harness, the toolboxes the framework, and the builder’s rule book the methodology. The sixth, architecture, is not pictured.
Six terms for how a system is built
As Figure 3.1 suggests, deploying production systems requires distinguishing between abstract design, executable code, runtime containment, and overarching doctrine. Conflating these layers leads engineering teams to misdiagnose failure modes and misjudge implementation costs:
- Pattern: A generalized, reusable template that resolves a recurring coordination or reasoning challenge (Google Cloud). Patterns define how a model interacts conceptually with tools and memory. Familiar examples include ReAct loops, reflection steps, and dynamic routing. Patterns are abstract designs, not executable implementations.
- Scaffold: The concrete source code wrapping the foundation model that translates an abstract pattern into running software. Established through empirical source-code analysis across open-source code agents, the scaffold is the exact code implementing loop primitives, tool dispatch, error recovery, and context compaction (Inside the Scaffold, arXiv 2604.03515). Two systems implementing the same ReAct pattern can utilize radically different scaffolds, producing divergent cost and reliability profiles.
- Harness: The operational execution environment that surrounds and isolates the model. The operational boundary is straightforward: if a component is not the foundation model itself, it belongs to the harness (arXiv 2603.25723). The harness manages virtual machine sandboxing, permission firewalls, API network proxies, credential management, and audit telemetry.
- Architecture: The structural topology connecting cognitive nodes, data stores, external tools, and communication channels. Architecture describes how multiple models and scaffolds compose into an end-to-end system.
- Framework: A packaged, distributable software library providing developers with off-the-shelf scaffolds and harness abstractions. Popular examples include LangChain, AutoGen, and CrewAI. While frameworks accelerate early development, enterprise teams often bypass generic framework abstractions to maintain deterministic control over execution state (Anthropic).
- Methodology: The disciplined engineering doctrine governing how systems are designed, deployed, and audited. A methodology dictates how an engineering team assesses organizational constraints, configures structural dials across the software stack, and evaluates performance using multidimensional benchmarks.
Four distinctions at run time
While the macro hierarchy clarifies system packaging, everyday engineering failures frequently stem from conflating runtime primitives. We establish four mandatory distinctions:
- Context vs. State vs. Memory:
- Context is the ephemeral token sequence passed into a single inference call (CoALA, arXiv 2309.02427). It is strictly bounded by window limits and consumes active compute.
- State is the serializable, persistent record of execution progress maintained by the scaffold. State stores checkpoints, blackboard variables, and task status across session boundaries (Lever 6).
- Memory refers to external knowledge stores queried dynamically into context. Confusing context with memory leads teams to append raw conversational histories, causing token inflation and reasoning degradation.
- Tool vs. Skill:
- A tool is a stateless interface specification enabling the model to invoke an external endpoint or executable function.
- A skill is an accumulated, multi-step executable routine stored in procedural memory (Voyager, arXiv 2305.16291). Skills expand an agent’s behavioral inventory over time through autonomous composition (Lever 7).
- Guardrail vs. Sandbox vs. Gate:
- A guardrail is a probabilistic filter evaluating text prompts or outputs against policy rules.
- A sandbox is a deterministic, operating-system isolation boundary restricting physical access to filesystems, network egress, and compute resources (Anthropic). Treating text guardrails as security boundaries is flawed, as adaptive prompt injections bypass them at rates exceeding 90 %.
- A gate is a synchronous execution pause point requiring automated verification checks or human approval before proceeding (Levers 5 and 8).
- Trajectory vs. Trace:
- A trajectory is the cognitive sequence of thoughts, tool selections, and environmental observations produced by an agent solving a task (MAST, arXiv 2503.13657).
- A trace is the low-level systems telemetry capturing execution latency, network payloads, API call timings, and token consumption across the harness infrastructure.
Why the distinctions matter
Separating the abstract pattern from the executable scaffold, and probabilistic guardrails from physical sandboxes, eliminates false equivalences. It ensures that engineering teams diagnose root causes accurately rather than attributing scaffold execution bugs to model reasoning deficiencies.
With the vocabulary fixed, the report can state its purpose. The next chapter says what is being compared, which hypotheses are tested, and where the argument is headed.
4. The plan: tell the methods apart, weigh the evidence, choose by situation
With the ground and the vocabulary in place, this chapter states what the report sets out to do. Its subject is the growing number of agentic methodologies. Its aim is to separate them, judge them on evidence, and arrive at one situational methodology, with the gaps that remain named.
Methodologies for building agents now appear faster than anyone can compare them. Some organize several agents into a debate. Others break a task into a hierarchy of subtasks, or run it down an assembly line. Each describes the mechanisms an agent should respect in order to work safely and well.
They have one thing in common, and it is the thread of this report. They were all conceived from a human point of view. They assign “roles”, define “reporting lines”, and rely on “peer review”. Faced with a computational problem, their authors rebuilt the structures of a human organization.
Figure 4.1: A debate, a hierarchy and an assembly line, and an engineer who opens the base of one to look at the mechanism underneath, an editorial allegory by this report. The forms are borrowed from human organizations, as MetaGPT, arXiv 2308.00352 does openly. The first hypothesis asks whether one mechanism lies under all of them.
That observation raises three questions. Do these methodologies really differ, or are they variations on one mechanism? Is the resemblance to human organizations necessary, or only convenient? And how much of the work can an agent actually carry? The report turns each question into a hypothesis and tests it.
Hypothesis 1 (Reducibility): The diversity of current methodologies reduces to the setting of invariant structural levers. We will test whether a single design framework can adequately describe architecturally opposed systems.
Hypothesis 2 (Organizational Convergence): The settings of these levers converge on the solutions of human organizations. We will examine whether this resemblance is a necessary evolution or a temporary crutch masking underlying LLM limitations.
Hypothesis 3 (The Delegation Boundary): For each structural lever, there exists a boundary between what an agent can safely carry and what demands a human. We will ask whether that boundary is a technical limit that engineering will move, or a permanent one.
The five parts follow those hypotheses. Part II goes down to the first principle shared by every agent, builds eight levers on top of it, and tests the first hypothesis. Part III reads the existing patterns, frameworks and protocols as settings of those levers, and weighs the evidence behind them. Part IV examines the human resemblance and takes up the second and third hypotheses. Part V draws the consequences for someone who has to build.
The destination can be stated now. What separates one methodology from another, in the end, is neither its architecture nor how closely it imitates a human team. It is what it costs, in tokens, in time and in human attention, to make explicit in software what a human organization leaves unsaid. From that economic boundary the report derives a way of choosing: a matrix that sets the eight levers against the situation of the organization that will pay for them. The final chapter presents that matrix as the result of the whole inquiry.
Sources cited on this page (16)
- AI Act
- Anthropic, Building Effective Agents
- Anthropic, How we contain Claude
- arXiv 2603.25723
- CoALA, arXiv 2309.02427
- Google Cloud Architecture
- Google Research
- IBM
- Inside the Scaffold, arXiv 2604.03515
- MAST, arXiv 2503.13657
- MetaGPT, arXiv 2308.00352
- NIST AI Risk Management Framework
- OpenAI for Developers 2025
- Stanford CRFM
- The Attacker Moves Second, arXiv 2510.09023
- Voyager, arXiv 2305.16291