Memdoor assembled five Qwen3.8-27B models into a collaborative team that outperformed Fable 5 on LiveCodeBench Hard. Its approach divides problem-solving across specialized roles, shares memory between them, and revises the result. That makes it worth examining as an engineering pattern for teams building Agent systems.
Five Qwen Agents Solve Problems as a Team
The result: five models outperform one stronger model
Memdoor's team-solve workflow uses five Qwen3.8-27B models.
They do not solve the task independently and then vote. Task state, the solution process, and intermediate results are retained and passed to different team members for specialized work.
According to the project's release announcement, the workflow scored higher than Fable 5 on LiveCodeBench Hard.
The easiest mistake here is to treat this as the score of an individual model. The result comes from collaboration among five models, not a single inference by one of them. The underlying model is still Qwen3.8-27B, but the effective unit of problem-solving is now an Agent team.
The result matters, but not because five smaller models are inherently stronger than one larger model.
It changes a key variable. Instead of assuming that one reasoning process must contain all available context, multiple Agents save, transfer, and revise state in stages.
The original announcement also noted that the story reached the Hacker News front page. At the time, the page had 74 points and 38 comments.
The code is public: a reproducible workflow, not just a paper score
Memdoor has published its team-solve example and corresponding code on GitHub:
- GitHub: https://github.com/guregodevo/memdoor/tree/main/examples/workflows/team-solve
- The associated Hacker News discussion can be traced through the repository and release announcement.
That is more valuable than a benchmark screenshot.
Many Agents described in research papers define their roles clearly but leave critical implementation details implicit: how state is transferred, which members can see each other's output, and whether failed steps are retried.
The team-solve repository puts the orchestration model in code. Readers can inspect how the five roles are created, how the task is divided, how memories are written, and how the final answer is assembled.
According to the repository example, collaborative solving involves role specialization, shared memory, and workflow orchestration. It does not send the same prompt to five models and take a majority vote.
The execution path worth reproducing is:
task input
→ role assignment
→ independent analysis and shared memory
→ write intermediate results back
→ conflict checks and revision
→ final answer
With the repository available, developers can inspect how Qwen3.8-27B is invoked, how the model service is configured, which sampling parameters are used, and how the LiveCodeBench Hard evaluation script works.
The counterpoint: an Agent's bottleneck may be context
In this case, the most important variable is not the number of models.
It is context management.
When a single model handles a complex programming problem, it typically has to organize the problem statement, relevant files, prior reasoning, and error logs. As the context grows, attention becomes harder to allocate. A model with more parameters may still overlook early constraints or be misled by one flawed analysis.
A team-based workflow offers another approach:
- One Agent interprets the problem and its constraints.
- One Agent explores viable approaches.
- One Agent checks the code and boundary conditions.
- Another Agent revises the solution based on feedback.
- A synthesis role determines the final output.
The exact roles depend on the repository implementation. The key point is that they do not all need to read the same complete history at once.
Memdoor's name also points to this design priority: memory. Team members receive prior information through shared task state and memory.
This approach has costs. Compressing information can discard details, while faulty summaries can create false consensus.
It also changes how failures unfold.
A single model can lose its way across an entire reasoning chain. A team-based Agent system can isolate an error within one role and let other members continue from an explicit record.
It would therefore be too absolute to say that an Agent's bottleneck is intelligence rather than context. A more accurate claim is that, in long-chain tasks, context organization may be more worth optimizing than further scaling a single model.
Engineering tradeoffs: concurrency, latency, and error propagation
Five collaborating models do not naturally mean five times the cost.
Nor do they naturally consume five times as many Tokens as a single model.
If roles can run in parallel, wall-clock time may be lower than with sequential execution. If the workflow includes review and revision chains, however, costs rise significantly. Actual expense depends on how much context each role reads, how much memory it writes, and how many retries it requires.
There are four questions worth examining.
1. Concurrency gains
Five Agents can work well when launched simultaneously to explore different approaches.
But if every member must wait for another member to write back shared memory before proceeding, the concurrency advantage disappears. The public code makes the task dependency graph more important to examine than the number of roles.
2. Token budget
Every Agent may carry shared context, and repeated reads multiply input Tokens.
A more efficient design gives each role a different view. For example, a debugging role receives the code and error logs, while a review role receives the patch and test results, rather than giving every member the full conversation.
3. Conflicting results
When two Agents reach different conclusions, the system cannot simply use whichever output arrived last.
It needs explicit conflict-resolution rules: adjudicate by test results, assign a fixed role to review the disagreement, or allow multiple rounds of debate. More debate rounds will further increase latency.
4. Error propagation
This is the risk most likely to be overlooked in a collaborative system.
Once a faulty summary enters shared memory, other members may treat it as fact. Incorrect code can also become a premise that later Agents continue to patch.
Memory writes therefore cannot rely on append alone. They need at least source labels, status fields, and a rollback mechanism. A practical data structure could resemble this:
{
"artifact": "candidate_fix.py",
"source_agent": "debugger",
"status": "needs_review",
"evidence": ["pytest: 18 passed, 2 failed"],
"version": 2
}
This is not ready-made code from the Memdoor repository. It illustrates the minimum fields needed to define the engineering boundaries. The actual implementation should still follow the repository.
For production systems, a team of Agents is not necessarily more reliable than a single Agent. Team operation adds scheduling, monitoring, and attribution costs. Multiple Agents make sense only when the task can be clearly divided, results can be verified, and memory can be transferred reliably.
Editorial perspective
The significance of this result does not lie in the claim that “five Qwens defeated one stronger model.” A single benchmark cannot establish that Agent teams generally outperform individual models. Test-set difficulty, task distribution, sampling parameters, and judging methods could all change the ranking. Fable 5's precise identity and the complete evaluation configuration also require further verification through the repository, release page, and leaderboard.
Public code provides a more concrete signal: Agent-system optimization is shifting from “using a larger model” toward “designing a better collaboration structure.” What distinguishes this attempt is that roles, memory, and orchestration at least exist in inspectable code rather than appearing only in a demonstration video.
The next projects worth watching will likely focus on state transfer, conflict adjudication, and failure recovery. A team's value may come not from using more models, but from turning one fragile, long reasoning process into multiple verifiable and reversible steps. That conclusion, however, remains provisional if the evaluation setup or task decomposition cannot be reproduced.
Source
https://github.com/guregodevo/memdoor/tree/main/examples/workflows/team-solve