Scaffolding Around the Mind: How Harnesses Turned Language Models into Agents

If you have used an AI coding assistant, a research agent, or any tool that lets a model browse the web, run code, and finish a multi-step job on its own, you have already benefited from something the industry calls scaffolding. The model itself is only half the story. The other half is the orchestration layer wrapped around it, and in 2026 that layer has become the primary battleground of applied AI.

What Scaffolding Actually Is

A large language model, on its own, is a text-in, text-out engine. It cannot open a file, click a link, or remember what it did yesterday. Scaffolding, sometimes called a harness or agent framework, is the code that surrounds the model and gives it hands, eyes, and a working memory. The International AI Safety Report 2026 describes scaffolding as the tools such as memory, computer interfaces, and web browsers, together with the code that combines them with the model, allowing agents to interact with the world, make plans, remember details, and pursue goals with far less human oversight.

In practice a modern scaffold provides four things. It provides perception, meaning the ability to read the current state of an environment such as a repository, a browser page, or a terminal. It provides planning, typically through structured chain-of-thought reasoning where the model decomposes a goal into steps. It provides tool use, exposed as function calls the model can emit and the scaffold executes on its behalf. And it provides memory, whether a running conversation history, a scratchpad file, or an external vector store, so the agent can work on tasks that outlast a single context window.

The dominant design pattern remains the agentic loop, descended from the ReAct paradigm of 2022. The scaffold sends the model the goal plus everything observed so far, the model responds with a thought and an action, the scaffold executes that action and appends the result, and the cycle repeats until the model declares the task complete. Everything else in the field, from sub-agent orchestration to context compaction, is an elaboration of this loop.

The State of the Art in 2026

Three developments define the current frontier.

The first is that scaffolding has become the decisive variable in measured capability. Scale AI runs every model through an identical standardized scaffold on SWE-bench Pro, while vendors run their own tuned harnesses, and the same model family can score roughly 52 percent on the neutral scaffold versus 69 percent on the vendor's own harness. Researchers forecasting agent performance now explicitly condition their predictions on whether state-of-the-art scaffolding, so-called high elicitation, is used, with projected success rates on real-world software tasks ranging from the mid fifties to the high eighties depending on the harness alone. The lesson is blunt: benchmark numbers without the scaffold specified are close to meaningless.

The second development is orchestration at scale. Frontier models are increasingly deployed as managers rather than workers, coordinating fleets of specialized sub-agents. Australia's cyber security agency recently highlighted Microsoft's MDASH, a multi-model harness that orchestrates more than one hundred specialized agents across an ensemble of frontier models to discover, debate, and prove software vulnerabilities end to end, an effort credited with contributing to Microsoft's largest Patch Tuesday on record in June 2026. Analysts describe this as the scaffolding shift: as tool-calling accuracy crossed the ninety percent threshold, it became reliable to compose agents into constellations, with a strong general model routing work to cheaper specialists.

The third development is smarter context management. Long-horizon tasks generate more history than any context window can hold, so the best scaffolds now compact, summarize, and selectively retrieve. Research on recursive language models, in which a model programmatically navigates its own context in focused chunks rather than reading it linearly, has shown small models matching much larger ones on long-context tasks. Production harnesses such as Claude Code, Codex CLI, and OpenHands all ship some form of automatic compaction, sub-agent delegation, and persistent scratchpad memory.

Comparing the Frontier Models as Agent Brains

The scaffold explores the ceiling, but the base model sets it. As of mid 2026 the frontier is a genuinely close race, and reported figures vary considerably depending on whose harness ran the evaluation, so treat every number as scaffold-dependent.

Anthropic's Claude line has held the top of the agentic coding leaderboards for much of the past year. Claude Opus 4.5 was reported as the first model to break the eighty percent barrier on SWE-bench Verified in late 2025, and successive releases through Opus 4.6, 4.7, and 4.8 pushed vendor-reported scores into the high eighties, with the newest Fable 5 tier reported at 95 percent on SWE-bench Verified on Anthropic's own harness. Reviewers consistently rate Claude highest on prose quality and truthfulness benchmarks, and its tight integration with the Claude Code harness is a large part of its practical edge. The tradeoff is price, with the top tiers at the premium end of the market.

