auto-deep-researcher-24x7 深度解析：当 AI 替你在深夜跑实验，科研终于变成「睡觉也能进步」的游戏

背景：深度学习研究的「时间税」问题

做深度学习研究的人都清楚一个残酷的事实：真正有价值的工作是"想"，但大部分时间都花在了"等"上。

写代码、调超参、跑实验、等结果、分析日志、调整方向、再跑实验——这个循环往复的「实验-ops」周期占据了研究人员 70% 以上的时间。一个标准的 ImageNet 训练任务，少则几小时，多则几天。研究员们不是在跑实验，就是在等实验跑完。

更糟糕的是，这个循环是串行的——你必须等前一个实验完成，才能根据结果决定下一步。深夜跑实验是常态，周末守 GPU 是基操，凌晨三点起来看 loss 曲线这种事，在 ML 圈子里根本算不上什么值得抱怨的事。

这不是个别现象。这是整个深度学习研究范式的结构性成本。

auto-deep-researcher-24x7（下文简称 Deep Researcher）做了一件看似简单、实则颠覆的事情：把这个「人-实验」串行循环，彻底自动化了。 你给 AI 一个目标，它自己设计方案、自己写代码、自己跑实验、自己分析结果、自己决定下一步——7×24 小时不间断，在你睡觉的时候也在工作。

这个项目在 GitHub 创建不到 24 小时就登上了热门榜，今天我们来深度拆解它的架构、设计哲学，以及它对 AI 科研工作流的根本性改变。

核心概念：什么是 Deep Researcher Agent

Deep Researcher 是一个自主深度学习实验 Agent，核心理念是：

一个 AI agent，在人类定义好目标和约束后，自主运行 7×24 小时的深度学习实验循环——包括写代码、调参、训练、监控、分析、决策。人类只在必要时介入方向调整。

从功能上看，它是一个由 AI 驱动的实验自动化引擎；从架构上看，它是一个 Leader-Worker 多 Agent 协作系统；从成本上看，它是目前已知的最低成本的持续实验方案——24 小时循环只需要约 $0.08。

核心能力可以拆解为四个步骤的无限循环：

THINK → EXECUTE → MONITOR → REFLECT → (repeat)

• THINK：分析当前实验结果，理解与目标的差距，制定下一个实验方案
• EXECUTE：修改代码、配置参数、启动训练
• MONITOR：以零成本监控训练过程（无 LLM 调用）
• REFLECT：训练完成后解析结果，与基线对比，决定是否继续或调整方向

架构解析：如何用 $0.08/天跑一个永不眠的 AI 研究员

整体架构

Deep Researcher 的架构分为四层：

┌──────────────────────────────────────────────────┐
│              Deep Researcher Agent                │
│                                                    │
│  ┌──────────────────────────────────────────────┐  │
│  │       Core Loop (core/loop.py)              │  │
│  │   THINK → EXECUTE → MONITOR → REFLECT        │  │
│  └──────────────────────────────────────────────┘  │
│                                                    │
│  ┌──────────┐  ┌──────────┐  ┌──────────────────┐ │
│  │  Leader  │  │  Workers │  │   Memory Manager │ │
│  │  Agent   │  │  Pool    │  │   (Two Tiers)    │ │
│  └──────────┘  └──────────┘  └──────────────────┘ │
│                                                    │
│  ┌──────────┐  ┌──────────┐  ┌──────────────────┐ │
│  │ Experiment│  │   GPU    │  │   Tool Registry  │ │
│  │  Monitor  │  │ Utilities│  │ (Per-Agent Minimal)│ │
│  └──────────┘  └──────────┘  └──────────────────┘ │
│                                                    │
│  ┌──────── Skills Layer ──────────────────────┐  │
│  │ daily-papers | paper-analyze | conf-search  │  │
│  │ report | obsidian-sync                      │  │
│  └─────────────────────────────────────────────┘  │
└──────────────────────────────────────────────────┘

Leader-Worker 模式：上下文效率的极致优化

Deep Researcher 采用了独特的 Leader-Worker 双层 Agent 架构：

Leader Agent 在整个实验循环中保持上下文持久化——它能看到全局：已尝试的方向、失败的原因、当前基线性能、目标差距。这使得它能够做连贯的多步推理，而不需要在每一步都重新加载上下文。

Worker Agents 是无状态的——每次调度都是独立的，不携带历史上下文。为什么这样设计？因为：

1. 每个 Worker 的任务相对简单（改一行代码、跑一次实验），不需要历史信息
2. Worker 之间切换零成本——上一个 Worker 的上下文无需清理
3. Leader 负责累积记忆和决策，Worker 负责执行，分工清晰

