🎯核心问题：AI能做完整的研究循环吗

2025年以来，"AI Scientist"概念火爆——让LLM自动生成研究想法、跑实验、写论文。但大多数实现都有一个致命问题：它们把LLM当作裁判。LLM提出想法，LLM评价结果，LLM决定是否继续。这是一个没有外部ground truth的闭环——系统可以自我感觉良好，但实际上什么都没学到。

ScholarLoop的回答截然不同。它的核心设计原则是：

LLM只做开放式推理。一切可验证的——搜索空间裁剪、去重、校准、数字溯源、晋升门槛——都是确定性的、经过单元测试的代码。指标是唯一的优化目标，没有LLM-as-judge。

这意味着ScholarLoop不是一个"让LLM自己跟自己玩"的系统。它更像是一个确定性的实验harness，LLM在其中扮演PhD学生的角色——提出假设、设计实验——但所有可机器验证的判断都由不可绕过的代码执行。就像真实的PhD训练一样：你的导师不会因为你说"我的方法很好"就给你毕业，你需要拿出可复现的数字。

ScholarLoop模拟的完整PhD工作流是：

# 一个PhD的实际工作循环 read papers → find a gap → run real experiments → reflect → write & self-review

这不是一个比喻。ScholarLoop的8个代理分别对应这个循环中的每一步，每一步都有明确的输入/输出schema、验证-重试机制，以及一个共享的审计追踪。

🏗️架构全景：8个代理，一个harness

ScholarLoop的架构可以用一句话概括：8个代理跑在同一个确定性harness上。每个代理都是一个LLM调用，有类型化的JSON-schema输入/输出、validate→retry机制，以及一个共享的审计追踪（AgentTrace）。没有任何代理可以绕过harness直接修改状态。

8个代理的角色分工

📋 代理流水线
阶段 代理 职责
🎯 定向 Director 读取ledger+文献趋势，设定下一轮研究方向、主题和预算
🔭 文献 Lit Scout 从arXiv+OpenAlex拉真实论文，按引用量排序，提取可测试的技术
💡 推理 Reasoner 结合约束+文献+过往教训，提出下一个实验方案
🗳️ 辩论 Debate Panel 三个角色（Innovator/Pragmatist/Contrarian）投票：值得花GPU吗？
🪜 漏斗 Funnel smoke → verify → full，廉价筛选杀死大部分想法
⚙️ 执行 Runner 跑真实的PyTorch实验，由冻结的metric评分
🪞 反思 Reflector 把结果提炼为一条教训，存入衰减技能库
🚦 导航 Advisor PROCEED · REFINE · PIVOT——引导循环方向
✍️ 写作 Writer + Reviewer 确认的发现→数字溯源的论文草稿→同行评审

关键设计：harness即产品

注意一个微妙但极其重要的设计决策：检索是确定性工具，提取是代理。Lit Scout的文献检索部分（ArxivClient、OpenAlexClient）是纯HTTP客户端，没有LLM参与——它们只是拉取论文、去重、按引用量排序。只有从论文中提取可测试技术的那一步才用LLM。这意味着文献检索是可单元测试的（用canned payload），不会因为LLM的随机性而变得不可靠。

同样，Debate Panel的三个critic不是"让LLM判断实验好不好"——metric决定好坏，debate只是一个廉价的前置过滤器，决定一个proposal是否值得花GPU去跑。这是一个关键的安全设计：debate永远不会变成一个被hack的优化目标。

🔄循环工程：杠杆不在prompt里

ScholarLoop最深刻的洞察是：杠杆不在任何单次agent调用中——而在围绕它们的外循环中。它如何扇出、在什么上花算力、记住什么、何时停止。ScholarLoop把这个外循环当作产品来工程化。

一个受治理的轮次（governed round）长这样：

Director topic ─▶ Reasoner ✦ proposes N distinct ideas │ fed: literature priors · relevance-ranked skills · each agent's track record ▼ ╭──────────── parallel smoke screen · max_workers ────────────╮ │ idea₁ 4.2 idea₂ 7.3 ✗ idea₃ 4.4 … ideaₙ │ cheap · concurrent ╰──────────────────────────────┬──────────────────────────────╯ survivors only │ (the clearly-worse die here) ▼ verify · 3 seeds + significance ─▶ full · 5 seeds compute spent on the few │ ▼ calibrate every agent's claim · distill one lesson → skills │ ▼ governor ▸ budget? rounds? converged? ──▶ stop ◇ or next round ↺

四根支柱

每一根支柱都是几行确定性代码，且都被测试钉住，不会悄悄腐烂：

