The Rise of the Harness

Every era of computing has been defined by its dominant interface. The command line made computers operable by experts. The graphical user interface made computers accessible to everyone else. Today, we believe a new dominant interface—the harness—is making computers usable to large language models.

Each interface arose after significant hardware advances. Each has created new uses for the computer and both assumed and created new kinds of users.

The CLI assumed expert operators who could adapt themselves to the machine and interact with the computer’s primitives directly—its files, processes, and commands. It rewarded precision, composition, and expertise.

The GUI inverted that relationship. Rather than asking people to adapt to computers, it asked computers to adapt to people. Windows, icons, menus, and buttons became the scaffolding for human cognition, allowing millions of people to manipulate increasingly sophisticated software without understanding its internal machinery. For more than forty years, this paradigm shaped our industry. We optimized usability, discoverability, responsiveness, and ultimately User Experience (UX).

Today, we believe another transition is underway.

At our company, we arrived at this conclusion not through strategic planning, but through building AI-native products. We realized we were no longer writing software exclusively for people. Increasingly, we were building software whose primary consumer would be another intelligent system.

That forced us to ask a surprisingly basic question:

What is the equivalent of a GUI for an AI?

The answer did not emerge overnight.

The Harness Emerges

Throughout 2024 and 2025, developers experimented with dozens of techniques to make language models more agentic. Retrieval augmented generation extended their knowledge. Memory allowed them to persist across sessions. Tool calling gave them the ability to act. Planning loops enabled iterative reasoning. Orchestration frameworks coordinated increasingly sophisticated workflows. The Model Context Protocol (MCP) created a common way to expose external capabilities. Evaluation pipelines, observability, runtime environments, and execution frameworks appeared in rapid succession.

Initially these appeared to be separate innovations, each solving a different problem.

Looking back, they were all building different parts of the same architecture.

During 2026, these ideas have begun to coalesce into a recognizable pattern: the harness.

A harness is far more than a sophisticated prompt. It is the operational environment that transforms a language model into an agent. It manages context across time, exposes capabilities through tools and APIs, maintains memory, governs permissions, orchestrates execution, and creates the feedback loops that allow an agent to iteratively improve its work.

This distinction matters. An LLM is an extraordinary reasoning engine, but by itself it is not an operational system. Without memory, tools, state, or a means of interacting with the world, it remains conversational. The harness is the scaffolding within which the model becomes an agent.

From UX to AX

Thinking this way reframes a surprising amount of software architecture.

For decades we have optimized User Experience (UX). Increasingly, we will need to optimize Agent Experience (AX).

Agent Experience is not about making software easier for humans to use. It is about making capabilities legible, reliable, and composable for intelligent agents. Can an agent discover your application’s capabilities? Can it access the right context? Can it invoke tools safely? Can it recover gracefully from failures? Can it maintain continuity over long-running tasks? Can a human step into the loop without disrupting the agent’s work?

These are becoming architectural concerns rather than implementation details.

Why Software Came First

One reason Claude Code feels historically significant is that it may be the first widely adopted harness. Not the first system to assemble these ideas, but perhaps the first to make them feel coherent, practical, and indispensable.

Its breakthrough was not simply that it could generate code. It embedded an AI inside a software repository—a uniquely rich cognitive environment where humans and agents collaborate through the same executable artifacts.

Software repositories possess properties that are rare in other domains. They are recursively structured, semantically meaningful, machine-readable, and human-readable. Every modification can be compiled, tested, and evaluated. The compiler, test suite, and runtime provide continuous objective feedback. Humans and agents work within the same substrate, each contributing to an artifact that can immediately demonstrate whether it behaves as intended.

This may explain why software engineering has become the first profession where autonomous agents have proven genuinely useful. The models matter, but equally important is the environment in which they operate.

There is another signal that this transition is part of a longer evolution.

For more than a decade, the command line has experienced an unexpected renaissance among developers building cloud infrastructure, DevOps platforms, and distributed systems. As computing shifted from single machines to fleets of services, containers, pipelines, and infrastructure defined as code, operators increasingly found themselves orchestrating workflows rather than manipulating individual applications. The tools they reached for looked less like desktop applications and more like shells, scripts, pipelines, and runners.

That resurgence was not a rejection of the GUI. It reflected the emergence of a different class of computing problem.

Agentic systems may represent the next step in that progression.

Just as the GUI projected software into a form optimized for human cognition, the harness appears to be projecting software into a form optimized for machine cognition. We are only beginning to discover what those projections should look like. Memory, planning, execution, tools, permissions, evaluation, and orchestration may prove to be the first generation of abstractions, much as windows, icons, and menus became the defining abstractions of graphical computing.

The Next Interface

If that is true, then the history of computing can be understood as a succession of interfaces that expanded the audience of computation.

The command line democratized computing for experts.

The graphical user interface democratized computing for everyone.

The harness may democratize computation for intelligent agents.

For software developers, the implication is profound.

For decades, we have asked one fundamental design question:

How will a human use this system?

Increasingly, we will need to ask a second:

How will an agent use it?

The applications that define the next decade will answer both.

The most successful software companies of the last forty years mastered User Experience.

The most successful software companies of the next forty will master Agent Experience.