# core/agents.py 中的 Agent 调度核心逻辑（简化）
class AgentDispatcher:
    """
    Leader-Worker 架构的核心调度器
    Leader 保持长上下文，Worker 每次独立调度
    """
    
    def dispatch(self, task_type: str, context: dict) -> dict:
        leader = self.get_leader_agent()
        worker = self.get_worker_for_task(task_type)
        
        if task_type == "plan":
            # Leader 做规划：需要全局上下文
            return leader.invoke(context)
        else:
            # Worker 做执行：无需历史上下文
            return worker.invoke(context)  # 每次都是新鲜上下文

这种架构在 token 效率上有巨大优势——如果把历史上下文累积在 Worker 里，每次调用的 token 成本会线性增长。Leader-Worker 解耦后，每个 Worker 调用的 token 量被固定在最精简的范围内。

零成本监控：GPU 训练的 $0.08/天秘密

这是 Deep Researcher 最精妙的设计决策之一。

传统的 AI Agent 在执行任务时，每个「检查状态」的动作都需要一次 LLM API 调用。但深度学习训练有 90% 以上的时间都在等待 GPU 计算——这个阶段状态非常稳定（训练中/训练完/崩溃），根本不需要 LLM 来判断。

Deep Researcher 的 core/monitor.py 实现了真正的零成本监控：

# core/monitor.py - 零成本训练监控
class ExperimentMonitor:
    """
    训练监控三件套，全程零 LLM 调用
    """
    
    def check_process_alive(self, pid: int) -> bool:
        """进程是否存活 - os.kill(pid, 0)，零成本"""
        try:
            os.kill(pid, 0)
            return True
        except ProcessLookupError:
            return False
    
    def get_gpu_utilization(self) -> dict:
        """GPU 利用率 - nvidia-smi，零成本"""
        result = subprocess.run(
            ['nvidia-smi', '--query-gpu=utilization.gpu,memory.used', 
             '--format=csv,noheader,nounits'],
            capture_output=True, text=True
        )
        return self._parse_smi_output(result.stdout)
    
    def read_last_logs(self, log_path: str, lines: int = 20) -> list:
        """最新日志行 - 文件 tail，零成本"""
        with open(log_path, 'r') as f:
            return tail(f, lines)  # 最后 N 行，无 LLM 调用

整个训练过程中，Agent 只在训练完成或崩溃时才醒来做决策。中间只做进程检查、GPU 监控、日志读取——全部是系统级调用，没有任何 LLM token 消耗。

这就是为什么 24 小时实验循环只需要 ~$0.08 的原因：大部分时间 Agent 都在睡觉，只有结果出来时才醒一次。

双层记忆系统：人类意志与机器经验的分工

Deep Researcher 的 core/memory.py 实现了一个双层记忆架构，这是整个系统可控性的关键：

# core/memory.py - 双层记忆架构
class MemoryManager:
    """
    Tier 1 (Brief): 人类编写的冻结层 - 项目的"宪法"
    Tier 2 (Log): Agent 编写的滚动层 - 实验记录与决策
    """
    
    TIER1_MAX_CHARS = 1200   # 人类意志，简洁至上
    TIER2_LOG_MAX = 2000    # 机器经验，严格压缩
    
    def read_tier1(self) -> str:
        """
        读取 PROJECT_BRIEF.md - 目标、约束、搜索空间
        这部分由人类编写，Agent 只能读不能改
        """
        return self._load_file("PROJECT_BRIEF.md")
    
    def read_tier2(self) -> str:
        """
        读取 MEMORY_LOG.md - 里程碑、失败教训、决策原因
        Agent 编写，滚动压缩，保留最有价值的经验
        """
        return self._load_and_compact("MEMORY_LOG.md")
    
    def _compact_tier2(self, content: str) -> str:
        """
        压缩规则：
        - 里程碑：超过 1200 字符时丢弃最老的
        - 决策记录：只保留最近 15 条
        - 总日志：硬上限 2000 字符，超出则激进压缩
        """
        # 省略压缩实现，核心是分层淘汰策略
        pass

Tier 1 是人类写的 PROJECT_BRIEF.md，包含：

• 研究目标（具体指标，如"ResNet-50 在 CIFAR-100 上达到 80%+ 准确率"）
• 约束条件（使用哪块 GPU、单次最多跑多少 epoch）
• 搜索策略（如果准确率 < 75% 尝试 A 方向，75-80% 尝试 B 方向）

Tier 2 是 Agent 写的 MEMORY_LOG.md，包含：

