Memdoor's five-agent Qwen3.8-27B team beats Claude Fable 5 on LiveCodeBench Hard

What happened

Memdoor, an open-source project, published a multi-agent coding workflow called team-solve on GitHub on October 31, 2026. The system uses five Qwen3.8-27B model instances — each assigned a distinct role — and an additional repair worker to solve competitive programming problems from LiveCodeBench Hard. The results: a mean score of 9.8 out of 10 across five passes on the first ten problems, compared to 8.0 for a single Claude Fable 5 call and 9.6 for the GVS5H harness by Lee (2026) that it reproduces.

AI Weekly reported the results on November 1, noting that the workflow reuses the GVS5H authors' exact prompts, making it an implementation test rather than a prompt-engineering win. The agents communicate only through files on disk — the planner writes a plan file, the solver writes solution.py, the manager reads the test logs, the repair worker patches — and each agent starts from a fresh context with only the files it needs.

How the multi-agent workflow works

The team-solve workflow assigns five roles: a planner who writes the overall approach to a problem, two parallel ideators who generate alternative solution strategies, a solver who implements the chosen approach, and a manager who reads the test output and decides whether to accept, reject, or iterate. On top of these five runs a repair worker that patches failing tests.

Unlike a single large model that processes everything in one context, these agents never share a chat history. The planner writes a plan file to disk. The solver reads that file and writes solution.py. The manager reads both the solution and the test runner output. When a test fails, the repair worker reads the solution file and the test output, patches the code, and writes the updated solution back. Each re-entry is cold — the next agent sees only the files, not the conversation that produced them.

The model in every role is Qwen3.8-27B with a 128K reply cap, served through a pinned backend. The workflow reuses the exact prompts from the GVS5H authors, which means the comparison to Fable 5 is apples-to-apples on method: the only difference is the model and the orchestration pattern.

The economics

Fifty runs consumed 15.3 million output tokens and cost $35.79 total, or $38.77 counting 16 incomplete attempts. A median run took 40 minutes and cost $0.39. By contrast, running Claude Fable 5 on the same problems would cost significantly more per call — and Fable 5 requires API access to Anthropic's proprietary infrastructure rather than a self-hosted open-weight model.

The cost structure illustrates the multi-agent thesis: smaller models working in parallel can match or beat larger proprietary models at a fraction of the inference cost, especially on tasks that decompose naturally into sub-problems. The total token use is higher (five agents generating tokens), but each token is much cheaper, and the architecture is fully self-hostable.

The contamination caveat

The authors flag a significant limitation up front: the LiveCodeBench Hard problems date from March 29 to April 6, 2025, and Qwen3.8-27B may have seen them in training. 'Contamination cannot be ruled out,' the README states. This matters because a model that has memorized a problem and its solution will perform better than one encountering it fresh, independent of the multi-agent architecture.

The same contamination risk applies to Fable 5's score (8.0) — it may also have seen the problems — but the gap between 9.8 and 8.0 could be partly explained by differential contamination rather than pure architectural advantage. The fairest test would be on problems released after the training cutoff of both models, which the open-source community has not yet run.

Why it matters

The result is a live demonstration of a thesis that has been circulating in AI research for months: that orchestrating multiple smaller, cheaper models can outperform a single larger proprietary model on specialized tasks. The GVS5H approach — five roles plus a repair worker — is not new (Lee published it in 2026), but Memdoor's implementation on Qwen3.8-27B shows the approach is reproducible and cost-effective.

For developers and startups, the implication is practical: frontier coding performance does not necessarily require access to the most expensive proprietary APIs. Open-weight models orchestrated with simple file-based communication can achieve competitive results. The trade-off is latency — a 40-minute median run is not interactive — but for batch coding tasks, research evaluation, and automated bug fixing, the economics are compelling.

The results also land in a broader trend of open-weight model coordination. Other recent projects include Nesformer compiling an NES CPU into Qwen model weights, and Lyra's Evil-Qwen manipulation, suggesting the Qwen model family is attracting an active experimentation community around its capabilities and limitations.

Caveats

The benchmark is small (10 problems, five passes) and contamination is likely. Multi-agent orchestration adds significant latency and complexity compared to a single model call. The workflow uses the GVS5H prompts unchanged, which makes it a replication rather than a novel contribution. The results have not been independently reproduced on different problem sets or with different model backends. The 9.8 score is the mean across passes; individual runs may vary, and the authors do not disclose variance or failure cases beyond the 16 incomplete attempts.