AI Harnesses Are For Everyone

The major labs spent the first half of 2025 adding memory to their chat products. ChatGPT now references your past conversations. Claude has Projects with persistent context and custom instructions. Gemini has Gems with custom personas and uploaded knowledge. These are real improvements. The model remembers your name, your preferences, your last few requests.

A harness goes further. Where memory gives the model a few facts about you, a harness gives it the full context of your work: project structure, conventions, workflows, and the specific ways you prefer to interact with data. You can build your own memory layer inside a harness, writing session state to disk so the model picks up where it left off. It is not an application you install. It is a directory, a few markdown files, and a set of conventions that turn a capable but stateless model into a persistent collaborator that works the way you work.

I started building one in January 2026. The thing that surprised me was not the productivity gain (though that was real). It was that the harness let me push the model into preferential behavior: my file naming conventions, my commit message style, my preferred way of structuring research before writing. The model stopped being a generic tool and started being my tool.

The basics

An LLM (large language model) is the neural network that generates text. When you talk to ChatGPT or Claude through a browser, you are talking to an LLM wrapped in a chat interface. It can reason, write code, summarize documents, and hold a conversation, but on its own it has no memory between sessions and no ability to take actions in the world.

An agent is an LLM given tools. Instead of just generating text, it can read files, run commands, search the web, and take actions. Claude Code, OpenAI Codex, and Gemini CLI are agents. They operate in a loop: read context, decide what to do, act, observe the result, repeat. The ability to use tools is the key capability that separates an agent from a chatbot.

A context window is the agent’s working memory. Everything the model can see during a single session (your instructions, the files it has read, the conversation so far, its own previous actions) must fit inside this window. Current models have windows of 128,000 to 200,000 tokens (a token is roughly three-quarters of a word). That sounds like a lot until you realize the agent is reading your project, your conversation history, and its own tool outputs simultaneously.

Past roughly 40% of the window, performance degrades. Every wrong turn and correction consumes tokens that push you deeper into what Dex Horthy calls the “dumb zone.” The most common failure mode is asking for something, watching it go wrong, correcting it, watching it go wrong again, and repeating until you run out of context or give up.

A harness is the infrastructure that keeps you out of the dumb zone. It is the set of files (an AGENTS.md describing the project, skill files describing workflows, memory files capturing session state) that an agent reads at the start of every session so it does not have to rediscover your project from scratch. A well-built harness also lets you serialize state and start fresh sessions as context gets heavy, carrying forward what matters and leaving behind what does not.

A specification is a structured description of what you want the agent to do, written clearly enough that the agent can execute it without constant correction. Specifications live inside the harness and provide the context that long-running agents need to stay on track across multiple sessions. Where the harness describes the project and how you work, specifications describe the work itself: the goal, the constraints, the decisions already made, and the criteria for knowing when it is done. The harness manages specifications the same way it manages skills and memory: as files on disk that the agent reads at the start of each session.

Level	What it is	What you get	What you manage
Chat	Browser conversation with an LLM	One-shot Q&A	Nothing: it forgets
Project	Chat with uploaded files or a system prompt	Some context per session	Manual file uploads, copy-paste
Agent	LLM with tools (file access, shell, web)	Actions, not just words	Permissions, tool configuration
Harness	Agent with persistent project context and structured workflows	A collaborator that knows your work	The harness files themselves
Specification	A structured description of a task or project managed by the harness	Long-running agents that stay on track	Goals, constraints, decisions, acceptance criteria

What changed

The capability crossed a threshold in late 2025. The models became good enough that delegating entire tasks (not just asking questions) became the default workflow for people paying attention. The bottleneck shifted from “can the model do this” to “can I describe what I want clearly enough.”

When	What happened
Jun 2024	Claude 3.5 Sonnet: noticeably better at code than anything before it
Late 2024	Model Context Protocol: standardized tool interface for LLMs
Early 2025	Claude Code, Codex CLI, Gemini CLI: agents in the terminal
Mid 2025	ChatGPT memory, Claude Projects: labs add persistence to chat
Late 2025	OpenCode, Aider, dozens of open-source agents: the ecosystem matures
Dec 2025	Capability threshold: delegation becomes the default workflow
Jan 2026	OpenClaw (a persistent, personality-rich local agent) becomes the fastest-growing project on GitHub
Early 2026	OpenAI acquires OpenClaw. Claude Cowork, Claude Skills, NVIDIA NemoClaw: harness-like features go mainstream

