The Harness That Learns You

On day one, your agent doesn't know you. It asks how you like things done, re-derives your project's conventions, and pulls half a repository into context just to orient itself — and you pay for every token of that orientation. On day one thousand, it does all of it again, identically. The layer responsible is the harness — the instructions, memory, tools, and control flow wrapped around the model — and until recently it had one defining property: somebody wrote it once, and it never changes. A wave of 2026 research has started to make that layer learn. Harnesses that adapt to the task, to the environment, and to the model are now measured results. This piece walks that ladder rung by rung, says what each rung already buys you, and then names the rung nobody has climbed: the harness that adapts to you. No paper we have found demonstrates it. The reason, we will argue, is not a missing mechanism — the machinery on the lower rungs doesn't care what it adapts to. It is a missing check.

XO Labs Inc. · August 2026

TL;DR: The complaint is universal and documented: agents re-ask what they were told, repeat last month's mistake, and leave the upkeep of their own scaffolding — the instruction files, the memory hygiene, the tool configuration — to the human. The wish, stated as four behaviors: an agent that remembers you, correctly; that stops repeating a failure once corrected; that learns where your work leads — which kind of work, for you, follows which; and that maintains its own harness. A 2026 research wave has climbed the first rungs toward this: harnesses that adapt to the task (47.9% → 96.9% on one benchmark, with harness overhead falling from ~6 calls per episode toward 1), to the environment (a harness that rewrote its own components lifted a coding benchmark 69.7% → 77.0% and transferred with 12% fewer tokens), and to the model (an automated loop lifted one model's pass rate on held-out tasks — tasks its loop never tuned on — from 40.5% to 61.9%; evolved harness state moved across models, 0.00 → 43–45). The fourth rung — adapting to the person — has, as far as we can find, no demonstration anywhere. What blocks it is the check every lower rung depends on: those rungs keep an edit only if a rerun or a state comparison proves it helped, and nobody has established what the equivalent proof is for it learned me correctly. That open question, not any missing algorithm, is the distance between the agent you have and the agent you want.

1. Day one, day one thousand

Anyone who works with an AI agent daily knows the shape of the problem, even if they've never named the layer it lives in. The agent asks a question it asked last week. It confidently repeats a mistake you corrected a month ago. It reads files it doesn't need, filling its context window — the bounded working memory an agent reasons over — with material that makes it slower, worse, and more expensive at once. And the standing fix is manual: you edit the instruction files, you prune the memory, you curate which tools it may touch.

This is not one user's bad luck. "You correct the same mistakes across sessions, and every tomorrow starts fresh," writes one practitioner in a 2026 essay whose title — Why Your AI Agent Keeps Making the Same Mistakes — is its own genre now. A Cursor forum user, on the same experience from inside a different product: "I am constantly repeating myself when starting a new chat." An entire product category — external memory layers such as Letta, mem0, and Zep — exists because this complaint is common enough to sell to.

The layer responsible is the harness: everything around the model — context assembly, memory rules, tool routing, permissions, retries. In production agents it is most of the system; our anatomy of a production coding agent measured roughly 98.4% of one as this infrastructure. And in every product you can buy today, it is static: written once, shipped to everyone, identical on your first session and your thousandth. Whatever the model learned about you during a session evaporates when the session ends, because the layer that could have kept it doesn't learn.

2. The wish, in four behaviors

Stated concretely, the harness that learned you would do four things the static one cannot. The first two and the last are documented, global complaints — where a source below is a vendor selling an adjacent product, we note it, and the shape of the complaint deserves more trust than any single figure. The third is the wish's forward edge: less complained about, because no product we know of even attempts it.

It remembers you, correctly. Today's memory features write notes to themselves without any check on what gets written — and users notice both failure modes: the note that never got written, and the wrong note that did. Simon Willison, on ChatGPT's memory: "I really don't want my fondness for dogs wearing pelican costumes to affect my future prompts where I'm trying to get actual work done!" The failure compounds silently — "context poisoning," in one practitioner taxonomy, is "when a hallucination or other error makes it into the context, where it is repeatedly referenced." And unneeded context is not just noise, it is a bill: one developer measured his plugged-in tool descriptions consuming "66,000+ tokens of context before I even started a conversation" — overhead injected invisibly into every prompt. The research side agrees context is a budget, not a bucket: an eighteen-model study found "performance grows increasingly unreliable as input length grows," and Anthropic's own engineering guidance concludes context "must be treated as a finite resource with diminishing marginal returns" (vendor source). A harness that learned you would know what to keep, what to drop, and what about you deserves to persist — and would be accountable for getting it right.

