用于编程问题的多agent拉带，被写作"Memdoor工作流程". 5个角色(计划者，2个理想者，解析者，管理者)和1个修理工各自从新的上下文开始，只通过磁盘上的文件来交谈。 运行样本的外壳脚本决定成功，而不是模型。 它是GVS5H(Lee,2026:5个Qwen3.8-27B型号在LiveCode Bench Hard上与Fable 5相匹配)的方法。
用作者在Qwen3.8-27B上的精确提示重构，他们的回路在前10个LiveCode Bench Hard问题上得分平均为9.8分相差10分5分，而他们自己的吊带为9.6分，而仅Fable 5则得分为8.0分(以下，每跑一次公布).
编码员从方法描述(2026-10-25)中将这些文件自己写出。 没有人手写他们。
GVS5H的自带，被重建为同型号上的Memdoor工作流程：Qwen3.8-27B，一顶128K回放盖，作者的提示和回放。 他们的"LiveCode Bench Hard"榜单的前十个问题，5个通过，每个程序在每个公众上分级，并用他们的校正分数进行隐藏测试。
作者的列是他们的寄存器重级的结果文件
(q38 multimagent pN，寓言5 single pN)，其纸上的数字。
座椅/结果/座椅/座椅/座椅
运行：每个请求和答复，程序，分级器的全部输出，每个
呼叫的成本和服务它的宿主，和每一个不计其数的尝试。
50个中49个已解决；50个运行费用35.79美元(15.30万个输出符号),38.77个与
被时钟切断的16次尝试，停止修复或暂停。
注：有10个问题，每个问题5个，不是作者的100个。 比赛
该模型可能出现在
培训：不能排除污染。 小说5的一栏是单调
问题来自作者的文档；它没有运行在这个控制带中。 循环
只看到公开的样品；分数是隐藏的测试。 跑来跑去
40分钟模型时间(最长为4小时)和0.39美元的中位数。 全部开始
OpenRouter，不是本地机器；Modal不发布其精度。
在运行的脚本和四个回溯中显示本地路径
读取 < scratch > 和 $HOME；运行中没有其他内容经过编辑。
和作者们一样每个消息，字节为：
lib/test parity.py (英语).
运行他们的多代理解析和我们的工作流程与一个脚本模型并运行
比较每个请求(四个案例，都相同；一个特征改变
情况不同。 温度(计划0.3、设想0.4、经理和工人)
0.2)，上p 0.95和top k 20(他们的 vLLM 应用自模型本身)
1228K帽，最多10发子弹，一名停产工人总结，以及
答复中没有任何文字按其推理予以答复。
分别相。 主持人。 在FP8中他们自己的VLLM. 我们的
OpenRouter，按顺序询问 Modal, CoreWeave, Parsail, Wafer 直至 Modal
减速为14个令牌/s，然后仅FP8主机(Wafer, Parsail, CoreWeave):
203个电话由Modal接通，27个由CoreWeave接通，115个由Wafer接通。
FP8命令的电话 Wafer。 三跑被中跑移动，他们的
完成步骤保存(log/host-switch.txt).
付出了多少代价？问题文本是错配：我们的第一个版本写了
它自己的任务文件围绕每个问题，而27B计划从它比
从作者确切的 LiveCode Bench 文本(arc196 c's plan:0 of 2对2)中得出
第2节。 四个Memdoor的改变让一个工作流程问他们的操纵要求什么：一个任务
解答模型在未写入文本时的推理，top p/top k on a
模式行，标记断接在封顶处的回复，以及一个持续通话
它自己的四小时钟。
其所失处。 两次，同样的两个漏洞在作者的循环：
- Pass 5, abc399 e (已隐藏44个中的32个)：第1轮程序是正确的；管理者发明了一个反例，预想答案错误，团队重制，新程序通过样本，没有覆盖案件。
- 第4道，arc196 c和arc196 d：一个通过每个隐藏测试的程序被后一轮所覆写，因为管理者没有说完成；两者在循环结束前都得到了正确的程序回回(arc196 d在回合8时，arc196 c通过最后呼叫),3.44分和4.24分两个最昂贵的跑道。
两者都可以在不改变方法的情况下被修复(在小输入上检查管理器的反比对野蛮力量的反比；保留通过样本的最后程序). 这些数字也没有。
卷起-fsL https://memmdoor.ai/install.sh-QQ-bash
门连接开路特#或anthropic,openai,gemini,chatgpt
git Clone -- -- 深度1 https://github.com/guregodevo/memdoor
mkdir -p ~/.memdoor/工作流程
cp-r memdoor/examples/workflows/team- solve~/.memdoor/workflows/# 库：任何项目都能看到它。
Mkdir 我的问题我的问题
cp-r./memdoor/examples/workflows/team-solve/sample/ *. #任务.md + tests/1.in. 5.out.
memdoor工作流程运行团队- 解析 -- 等待 Stderr 上的进展，每个样本通过时退出 0
工作流量在门上图伊绘制同样的跑道现场。 为了你自己的问题
替换任务.md，并将配对测试/N.in/测试/N.out文件放在旁边。
程序是溶液.py，从stdin读取，与样品比较
d. 它需要Python 3和击打。 要用一个回转来保存，复制
输入工程的.memdoor/workflows/。 工程副本取胜。
台阶上没有模型无论什么/模型被钉在答案，一个本地的
包括(为 Janis、 Ollama 或 llama- server 连接地铁)。
解决测试检讨修复校验
{\fn黑体\fs22\bord1\shad0\3aHBE\4aH00\fscx67\fscy66\2cHFFFFFF\3cH808080}你觉得呢？
每个 agent 提示称"新鲜上下文，读取文件，不要依赖聊天". 纸上记下了分类纪律的收益有一个修补圆形，没有人类大门。 最后一步是整个判决：
类型：命令
要求：
- 表型：修理
命令( X):
检查=.memdoor/工作流程/团队-解决方案/检查-样本.sh
[ -f "$check" ] || check="$HOME/.memdoor/workflows/team-solve/check-samples.sh"
shash "$check" > 最终测试-输出.log 2>&% 1
结果=美元？
猫最后测试输出.log
退出“结果”
每个步骤都是一个YAML文件，以步骤/，格式
马里奥，引擎在下面。
需要：是DAG。 改变一个角色意味着改变它的及时性。
样本：将字符串的子弦数到{a,b,c}，每个字母的计数相等，可达20万个字符。 通过 OpenRouter 在默认的梯子上运行：
- 8个步骤中的8个，5个样本中的5个。 解析器取取了思想家A的前缀状态法，O(N)用(a-b,a-c)对的字典。 300个随机线上的野蛮力量事后发现没有不匹配，它运行在0.04秒以N=20万。 经理发现没有修理
- 一个想法家的提供者放弃了溪流的中答。 编解码器已经写
最大回扣：0，所以跑道在那里死了。 agent步骤现在携带了最大值 retries:1，运行恢复为 --partition，它保留了该程序
策划者和其他思想家的作品。
- 构思器会提示编解码器写出命名了样本的方法(A：流取前缀状态计数，B：排序前缀状态)，这将引导其他任何问题的错误方式。 他们现在要求A提供最直接的可证明的算法，B提供来自不同技术家族的算法(2026-10-28).
- 第一次尝试以"没有agent命名的编码器"失败了 0 s 中的每一个步骤：一次运行只在其工作空间中查看了它的agent. 这在同一天的网关上被固定(v1.692.0).
本文由 AI宝库自动抓取并翻译，版权归原作者所有；如需查看原文请点下方链接。
A multi-agent harness for programming problems, written as a Memdoor workflow. Five roles (planner, two ideators, solver, manager) and a repair worker each start from a fresh context and talk only through files on disk. A shell script that runs the samples decides success, not a model. It is the method of GVS5H (Lee, 2026: five Qwen3.8-27B models match Fable 5 on LiveCodeBench Hard).
Rebuilt with the authors' exact prompts on Qwen3.8-27B, their loop scored a mean of 9.8 of 10 over five passes on the first ten LiveCodeBench Hard problems, against 9.6 for their own harness and 8.0 for Fable 5 alone (below, every run published).
The coder wrote these files itself from a description of the method (2026-10-25). Nobody hand-wrote them.
GVS5H's own harness, rebuilt as a Memdoor workflow on the same model: Qwen3.8-27B, a 128K reply cap, the authors' prompts and loop. The first ten problems of their LiveCodeBench Hard list, five passes, every program graded on every public and hidden test with their corrected grader.
The authors' columns are their repository's regraded result files
(q38_multiagent_pN, fable5_single_pN), the numbers in their paper.
bench/results/parity-5pass/ holds all 50
runs: every request and reply, the program, the grader's full output, each
call's cost and the host that served it, and every attempt that did not count.
49 of 50 solved; the 50 runs cost $35.79 (15.3M output tokens), $38.77 with
the 16 attempts that were cut by a clock, stopped for a fix or paused.
Note: ten problems, five passes each, not the authors' 100. The contests
date from 29 March to 6 April 2025, and the model may have seen them in
training: contamination cannot be ruled out. Fable 5's column is a single call per
problem from the authors' files; it was not run in this harness. The loop
sees only the public samples; the score is the hidden tests. A run took a
median of 40 minutes of model time (the longest 4 hours) and $0.39. All on
OpenRouter, not a local machine; Modal does not publish its precision.
Local paths in the run scripts and in four tracebacks a manager was shown
read <scratch> and $HOME; nothing else in the runs is edited.
Same as the authors'. Every message, byte for byte:
lib/test_parity.py
runs their multiagent_solve and our workflow against one scripted model and
compares each request (four cases, all identical; a one-character change makes
them differ). The temperatures (plan 0.3, ideation 0.4, manager and worker
0.2), top_p 0.95 and top_k 20 (what their vLLM applied from the model's own
config), the 128K cap, up to 10 rounds, a cut-off worker summarized, and a
reply with no text answered by its reasoning.
Different. The host. Theirs was their own vLLM in FP8. Ours is
OpenRouter, asked in the order Modal, CoreWeave, Parasail, Wafer until Modal
slowed to 14 tokens/s, then the FP8 hosts only (Wafer, Parasail, CoreWeave):
203 calls were served by Modal, 27 by CoreWeave and 115 by Wafer, every one
of the FP8 order's calls by Wafer. Three runs were moved mid-run, their
finished steps kept (log/host-switch.txt).
What it took. The problem text was the mismatch: our first version wrote
its own task file around each problem, and the 27B planned worse from it than
from the authors' exact LiveCodeBench text (arc196_c's plan: 0 of 2 against 2
of 2). Four Memdoor changes let a workflow ask what their harness asks: a task
answers with the model's reasoning when it wrote no text, top_p/top_k on a
model line, mark_cutoff for a reply cut at the cap, and a call that runs on
its own four-hour clock.
Where it lost. Twice, the same two gaps in the authors' loop:
- Pass 5, abc399_e (32 of 44 hidden): round 1's program was right; the manager invented a counterexample with a wrong expected answer, the team rewrote it, and the new program passed the samples, which do not cover the case.
- Pass 4, arc196_c and arc196_d: a program passing every hidden test was overwritten by a later round because the manager did not say done; both got a correct program back before the loop's end (arc196_d at round 8, arc196_c through the final call), at $3.44 and $4.24, the two most expensive runs.
Both are fixable without changing the method (check a manager's counterexample against a brute force on small inputs; keep the last program that passed the samples). Neither is in these numbers.
curl -fsSL https://memdoor.ai/install.sh | bash
memdoor connect openrouter # or anthropic, openai, gemini, chatgpt
git clone --depth 1 https://github.com/guregodevo/memdoor
mkdir -p ~/.memdoor/workflows
cp -r memdoor/examples/workflows/team-solve ~/.memdoor/workflows/ # the library: any project sees it
mkdir my-problem && cd my-problem
cp -r ../memdoor/examples/workflows/team-solve/sample/* . # task.md + tests/1.in … 5.out
memdoor workflow run team-solve --wait # progress on stderr, exit 0 when every sample passes
/workflow in memdoor tui draws the same run live. For your own problem,
replace task.md and put paired tests/N.in / tests/N.out files beside it.
The program is solution.py, read from stdin, compared to the samples with
diff. It needs Python 3 and bash. To keep it with one repo instead, copy
the folder into that project's .memdoor/workflows/. The project's copy wins.
The steps name no model. Whatever /model is pinned to answers, a local one
included (memdoor connect local for janis, Ollama or llama-server).
plan ──┬── ideate-a ──┬── solve ── test ── review ── repair ── verify
└── ideate-b ──┘
Every agent prompt says "fresh context, read the files, do not rely on chat". The paper credits that ledger discipline for the gain. There is one repair round and no human gate. The last step is the whole verdict:
type: command
requires:
- table_pattern: repair
command: |
check=.memdoor/workflows/team-solve/check-samples.sh
[ -f "$check" ] || check="$HOME/.memdoor/workflows/team-solve/check-samples.sh"
bash "$check" > final-test-output.log 2>&1
result=$?
cat final-test-output.log
exit "$result"
Each step is one YAML file in steps/, the format of
mario, the engine underneath.
requires: is the DAG. Changing a role means changing its prompt.
The sample: count the substrings of a string over {a, b, c} with equal counts of each letter, up to 200,000 characters. Run on the default ladder through OpenRouter:
- 8 of 8 steps, 5 of 5 samples. The solver took ideator A's prefix-state method, O(N) with a dictionary of (a−b, a−c) pairs. A brute force on 300 random strings found no mismatch afterwards, and it runs in 0.04 s at N = 200,000. The manager found nothing to repair.
- One ideator's provider dropped the stream mid-answer. The coder had written
max_retries: 0, so the run died there. The agent steps now carry max_retries: 1, and the run was resumed with --partition, which kept the
planner's and the other ideator's work.
- The ideator prompts the coder wrote named the sample's methods (A: a streaming prefix-state count, B: sorting prefix states), which would steer any other problem the wrong way. They now ask A for the most direct provable algorithm and B for one from a different family of technique (2026-10-28).
- The first attempts failed every step in 0 s with "no agent named coder": a run looked its agent up only in its own workspace. That was fixed in the gateway the same day (v1.692.0).
Auto-fetched and translated by AI Gem Box. All rights belong to the original author.