Handoff Tax bills trajectories, Open-MOPD hits 83%, SWE agents finish 5%

TL;DR

• Handoff Tax study finds the inherited trajectory, not compute, is the real escalation cost.
• ByteDance’s Open-MOPD lifts distillation recovery from 35.6% to 83.4% by rebalancing gradient share.
• SWE Refactor Bench clears 5.4% end-to-end across 520 frontier-agent runs.
• 68% of test-passing SWE Refactor submissions still broke under adversarial verifier agents.
• 13 of 20 tasks received zero accepted solutions from any frontier model across all runs.

Today’s three research features share a lens: the interesting failure lives in the handoff between stages, not the model itself. The Handoff Tax study finds escalating from Haiku to Opus loses to a clean Opus restart — the culprit is the trajectory the strong model inherits, not the compute it burns. ByteDance’s Open-MOPD shows naive multi-teacher distillation hands instruction-following just 0.99% of gradient tokens despite carrying ~20% of prompts, and rebalancing that share lifts recovery from 35.6% to 83.4%. SWE Refactor Bench builds a 130,000-check fixed test suite, then finds adversarial verifier agents still break 68% of the submissions that passed it — while only 5.4% of 520 agent runs finish an end-to-end stack migration.

None of the three papers proposes a new architecture. Each isolates a stage-to-stage transition — model-to-model, teacher-to-student, tests-to-adversary — and shows that’s where the pipeline’s headline number actually gets set.

Handoff Tax study: restart Opus, don’t escalate to it

Source: hf-daily-papers · published 2026-08-24

TL;DR

• Raw escalation from Haiku to Opus cost $1.61 and lost to a clean Opus restart at $0.90 with higher accuracy.
• Escalation recovered only 47% (Claude) / 36% (GPT) of the LC–HC quality gap on SWE-bench Verified.
• Dropping the inherited trajectory lifted recovery to 64% / 84% — the trajectory itself was the tax.
• Downshift keeps 80% of LC cost savings only when the strong model’s trajectory is preserved as breadcrumbs.

The restart paradox

The default move when a cheap coding agent gets stuck is to hand its trajectory to a stronger model. A new paper — 58,000 agent runs and 36 billion tokens across Claude and GPT families — argues that move is usually strictly worse than throwing the work away and starting over.

On SWE-bench Verified with the mini-swe-agent scaffold, raw escalation from Haiku 4.5 to Opus 4.7 cost $1.61 per task and underperformed a fresh Opus-only run costing $0.90. The receiver pays twice: once to read the loser’s trajectory, again to reason its way out of it. Quality recovery — the fraction of the LC/HC accuracy gap the handoff recaptures — sat at 47% for Claude and 36% for GPT. Deleting the inherited trajectory entirely (Traj-drop) pushed recovery to 64% and 84% respectively. The trajectory itself was the tax.

Why the direction matters

The asymmetry is the real result. Downshifting from Opus to Haiku mid-run preserved 80% of the cost savings an LC-only run would have delivered, while landing well above LC-only accuracy. But downshift only works if the HC trajectory is kept: strip it and quality collapses to 28% recovery, because the LC model spends 1.6–2.0× more steps re-deriving what the strong model already figured out.

So the interface flips by direction:

The alphaXiv reviewer’s line captures the design lesson: treating context as “neutral state” is a fundamental error in current agent orchestration ¹. Context has a shape, and the shape carries weight independent of the facts inside it.

One instance of a wider fragility

The result rhymes with a body of multi-turn work. The “Lost in Conversation” study finds a 39% accuracy drop when identical requirements arrive as incremental shards, with near-full recovery (95%) when those shards are concatenated at the end ². JetBrains’ December 2025 context-management work reports a 30% “lost-in-the-middle” hit on long trajectories and argues compact summaries beat larger windows ³. Models are anchored to the structure of what they inherit, not just its content.

Practitioners already do the paper’s prescription without the vocabulary: Devin’s “timeline scrubbing” and the “restart with a tighter brief” pattern are Traj-drop by another name ⁴.

The economics get worse off-Claude

The paper’s dollar figures are calibrated to Claude’s relatively tight LC/HC price ratio. Independent per-resolved-task pricing puts Claude 4.5 Opus at $0.68 vs. DeepSeek V3.2 at $0.028 — a 24× spread ⁵. Widen the ratio and downshift savings compound while escalation penalties dwarf the paper’s numbers.

