Mesa

Thesis. Coding agents like Claude Code and OpenCode are no longer end-user tools. They are becoming an infrastructure primitive. The strongest AI systems now build on top of them instead of rebuilding them, and that shift should change how agentic products are designed.

Coding agents are becoming primitives

Coding agents are still usually framed as products: developer tools with a terminal UI and a model behind them. That framing is already outdated.

Modern agents like Claude Code, OpenCode, and Codex CLI can now run headlessly and be driven programmatically. Increasingly, users are not interacting with them directly. Instead, they are choosing systems that orchestrate them as part of a larger workflow.

Products like Claude Cowork, Ralph loops, and Clawdbot already treat a coding agent as a backend service. In these systems, the user-facing product is the orchestrator. The agent itself is the execution engine.

The right mental model is no longer “coding assistant.” It is a general-purpose execution layer: software that allows a model to operate in a real environment, manage context, execute tools, and modify state.

Once you look at these systems through that lens, they stop resembling applications and start resembling infrastructure.

Rebuilding harnesses will not differentiate you

Many teams building agentic products today are quietly rebuilding a weaker version of Claude Code without realizing it.

They write planners, retry logic, state machines, and recovery systems. They invest heavily in execution control because, until recently, this was the only way to make agents reliable.

Six months ago, this approach made sense. Harnesses were immature, hard to drive programmatically, and poorly integrated with real environments. If you wanted robustness, you had to build it yourself.

That window is closing quickly.

Rebuilding a harness today is no longer a durable advantage. It is a bet on a layer that is rapidly becoming standardized. The core problems of executing tools, managing memory, and controlling environments are converging quickly, and being solved well enough by a small number of teams.

We've seen this transition before, most clearly with databases. Early on, many teams experimented with storage engines and query planners. Over time, interfaces stabilized, systems converged, and a small number of general-purpose databases became the foundation almost everything else was built on. Once that happened, rebuilding the layer stopped being a differentiator.

As this happens, leverage moves up the stack. It no longer comes from low-level execution control. It comes from understanding workflows, designing environments, and deciding how agents are applied to real tasks.

This is the same pattern every infrastructure layer follows. Few companies build databases. Fewer still write operating systems.

Agent harnesses are headed in the same direction.

How to build agentic products now

Once you treat coding agents as infrastructure, the architecture becomes simpler.

A long-lived agent runs inside a sandbox with a real filesystem and durable state. Planning, tool execution, memory, and compaction are handled inside the harness. Your product layer interacts with it remotely, triggering tasks, wiring in tools and integrations, and supervising execution.

The value you add is no longer in building an agent. It is in deciding when agents run, what they are allowed to do, how they interact with your systems, and how results are presented to users.

In practice, this means you are not designing agents. You are designing how agents run, what they can touch, and how humans supervise the results.

The stack is reorganizing

A new primitive has emerged.

We now have a small set of well-crafted, general-purpose agent harnesses that equip models with context management, tool execution, and environmental awareness. These systems are becoming foundational to any serious agentic application.

As with databases, runtimes, and containers, a few groups will build and maintain this layer. Most teams should build on top of it.

That shift changes the default assumption for anyone building agentic systems today. The central question is no longer how to build a better harness. It is how to build the right product on top of one.