OpenAI's GPT-5 family, currently at GPT-5.5 and the GPT-5.6 Sol variant, sits within a few points of the Claude frontier on independent standardized harnesses and is often preferred for structured reasoning and maintaining complex frameworks over long documents. Its Codex CLI harness is the direct competitor to Claude Code, and the two are frequently benchmarked head to head on the same task suites.

Google's Gemini 3 and 3.1 Pro are the multimodal leaders by a clear margin, with the largest category gap of any frontier comparison appearing on video understanding benchmarks. Gemini is also the cheapest of the closed frontier models for short prompts, though pricing roughly doubles above two hundred thousand tokens of context. For workloads heavy in images, video, or document vision, it is generally the strongest pure-capability choice.

The most important structural shift is below the closed frontier. A cluster of open-weight models, including DeepSeek V4 Pro, MiniMax M2.5 and M3, GLM-5, Qwen 3.5 and later, and Kimi K2.5 and K3, now sits around the eighty percent mark on SWE-bench, with Kimi K3 reported within three points of the very best closed models on an independent harness. Teams that can self-host now have frontier-adjacent capability at a fraction of the cost, and the emerging best practice is routing: a deliberate policy that sends each task class to the cheapest model that clears the quality bar, inside one shared scaffold.

A Simple, Complete Example

The clearest way to understand scaffolding is to build a tiny one. The following is a complete, runnable Python file implementing a minimal ReAct-style agent loop with two tools, a calculator and a small mock knowledge base. It uses no external libraries and no API key, simulating the model's decisions with a simple rule-based stand-in so you can watch the loop mechanics directly. In a real system you would replace the mock_model function with a call to a frontier model API and let the model itself choose the actions, but every structural element here, the tool registry, the observation history, the think-act-observe cycle, and the termination condition, is exactly what production harnesses do at far greater sophistication.

"""
minimal_scaffold.py

A minimal ReAct-style agent scaffold, complete and runnable with no
dependencies. It demonstrates the four pillars of scaffolding:
perception (observations), planning (the think step), tool use
(the action step), and memory (the transcript).

Run:  python minimal_scaffold.py
"""

import ast
import operator


# ---------------------------------------------------------------
# Tools: capabilities the scaffold exposes to the model
# ---------------------------------------------------------------

def calculator(expression: str) -> str:
    """Safely evaluate a basic arithmetic expression."""
    allowed_ops = {
        ast.Add: operator.add,
        ast.Sub: operator.sub,
        ast.Mult: operator.mul,
        ast.Div: operator.truediv,
        ast.Pow: operator.pow,
        ast.USub: operator.neg,
    }

    def _eval(node):
        if isinstance(node, ast.Expression):
            return _eval(node.body)
        if isinstance(node, ast.Constant) and isinstance(node.value, (int, float)):
            return node.value
        if isinstance(node, ast.BinOp) and type(node.op) in allowed_ops:
            return allowed_ops[type(node.op)](_eval(node.left), _eval(node.right))
        if isinstance(node, ast.UnaryOp) and type(node.op) in allowed_ops:
            return allowed_ops[type(node.op)](_eval(node.operand))
        raise ValueError("Unsupported expression")

    try:
        tree = ast.parse(expression, mode="eval")
        return str(_eval(tree))
    except Exception as exc:
        return f"calculator error: {exc}"


def knowledge_lookup(query: str) -> str:
    """A tiny stand-in for a search or database tool."""
    facts = {
        "eiffel tower height": "The Eiffel Tower is 330 meters tall.",
        "empire state height": "The Empire State Building is 443 meters tall.",
    }
    for key, value in facts.items():
        if key in query.lower():
            return value
    return "No result found."


