The Durable Layer | Fulton Ring

When OpenAI launched GPT-6 Astra, the headline was a benchmark: 99.9% on ARC-AGI-3. Four days later, the ARC Prize Foundation ran the same model on the same benchmark and got 62.7% ^[1].

Nothing changed in the model weights. The difference was the harness: the software that manages what the model sees and how it remembers. The Standard harness treats working notes as plain text; the Provider Adapter harness preserves the model’s internal reasoning state between requests.

The result was a 37-point spread ^[1]. For context, the entire gap between Astra and its nearest competitor on the same test is 69 points ^[2].

Setup	Score	Cost	Notes
OpenAI (Provider Adapter)	99.9%	$18.8K	State preserved, compacted
ARC Prize (Standard)	62.7%	$26K	Model writes its own notes
OpenAI (Standard reproduction)	13.3%	—	Baseline reproduction
ARC Prize (Standard reproduction)	7.8%	—	Baseline reproduction

The 5.5pp discrepancy between the two “Standard” reproductions is the first signal that harness specifications are documented loosely enough for identical configurations to diverge ^[1].

It also creates a misleading impression: that the harness is a complex piece of proprietary engineering. It isn’t.

The machinery is a commodity

The mechanical loop of a harness is a solved problem. Tear down the source of the most successful production harnesses (Claude Code, Codex CLI, OpenCode) and you find the same pattern: an async loop, a list of tools, and a full history resend ^[6].

In a recent audit of eleven production coding harnesses covering roughly 4 million lines of code, zero production systems used general-purpose agent frameworks or vector-embedding RAG for code retrieval ^[6]. Instead, they all run on hand-rolled loops and deterministic retrieval: ripgrep, tree-sitter, and curated context files like CLAUDE.md ^[6]. The research concludes with a 90-line minimum-viable-harness scaffold that reproduces the basic logic of these systems ^[6].

We see this convergence in the implementation details. Claude Code’s system prompt consists of roughly 500 conditional fragments. Its anti-looping logic is prose: “if the user denies a tool you call, do not re-attempt the exact same tool call.” OpenCode handles the same problem as a permission rule (“doom_loop: ask”). Codex CLI uses diff-based editing via apply_patch, while Claude Code uses string replacement.

The “secret” to the 99.9% ARC score is also public. The Responses API exposes reasoning items to any client. Prime Agent, an open-source harness, hit 95% on ARC-AGI-3 simply by wiring in that state carry ^[5]. The feature is available to everyone. The decision to use it is the only thing that differentiates the result.

The mechanical knobs

If the loop is a commodity, where do the points actually sit?

There are mechanical knobs in the harness that have measurable effect sizes. I have ranked these by their impact on performance, based on current research.

1. History and Eviction Policy

The biggest single lever is how the harness handles the aging of context. Naive rolling truncation is the worst default because it deletes the oldest observations, which in exploratory work are the most load-bearing: the turn where the model learned a rule it now applies.

Replacing rolling truncation with a “half-life” shortening policy (recent results verbatim, older results compacted or truncated with omission markers) moved the fail-to-pass fraction from 28% to 49% and complete solutions from 43 to 72 on SWE-bench Verified ^[4]. The improvement transferred, frozen, across three other model families ^[4].

The nuance here is that this lever only binds when context pressure exists. In wide-window regimes (like Qwen3.6), the same treatment made almost no difference ^[4]. The specific policy will decay as windows grow, but the discipline of logging payload diffs and managing eviction is a durable engineering practice.

2. State Carry

As seen in the ARC Astra results, preserving opaque reasoning state between requests is a massive multiplier. When reasoning effort is turned off, a Standard harness scores 35.2% while the Provider Adapter scores 96.7% ^[1]. The state machinery, not the deliberate reasoning, is doing the heavy lifting.

However, this is not a neutral knob. It is provider-specific machinery. You cannot use a Provider Adapter to compare two different model vendors.

3. Tool and Interface Quality

The quality of the interface between the model and the tool is often a cheaper lever than a model upgrade. Improving the edit-tool format alone led to up to 10x improvements across 15 models ^[9]. Vercel found that reducing a toolset from 15 tools to 2 tools moved their success rate from 80% to 100% ^[9]. Adding a single high-quality tool provided a 2.1-2.2pp lift, roughly a routine model upgrade ^[7].

The mechanism is the reduction of compounding errors. When tool descriptions are written for humans, they fail for agents. Interface rewriting that focuses on cross-tool dependencies and parameter constraints can lift query-level success by ~61% as catalogs scale ^[8].

4. Subtraction

Harnesses often encode stale assumptions about what a model cannot do. These assumptions become “dead weight” that caps performance.

