Anthropic研究员Nicholas Carlini用16个并行Claude实例 + 2000次会话 + $20000成本，从零写出了能编译Linux 6.9内核的C编译器。这里面的Harness模式，你现在就能复用到自己的项目中。

发生了什么

5月27日，Anthropic Safeguards团队的研究员Nicholas Carlini发布了一篇引爆HN的技术报告。他用一个自制的"无限循环Harness"驱动16个并行Claude实例，在2周内从零编写了一个完整的C编译器——用Rust语言实现，零外部依赖，100,000行代码。

关键数据：
- 16个 Claude实例并行工作，每个跑在独立Docker容器里
- 2000次 Claude Code会话
- 20亿 输入token + 1.4亿 输出token
- $20,000 API成本（远低于人类团队成本）
- 能编译 x86、ARM、RISC-V 三重架构的 Linux 6.9内核
- 能编译 QEMU、FFmpeg、SQLite、Postgres、Redis
- 99%通过GCC torture测试集
- 能编译运行Doom（开发者终极验证）

这不是演示项目。这是实打实的生产级编译器，通过了GCC最严格的标准测试套件。

核心：Harness模式是什么

Carlini的"Harness"不是复杂的编排框架，而是一个极其简单的bash循环：

# 无限循环 Harness — 核心就这一行
while true; do
    claude -p "$(cat AGENT_PROMPT.md)"
done

就是这行命令，让Claude在完成一个任务后立即拾取下一个。没有消息队列，没有状态机，没有复杂的任务调度器。就是一个while循环 + 一个prompt文件。

但简单的背后藏着精巧的设计。Harness的真正价值在于任务分发和并行协作机制：

1. 独立Docker容器 + 共享Git仓库

每个Claude实例运行在独立的Docker容器中，通过共享Git仓库协作：

# 每个Agent的基础环境
FROM ubuntu:22.04
RUN apt-get update && apt-get install -y git build-essential rustc cargo
RUN cargo install claude-code
COPY AGENT_PROMPT.md /agent/
WORKDIR /agent/workspace

# 启动16个并行Agent
for i in $(seq 1 16); do
    docker run -d --name claude-agent-$i \
        -v /shared/repo:/agent/workspace \
        claude-agent-image
done

2. 简单锁文件机制防冲突

没有用数据库锁，没有用Redis。就用文件系统：

# AGENT_PROMPT.md 中的锁机制
# 在执行写操作前：
if [ -f /agent/workspace/.lock ]; then
    echo "Locked, picking next task..."
    exit 0
fi
touch /agent/workspace/.lock
# ... 执行任务 ...
rm /agent/workspace/.lock

3. 任务分工策略

16个Agent不是无脑做同一件事。通过不同的prompt变体实现分工：

Bug修复Agent（4个）：根据测试失败日志修复bug
代码去重Agent（2个）：扫描并合并重复代码
性能优化Agent（3个）：优化热点路径
代码质量Agent（3个）：改进可读性和架构
文档Agent（2个）：同步更新文档
测试Agent（2个）：为已有代码补充测试

# 不同类型的Agent使用不同的prompt文件
while true; do
    claude -p "$(cat AGENT_BUGFIX.md)"   # bug修复Agent
done

while true; do
    claude -p "$(cat AGENT_OPTIMIZE.md)" # 性能优化Agent
done

4. Linux内核编译的"GCC对照法"

这是整个Harness最精巧的设计。独立测试可以随机分配给不同Agent，但编译Linux内核是一个不能拆分的巨型任务。Carlini的做法：

# 对照法并行修复
# 1. 用GCC编译内核（已知正确的输出）
gcc -o kernel_gcc vmlinux.c

# 2. 用自研编译器编译同一个文件
./our_compiler -o kernel_ours vmlinux.c

# 3. 对比差异，按文件拆分给16个Agent并行修复
diff <(objdump -d kernel_gcc) <(objdump -d kernel_ours) \
    | split_by_file \
    | parallel -j 16 "claude -p 'Fix this compilation diff: {}'"

你可以怎么用：三步搭建自己的Harness

第一步：创建Agent Docker镜像

FROM python:3.12-slim
RUN pip install claude-code-mcp  # 或 hermes-agent
COPY agent_entrypoint.sh /agent/
RUN chmod +x /agent/agent_entrypoint.sh
WORKDIR /workspace
ENTRYPOINT ["/agent/agent_entrypoint.sh"]

第二步：编写Agent入口脚本

#!/bin/bash
# agent_entrypoint.sh

AGENT_TYPE=${AGENT_TYPE:-"general"}
PROMPT_FILE="/agent/prompts/${AGENT_TYPE}.md"