🏗️ 四根循环工程支柱
支柱 带来什么 代码位置
🌐 并行种群漏斗 宽探索窄付费——提出N个想法，同时smoke筛选全部，只爬升幸存者 Orchestrator.population_step(k, max_workers)
🛑 自停治理器 无人值守运行——在$预算、轮次上限、或loop-until-dry收敛时停 Governor(max_cost, max_rounds, dry_patience)
🎯 通用预测-验证 循环学会信任自己的哪些代理——Reasoner的delta预测和Debate的go/no-go都被对ground truth打分 CalibrationLog → next prompt
🧭 相关性排序的上下文 不断增长的技能库保持有用——浮现与当前想法相关的教训，而非最重的 SkillLibrary.render(query=…)

多保真度漏斗：smoke → verify → full

这是ScholarLoop在算力分配上最精妙的设计。每个想法都要爬一个三级阶梯：

smoke（1个seed，单次快速跑）→ verify（3个seed + 统计显著性）→ full（5个seed，最终确认）

每一级都有一个晋升门槛（promotion gate）：必须击败当前frontier（或baseline）才能爬到下一级。smoke用的是宽松门槛（high recall，只杀明显差的），verify用的是严格显著性门槛（high precision，需要置信区间下界也过线）。这是标准的多保真度形状：廉价阶段保留候选，昂贵阶段确认它们。

净效果：一个你可以真正放手让它跑的循环——它扇出探索，并行廉价筛选，把算力集中在幸存者上，自我校准，并且知道何时该停。

🛡️防reward hacking：冻结评分与编辑白名单

这是ScholarLoop区别于所有"AI Scientist"系统的核心特征。一个自主研究循环最大的风险不是"它不够聪明"，而是"它学会了作弊"。如果LLM能修改train.py来伪造metric，或者能看到验证集，或者能在论文里编造数字——那整个系统就是一个昂贵的幻觉。

ScholarLoop的三层防护：

1. 两阶段冻结评分

train.py（被LLM编辑的实验代码）无法伪造metric，也看不到验证集。评分由一个独立的prepare模块完成——它在train.py运行之前就冻结了数据集分割和评分逻辑。train.py只能输出一个SCHOLARLOOP_RESULT行，由runner解析。这个分离是物理的：train.py跑在子进程中，prepare模块的输出是只读的。

项目甚至内置了一个cheater引擎——一个故意尝试reward-hack的train.py，用来证明防护有效。它尝试在train.py里直接写入一个好的metric值，但冻结的prepare模块会忽略任何来自train.py的"自报"分数。

2. 编辑白名单

Reasoner代理可以编辑train.py来尝试不同的架构和超参数，但它只能修改白名单中的参数。它不能修改评分逻辑、数据加载、验证集分割。编辑通过一个allowlist机制执行——任何不在白名单中的编辑都会被拒绝，并记录为"不可接受的提案"。

3. VerifiedRegistry数字溯源

Writer代理撰写论文时，每一个数字都必须追溯到一条已记录的测量。VerifiedRegistry是一个确定性审计层：它记录每个实验的每个config值、每个metric分数、每次测量的原始值。Writer生成的论文中任何不在registry中的数字都会被标记为"未溯源"。这个审计是确定性代码，不是代理——Writer提议，registry验证。

# paper.py 中的数字溯源逻辑 def grounded_registry(entries, registry_dir, extra=None): reg = VerifiedRegistry(path=":grounded:", exp_id="paper") for e in entries: if e.verdict != "kept": continue # 每个config值 → registry for k, v in (e.config or {}).items(): if isinstance(v, (int, float)): reg.capture(f"{e.id}.cfg.{k}", float(v)) # 每个分数 → registry s = e.primary_score() if s is not None: reg.capture(f"{e.id}.score", s) # 每条原始测量 → registry p = Path(registry_dir) / f"{e.registry_id or e.id}.json" if p.exists(): for k, m in VerifiedRegistry.load(p).measurements.items(): reg.capture(f"{e.id}.{k}", m) return reg

这意味着ScholarLoop生成的论文中不可能出现编造的数字。如果Writer写了"准确率达到95.3%"但registry里没有95.3这个值，审计就会标记它。在真实捕获的两个Opus运行中，论文的数字溯源检查全部通过——✅ every number traces to a recorded measurement。

🧠自我校准：让循环学会信任谁

ScholarLoop的另一个核心创新是通用预测-验证（Universal Predict-then-Verify）。这不是只对Reasoner做的——任何生成可验证声明的步骤都可以被打分。

两种声明类型：

delta预测——Reasoner说"这个改动会把val error降低1.5%"。实验跑完后，系统比较预测的delta和实际测量的delta。误差是绝对差距；"命中"是方向对了（降低还是升高）。