Anthropic found that letting Opus 4.6 filter its own tool outputs via code execution lifted BrowseComp from 45.3% to 61.6% ^[3]. Compaction lifted the same benchmark from 43% (Opus 4.5) to 84% (Opus 4.6) ^[3].

The lesson is that subtraction beats addition. Every token in a prompt depletes attention. Progressive disclosure through “skills” or tool search is more effective than a fat system prompt. The practice this suggests is a subtraction audit with every new model release: remove one component of the harness at a time and measure whether the model now performs the task more reliably.

The durable layer: Domain Context

Mechanical levers are useful, but they decay. A specific eviction policy becomes irrelevant as context windows expand. A specific tool format becomes trivial as models grow tolerant of malformed commands.

The durable differentiator is the domain-specific context a company curates for its harness. This is the layer that compounds and cannot be copied.

We see this in the most successful vertical AI companies. Harvey’s moat is not its harness machinery; it is years of attorney-tagged legal reasoning data ^[12]. As their team has noted, the process data for these tasks simply does not exist on the internet. By embedding firm precedents and templates, they create high switching costs that no generic agent framework can overcome.

Cursor’s advantage comes from trillions of tokens of real coding sessions and real-time RL on production traffic ^[13]. Their updates happen every five hours, refining the model’s ability to make “edits that stick” based on how real developers actually resolve errors.

Intercom achieved a 65% reduction in hallucinations compared to a raw Sonnet 4.6 deployment by running RL on billions of customer interactions and building domain-specific evals ^[14].

In these cases, the base models are often open-weights or commodity frontier models. The proprietary value is the domain data and the evaluation sets used to refine the harness. Without domain evals, you cannot measure improvement, which means you cannot iterate. The eval is the moat.

The reliability problem

The strongest evidence for the necessity of curated context is the Lost-in-Conversation phenomenon.

Research on 200k+ simulated conversations shows a -39% degradation in performance between single-turn and multi-turn interactions ^[11]. When you decompose this loss, the a-ha is the delta: aptitude loss is minor at -16%, but unreliability spikes by +112% ^[11].

The model does not forget how to solve the problem; it makes a premature assumption in turn 2 and spends the next ten turns justifying it. Reasoning models such as o3 and R1 degrade the same way, often generating longer responses containing more assumptions ^[11].

Crucially, test-time compute does not fix this. Harness-side remediations, such as “Snowball” (repeating prior instructions), only recover 15–20% of the gap ^[11].

The only condition that restores reliability is fully specified context: the necessary information delivered all at once, rather than trickled through a conversation. The most valuable part of a harness is then not the loop or the orchestration. It is the ability to curate and inject the exact domain context that keeps the model from drifting.

Honest concessions

There are several counter-arguments to the “curation as the only moat” thesis that deserve a direct answer.

First, critics point to Harvey’s early lead as a result of GPT-4 access and a prestige-first GTM strategy rather than data curation ^[12]. This is true. Access and trust were the accelerants, but curation is the durable layer. Access is a temporary advantage; data is a compounding one.

Second, one might argue that mechanical levers and domain curation are competitors. They are not. They are additive. You can have the best legal dataset in the world, but if your harness uses rolling truncation and deletes the user’s core constraints by turn 20, the model will still fail. The mechanical knobs set the ceiling; the curated context fills the room.

Third, multi-agent orchestration is often presented as a way to solve these problems. However, the data suggests multi-agent setups are mostly token-spending in disguise. At matched thinking-token budgets, single-agent setups match or beat almost all MAS architectures ^[10]. MAS only becomes competitive under heavy context degradation ^[10]. The real function of a subagent is not coordination intelligence but context isolation: condensing information before it returns to the main loop.

Finally, a well-curated harness can actually make model choice matter more, not less. Evidence shows harness-induced variance can be 7.8x higher than model-induced variance ^[7]. While a basic harness might mask the differences between two frontier models, a high-fidelity harness exposes them. The interaction between the harness and the model is where the final performance is determined.

Recommendations for builders

If you are building an agentic system, stop focusing on the plumbing. The loop is a commodity.

Own the data layer. Identify the “process data” that does not exist on the internet for your domain. Tag it, structure it, and use it to create a deterministic retrieval pipeline.
Build domain-specific evals. If you cannot measure a 1pp shift in reliability, you are guessing. The eval is your primary asset.
Perform subtraction audits. Every time a new model is released, assume your current harness constraints are dead weight. Remove them one by one and measure the effect on the benchmark.
Distinguish token-spending from context. Do not confuse a complex multi-agent architecture with a sophisticated context strategy. If your agentic flow is just a way to spend more tokens for the same result, it is a cost sink, not a feature.

The goal is to move from a system that relies on the model’s general aptitude to one that relies on a curated, reliable fabric of domain context. That is where the points, and the business, actually sit.