One caveat worth holding: a practitioner survey argues context accumulation drives >99% of session spend and that agent PRs merge at roughly half the human rate regardless of routing sophistication ⁶. If merge-rate is the real ceiling, optimizing which model holds the pen mid-run is a second-order fix. The actionable finding is smaller and sharper: when a cheap agent stalls, don’t promote it. Restart.

---

ByteDance’s Open-MOPD recovers 83% of teacher gains, up from 36%

Source: hf-daily-papers · published 2026-08-18

TL;DR

• SIA Lab (ByteDance × Tsinghua) ships Open-MOPD and D³-MOPD as a reproducible multi-teacher distillation recipe.
• Open-MOPD lifts recovery from 35.6% to 83.4% of the SFT→specialist-RL gap on SmolLM3-3B.
• Instruction-following got only 0.99% of gradient tokens despite being ~20% of prompts in the naive setup.
• Follow-up D³-MOPD closes ~97% of the gap with 3× fewer rollout steps on Qwen3-30B-A3B.

One lab, two papers, one recipe

Open-MOPD (Aug 18) and D³-MOPD (Aug 24) aren’t independent drops. Both come out of the Scalable Intelligent Model Technology Joint Research Center — the ByteDance Doubao Seed × Tsinghua AIR lab stood up in late 2024 to harden techniques for the MiMo and Doubao production stacks ⁷. Read them as v1 and v1.1 of the same story: diagnose why merging domain-specialist RL experts into one student model bleeds capability, then make the fix cheaper.

The context matters. Thinking Machines Lab spent October arguing that on-policy distillation — sampling from the student, scoring every token with a teacher’s reverse-KL — is the “missing middle” between SFT and RL, and that it drops into a GRPO/PPO loop in about ten lines of PyTorch ⁸. Industrial reports on MiMo-V2-Flash, GLM-5 and DeepSeek-V4 have all name-checked multi-teacher OPD as the terminal consolidation step. What was missing was an academic-budget, fully open version. Open-MOPD ships exactly that: MixSFT, three RL teachers, distillation stage, checkpoints and trajectories on an 8×A100-80GB node ⁹.

The diagnosis isn’t teacher conflict — it’s token budget

The paper’s most interesting move is negative. Token-level disagreement between math, code and instruction-following teachers exists (mean 0.126 nat), but consensus targets and conflict masks actually hurt performance. The real bottleneck is that concise domains get drowned out. In a naive setup, instruction-following contributed 0.99% of gradient tokens despite being ~20% of prompts, because math and code reasoning traces are ~25× longer.

Open-MOPD’s three knobs address this directly: token-share balancing equalizes per-domain gradient volume, gap-following allocation reweights toward domains with larger running reward magnitude, and reward refresh recomputes student log-probs before each inner PPO update so the distillation signal isn’t stale. The payoff, on SmolLM3-3B:

Instruction-following jumped from 43.64 to 49.58; code from 19.26 to 21.73 on LiveCodeBench.

What D³-MOPD adds

D³-MOPD swaps the static domain mixture for an off-process watcher that tracks per-domain reverse-KL headroom and descent velocity, then reallocates rollout budget on the fly. Same peak score, 3× fewer rollout steps, and the distilled student surpasses its specialist teachers on 3 of 7 evaluated domains on Qwen3-30B-A3B ¹⁰. That last detail is the interesting one — it undermines the folk assumption that the student is ceiling-bound by any single teacher.

Where the doubts sit

Two threads of dissent deserve airtime. A 2026 critique argues OPD’s headline gains are partly illusory: it raises pass@1 by making the student more likely to surface solutions it already knew, without expanding the solvability boundary ¹¹. If that’s right, “83.4% recovery” is a ceiling artifact. Separately, work on Behavior Leverage Imbalance shows that uniform token-share weighting can still miss high-leverage structural tokens — a Soft Clamp on mode-entry tokens like <tool_call> cut tool-call errors from 13.7% to 9.0% on APIGen-MT ¹². Open-MOPD’s own concession that conflict masks hurt performance is consistent with this: where the signal fires may matter more than aggregate per-domain budget.

The open question isn’t whether the recipe works at 3B — it clearly does. It’s whether the token-budget diagnosis survives at 70B+, and whether D³-MOPD’s teacher-surpassing results are the start of a real ceiling break or a Qwen3-30B-A3B artifact.

Further reading

• D^3-MOPD: Adaptive Dynamic Domain ScheDuling for Efficient Multi-Teacher Distillation — hf-daily-papers

