Two numbers to start: 77.5 and 78.2. Same exam — SWE-bench Verified, five hundred human-verified real-repository bug-fix tasks. The first comes from a 9-billion-parameter small model. The second comes from an agent that leaves the source code largely alone and asks the compiler instead. The gap is 0.7 points, but the paths are nearly opposite.
Over the past year, top coding agents have competed on parameter count, long context, and multi-model collaboration. These two new routes both ask the same question: is the money being spent where it counts?
🏃 The Ten-Hour Marathoner: arXiv 2609.34378
Marathoner comes from teams at Ant Group, Peking University, and the University of Macau, built on Qwen3.5-9B, a small open-weights model. The keyword in the paper's title is Ultra-Long-Horizon: keeping an agent working productively on real repositories for more than ten consecutive hours.
Training proceeds in four steps. First, task construction: 100,000 large PRs are extracted from over 10,000 GitHub repositories, each adding more than 1,000 lines of code, and synthetic tasks are built on these real changes. Second, Multi-Task Chaining: five tasks are strung together with an execution cap of 40 hours. Third, rejection-sampling fine-tuning on trajectories generated by strong teacher models across multiple execution frameworks. Fourth, reinforcement learning, with every rollout genuinely run and verified in an isolated sandbox.
The most distinctive piece is the reward design, called Later Stage Bonus Reward, which explicitly rewards effective actions in the later phase of execution. The rationale is blunt: the most common way long-horizon agents die is fading late — methodical in the first half, chaotic in the second. 【Inference】 This reward essentially writes a human marathoner's pacing strategy into the objective function.
The scoreboard: 77.5 on SWE-bench Verified, up from 43.8 for the base model — a 33.7-point gain. On two long-horizon benchmarks, FrontierSWE and SWE-Marathon, it reportedly surpasses Gemini-3.1-Pro 【as reported by AICrier's analysis of the paper】. The abstract claims that on the hardest tasks, it can work continuously for over ten hours and complete over 1,000 tool calls.
What does ten hours mean? A standard workday. A thousand tool calls is one or two tool keystrokes per minute, held steady for ten straight hours.
One caveat must be stated. According to AICrier's reading, the average FrontierSWE run is 3.56 hours and 648 tool calls; the ten-hour and thousand-call figures come from the hardest execution subset — an upper bound, not an average. Also, the paper is thirty pages, and the weights, training code, and datasets have not been released, so third parties cannot yet rerun it.
🔍 The Translator That Doesn't Read Code: A Developer's Release
Around the same time, a developer released Benzi. Its core claim in one sentence: let the compiler and static analysis read the code on the model's behalf.
The mainstream agent approach grabs code snippets or builds vector indexes to approximate program structure. The costs: token consumption bloat, context drift, forgetting after compression, and breakage on multi-file refactors the moment line numbers shift. Benzi takes a different route: before changing code, have the compiler report the blast radius of the change and run the full suite of static checks. The model rarely needs to ask who calls this function.
A comparison of reading volume published by the developer: on the same tasks, Benzi plus Sonnet read 9,125 lines of code; Claude Code plus Sonnet read 20,704; DeepSeek's agent framework read 43,598; OpenCode exceeded 65,000 and was disqualified for repeated failures. A "truth tiers" scheme separates statically verifiable facts from statically unverifiable ones, bridged by a runtime tracer.
Benchmark score: 78.2% on SWE-bench Verified, with per-fix cost under 10 cents, using the V4flash model. Language coverage spans nine mainstream languages from Python and JS/TS to Rust.
Must be flagged: all figures above are developer self-reports; no third-party reproduction exists yet. 【Judgment】 In this field, the distance between self-reported and reproduced scores is usually far greater than 0.7 points.
🧮 Two Ledgers
| Dimension | Marathoner | Benzi | |---|---|---| | Core bet | Endurance can be trained into weights | Structural knowledge can be gotten free from compilers | | Base | Qwen3.5-9B open-weights small model | Claude Sonnet family plus compiler toolchain | | SWE-bench Verified | 77.5 (base: 43.8) | 78.2 (self-reported) | | Per-fix cost | Not disclosed | Under $0.10 (self-reported) | | External reproduction | Weights and code not released | No third-party reproduction | | Most direct weakness | Ten hours only on the hardest subset | Limited to languages with compiler coverage |
The striking convergence is verifiability. Marathoner's RL must actually run tests to get real feedback; every Benzi write passes syntax and semantic validation. Zhichai's September 14 ripwire breakdown put it this way: an agent needs a determinate floor before acting, and structural information lost to grep must be paid for once on the index side. Benzi essentially paves that whole floor; Marathoner trains long-distance running on it. 【Judgment】
🧭 Until Reproduced, It's All Self-Report
Both efforts share a background note: industry trust in benchmark scores is thinning. If the 77.5 and 78.2 can be reproduced by external teams, the coding-agent cost curve gains a visible kink downward: small model with a good curriculum, or large model with good tooling. If not, they are just two more handsome self-reported numbers on a leaderboard.
---
Sources: arXiv 2609.34378 (Marathoner, submitted 2026-09-28), AGI Hunt daily digest 2026-10-02, AICrier's analysis of Marathoner, AGI Hunt's coverage of Benzi.
Caveats: The comparison above Gemini-3.1-Pro and FrontierSWE average execution times are cited from AICrier and not independently checked against the paper's tables; all Benzi figures are developer self-reports with no third-party reproduction; the exact identity of V4flash is unconfirmed; the ten-hour and 1,000-tool-call figures are upper bounds from the hardest execution subset, with averages of 3.56 hours and 648 calls per AICrier.