By Hamza Faisal
A team of researchers has shown that five copies of a small, openly available coding model can outperform one of the world's most capable proprietary systems — not by training a bigger model, but by organizing the small ones better. The method, called GVS5H — short for "Gorilla vs. 5 Humans" — comes from researchers at Persis Capital. It needs no extra training data, no fine-tuning, and no task-specific demonstrations.
The idea is simple: instead of asking a model to solve a hard coding problem in a single pass, give the same model five fresh brains and a shared notebook, and let it manage itself. Each role runs in a brand-new context, so no single instance carries the whole conversation, and every role coordinates through files on a shared disk rather than by talking to the others directly.
One model, five fresh brains, one shared notebook
The loop works like a tiny software team. A manager instance reads the problem and writes a short strategy plus three to six seed tasks into a plan file. A worker brainstorms the core difficulty and candidate approaches, then another fresh worker executes one task at a time, rewriting the current solution and a curated set of notes. A verifier runs the candidate against the problem's public tests, and a failing test overrides any claim of completion, forcing the loop to continue with a fix. A finalizer writes up the definitive solution when the round budget — ten manager-to-worker cycles at most — runs out.
The shared ledger is the whole trick. The workspace holds the problem statement, the plan, a task list, curated notes, and the current solution, and each worker sees only the ledger plus the single task it has been assigned. Workers never talk to each other, and the plan and notes files are capped so they cannot grow without bound.
Cheaper than frontier — and sometimes better
The researchers tested the method on the 100 most recent hard problems from LiveCodeBench, a benchmark designed to limit training-data contamination, running each model five times with reasoning on. The headline result: Alibaba's open-weight Qwen3.8-27B jumped from 66.8 percent on its own to 92.4 percent when orchestrated — a gain of 25.6 percentage points that edges past Anthropic's Claude Fable 5, which scored 90.4 percent as a single call.
The larger open sibling did even better. Qwen3.8-Flash-Next reached 93.0 percent under orchestration, beating Fable 5 at what the paper puts at 9 percent of the cost. OpenAI's GPT-5.6-Terra climbed from 80.8 percent to 88.0 percent. Across eleven open and closed-weight models, the method delivered gains of as much as 25.6 points, lifting several cheaper models to frontier-level performance on self-hostable weights.
The catch: it doesn't work for every model
Gains are not universal — some models were unchanged or worse under orchestration — so the technique works reliably on some backends, not as a magic multiplier for every model.
The loop also spends more compute than a single call, and the paper makes no equal-token claim; the question it answers is whether that extra spend buys better solutions than simply moving to a larger model.
There is also a benchmarking caveat: giving models an agentic loop on a test designed for single-pass evaluation is not quite the same contest, and LiveCodeBench is a 2025-era benchmark some researchers consider saturated. Even with those caveats, the result points in a direction the industry has been circling: the next leap in coding performance may come from how models are organized at inference time, not only from how big they are trained to be.