It stops repeating the failure. The correction you gave the agent lives in one conversation's context and dies with it. Next session, the same wrong guess. This is the "agent amnesia" essay genre of §1, and it has a precise structural cause: nothing in the loop writes the lesson anywhere durable, and nothing checks that a written lesson actually took. The wish is not "an agent that never errs"; it is an agent whose error rate on things you have already corrected goes to zero over time — the way a colleague's does.

It learns where your work leads. Beyond remembering facts about you, the harness that knew you would learn the shape of your work — that one kind of task, for you, reliably leads to another. The refactor that always wants its changelog entry. The bug fix that is not done, by your standards, until a regression test exists. The analysis that is really the first half of a decision you will ask about tomorrow. Today the agent treats every request as an isolated task, because the harness records nothing about what followed what; a harness that did would start identifying the intent behind a request — anticipating the work your work implies, or at least never being surprised by it. Of the four behaviors this is the least attempted anywhere: it requires exactly the cross-session record of sequences of work that no current product keeps.

It maintains itself. Today the harness has a gardener, and the gardener is you. This is so accepted that Anthropic's own best-practices documentation for Claude Code, its widely used coding agent, prescribes the chore of tending CLAUDE.md — the instruction file users hand-write to steer the agent: "Treat CLAUDE.md like code: review it when things go wrong, prune it regularly" — and warns that bloated instruction files cause the agent to ignore your actual instructions. The tool's creator describes their team's cadence the same way: "We remove from it with every model release." By mid-2025 the discipline had a name — context engineering, "the art and science of curating what will go into the limited context window," in Anthropic's phrase — a job title's worth of ongoing human labor that quietly concedes the point: the harness does not maintain itself, so someone must.

Four behaviors, one root: the layer that could learn these things is the one layer in the stack that never learns.

3. The ladder the papers already climbed

Since March 2026, a wave of research groups — a dozen-plus entries at our last count — has been making the harness learn. We have read that wave closely and published the full analysis separately; here we take from it only what matters for the wish: what, exactly, have adaptive harnesses been shown to adapt to? The answer sorts onto a ladder — each rung a step up, one more thing the harness has been shown to adapt to — and the ladder points at you.

One instruction before the rungs: read the numbers below as existence proofs, not magnitudes. Each sits on its own benchmark against its own baseline, and the argument would survive with every figure halved. What matters at each rung is what it shows to be learnable — that harness behavior can change with experience at all, that the useful intervention is environment-specific, that the right fixes are model-specific. The numbers aren't the argument; the adaptation target is.

Rung one: the harness adapts to the task. EvoHarness-RL (2608.05446, UIUC + Meta AI) trains an agent's use of its harness — when to consult external memory, when to write to it — against the environment's own record of task success. On ALFWorld, a text-game benchmark of multi-step household tasks, an 8-billion-parameter model — small by frontier standards — rises from 47.9% to 96.9% on tasks like those it trained on, and reaches 86.6% on task types held back entirely (their Table 1). The learned policy also discovers an economy nobody hand-wrote: harness calls fall from roughly six per episode toward one as experience accumulates (their §4.1). Because that experience lives in external state rather than in the context window, it also survives what kills session knowledge today — the window filling up and being summarized away. What this rung buys of the wish: the beginnings of behavior two — past episodes changing what the harness does next — and the first evidence that harness overhead is a learnable cost, not a fixed tax.

Rung two: the harness adapts to the environment. Harness-R1 (2608.02276, SJTU + Xiaohongshu) has a separate small model edit the harness's executable hook code, rewarded by rerunning the patched agent and measuring the delta: average success rises 44.3% to 53.6% across three environments — and, tellingly, which intervention point matters most differs per environment (their Table 1, §5), which is exactly the selection a shipped-to-everyone static harness cannot make. AHE (2604.25850, Nex-AGI) lets an agent evolve its own harness components — prompts, tool descriptions, middleware, memory — with every edit verified against the next round's task outcomes: ten iterations lift pass@1 — success on the first attempt — on Terminal-Bench 2, a benchmark of real terminal tasks, from 69.7% to 77.0%, surpassing a strong human-designed harness, and the evolved result transfers unchanged to SWE-bench-verified (real GitHub issue fixes) "at 12% fewer tokens than the seed" — the starting harness it evolved from (v4 abstract). And where an environment has hard rules, AutoHarness (2603.03329) shows the harness can absorb them structurally: in a chess competition, 78% of one frontier model's losses "were attributed to illegal moves"; a synthesized code harness prevented all illegal moves across 145 text games, letting the smaller model outperform its larger sibling — in game environments, an important scope limit. What this rung buys: behavior four begins — the component-editing, rule-encoding, description-pruning work that context engineering currently assigns to you, done by a loop, and done measurably cheaper.

