Skip to content
AI Coding

Five Qwen3.8-27B Models Match Fable 5 with GVS5H

Run GVS5H ledger self-orchestration on five Qwen3.8-27B contexts: exact uv commands, file roles, three pitfalls, and the ~3× token tradeoff vs Fable 5.

5 min readBeginner

Two ways to chase frontier coding scores: pay for one giant proprietary call, or keep a smaller open model and organize it. Right now the second path is getting real traction – five Qwen3.8-27B contexts under GVS5H land in Fable 5 territory on LiveCodeBench Hard, and people are cloning the repo the same day they read the abstract.

Single-call Qwen3.8-27B: 66.8% pass@1 on the 100 newest hard LCB problems. Same weights with ledger self-orchestration: 92.4%. Claude Fable 5 single-call on that set: 90.4%. Orchestrated Qwen3.8 Flash Next: 93.0% at roughly 9% of Fable inference cost (arXiv:2608.26480, Sep 2026 revision). No fine-tune. Training-free scaffold only.

What GVS5H actually is (ledger, not magic)

GVS5H (“Gorilla vs. 5 Humans”) is zero-shot self-orchestration. One model plays every role. Every call starts empty and only reads a shared disk workspace – the ledger.

  • task.md – problem statement
  • plan.md – manager’s short strategy (capped ~4k chars)
  • notes.md – curated findings (capped ~8k chars; workers rewrite, they don’t endless-append)
  • tasks.json – task list mirror
  • solution.py – current code

v2 flow is boring on purpose. Manager drops a 3-6 sentence plan and seed tasks. Brainstorm worker fills notes. Manager refreshes the list and picks one next task. Execute worker rewrites solution + notes. If public tests exist, a verifier writes pass/fail back. Cap is 10 manager→worker cycles, plus a no-progress guard and a cut-off summarizer when a call slams the token wall. Workers never chat. Files are the only memory.

Think of it like five people who never meet and only leave sticky notes on the same whiteboard. The whiteboard is why a 27B can behave like a much larger single-pass model.

Step-by-step: run five Qwen3.8-27B contexts under GVS5H

Clone the official tree and stay on v2-current. You need uv plus credentials for an OpenAI-compatible, Anthropic, DashScope, OpenRouter, or local vLLM backend.

git clone https://github.com/slee-persis/GVS5H.git
cd GVS5H/codebase/v2-current
export OPENAI_API_KEY=... # or ANTHROPIC_API_KEY / DASHSCOPE_API_KEY / etc.

Pinned paper runs used local vLLM FP8 for Qwen3.8-27B and Flash-Next. Point your server at the quant, then:

LCB_RELEASE=release_v6 
ESCALATION_CLOUD_MAX_TOKENS=128000 
ESCALATION_CLOUD_TIMEOUT=7200 
MULTIAGENT_MODEL=openai:your-qwen-endpoint-name 
uv run --no-project --python 3.12 --with 'datasets<4' --with numpy --with anthropic 
 python escalation/run_bench.py --engine multiagent --only lcb --lcb 100 --parallel 8
  1. --engine multiagent turns on the ledger manager. --engine single is the one-shot baseline.
  2. --lcb 100 is the hard LCB-100 slice the paper reports. Smaller numbers = cheaper smoke tests.
  3. Pass@1 prints at the end. Aggregates: runs/results.json. Full workspaces: runs/ws/.
  4. Prefixes: openai:, anthropic:, dashscope:, openrouter: – each with its own *_API_KEY.

Published temperatures: plan 0.3, brainstorm 0.4, execute and task-list curation 0.2. Single-call baseline also 0.2. Don’t tweak those first – match the write-up, then experiment.

Pro tip: Start with --lcb 5 and --parallel 2. Open a workspace mid-run and watch plan.md / notes.md / solution.py change. Fastest way to see what the scaffold actually does.

Common pitfalls when you try this at home

Gains aren’t universal. Some models stay flat or get worse under the manager. A bad early plan locks later workers onto a slow or buggy path because everyone inherits the same notes and solution.py.

  • Token bill ~3×. One call becomes plan + brainstorm + up to ten worker rounds + finalizer. Average output tokens roughly triple. Still often cheaper than Fable 5 single-call at the mid-Sep 2026 list-rate snapshots logged in the paper.
  • Output caps love Qwen3.8-27B. Long single-arm 128k runs hit the ceiling a lot; some stretched loops even dumped repetitive garbage near 250k. Fresh contexts plus the cut-off summarizer recover many empty/no-code cells – that recovery is a big slice of the headline lift.
  • Verifier coverage is partial. Turns out only 73/100 hard problems expose stdin-style public tests the loop can run mid-flight. The other 27 are LeetCode-style: no live pass/fail until the hidden grader.
  • Routing noise. OpenRouter multi-provider paths mixed quants, stalls, and truncated streams. Pin a backend (your vLLM or first-party API) if you’re comparing numbers.

GVS5H vs single-call vs “just buy Fable”

Approach LCB-100 hard pass@1 (reported) What you pay for Best when
Fable 5 single 90.4% Frontier API rate One-shot simplicity; budget secondary
Qwen3.8-27B single 66.8% Cheap / local tokens Quick drafts, not hard contests
Qwen3.8-27B + GVS5H 92.4% ~3× tokens, still self-hostable One strong GPU (or FP8 vLLM) and Fable-class coding
Qwen3.8 Flash Next + GVS5H 93.0% ~9% of Fable cost (paper) API path; max accuracy per dollar

Fixed pipelines, trained routers, debate stacks – plenty of other multi-agent designs exist. GVS5H’s bet is narrower: same weights, no training, dynamic task list, filesystem ledger only. On this hard coding slice, that was enough to push a 27B past a frontier single call. Later pairings that actually help: local Qwen3.8 serving, LiveCodeBench contamination windows, coding-agent ledger design.

FAQ

Do I need five physical GPUs?

No. One solid GPU serving quantized / FP8 Qwen3.8-27B is the local story. “Five models” means five fresh contexts of the same weights – sequential or lightly parallel – not five full concurrent loads.

Will this fix every coding task I throw at Qwen?

No – and that’s the usual misconception. The scaffold helps when the failure mode is “can’t organize long reasoning / loses the thread.” On LCB Hard that was the main gap. If your model already plans cleanly and stops cleanly, extra rounds add less and can occasionally talk themselves into a worse plan. Run --engine single vs multiagent on a tiny slice of your workload before you trust any headline number.

Where do I read the primary sources?

github.com/slee-persis/GVS5H (MIT code). arXiv:2608.26480 (CC BY 4.0 paper/figures). Benchmark: LiveCodeBench release_v6 hard. Scores above are from the Sep 2026 revision – re-check the repo if you’re reading later.

Clone it. Run --engine multiagent --lcb 5 against your Qwen endpoint tonight. Open one runs/ws/ folder and watch the ledger write itself. That’s the whole trick.

Related Tutorials