---

SWE Refactor Bench: agents finish 5% of stack migrations

Source: hf-daily-papers · published 2026-08-23

TL;DR

• 28 of 520 agent runs (5.4%) completed a whole-repository stack migration end-to-end under a three-stage protocol.
• 13 of 20 tasks received zero accepted solutions from any frontier model across all runs.
• 68% of submissions that passed a 130,000-check fixed test suite were still broken by adversarial verifier agents.
• Language rewrites scored 5.6 on the composite, vs. 31.4 for build-toolchain swaps — difficulty tracks rewrite depth.

The blindness problem

Every existing coding benchmark scores agents on a red-to-green signal: tests were failing, now they pass. That signal is meaningless for migrations, because the original repo already passes its tests. An agent can “migrate” C to Rust by shimming the C library behind a Rust FFI wrapper and score 100%. SWE Refactor Bench argues this is why leaderboard numbers on migration tasks are inflated — and the data backs it up. Vals AI’s public Code Migration board shows Claude Opus 5, Claude Fable 5, and GPT-5.6 Sol clearing 53–57% of hidden behavior tests ¹³; the same models under SWE Refactor Bench’s protocol top out at 47/100 composite and 5.4% end-to-end. The behavioral pass rates are roughly consistent — the gap is everything else.

That “everything else” is a three-stage gauntlet. Stage I is an LLM-judged Migration Audit that vetoes shims and leftover source-stack code (majority vote of three independent judgments per criterion). Stage II runs the fixed behavioral suite — averaging ~6,500 checks per task — with all-or-nothing scoring; one failing test zeroes the stage. Stage III unleashes six independent coding agents, each with one hour, to find an executable counterexample that passes on the original and fails on the migration.

Stage III is where the carnage happens. Of 88 submissions that cleared both the audit and 130,000+ fixed tests, 60 (68%) were broken by the adversarial verifiers ¹⁴. That number is the paper’s most durable finding: even a very large static suite is not a proxy for behavioral equivalence when an adversary is allowed to write new tests.

Where agents actually fail

The failure modes cluster. Among 340 runs that passed the audit, 58% got to a 99% test pass rate but only 26% hit 100% — the “last 1%” is typically a missing metadata field, an off-by-one in a build manifest, or an unhandled edge case in a rarely-called API path. Difficulty tracks the depth of the rewrite: build-toolchain swaps (Autotools→CMake, Maven→Gradle) score 31.4, framework rewrites 12.0, and full language rewrites 5.6. Only 12 of 182 language-migration attempts even reached Stage III.

The Bun counterpoint

The paper’s binary framing needs a caveat, and it comes from a real shipped migration. The Bun team ported their runtime from Zig to Rust using parallel Claude Code agents in about two weeks. The result passed its test suite — but Zig creator Andrew Kelley called it “unreviewed slop,” citing ~13,000 unsafe Rust blocks (~4% of the repo) and 19 regressions that reached production ¹⁵. Under SWE Refactor Bench, some of those regressions would fall to Stage III verifiers. The unsafe density would not; the benchmark measures observable behavior, not code quality or safety invariants.

Independent reviewers add a methodology caveat too: 20 tasks is thin, and with 13 of them yielding zero solutions, the “hardest 65%” of the corpus currently produces no signal beyond “everyone fails” ¹⁶. SWE-EVO’s Fix Rate metric ¹⁷ takes the opposite philosophical fork, rewarding partial progress. Both are defensible — but the 5.4% headline is partly an artifact of hurdle-based scoring, not raw capability collapse. What is not an artifact: agents that look complete on tests, and aren’t ¹⁸.

Round-ups

JIT-Agent synthesizes custom agent harnesses for off-the-shelf LLMs

Source: hf-daily-papers

JIT-Agent trains a model to generate composable four-module harnesses tailored to each task, boosting off-the-shelf LLMs across DeepSearchQA, OdysseyBench and OpenCode. The approach self-evolves via distillation and lifts performance on models from Claude Code down to smaller open weights.

Mixed SFT beats next-chunk RL on no-CoT reasoning data

Source: hf-daily-papers

Revisiting post-training under no-CoT corpora, mixed supervised fine-tuning matches or exceeds next-chunk RLVR on math and out-of-domain accuracy while running more efficiently. The result challenges the default assumption that reinforcement learning is the stronger recipe when chain-of-thought traces are unavailable.