• 已尝试的方向及结果
• 失败原因分析
• 关键决策及依据

这种设计确保了：人类的意志（目标）是稳定的，机器的经验（记录）是滚动的。人类可以随时通过修改 Tier 1 来改变方向，但不会因为 AI 的试错历史而迷失目标。

工具注册表的 Token 优化：减少 220K tokens/天的浪费

这是另一个被低估的优化。当 AI Agent 需要使用工具时，每个工具定义大约占用 200 tokens（描述、参数schema等）。如果一个 Agent 配备了 15 个工具，每次 API 调用就要额外支付 3,000 tokens 的工具定义开销。

Deep Researcher 的 core/tools.py 采用了按需精简工具集策略：

# core/tools.py - Per-Agent 精简工具集
class ToolRegistry:
    """
    每个 Agent 变体只配备完成当前任务所需的最小工具集
    """
    
    TOOL_SETS = {
        "idea": ["read_file", "write_file", "glob"],        # 思考型：只需读文件
        "code": ["read_file", "write_file", "bash"],         # 编码型：需要读写+执行
        "monitor": ["bash"],                                  # 监控型：只需执行命令
        "writing": ["read_file", "write_file", "search"],    # 写作型：需要搜索
    }
    
    def get_tools_for_agent(self, agent_type: str) -> list:
        """
        根据 Agent 类型返回精简工具集
        4 工具 vs 15 工具 = 800 tokens vs 3000 tokens/次
        100 次/天 = 节省 220,000 tokens/天
        """
        return self.TOOL_SETS.get(agent_type, self.TOOL_SETS["code"])

一个典型的 100 次/天的实验循环，通过工具集精简，可以节省约 220,000 tokens 的工具定义开销——在 Claude Sonnet 的价格下，这相当于每天节省约 $1.1。

实战：从零启动一个 24/7 实验

Step 1: 创建项目

Deep Researcher 的最小化项目结构只有两个文件：

mkdir ~/cifar100-resnet-experiment
cd ~/cifar100-resnet-experiment

Step 2: 编写 PROJECT_BRIEF.md（最重要的一步）

# Goal
Train a ResNet-50 on CIFAR-100 to reach 80%+ accuracy.

# Codebase
Create the training code from scratch in PyTorch.
- Data: auto-download via torchvision
- Checkpoints: ./checkpoints/
- Logs: ./logs/

# What to Try
- Start with a basic ResNet-50 baseline.
- If accuracy < 75%: improve optimization and schedule.
- If accuracy is 75-80%: try augmentation.
- If accuracy > 80%: stop and report.

# Constraints
- Use GPU 0 only
- Max 100 epochs per run
- Save checkpoints every 10 epochs

# Current Status
No experiments yet.

这就是你和 AI 研究员之间的「劳动合同」——目标清晰、约束明确、决策树完备。

Step 3: 启动

cd auto-deep-researcher-24x7
/export ANTHROPIC_API_KEY="sk-ant-xxxxx"
/auto-experiment --project ~/cifar100-resnet-experiment --gpu 0

接下来发生的事情

1. 第一次 THINK：Agent 读取 PROJECT_BRIEF.md 和 MEMORY_LOG.md，理解目标是 CIFAR-100 上 ResNet-50 达到 80% 准确率，当前无任何实验记录。制定第一个实验计划：基线配置。
2. 第一次 EXECUTE：Agent 创建 PyTorch 训练代码（ResNet-50 baseline），设置标准 SGD + cosine schedule，写入 train.py。
3. 第一次 MONITOR：Agent 启动训练，随后进入零成本监控模式。训练期间 Agent 不消耗任何 LLM tokens，只检查进程是否存活、GPU 利用率、loss 曲线是否崩溃。
4. 第一次 REFLECT：训练完成（假设达到 73%），Agent 解析结果日志，与目标 80% 差距较大。分析原因：baseline 配置过于简单，需要更强的数据增强。更新 MEMORY_LOG.md，决定第二次实验加入 CutMix 和 AutoAugment。
5. 第二次循环：THINK → EXECUTE（加入增强）→ MONITOR → REFLECT（达到 77%）→ 继续调整...
6. 持续循环：Agent 不断尝试、监控、分析、决策，直到达到目标或人类干预。

整个过程中，人类只在 PROJECT_BRIEF.md 和 HUMAN_DIRECTIVE.md 中定义方向，其余全部由 Agent 自动完成。

与传统方案的对比

性能优化：如何让 AI 实验员跑得更便宜

1. Claude Code 集成：8 个 Slash Commands

安装脚本提供了 8 个深度集成的 slash commands：