TOOLS = {
    "calculator": calculator,
    "knowledge_lookup": knowledge_lookup,
}


# ---------------------------------------------------------------
# The "model": replace this function with a real API call in
# production. It receives the goal and full transcript and must
# return a dict with a thought and either an action or an answer.
# ---------------------------------------------------------------

def mock_model(goal: str, transcript: list) -> dict:
    observations = [t["observation"] for t in transcript if "observation" in t]

    if not any("Eiffel" in o for o in observations):
        return {
            "thought": "I need the height of the Eiffel Tower first.",
            "action": ("knowledge_lookup", "eiffel tower height"),
        }
    if not any("Empire" in o for o in observations):
        return {
            "thought": "Now I need the height of the Empire State Building.",
            "action": ("knowledge_lookup", "empire state height"),
        }
    if not any(o.strip() == "113" for o in observations):
        return {
            "thought": "I have both heights. I will compute the difference.",
            "action": ("calculator", "443 - 330"),
        }
    return {
        "thought": "I have everything needed to answer.",
        "answer": (
            "The Empire State Building (443 m) is 113 meters taller "
            "than the Eiffel Tower (330 m)."
        ),
    }


# ---------------------------------------------------------------
# The agent loop: the heart of every scaffold
# ---------------------------------------------------------------

def run_agent(goal: str, max_steps: int = 8) -> str:
    transcript = []  # this is the agent's working memory

    print(f"GOAL: {goal}\n")

    for step in range(1, max_steps + 1):
        decision = mock_model(goal, transcript)
        print(f"Step {step}")
        print(f"  Thought: {decision['thought']}")

        if "answer" in decision:
            print(f"  Final answer: {decision['answer']}")
            return decision["answer"]

        tool_name, tool_input = decision["action"]
        tool_fn = TOOLS.get(tool_name)
        if tool_fn is None:
            observation = f"Unknown tool: {tool_name}"
        else:
            observation = tool_fn(tool_input)

        print(f"  Action:  {tool_name}({tool_input!r})")
        print(f"  Observation: {observation}\n")

        transcript.append(
            {
                "thought": decision["thought"],
                "action": f"{tool_name}({tool_input})",
                "observation": observation,
            }
        )

    return "Stopped: reached the maximum number of steps."


if __name__ == "__main__":
    run_agent(
        "How much taller is the Empire State Building than the Eiffel Tower?"
    )

Running this produces a four-step trace: the agent looks up one height, then the other, then calls the calculator, then answers. Swap the mock for a real model and add real tools such as a shell, a browser, and a file editor, and you have the skeleton of Claude Code, Codex CLI, or OpenHands. Add compaction of the transcript when it grows too long, add the ability to spawn a copy of the loop as a sub-agent for a subtask, and add a verifier that checks the answer before it is returned, and you have the state of the art.

Where This Is Heading

The pattern of the past year is that scaffolding gains have compounded faster than raw model gains. The same base model, wrapped in a better harness, jumps ten to twenty points on hard agentic benchmarks. That is why the labs now ship models and harnesses together, why open-weight models paired with excellent open scaffolds like OpenHands can crowd the frontier, and why any serious evaluation must state its scaffold as prominently as its model. The mind matters, but in 2026, so does the scaffolding around it.

Sources

Figures and claims above draw on the International AI Safety Report 2026 (arxiv.org/pdf/2602.21012), Pimpale et al. on forecasting frontier agent performance, the Australian Signals Directorate's July 2026 update on AI model harnesses (cyber.gov.au), Scale AI's standardized SWE-bench Pro harness results as summarized by Morph (morphllm.com/best-ai-model-for-coding), the iternal.ai LLM selection guide (July 2026), and Tomasz Tunguz's essay "AI Managing AI" (tomtunguz.com, January 2026). Benchmark numbers are scaffold-dependent and vendor-reported figures typically exceed independent standardized results.