I started building a harness after discovering OpenCode and reading Anthropic’s guide to building skills. The early friction (chasing the model, mismanaging context, accumulating cruft) was exactly the dumb zone problem. Building the harness was the fix. Taking inventory of what changed once implementation commoditized was the motivation: once the model can build anything you can describe, the remaining value is in context engineering and systems thinking, not in practicing implementation. The harness is the primary tool for that specification work.

Back to composable

The common thread across every major lab right now is tool use. Not chat. Not memory. Not reasoning benchmarks. The race is to give models hands and feet: the ability to read files, run commands, call APIs, and interact with the software you already use. Anthropic shipped tool use across the Claude 3 family in mid-2024. OpenAI followed with the Responses API, built-in web search, file search, and computer use. Google built Gemini CLI around the same pattern. Every agent product that shipped in 2025 (Claude Code, Codex CLI, Gemini CLI, OpenCode, Aider) is fundamentally an LLM with a bash session.

The research validates the practice. Wang et al.’s CodeAct paper (ICML 2024) demonstrated that using executable code as a unified action space outperforms JSON-based tool calling by up to 20% in success rate. The models are better at writing code to accomplish tasks than they are at selecting from pre-defined tool menus. This is why the agent products all converged on the terminal: the shell is a composable interface the models already understand from training data.

The harness sits on top of this composable layer. It does not replace the tools. It structures which tools the model has access to, how it uses them, and what context it carries into each session. The harness is the specification layer that makes tool use repeatable and personalized.

Each lab is packaging this differently:

Anthropic is betting on the individual. Claude Code put a capable agent in the terminal with direct filesystem access. Cowork extends this with persistent file access, skills, and connectors, all without requiring a terminal.

Microsoft is betting on the organization. Copilot is embedded in Microsoft 365, Teams, and Windows. Copilot Studio lets administrators build managed agents with 1,400+ connectors. Most people will encounter AI through their employer, and the employer wants guardrails.

The open-source ecosystem is betting on the builder. OpenClaw demonstrated that a persistent, personality-rich agent with sophisticated memory could run on local hardware. NVIDIA NemoClaw wraps OpenClaw with OpenShell security and privacy controls and routes to local Nemotron models on your own GPU.

Google is betting on scale and cost. They design their own silicon (TPUs) and can execute tokens cheaper than anyone running on GPUs. Gemini CLI exists. NotebookLM is interesting for research workflows. The bet is that you will keep putting more of your work into their systems, and they will make inference so cheap that the volume becomes the moat.

NVIDIA is betting on the hardware layer. NemoClaw is the agent. DGX Spark and RTX are the silicon. The bet is that the most serious users will want dedicated local compute for their agents, and NVIDIA will sell the hardware that makes that possible.

The common thread: inference is moving from the cloud to the edge of your work. Not “edge” in the hardware sense (though that is happening too) but in the workflow sense. The AI is no longer a website you visit. It is a presence in your terminal, your editor, your file system.

Value capture

The productivity framing around AI is mostly wrong. The question is not “how much more can you produce” but “who captures the value of what you produce, and at what cost to you.”

Agentic building is genuinely addictive. You pull a lever with each prompt and get random rewards and sometimes amazing payouts. I noticed it early: there is a real risk to dopamine hijacking where you feel that output equates to value. The harness fights this, not by reducing what you produce, but by reducing the cognitive load of producing it. Less time wrestling with context management, less time re-explaining your project, less time in the dumb zone.

The leverage is in context management. The harness is the primary entry point: it structures the persistent context that shapes every session before you get into project-specific work. Get the harness right and every interaction starts from a better position. Get it wrong (or skip it entirely) and you spend your cognitive budget on overhead instead of on the work that matters.

Specification vision

Parkour practitioners develop what’s sometimes called “parkour vision,” the ability to see movement possibilities that are invisible to everyone else. Walls become vertical floors. Handrails become pathways. Jasmine Sun argues that programmers have something similar: “software vision,” a trained instinct for recognizing when a problem has a software-shaped solution. If you do a task three times, there is probably a script that should be doing it. That instinct is learned, not innate, and most people have never had a reason to develop it.

