Qwen3.8-27B Multi-Agent Team Beats Claude Fable 5 on LiveCodeBench Hard for 9% of the Cost

A multi-agent scaffold that routes reasoning state through five shared files on disk — rather than through a model's context window — has allowed five copies of Alibaba's Qwen3.8-27B to outscore Claude Fable 5 on one of competitive programming's most contamination-resistant benchmarks, while costing roughly a tenth as much per run. The result, newly reproduced by the open-source Memdoor CLI and published November 1, corroborates and extends a September 2026 research paper that has quietly upended assumptions about which models are worth paying frontier prices for on hard coding tasks.

The underlying approach is called GVS5H — Gorilla vs. 5 Humans — introduced in arXiv paper 2608.26480 by a team of researchers at Persis Capital. The method requires no additional training: a single model plays all roles in a structured team, coordinating exclusively through files on disk, with no peer-to-peer messaging between agents.

How the File-Based Ledger Actually Works

The scaffold maintains five files throughout each run: task.md (the problem statement), plan.md (the manager's strategy), tasks.json (role assignments and status), notes.md (shared reasoning observations), and solution.py (the evolving candidate). Each agent instance spawns into a fresh context window, reads only the files relevant to its role, completes its step, writes output back to disk, and terminates. No agent reads another agent's live context.

This design solves a documented failure mode. Qwen3.8-27B in single-call mode produced a phrase repeated 7,743 times on one LiveCodeBench Hard problem in the paper's testing — a runaway reasoning loop that is unrecoverable inside a single context window. The file-based scaffold sidesteps this by capping each agent's individual reasoning budget and spawning each successor in a fresh context that sees only a compacted, curated summary of prior work. The multi-agent framing is convenient shorthand; what the scaffold actually provides is external persistent working memory that resets context degradation at each step. Guards prevent other failure modes: MAX_ITERS limits total iterations, a no-progress guard detects stalls, and a cut-off summarizer condenses history before hitting context limits.

LiveCodeBench Results: What the Paper Shows

LiveCodeBench Hard draws problems from Codeforces, LeetCode, and AtCoder after models' training cutoffs, specifically to resist contamination. LCB-100 is the 100 most recent Hard problems in release_v6. The paper's authors corrected two evaluator bugs before reporting any results: a stateless binary readline mock that penalized models using the buffer.readline() pattern, and four problems that accept multiple valid answers but had single-answer evaluation keys.

Under the paper's standard conditions — five passes, 128K reasoning budget, reasoning enabled — the results across major model families were:

• Qwen3.8-27B: 66.8% single-call → 92.4% team-solve (+25.6 percentage points, p < 2.5×10⁻⁵)

• Claude Fable 5: 90.4% single-call (reference baseline only; not tested under team-solve)

• Qwen3.8-Flash-Next: 84.2% → 93.0% (highest result in paper)

• DeepSeek-V4.1-Flash: 88.4% → 92.0%

• GPT-5.6-Terra: 80.8% → 88.0%

Qwen3.8-27B showed the largest absolute improvement of any model tested. One material caveat: Fable 5 was tested in single-call mode only. Whether a Fable 5 team-solve would score higher than 90.4% remains untested and unknown.

The Memdoor Reproduction: A Fresh 10-Problem Test

On October 31, the open-source Memdoor CLI reproduced the GVS5H harness as a built-in team-solve workflow and ran it against the first ten LiveCodeBench Hard problems. Across five passes (50 fully independent scaffold runs), the team solved 49 of 50 problems for a mean score of 9.8 out of 10. Claude Fable 5 in single-call mode scored 8.0 on the same ten problems. The 50 runs consumed 15.3 million output tokens at a total cost of $35.79 — a median of $0.39 per run at current OpenRouter pricing for Qwen3.8-27B.

These 10-problem results cannot be directly equated to the paper's 100-problem figure; the subset is small and may not represent the full distribution. What the Memdoor run establishes is that the GVS5H harness reproduces outside the paper's own codebase, by a different author, with consistent methodology and plausible performance.

Why the Cost Advantage Holds Even With 3× More Tokens

The scaffold uses approximately three times as many output tokens as a single-call approach because each agent step generates reasoning traces written to files. Tran and Kiela (arXiv:2604.02460, 2026) showed that single-agent systems match multi-agent systems at equivalent token budgets — a valid objection to multi-agent claims in general. GVS5H's answer is economic rather than architectural: Qwen3.8-27B output tokens cost $2.55 per million on OpenRouter; Fable 5 output costs $50 per million. A 3× token overhead on a model priced at 5% of the per-token rate still comes out substantially ahead.

Cost per solved problem for Qwen3.8-27B under team-solve works out to $0.52; for Qwen3.8-Flash-Next (the complementary MoE variant), it drops to $0.062. A full pass over the 100-problem set costs $47.82 for the Qwen3.8-27B manager arm versus $61.11 for Fable 5 single-call. Qwen3.8-27B is a dense model — 27 billion parameters active per inference step — and runs in FP8 precision on a single consumer-grade GPU, making self-hosted inference viable for teams that want to cut API costs entirely.

Limitations the Community Has Not Stopped Raising

Hacker News discussion since September has centered on whether the shared files allow intermediate solutions to leak between passes. The paper's multi-pass setup starts each pass from empty files, making the five passes genuinely independent. Within a single pass, agents share a live ledger — that is the designed mechanism. The concern is whether pass@5 accounting correctly captures this structure; the paper's authors say yes, but the community remains divided.

The manager role introduces a second documented weakness: it can accept a confidently wrong solution without detecting the error. The paper records a case where an incorrect early plan from a Qwen3.6-35B manager anchored all downstream workers, and the team produced a wrong answer with high confidence.

What This Means for AI Coding Infrastructure

The GVS5H paper and the Memdoor reproduction together establish a concrete, reproducible method for reaching competitive-programming performance comparable to the frontier without paying frontier API prices. The more durable implication is architectural: the scaffold works because reasoning state belongs on disk, not in a context window. Context windows degrade under extended reasoning chains; disk files do not. Agent frameworks that treat persistent external files as a first-class memory primitive — rather than an implementation shortcut — are pointing toward the same conclusion from a different direction.

Whether GVS5H-style coordination becomes standard for hard reasoning tasks, or whether purpose-trained multi-agent models eventually replace it, the cost-performance benchmark it set on November 1 is now a documented reference point that future approaches will need to address explicitly.