Coding agents are being rebuilt for long horizons: 11.3 SWE-bench points, a 15.2% backup gap, and a 42% ceiling on perf fixes

Reminders you distill, not append

Long-horizon coding tasks have a failure mode everyone who has run an agent recognizes: the agent starts well, drifts, and by step forty is confidently editing the wrong file. One common fix is inference-time reminders — scaffolding prompts that nudge the agent back on track — but those add complexity and cost to every run. In a preprint posted this week, the OPRD method (on-policy reminder distillation) moves the reminders into training: it distills trajectory-level guidance into the student model, and the student then operates without reminders at inference time while maintaining performance. The reported numbers are strong: benchmark-averaged task resolution on SWE-bench improves by 11.3 points over the Qwen3.5-4B base model, and the aggregate error-event count in long-horizon coding tasks falls by 50.2%. m:…8235

The design lesson is architectural. Inference-time scaffolding is a tax you pay forever — on latency, on tokens, on the brittleness of prompts that must survive every rollout. Distillation converts a recurring runtime cost into a one-time training cost, and the 11.3-point gain suggests the distilled guidance is doing real work. For teams running coding agents at scale, the implication is worth weighing: the agents that win long horizons may be the ones whose training absorbed the scaffolding into the weights, which is a cheaper agent to serve and a simpler system to operate. m:…8235

Agents that don't back up

If OPRD is about agents that stay on track, the RegretBench preprint is about what happens when they don't. Its headline finding is a gap that should worry anyone deploying autonomous coding agents: agents complete 86.1% of tasks, but demonstrate only 15.2% backup awareness — they rarely preserve state before taking irreversible actions. The asymmetry is the story. An agent that succeeds most of the time but never checkpoints is an agent one destructive command away from a disaster it cannot undo, and the benchmark suggests this is the default behavior, not an edge case. m:…8111

The paper's answer is BackUpper, a plug-in backup layer rather than a prompt asking the agent to remember to back up. It reports 92.2% state restoration similarity, uses 7x fewer tokens than having the main agent do its own backups, and can align with user-defined preferences for backup scope with an 84.5% F1 score. The plug-in framing matters: backup becomes infrastructure the agent sits on top of, not a behavior the agent must learn. Combined with OPRD's lesson, a pattern forms — the field is moving reliability out of the agent's prompt and into its training and its tooling, where it can be measured and guaranteed rather than hoped for. m:…8111

The system-level ceiling

The third preprint, MicroPerf-Bench, finds the ceiling that remains even when agents write correct code. The benchmark injects performance anti-patterns into microservice systems and measures whether agents can localize and fix the resulting bottlenecks. The best-performing agent configuration recovers only 42.0% of the injected performance degradation. The primary failure mode is not syntax or functional errors — it is system-level bottleneck localization, finding where in a distributed system the time is actually going. Worse, functional correctness in code changes does not correlate with end-to-end performance improvement: an agent can produce a correct patch that makes nothing faster. m:…3385

That last finding is the one to sit with. Most coding-agent evaluation still rewards producing code that works; MicroPerf-Bench suggests the frontier skill is producing systems that perform. An agent that cannot attribute latency to a component cannot optimize it, and no amount of file-level correctness closes that gap. For engineering teams, the practical read is to scope agent autonomy to what the measurements support: code-level tasks where agents are strong, with system-level optimization still under human review. m:…3385

Kernels across abstractions

The fourth preprint goes in the opposite direction: down the stack, where agents are already strong. TileCas gives coding agents a way to navigate across multiple programming abstraction levels when generating GPU kernels, using cross-level diagnosis and abstraction scheduling to move between levels as needed. With AKO, the combination reaches a 4.84x speedup on KernelBench Level 3 workloads, compared with 3.75x for the baseline; integrating TileCas with KDA improves mean speedup by 69.2% across all tested configurations. Kernel work rewards exactly the kind of reasoning agents do well — it is local, measurable, and verifiable by execution — and TileCas exploits that by letting the agent choose the right abstraction for each part of the problem. m:…9406

Taken together, the four papers describe a field hardening its agents at both ends. Training absorbs the scaffolding (OPRD), infrastructure absorbs the safety net (BackUpper), benchmarks expose the system-level ceiling (MicroPerf-Bench), and abstraction-spanning interfaces push the floor lower on kernels (TileCas). The through line is that agent reliability is becoming an engineering discipline rather than a prompting art: measure the failure, move the fix into training or tooling, and verify by execution. All four are preprints, so the numbers are reported findings awaiting independent replication. But the direction of travel is consistent. m:…8235 m:…8111 m:…3385 m:…9406