Rung three: the harness adapts to the model. Models differ in their failure modes, and harness advice tuned for one is wasted on another — a problem that grows as model variety does. Self-Harness (2606.09498) automates model-specific harness edits from mined weaknesses: on held-out Terminal-Bench 2.0 tasks, pass rates rise 40.5% → 61.9%, 23.8% → 38.1%, and 42.9% → 57.1% across the three models it tested (their abstract). Living-Harness (2607.26598, Zhejiang + Alibaba) shows the accumulated harness state is itself portable: its store of memory and repair rules, distilled from scored episodes, was handed to entirely different models — no retraining involved; the new model simply reads the inherited store — and models that scored 0.00 on their own reached 43–45% with it (their Table 3). The caution on this rung is real, though: Continual Harness (2605.09998, Princeton + DeepMind) found a capability floor below which self-editing harnesses underperform the static baseline, and a separate analysis (2605.30621, Penn State + UCSC + Amazon) finds the benefit of an evolved harness is non-monotonic in model strength — weak models fail to activate or faithfully follow the artifacts the harness hands them. A better harness partly substitutes for a bigger model, but not from arbitrarily far below. What this rung buys: the per-model tuning nobody's engineering team can afford to do by hand, at zero marginal human cost — with the floor as the honest asterisk.

What does a harness that has learned actually hold? Living-Harness gives the wave's most concrete answer, and it is worth drawing, because it is also the shape of what behavior one would need: not a longer prompt, but a store — episodic memory entries and a state graph whose transitions carry repair rules — that only verified experience is allowed to write into.

Every rung shares two properties. The adaptation is real and measured. And the thing adapted to is impersonal — a benchmark's tasks, an environment's rules, a model's quirks. The reader the wish belongs to appears nowhere in the loop. And it is one loop — beneath the very different mechanisms, every climbed rung runs the same cycle:

4. The rung nobody has climbed

State it plainly: no paper we have read — core wave, extensions, or the wider tracker of entries we maintain — demonstrates a harness adapting to a person. Nothing in the literature learns your conventions, your corrections, your tolerance for questions, your definition of done, or which work of yours leads to which. The ladder's fourth rung is not under-climbed; it is untouched.

It is worth being precise about what "you" would even mean, because at least four different things hide under the word, and they are not equally hard. A preference — you like concise answers, tabs over spaces — is a fact, easy to record and easy to check. A convention — how your services are structured, what your team calls things — is a fact about your world, checkable against your repositories. A behavioral pattern — when you do this kind of work, you usually follow it with that kind — is a statistical regularity, checkable only across many sessions; behavior three of §2 lives here. And contextual intent — which tradeoffs matter to you when; that you want your assumptions challenged on architecture decisions but not while you're on a deadline — is an inference, and verifying an inference about a person is the hardest measurement on this page. The wish spans all four, and its value concentrates at the hard end: the layers of "you" that would change the agent most are precisely the layers whose check is least defined.

What makes the wish reasonable anyway is that the machinery on the lower rungs never cared what it was adapting to. Each system runs the same loop: propose an edit to the harness, check the edit against an outcome, keep what checks out. Task, environment, model — the loop is indifferent. Swap in "this user's recorded corrections" as the thing edits respond to and the mechanism has no objection. What it lacks — the reason the rung is untouched rather than merely unclimbed — is the middle step. The check.

5. What the last rung actually requires

Here is the constraint the lower rungs teach, stated once and without apparatus: a self-editing harness keeps only the edits that something it cannot edit says helped. On the climbed rungs, that something exists and is cheap: rerun the task batch and measure the delta; compare the world's state to the goal state; let the benchmark's evaluator gate every commit. Where systems skipped the check and judged their own edits, the wave's documented failures cluster — plausible-looking patches that made agents measurably worse, self-revision loops that degraded the very scores they reported improving. The pattern should sound familiar from §2: a memory feature that writes notes about you with no check on what gets written is a self-editing harness without a judge — wrong-memories-at-scale is not a bug in the wish, it is the wish built without this constraint.