二元判断——Debate Panel投票"run"（这个想法值得跑）。实验跑完后，系统检查它是否产生了一个kept结果（击败了baseline）。

这些打分累积在一个CalibrationLog中，渲染成下一轮Reasoner的prompt块：

# CalibrationLog.render() 的输出示例 - reasoner: predicted the right direction 67% of 6 times; mean magnitude error 2.3. - debate: 40% of 5 go/no-go calls were correct.

这意味着循环知道自己的哪些代理更可信。如果Debate Panel只有40%的"run"投票产生了baseline-beating结果，Reasoner在下一轮就会对Debate的"run"投票持更多怀疑。这是一个闭环的校验循环——不是LLM评价LLM，而是ground truth评价LLM的判断，然后把结果反馈回去。

📚技能库：会衰减的PhD直觉

一个研究循环如果只有短期记忆，它就会反复犯同样的错误。ScholarLoop的SkillLibrary是一个确定性的教训存储——Reflector写入，Reasoner读取。

每个教训（Skill）有四个字段：

category（类别）——这条教训关于什么（如"learning_rate"或"overfitting"）。severity（严重度，0到1）——这条教训应该多重地影响未来决策。mitigation（缓解措施）——一条写给下一个Reasoner prompt的可操作建议。ts（时间戳）——产生这条教训的实验运行时间。

关键设计：时间衰减。每条教训的影响力每30天减半。这意味着最近的教训比陈旧的教训更有权重——但永远不会被删除。一个三个月前的教训权重是原来的1/8，但如果它仍然相关，它还会被浮现。

更精妙的是相关性排序。技能库不是按权重排序然后取top-K——它按"与当前方向的词汇相关性"来boost。当前方向由topic + guidance + literature priors组成。这意味着如果当前在研究"learning rate schedule"，那么关于"cosine annealing"的教训会被优先浮现，即使它的原始severity不如一条关于"weight decay"的教训高。

# skills.py 中的相关性排序 def active(self, now=None, *, top_k=None, min_weight=0.0, query=None, relevance_boost=2.0): qterms = _terms(query) if query else set() scored = [] for s in self.all(): w = s.weight(now, self.half_life_days) # 时间衰减权重 if w <= min_weight: continue rank = w * (1.0 + relevance_boost * _relevance(s, qterms)) # 相关性boost scored.append((s, w, rank)) scored.sort(key=lambda x: x[2], reverse=True) return [(s, w) for s, w, _ in scored[:top_k]]

去重是按内容哈希——同一个教训（category + mitigation）映射到同一个文件，所以一个被评审拒绝的方向不会每轮都作为新技能重新出现——它原地刷新。技能库是跨campaign持久化的（默认在~/.scholarloop/skills/<domain>/），所以直觉会在不同运行之间积累。

📊真实运行：两个Opus 4.8实战案例

ScholarLoop不只是理论——它已经在真实的Anthropic API上跑过两个完整campaign，使用Claude Opus 4.8。每个campaign都是真实的API调用、真实的PyTorch训练、真实的论文撰写和自我评审。

📊 两个Opus 4.8实战结果
领域 指标 baseline 最佳（确认） 爬升路径 成本 自评审
digits-mlp val error 5.0% 3.82% population → verify → full, governed ≈$0.45 reject 2/10
diabetes-mlp val RMSE 56.5 55.24 population → verify → full, governed ≈$0.77 reject 3/10

这两个campaign都是受治理的种群漏斗——每轮扇出多个想法，并行smoke筛选，只爬升幸存者，循环自行停止（收敛或轮次上限），并对每个代理的预测打分。每个campaign中都有想法击败了baseline，每个数字都能追溯到冻结metric的测量，而系统自己的评审者仍然拒绝了论文——认为改进太微小。它不是错的。

这一点值得强调：ScholarLoop的自我评审是诚实的。在digits-mlp的案例中，论文被reject（2/10分），评审者指出的弱点包括"没有描述数据集"、"没有baseline架构细节"、"多个变量混在一起没有ablation"、"只有两个超参数配置没有统计分析"。这是一个真正有用的同行评审——不是橡皮图章。

campaign_demo.py：一个完整campaign的确定性演示

不需要API key或GPU就能看到完整循环运行。campaign_demo.py用MockLLM脚本化驱动整个代理链，跑在真实torch上，确定性且免费：

=== CAMPAIGN · digits-mlp (real torch) · baseline 5.0% === 🎯 Director scale width/depth and tune the optimizer 🔭 Lit Scout wider/deeper layers (arXiv:1512.03385) · SGD momentum + cosine (arXiv:1608.03983) idea 1 🗳️ run 🪜 smoke 4.67% → verify 4.96% 🚦 proceed idea 2 🗳️ REJECT → skipped, no GPU spent idea 3 🪜 smoke 52.0% discarded 🚦 pivot predicted −1.0, measured +47 → calib_err 48.3