python install.py
# ✓ /auto-experiment     # 启动自动实验
# ✓ /experiment-status   # 查看当前状态
# ✓ /gpu-monitor         # GPU 监控
# ✓ /daily-papers        # 每日论文
# ✓ /paper-analyze       # 论文分析
# ✓ /conf-search         # 学术会议搜索
# ✓ /progress-report     # 进度报告
# ✓ /obsidian-sync       # Obsidian 同步

这些 skills 被打包为 Claude Code 可识别的工具，使得研究者可以在同一个 CLI 环境中既做日常开发，又管理 AI 实验。

2. Obsidian 集成：项目进度的可视化仪表盘

可选的 Obsidian 集成可以将实验进度自动同步到笔记库：

# Deep Learning Experiment Dashboard
## Project: CIFAR-100 ResNet-50

### 当前基线
- Run #3: 77.3% (2026-04-08 14:30)
- Best: 77.3%
- Goal: 80%

### 历史轨迹
- Run #1: 71.2% (baseline, SGD + cosine)
- Run #2: 74.8% (+ CutMix)
- Run #3: 77.3% (+ CutMix + AutoAugment)

### 下一步计划
- 如果 80% > acc >= 77%: 尝试 label smoothing
- 如果 acc >= 80%: 生成报告，任务完成

这样即使你不在电脑前，打开 Obsidian 也能实时看到 AI 在做什么、做到了什么程度。

3. 多 GPU 支持与 GPU 检测

# gpu/detect.py - 自动 GPU 检测与选择
def detect_available_gpus() -> list:
    """自动检测可用 GPU，默认保留最后一块"""
    result = subprocess.run(['nvidia-smi', '--query-gpu=index,name,memory.free', 
                           '--format=csv,noheader'], capture_output=True)
    gpus = parse_gpu_list(result.stdout)
    # 排除最后一块（通常是系统保留）
    available = [g for g in gpus if g['index'] != len(gpus) - 1]
    return available

4. Cloud GPU 保持活跃

# gpu/keeper.py - 云端实例保活
class GPUKeeper:
    """
    当使用云端 GPU 时，防止实例因空闲被回收
    通过定期最小化 GPU 活动保持实例活跃
    """
    pass

适用场景与局限性

适用场景

1. 超参数调优循环：固定的模型架构 + 大量的超参搜索
2. 数据增强实验：同一个模型 + 不同的增强策略对比
3. 消融研究：确定某个组件或技巧的贡献
4. 持续改进：模型上线后持续微调优化
5. 研究想法验证：快速验证一个研究假设是否值得深挖

局限性

1. 需要明确的目标指标：如果无法量化目标（如"让模型更有创意"），Agent 无法判断进展
2. 需要足够的领域知识：PROJECT_BRIEF.md 的 What to Try 决策树需要人类提供领域经验
3. 计算资源瓶颈：完全受限于 GPU 数量，没有 GPU 就没有加速
4. 创新性有限：Agent 擅长在给定搜索空间内优化，但难以产生全新的研究 idea
5. 调试困难：当实验方向走偏时，Agent 可能陷入局部最优而不自知

总结：科研的「第二阶段」

Deep Researcher 代表的不仅仅是一个实验自动化工具，它标志着 AI 科研工作流的范式转变。

在第一阶段，AI 是工具——研究员用 AI 来训练模型、分析数据。
在第二阶段，AI 是同事——研究员定义问题，AI 负责实验循环中的所有执行工作。

Deep Researcher 的架构设计有很多值得学习的工程智慧：

• Leader-Worker 解耦：持久上下文与无状态执行的分离，是多 Agent 系统token效率的关键
• 零成本监控：理解「什么阶段不需要 LLM」，是降低 AI 系统成本的核心洞察
• 双层记忆架构：人类意志与机器经验的分离，确保了系统的可控性与学习能力并存
• 工具集精简：从 15 个工具压缩到 4 个工具，是 token 优化的工程实践

最后，项目文档中的 AI_GUIDE.md 是一个非常有意思的创新——它专门为 AI 助手（Claude、ChatGPT、Codex）编写了配置指南，这意味着当你复制粘贴这个项目给任何一个 AI 助手时，它都能理解如何帮你部署和启动。这本身就是一种 Meta 的自我部署能力。

对于每一个还在手动跑实验、调参数、等结果的 ML 研究员来说，Deep Researcher 值得一试。你只需要写清楚目标，剩下的，交给 AI。

参考链接：

• GitHub: https://github.com/Xiangyue-Zhang/auto-deep-researcher-24x7
• Technical Report: https://arxiv.org/abs/2604.05854
• Architecture Doc: docs/architecture.md