Prefix Sliding cuts long-reasoning memory by dropping stale tokens

Source: hf-daily-papers

Prefix Sliding trims KV-cache costs during test-time scaling by discarding intermediate tokens deemed unimportant to later reasoning steps. The method pairs full attention with a sliding window and needs no retraining, letting existing reasoning models stretch to longer chains without extra GPU memory.

Gated Recurrent Transformers match deeper models with shared core

Source: hf-daily-papers

A shared transformer block is reused across depth under adaptive update gates, delivering quality on par with or better than deeper baselines. Under isoFLOPS and isoPARAMS tests, the recurrent design cuts parameter count and memory while preserving expressivity through learned depth reuse.

Code World Model uses executable code as the world’s state

Source: hf-daily-papers

Code World Model splits simulation into two parts: a language model emits executable code that updates persistent world state, while a video model renders observations from proxy representations. The decomposition enforces spatiotemporal consistency that pure video world models routinely violate.

LLM skills fracture across languages, multilingual self-play shows

Source: hf-daily-papers

Pitting LLMs against themselves in text-based games across languages exposes large cross-lingual gaps in spatial reasoning, imperfect-information play and resource allocation. Switching the intermediate reasoning language recovers part of the deficit, suggesting skills are tied to language rather than being fully invariant abstractions.

LibriBrain100 releases 100 hours of MEG data for speech decoding

Source: hf-daily-papers

LibriBrain100 offers 100 hours of magnetoencephalography recordings aimed at neural speech decoding at scale. Experiments show that deep within-subject data plus multi-subject supervised fine-tuning of pre-trained models sharply improves decoding accuracy, giving the brain-computer interface field a much larger training substrate.

Footnotes

1. alphaXiv review of arXiv:2608.24358 — https://www.alphaxiv.org/abs/2608.24358

   Treating context as ‘neutral state’ is a fundamental design error in current agent orchestration.

   ↩

2. beam.ai — ICLR 2026 coverage of Lost-in-Conversation — https://beam.ai/agentic-insights/iclr-2026-llms-lose-accuracy-in-multi-turn-conversations

   State-of-the-art models experience an average accuracy drop of 39% when subjected to these ‘sharded’ instructions… if these shards are simply concatenated into a single prompt at the end, performance recovers to nearly 95% of the baseline.

   ↩

3. JetBrains Research — Efficient Context Management (Dec 2025) — https://blog.jetbrains.com/research/2025/12/efficient-context-management/

   ‘Lost-in-the-middle’ effects can cause a 30% drop in accuracy when vital information is buried deep in a long, unsummarized trajectory… maintaining a compact summary of successful trajectories is more critical for reliability than simply increasing context window size.

   ↩

4. Entelligence — Loop Engineering Explained — https://entelligence.ai/blogs/loop-engineering-explained-why-the-hardest-part-of-ai-isn-t-the-model-anymore

   Tools like Devin allow users to ‘scrub the timeline’ and restore a specific checkpoint… If a full restart is necessary, the recommended strategy is to restart with a tighter brief—a condensed instruction list that includes the previous attempt’s failures.

   ↩

5. SSOJet — cheapest AI coding models — https://ssojet.com/blog/cheapest-ai-coding-models

   High-end models like Claude 4.5 Opus lead in accuracy (80.9%) but can cost up to $0.68 per resolved task… DeepSeek V3.2 reportedly costs as little as $0.028 per task, a 24x difference.

   ↩

6. Blackmatter VC — Loop Engineering practitioner verdict — https://blackmatter.vc/lab/loop-engineering-an-honest-verdict-from-someone-who-actually-runs-agent-loops

   The accumulation of context in long-running loops often accounts for over 99% of session spend… one study found agent solutions are merged by maintainers at roughly half the rate of human solutions.

   ↩

7. ByteDance Seed announcement — SIA Lab (Doubao Seed × Tsinghua AIR) — https://seed.bytedance.com/en/blog/bytedance-and-tsinghua-air-establish-joint-research-center-to-advance-industry-academia-research-collaboration-on-large-models

   The Scalable Intelligent Model Technology Joint Research Center (SIA Lab), established in late 2024 by ByteDance’s Doubao Seed Team and Tsinghua AIR, is the institutional home for the MOPD/Open-MOPD/D³-MOPD line of work targeting the MiMo and Doubao model families.

   ↩

