At the ICLR 2026 conference, a seasoned data scientist found themselves in a state of quiet frustration. Surrounded by the world's leading AI researchers, they noticed a recurring problem: the terms harness and scaffold were being used interchangeably, or worse, defined differently by every speaker. This was not a mere semantic dispute among academics. In the trenches of AI development, the way a model is wrapped determines whether it remains a sophisticated chatbot or evolves into a functional agent capable of altering the state of a computer system. The industry is currently grappling with a fundamental misunderstanding of what actually makes an agent an agent.

The Execution Layer and the Illusion of Agency

Consider the experience of a developer using Claude Code, Anthropic's coding agent, to resolve a complex bug within a local terminal. The difference between asking a model to write a snippet of code and allowing an agent to read files, modify source code, and execute tests is an order of magnitude in complexity. The intelligence does not reside solely in the model's weights, but in the execution layer that surrounds it. To use a biological analogy, the LLM is the brain, but the agentic framework provides the limbs, the sensory organs, and the nervous system required to interact with the physical or digital world.

OpenAI's Codex serves as a primary example of this distinction. Codex is an exceptional engine for generating code, yet it possesses no inherent ability to run that code, observe the output, and iterate based on an error message. An LLM is, at its core, a stateless function that maps an input string to an output string. It cannot maintain a loop, it cannot remember the result of a previous call unless that result is fed back into the prompt, and it cannot independently trigger an external API. The model can express an intention to use a tool, but it cannot actually pull the trigger.

This is where the concept of the harness becomes critical. A harness is the operational infrastructure that connects the model to the external world. Anthropic explicitly describes Claude Code as the agentic harness around Claude. The harness manages the loop: it intercepts the model's request to use a tool, executes that tool in a secure environment, captures the output, and feeds it back to the model. It decides when the model has reached a stopping point or how to handle a runtime exception. Without this harness, the model is a brain in a vat, capable of thinking but incapable of doing.

The architectural choice of the harness defines the product's flexibility. Some systems, like Claude Code, are tightly coupled with a specific model to maximize performance. Others, such as the Antigravity CLI or the Hermes Agent framework, treat the harness as a modular shell. In these open-source frameworks, the harness remains constant while the underlying model can be swapped. This creates a scenario where the same high-performance model can feel like two entirely different products depending on the control logic of the harness. Harness engineering is therefore becoming a distinct discipline, focusing on stop-conditions, guardrails, and the translation of text into action.

Scaffolds versus Harnesses: Blueprints and Engines

For the developer, the shift from a standard LLM to an agent is felt not in the speed of the response, but in the level of control. To understand this, one must distinguish between the scaffold and the harness. While they work in tandem, they serve entirely different purposes in the agentic stack.

A scaffold is the conceptual blueprint. It defines how the model should behave and how it perceives its environment. The scaffold includes the system prompt that establishes the agent's identity, the detailed descriptions of available tools, the parsing rules used to interpret the model's output, and the strategy for context management. If the harness is the engine, the scaffold is the map and the rulebook. It determines the perspective the model takes and the logic it follows to reach a goal. Context management within the scaffold is particularly vital, as it allows the agent to remember what it attempted in step one to inform its decision in step ten.

In contrast, the harness is the active execution layer. It is the mechanism that turns the scaffold's blueprints into reality. The harness is responsible for the actual API calls, the management of the recursive loop, and the enforcement of safety boundaries. When a model outputs a specific string indicating a tool call, the harness is the component that recognizes this pattern, pauses the model's generation, executes the requested function, and resumes the session with the new data.

An agent is the synthesis of the model, the scaffold, and the harness. This realization shifts the focus of optimization. When an agent fails, the developer must ask whether the failure occurred in the model's reasoning, the scaffold's instructions, or the harness's execution. If a model is brilliant but the harness is poorly designed, the agent will frequently fall into infinite loops or crash when encountering unexpected API responses. The reliability of an AI agent is a direct reflection of the robustness of its harness engineering.

The Hierarchy of Agency: Tools, Skills, and Sub-agents

Designing an agent requires a tiered approach to how the system interacts with the external world. The most basic unit is the tool. A tool is a discrete function, such as a database query, a web search, or a Python interpreter. Tools are deterministic; they take a specific input and return a specific output. They are the hammers and screwdrivers of the AI world, providing the agent with basic capabilities that the model cannot perform through text generation alone.

However, complex tasks often require more than a single tool call. This necessitates the concept of a skill. A skill is a reusable package of knowledge or a multi-step procedure. If a tool is a hammer, a skill is a carpentry manual. For example, the process of investigating a bug, forming a hypothesis, and writing a patch can be encapsulated as a single skill. By calling a predefined skill, the agent can execute a sophisticated workflow with consistency, reducing the cognitive load on the main model and minimizing the chance of hallucinated steps.

At the top of this hierarchy is the sub-agent. A sub-agent is not merely a function or a script, but a fully realized entity with its own model, scaffold, and harness. While a tool is a one-way street of input and output, a sub-agent possesses its own reasoning loop. A main agent can delegate a high-level goal to a sub-agent, which then plans its own approach, executes its own tools, and returns a finalized result. This creates a hierarchical structure where a primary orchestrator manages a fleet of specialized sub-agents, each handling a different domain of the problem.

This evolution from tool to skill to sub-agent is what allows AI to move from simple task automation to autonomous system management. The independence of the sub-agent is the key differentiator; it can reason about its own failures and pivot its strategy without needing explicit instructions from the primary agent for every single step.

Context Engineering and the Cost of Failure

The performance of an agent is ultimately constrained by its context window, which acts as the agent's immediate field of vision. Context engineering is the art of deciding exactly what information occupies this limited space. This includes the system prompt, tool definitions, conversation history, and retrieved external knowledge. The goal is to provide the model with the minimum amount of information necessary to make the correct decision, avoiding the noise that leads to distraction or hallucination.

Memory in these systems is typically split into short-term and long-term stores. Short-term memory consists of the immediate dialogue and tool outputs held within the current context window. Long-term memory involves external databases or vector stores where information is archived and retrieved only when the harness determines it is relevant. The harness acts as the librarian, deciding which pieces of long-term memory should be promoted to the short-term context to guide the model's current action.

There is a critical distinction between errors made during the inference stage and those made during the training stage. An error in the scaffold or harness during inference is relatively easy to fix; a developer can simply update the prompt or the control logic and redeploy. However, if the context provided during the model's training or fine-tuning phase is flawed, the model's internal weights become distorted. In such cases, the model learns the wrong relationship between context and action, necessitating a costly and time-consuming retraining process. This level of precision in memory injection and context design is a core focus of the Hugging Face Context Engineering Course, which provides the technical framework for managing these complexities.

The disparity in quality between two AI services using the same underlying model is almost always a result of the harness and scaffold design. The model provides the raw intelligence, but the harness provides the professional discipline and the operational reliability required for production-grade agency.

True autonomy in AI is not a property of the model, but a property of the system that contains it.