“If you tell a friend they can now instantly create any app,” Sun writes, “they’ll probably say ‘Cool! Now I need to think of an idea.’ Then they will forget about it, and never build a thing.”

The harness develops a related instinct that I’d call specification vision: the ability to look at your own work and see where a clear description would let an agent handle it. Software vision asks “is this problem software-shaped?” Specification vision asks “can I describe this clearly enough that an agent could do it?” The answer is yes more often than you’d expect, and the harness is what makes the description stick across sessions.

The harness is not just a productivity tool for people who already write code. It is a framework for developing specification vision. When you build a harness (even a simple one: a directory, an AGENTS.md file, a first conversation where the agent knows who you are) you start to see your own work differently. Tasks that felt manual start to look describable. Workflows that felt fixed start to look like they have gaps that a clear specification could fill.

Where to go from here

This essay is the conceptual backbone. Every lever a harness gives you (identity, context, skills, memory, hands, gates, invocation) maps onto a real artifact on disk. The fastest way to feel that is to watch it happen with a concrete example.

The applied piece is a scrollytelling lesson that builds the harness through one mundane problem: planning the week’s dinners.

Larder: Claude Code is the terminal-and-files version. A folder, a CLAUDE.md, a skill, a commodity CLI as the helper, and a weekly retrospective that captures what the plan missed.

The companion piece the-larder-lesson explains why I picked meal planning as the worked example, and who the lesson is for.

The lessons assume you can create a folder and edit a text file. They do not assume you have opened a terminal before, and they do not assume you have built anything with an LLM. Links are homework, not hand-holding.

Thinkers

People whose work shaped the ideas in this essay.

• Andrej Karpathy: His conversation on No Priors is the clearest articulation of what changed in late 2025. On removing yourself as the bottleneck, on Jevons paradox for software, on education shifting from explaining things to humans to explaining things to agents.
• Steve Yegge: The AI Vampire reframes AI productivity as a value capture problem. Who gets the surplus? The dopamine hijack framing is essential reading.
• Jasmine Sun: Claude Code Psychosis introduced “software vision” and the parkour analogy. The second-order insight (realizing which problems are not software-shaped) is the one that sticks.
• Dex Horthy: No Vibes Allowed is the practical case for structured context engineering. The “dumb zone” framing and the research-plan-implement workflow pattern.
• Neal Ford: Why Everyone Eventually Hates Maven gave us the composable vs. contextual framework that explains why every agent product converged on the terminal.

Glossary

Terms used here (and in the lessons), defined once for reference.

Term	Definition
LLM	Large language model. The neural network that generates text. ChatGPT, Claude, and Gemini are interfaces to LLMs.
Agent	An LLM with tools: the ability to read files, run commands, and take actions, not just generate text.
Context window	The agent’s working memory. Everything it can see during a single session. Measured in tokens.
Token	A unit of text, roughly three-quarters of a word. Models process text as sequences of tokens.
Tool use	The ability for a model to call external tools: read a file, run a shell command, search the web, call an API. The capability that turns a chatbot into an agent.
Harness	A set of files that give an agent persistent context about a project. Includes project descriptions, skill files, memory files, and workflow definitions.
Skill file	A markdown file that teaches the agent a specific workflow or capability. Part of the harness.
Context engineering	The practice of managing what goes into the context window and when. The core skill for working effectively with agents.
Specification	A clear description of what you want the agent to do, structured enough that the agent can execute it without constant correction.
Composable	Tools that can be wired together in ways their designers did not anticipate. Unix pipes, CLI tools, shell scripts. Contrast with contextual.
Contextual	Tools that provide scaffolding through plug-in APIs. Fast to start, hard to extend past the designer’s assumptions. MCP is an example.
MCP	Model Context Protocol. Anthropic’s standardized plug-in API for connecting LLMs to external tools.
The dumb zone	The region past ~40% of the context window where model performance degrades. Term from Dex Horthy.

---

The harness exploration and self inventory are the backstory. The composable tools essay and the merge request as friction essay are the technical context.