while true; do
    # 尝试获取锁
    LOCKFILE="/workspace/.lock_${AGENT_TYPE}_$(date +%s)"
    if ! ln -s $$ "$LOCKFILE" 2>/dev/null; then
        sleep 5
        continue
    fi

    # 执行任务
    echo "[$(date)] Agent ${AGENT_TYPE} starting task..."

    # 使用Hermes Agent或Claude Code
    hermes run -p "$(cat $PROMPT_FILE)" \
        --workspace /workspace \
        --max-iterations 30 \
        2>&1 | tee "/workspace/logs/agent_${AGENT_TYPE}_$(date +%s).log"

    # 释放锁
    rm -f "$LOCKFILE"

    echo "[$(date)] Agent ${AGENT_TYPE} completed. Picking next..."
    sleep 2
done

第三步：启动Agent集群

#!/bin/bash
# 启动16个Agent，4种角色

# 准备共享工作区
mkdir -p /shared/repo /shared/logs
cd /shared/repo && git init

# 启动4种Agent类型
AGENT_TYPES=("bugfix" "optimize" "quality" "test")
AGENT_COUNTS=(4 3 3 2)

for i in "${!AGENT_TYPES[@]}"; do
    type="${AGENT_TYPES[$i]}"
    count="${AGENT_COUNTS[$i]}"
    for j in $(seq 1 $count); do
        docker run -d \
            --name "agent-${type}-${j}" \
            -e AGENT_TYPE="$type" \
            -v /shared/repo:/workspace \
            -v /shared/logs:/workspace/logs \
            agent-harness-image
        echo "Started agent-${type}-${j}"
    done
done

echo "All 12 agents running. Monitor: tail -f /shared/logs/*"

三个关键教训（直接来自Carlini实验）

教训1：测试质量决定Agent上限

Carlini在报告里说得非常直白：Claude会解决你给的任何问题。如果你的测试覆盖不够、测试用例质量不高，Agent产出的代码质量必然受限。

在GCC torture测试集上，Claude团队花了大量精力确保测试的完备性——因为Agent只会做测试要求它做的事。

实操建议：花在编写测试上的时间，应该至少占项目总时间的30%。好的测试是你的Agent的"需求文档"。

教训2：站在Agent的角度设计工作流

Carlini总结了三条"为Claude设计"的原则：

减少上下文污染：不要让Agent看到无关的历史提交、无关的测试日志
日志自动可解析：Agent的输出应该是结构化的（JSON），方便下游自动化
预计算统计数据：Agent不应该花token做可以用脚本算的事情

# 好的做法：预处理后喂给Agent
import subprocess, json

def prepare_context_for_agent():
    # 预计算编译错误统计
    errors = subprocess.run(
        ["grep", "-c", "error:", "build.log"],
        capture_output=True, text=True
    )
    # 结构化输出
    context = {
        "total_errors": int(errors.stdout.strip()),
        "failed_files": ["src/parser.rs", "src/codegen.rs"],
        "last_successful_build": "2026-06-01T00:00:00Z"
    }
    return json.dumps(context)

# Agent只看到结构化上下文，不读原始日志

教训3：并行化需要"可拆分性"

不是所有任务都能直接并行。Carlini的实验发现：

天然可并行的：独立bug修复、单元测试编写、文档生成
需要巧思拆分的：编译器架构重构、内核编译
目前无法并行的：核心算法设计、架构方向的重大决策

对于AI创业者来说，第一个想到的问题应该是：我的任务能不能拆成16份独立的子任务？如果可以，Harness模式就能直接套用。

对AI创业者的三个启示

启示1：Agent成本已经低于人类成本

$20,000写一个能编译Linux内核的C编译器。如果雇人类团队，光一个编译器工程师的年薪就远超这个数。而且Agent2周完成，人类需要数月甚至数年。

这对AI创业者的意义：凡是重复性高、可自动化的工作，现在就可以用Agent完成，成本已经低于实习生。

启示2：Harness比编排框架更重要

市面上的Agent编排框架很多（LangGraph、CrewAI、AutoGen），但Carlini的Harness只用了一个bash while循环。这提醒我们：

编排的复杂性不在框架，在于任务拆分和协作机制的设计。

一个简单的while循环 + 精心设计的prompt + 合理的锁机制，就足以驱动16个Agent协同工作2周。

启示3：Agent Teams是2026年最重要的趋势

Anthropic自己也在推Agent Teams方向。从Claude Code的--team模式到Carlini的16-Agent实验，多Agent并行协作正在从研究走向生产。对AI创业者来说，学会设计Agent协作工作流是一个明确的竞争壁垒。

行动建议

今天就试：拿你手上的一个项目，想想能不能拆成4份独立任务，用4个Claude窗口并行做
从测试开始：先写高质量的测试，再让Agent去通过测试——这是Carlini模式的核心
设计你的Harness：不一定要16个Agent，3-5个Agent的Harness就能跑起来
结构化Agent的输入输出：JSON格式的上下文 + 可解析的日志，机器可读

少即是多。最强大的Agent编排，可能就是一个while循环。

AI创业 #Agent工坊 #多Agent协作 #Harness模式 #ClaudeCode #一人公司