For learning you, nobody has established what the check even is. What is the rerun for "it understood my patterns correctly"? There are candidate signals, and they are worth naming because they are recordable today: you stopped re-correcting the thing; the mistake stopped recurring; the same work got accepted with fewer questions and fewer tokens. A personal harness could hold every edit on trial and keep it only if the sessions that follow actually go better by such measures. But every one of those measures is an idea, not a result. No paper defines them, collects them, or shows that gating on them works.

So the honest form of the question that ends this piece's argument is the one a builder would actually face: how would the harness know it learned you right? The lower rungs were climbed exactly when their version of that question got a mechanical answer. The fourth rung is waiting on its answer, not on its algorithm.

6. What this piece is not claiming

• Personalization is the wish, not a result. No system described here adapts to a person; the ladder's fourth rung is our extrapolation of a direction, and the papers carry no responsibility for it.
• Nobody has trained a harness on real user-interaction data. Whether such data is sufficient in volume, learnable in practice, or safe to collect is unestablished — and it is sensitive by construction: a record of how you work is exactly the thing you would least want leaked.
• Every number here is benchmark-scale. Games, text environments, terminal tasks, curated issue sets — not production work. Magnitudes are not comparable across systems (each sits on its own benchmark against its own baseline), and several results are first-version and unreplicated. Trust the direction of the wave over any single figure.
• The benefit is not uniform. The capability floor and the non-monotonic-benefit finding (§3, rung three) mean "a learning harness helps" is conditional on who is climbing.
• The ladder and the loop are our organizing devices, not the papers'. No paper uses this taxonomy. The rungs are not independent levels — a task lives in an environment, and a model runs both — and the mechanisms beneath them differ deeply: one system trains a usage policy, another edits executable code, another gates memory writes, another searches over whole harness programs. What they share is the loop's shape, not an architecture.
• The practitioner quotes are evidence of a complaint, not a measurement of it. No survey quantifies memory-failure prevalence or the hours spent maintaining instruction files; where a cited source sells an adjacent product, we have said so.

7. Day one thousand, revisited

The wish, restated as the day it describes. You open a session and the agent already works the way you've shaped it — not because you wrote the shaping down, but because the harness kept what a thousand sessions proved out. It doesn't ask the question it asked in January; the answer is in state that survived, because it earned its place. The mistake you corrected in March hasn't recurred since March. The work you ask for comes back shaped by where you usually take it next — the fix arrives with the regression test you would have asked for anyway. The instruction files you used to garden by hand are maintained by the loop that reads their consequences — every edit on trial, kept only when your next sessions went measurably better. The model behind it has changed twice this year; the harness noticed, re-tuned, and carried your accumulated state across, because the state was never the model's to lose.

None of this exists. The rungs below it now do. What separates the agent you have from that one is not intelligence, and after 2026 it is not mechanism either. It is one unanswered question — says who, about learning you? — and the wave described here is evidence that when that question gets its answer, the layer that never learned you will start.

References

• Ning, X., et al. (2026). EvoHarness-RL: Learning Self-Evolving Runtime Harness for Long-Horizon LLM Agents. UIUC + Meta AI. arXiv:2608.05446
• Shao, S., et al. (2026). Harness-R1: Learning to Edit Executable Runtime Harnesses from Agent Failure Trajectories. SJTU + Xiaohongshu. arXiv:2608.02276
• Lin, J., et al. (2026). Agentic Harness Engineering: Observability-Driven Automatic Evolution of Coding-Agent Harnesses. Nex-AGI. Numbers cited from the v4 abstract (May 18, 2026). arXiv:2604.25850
• Lou, X., et al. (2026). AutoHarness: Improving LLM Agents by Automatically Synthesizing a Code Harness. arXiv:2603.03329
• Zhang, H., et al. (2026). Self-Harness: Harnesses That Improve Themselves. arXiv:2606.09498
• Du, Y., et al. (2026). Living-Harness Is an Interactive-Agent Evolver. Zhejiang University + Alibaba. arXiv:2607.26598
• Karten, S., et al. (2026). Continual Harness: Online Adaptation for Self-Improving Foundation Agents. Princeton + Google DeepMind. arXiv:2605.09998
• Lin, M., et al. (2026). Harness Updating Is Not Harness Benefit: Disentangling Evolution Capabilities in Self-Evolving LLM Agents. Penn State + UCSC + Amazon. arXiv:2605.30621

Practitioner quotes in §§1–2 are linked where they appear.