8. Thinking Machines Lab — On-Policy Distillation blog — https://thinkingmachines.ai/blog/on-policy-distillation/

   On-policy distillation samples trajectories from the student and uses a teacher to score every token with dense reverse-KL supervision; the objective can be dropped into an RL loop (GRPO/PPO) with roughly ten lines of PyTorch.

   ↩

9. GitHub — BytedTsinghua-SIA/Open-MOPD — https://github.com/BytedTsinghua-SIA/Open-MOPD

   The repository releases the full pipeline — MixSFT, three domain RL teachers, and the multi-teacher distillation stage — with local shell launchers, SmolLM3-3B checkpoints, training trajectories and evaluation data intended for reproducibility on an 8×A100-80GB node.

   ↩

10. Moonlight review of D³-MOPD — https://www.themoonlight.io/en/review/d3-mopd-adaptive-dynamic-domain-scheduling-for-efficient-multi-teacher-distillation

    D³-MOPD reached the same peak performance with a 3× reduction in rollout steps and closed approximately 97% of the performance gap between student and teachers, with the student actually surpassing specialist teachers on three of seven evaluated domains on Qwen3-30B-A3B.

    ↩ ↩²

11. AlphaXiv discussion of on-policy distillation limits — https://www.alphaxiv.org/abs/2604.00626

    A 2026 line of critique argues OPD’s gains may be partly illusory: it primarily improves sampling efficiency — making the model more likely to surface a solution it already ‘knew’ — rather than expanding the solvability boundary, which remains bounded by the teacher.

    ↩

12. Medium analysis — Behavior Leverage Imbalance in MTKD — https://joansantoso.medium.com/engineering-an-asynchronous-graph-based-knowledge-retrieval-system-in-antigravity-f0a323e7a8df

    Aggregate token weighting masks extreme divergences at ‘mode-entry’ tokens like <tool_call> tags; Soft Clamp reduced tool-call errors from 13.7% to 9.0% on APIGen-MT, suggesting where teacher signals act matters more than their aggregate magnitude.

    ↩

13. Vals AI Code Migration leaderboard — https://www.vals.ai/benchmarks/code-migration

    Claude Opus 5 at the top with a score of 57.47%, followed closely by Claude Fable 5 (55.06%) and GPT-5.6 Sol (52.92%) […] percentage of hidden behavior tests passed after a migration

    ↩

14. Sam Codeman blog: ‘Only 28 of 520 agent runs completed a migration’ — https://www.samcodeman.com/writing/only-28-of-520-agent-runs-completed-a-migration

    68% of submissions that passed both the migration audit and 130,000+ fixed tests were ultimately debunked by agentic verifiers, proving that static verification is insufficient for architectural migrations

    ↩

15. Remio.ai analysis of Bun Zig→Rust migration — https://www.remio.ai/post/anthropic-claude-code-migration-took-bun-from-zig-to-rust-in-two-weeks-but-speed-wasn-t-the-hard-pa

    Andrew Kelley, the creator of Zig, criticized the resulting codebase as ‘unreviewed slop,’ highlighting that it contained over 13,000 unsafe Rust blocks—roughly 4% of the entire repository… while the migration passed its primary test suite, 19 regressions escaped into the production merge

    ↩

16. Moonlight review of SWE Refactor Bench — https://www.themoonlight.io/en/review/swe-refactor-bench-can-coding-agents-complete-a-long-horizon-whole-repository-stack-migration

    A primary methodology critique centers on the benchmark’s small task count of just 20 migrations […] 13 of the 20 tasks received zero accepted solutions across 520 total runs, suggesting that for the hardest 65% of the corpus, current frontier models provide no utility

    ↩

17. Liner review of SWE-EVO — https://liner.com/review/sweevo-benchmarking-coding-agents-in-longhorizon-software-evolution-scenarios

    SWE-EVO introduces the Fix Rate, a metric designed to capture ‘partial progress’ on long-horizon tasks while strictly penalizing regressions […] SWE Refactor Bench uses a more binary, hurdle-based Composite Score. If a model fails the initial ‘Audit’, it receives a zero regardless of test results

    ↩

18. Vector Labs practitioner brief — https://vector-labs.ai/insights/why-coding-agents-fail-at-real-migration-work-what-benchmark-blindness-means-for-your-technical-debt-strategy

    agents are effective at modernizing narrow ‘slices’ of test suites (e.g., migrating from unittest to pytest), they often leave behind ‘dead dependencies’ or unmigrated modules that create new categories of technical debt

    ↩