这一个运行展示了系统：

在提出想法前先从文献中找到依据——Lit Scout拉到了ResNet（arXiv:1512.03385）和cosine annealing（arXiv:1608.03983）的真实论文。在Debate Panel否决冗余想法时省下了GPU运行——idea 2被REJECT，没有花任何算力。在smoke阶段廉价杀死坏想法——idea 3的smoke跑出52%错误率，直接丢弃，没有full run。通过predict-then-verify发现自己的预测错误——idea 3预测降低1.0，实际升高47，calibration error 48.3，然后pivot。

💡对AI研究者的启示

1. 确定性代码 > 更好的prompt

ScholarLoop的核心杠杆不在任何agent的prompt里——而在外循环的工程设计中。并行扇出、廉价筛选、算力集中、自我校准、知道何时停——这些都是几行确定性代码，但它们才是让循环"可以放手让它跑"的关键。如果你在试图构建一个自主研究系统，你应该花更多时间工程化外循环，而不是调prompt。

2. Ground truth是唯一的优化目标

不要用LLM-as-judge作为优化目标。LLM可以做开放式推理——提出假设、设计实验、撰写论文——但一切可机器验证的判断都必须由确定性代码执行。metric决定质量，debate只是前置过滤器。这不是哲学立场，这是工程必要性：如果你让LLM当裁判，系统就会学会欺骗裁判。

3. 多保真度漏斗是算力杠杆

smoke → verify → full的三级漏斗是ScholarLoop在成本控制上的核心设计。大部分想法在smoke阶段（单seed，几秒）就被杀死，只有幸存者才进入昂贵的full run（5 seeds）。如果你在做任何形式的自动超参数搜索或架构搜索，这个模式都值得借鉴——它不是新的，但ScholarLoop把它和agent loop紧密集成的方式是新的。

4. 自我校准让循环越来越聪明

通用predict-then-verify意味着循环知道自己的哪些代理更可信。这比简单的"记住失败"更深——它在学习代理的认知偏差。如果Reasoner总是高估自己的改动效果，下一轮的prompt就会包含这个信息。这是一个真正的闭环学习系统，不是"跑更多轮就会更好"的盲目循环。

5. 可测试性是第一公民

ScholarLoop有108个测试，不需要API key或GPU——整个循环跑在确定性的MockLLM上。这意味着每一个循环工程支柱（并行漏斗、治理器、校准、技能库）都被测试钉住，不会悄悄腐烂。如果你在构建agent系统，这是最重要的工程实践：先让它可测试，再让它强大。

⚠️局限与展望

ScholarLoop目前是研究预览（research preview）。完整的PhD工作流骨架已经端到端跑通，防reward-hacking守卫已经就位并经过对抗性评审。但仍有重要局限：

实验沙箱化——目前train.py跑在子进程中，但没有容器隔离。一个足够聪明的LLM理论上可以通过文件系统副作用绕过某些边界。下一步是容器沙箱化残余边界。

领域覆盖——目前只有两个领域（数字分类和糖尿病回归）。但新增一个领域只需要一个YAML profile + 一个engine pair（prepare.py + train.py），零orchestrator改动。这个可扩展性设计是正确的，但需要更多领域来验证。

实验规模——目前的实验是CPU-fast的小规模ML任务。真正的研究需要更大规模的实验（GPU训练、长运行时间、大数据集）。harness的架构支持这一点，但还没有在那种规模上验证过。

LLM依赖——系统的推理质量受限于底层LLM。两个Opus 4.8运行展示了很好的推理质量，但更便宜的模型可能会在Reasoner和Debate环节表现更差。Calibration机制可以检测到这一点，但不能修复它。

📄项目信息

📄 ScholarLoop

仓库：github.com/renee-jia/scholar-loop

许可证：MIT

语言：Python 3.10+

状态：Research Preview

测试：108 tests, no API key or GPU needed

快速开始：

pip install -e ".[dev]" python examples/quickstart.py # 整个循环 <1s，无需GPU/API key python examples/campaign_demo.py # MockLLM驱动的完整campaign pytest -q # 108 tests
一句话总结：ScholarLoop不是"让LLM自己当科学家"——它是"给LLM一个不可绕过的确定性harness，让它在其中扮演PhD学生"。LLM做开放式推理，代码做一切可验证的判断，metric是唯一的优化目标。这是2026年自主研究系统应该有的样子。