Coding agents crack at turn five; the day's work is in the harness layer

Six agent harnesses paired with seven open-source models, 100-turn sessions building and revising a REST API server, and every model failed within five or six turns. That is StaminaBench from Amazon Science, and it measures what the dominant fraction-of-tasks-solved benchmarks miss: stamina, how many consecutive change requests an agent absorbs before it ships a regression. Tasks are generated programmatically with no LLM in the loop, the agent talks to the grader over HTTP, so the evaluation stays black-box and language-agnostic. Two of its findings reframe how to read every other agent leaderboard. Feeding test results back and letting the agent retry raised passed-turn count by up to 12x. A strong model swung up to 6x between its best and worst harness, while weak models failed under every harness. Past turn five, the model is not the bottleneck; the loop around it is.

That makes the day’s harness-infrastructure news matter more than it otherwise would. Cloudflare opened its Agents SDK as a base layer for third-party harnesses, exposing the distributed-systems plumbing every production agent re-derives: durable execution through Fibers (runFiber, stash, onFiberRecovered checkpoint a turn into the Durable Object’s SQLite so a crashed process resumes mid-turn), sandboxed code execution via Code Mode (a fresh Worker isolate per snippet, sub-10ms cold start), a SQLite-backed virtual filesystem, and runtime-generated durable workflows. Flue, an open-source framework from the Astro team built on the Pi harness, is the first to target it. Its model is declarative: you describe what an agent knows, its model, skills, sandbox, and instructions, rather than scripting the loop. The three-layer split they name, framework over harness over runtime, is the cleanest articulation yet of where this stack is settling.

The same consolidation showed up inside Claude Code. As of roughly 2.1.178, the explicit team tools are gone: TeamCreate and TeamDelete have collapsed into regular subagents. You spawn a named background subagent with Agent(name="worker", run_in_background=true), it can SendMessage back to the main conversation (which plain subagents could not), it holds state across turns, and the lead can shut it down. Fewer primitives, same capability. Orchestration is becoming a property of how you call subagents, not a separate subsystem to stand up.

If the harness is the loop, context is what feeds it, and two items go after what agents actually need to keep around. Probe-and-refine tuning takes on the contested question of whether AGENTS.md guidance helps, and argues the decisive variable is how the guidance gets produced. Using synthetic bug-fix probes to iteratively diagnose and patch a repo’s guidance file through single-shot LLM calls, with no agent loop during tuning, the authors reach 33.0% resolve on SWE-bench Verified against 28.3% for the static knowledge base it was seeded from and 25.5% unguided. The gain is coverage, not precision: refined guidance produced evaluable patches for 14.5 points more instances while per-patch precision held flat near 59%. Better guidance helps the agent reach the right file, not write a better change, and it is what lets a larger step budget pay off instead of wandering.

From the practitioner side, Aictx attacks the cold-start tax with a repo-local continuity layer under .aictx/, exposed through MCP tools with a CLI fallback. It hands the next session a compact resume: current task, last validated command, failed approaches, next suggested action. Across 200-plus sessions on a Rails monolith with Codex and Claude handing work back and forth, the author logs roughly 2.3k to 4.5k tokens of continuity overhead against 4k to 13k tokens of repo rediscovery avoided per prompt, the strongest case being Codex implements then Claude verifies. The framing worth stealing: continuity should live in the repository as inspectable records, not inside one agent’s context window.

Underneath all of it sits a question most memory systems answer by intuition: what must an agent actually remember? A formal account offers a separation theorem. When two domains share an observational bottleneck but demand incompatible optimal actions, any near-optimal policy must carry distinct memory at that bottleneck; current observations alone cannot suffice. And if memory holds enough to estimate values for related goals, it can approximately reconstruct the agent’s local transition dynamics. Memory becomes the substrate for domain disambiguation and planning, not just recall.

StaminaBench will get cited as a model leaderboard. Read it as a harness leaderboard, and the 6x best-to-worst harness gap is the number to track as Cloudflare’s SDK, Flue, and Claude Code’s subagent merge all push on the same layer. Worth watching: whether the next wave of agent benchmarks reports harness and model as separate axes, the way StaminaBench and the recent position papers on benchmark misalignment both argue they should.