一次 API 调用即可启动一个完整的自主工程团队——包括产品经理、架构师、程序员、审查员、测试人员——他们负责规划、构建、适配并端到端地交付复杂软件。 SWE-AF 是迈向自主软件工程工厂的第一步，能够从简单目标扩展到包含数百至数千次智能体 (Agent) 调用的复杂多问题程序。

单次调用开发体验 (DX)

curl -X POST http://localhost:8080/api/v1/execute/async/swe-planner.build \
  -H "Content-Type: application/json" \
  -d @- <<'JSON'
{
  "input": {
    "goal": "Refactor and harden auth + billing flows",
    "repo_url": "https://github.com/user/my-project",
    "config": {
      "runtime": "claude_code",
      "models": {
        "default": "sonnet",
        "coder": "opus",
        "qa": "opus"
      },
      "enable_learning": true
    }
  }
}
JSON

将 models.default 和任何角色键（coder, qa, architect 等）替换为你运行时 (Runtime) 支持的任何模型。

运行模式

SWE-AF 有两种工作模式：指向单个仓库，或在一次构建中协调多个仓库之间的更改。

单仓库模式

默认模式。传入 repo_url（远程）或 repo_path（本地），SWE-AF 将处理所有事项：

curl -X POST http://localhost:8080/api/v1/execute/async/swe-planner.build \
  -H "Content-Type: application/json" \
  -d '{
    "input": {
      "goal": "Add JWT auth",
      "repo_url": "https://github.com/user/my-project"
    }
  }'

多仓库模式

当你的工作跨越多个代码库时——主应用加上共享库、单体仓库 (Monorepo) 子项目，或依赖的微服务 (Microservices)——请作为数组传入 config.repos 并附带角色：

curl -X POST http://localhost:8080/api/v1/execute/async/swe-planner.build \
  -H "Content-Type: application/json" \
  -d '{
    "input": {
      "goal": "Add JWT auth across API and shared-lib",
      "config": {
        "repos": [
          {
            "repo_url": "https://github.com/org/main-app",
            "role": "primary"
          },
          {
            "repo_url": "https://github.com/org/shared-lib",
            "role": "dependency"
          }
        ],
        "runtime": "claude_code",
        "models": {
          "default": "sonnet"
        }
      }
    }
  }'

角色：

• primary —— 主应用程序。此处的更改驱动构建；失败会阻塞进度。
• dependency —— 为支持主仓库而修改的库或服务。失败会被捕获但不会阻塞。

使用场景：

• 主应用 + 共享 SDK 或工具库
• 位于独立仓库中的单体仓库 (Monorepo) 子项目
• 跨越多个微服务 (Microservices) 的功能（例如 API + 工作队列）

自主构建亮点

基于 Rust 的 Python 编译器基准测试（自主构建）：

构建过程记录包含175 个追踪的自主智能体 (Agents)，涵盖规划、编码、审查、合并和验证环节。

详情：examples/llm-rust-python-compiler-sonnet/README.md

为什么选择 SWE-AF

大多数智能体框架仅封装单个编码循环。SWE-AF 是一个协同工程工厂——规划、执行和治理智能体作为控制栈运行，能够实时自适应。

• 难度感知执行 — 简单问题快速通过，而复杂问题会触发更深层的适应和 DAG（有向无环图）级重规划，而非盲目重试。
• 工厂架构 — 并非单智能体包装器。规划、执行和治理智能体作为协同控制栈运行——该架构编码了工程策略，而非提示词（参见 智能原子单元）。
• 多模型、多提供商 — 为不同角色分配不同的模型（coder: opus, qa: haiku）。支持 Claude、OpenRouter、OpenAI 和 Google。
• 持续学习 — 启用 enable_learning=true 时，早期发现的约定和失败模式会被注入到下游问题中。
• 智能体级并行 — 依赖级调度 + 隔离的 Git 工作树允许大规模任务分发而无分支冲突。
• 舰队级编排 — 多个 SWE-AF 节点可通过 AgentField 连续并行运行，驱动数千个并发构建中的智能体调用。
• 显式妥协跟踪 — 当范围放宽时，债务被类型化、严重程度评级并传播。
• 长期可靠性 — 检查点执行支持在崩溃或中断后 resume_build。

实际案例

PR #179: Go SDK DID/VC 注册 — 完全由 SWE-AF 构建（使用 Haiku 类模型的 Claude 运行时）。一次 API 调用，零人工代码。

支持 Claude 及开源模型：使用任一运行时进行构建，并在一个扁平配置映射中调整各角色的模型。

• runtime: "claude_code" 映射到 Claude 后端。
• runtime: "open_code" 映射到 OpenCode 后端（OpenRouter/OpenAI/Google/Anthropic 模型 ID）。

自适应工厂控制

SWE-AF 使用三个嵌套控制循环来实时适应任务难度：

这是核心工厂控制行为：控制智能体监督工作智能体，并随着现实情况的变化不断重塑计划。

快速开始

使用 Railway 部署（最快）

一键部署 SWE-AF + AgentField 控制平面 + PostgreSQL。在 Railway 中设置两个环境变量：

• CLAUDE_CODE_OAUTH_TOKEN — 在 Claude Code CLI 中运行 claude setup-token（使用 Pro/Max 订阅额度）
• GH_TOKEN — 具有 repo 范围的 GitHub 个人访问令牌，用于创建草稿拉取请求

部署完成后，触发构建：

curl -X POST https://<control-plane>.up.railway.app/api/v1/execute/async/swe-planner.build \
  -H "Content-Type: application/json" \
  -H "X-API-Key: this-is-a-secret" \
  -d '{"input": {"goal": "Add JWT auth", "repo_url": "https://github.com/user/my-repo"}}'

1. 要求（本地）

• Python 3.12+
• AgentField 控制平面 (af)
• AI 提供商 API 密钥（Anthropic、OpenRouter、OpenAI 或 Google）

2. 安装

python3.12 -m venv .venv
source .venv/bin/activate
python -m pip install --upgrade pip
python -m pip install -e ".[dev]"

3. 运行

af                 # 在 :8080 启动 AgentField 控制平面
python -m swe_af   # 注册节点 ID "swe-planner"

4. 触发构建

# 默认（使用 Claude）
curl -X POST http://localhost:8080/api/v1/execute/async/swe-planner.build \
  -H "Content-Type: application/json" \
  -d @- <<'JSON'
{
  "input": {
    "goal": "Add JWT auth to all API endpoints",
    "repo_url": "https://github.com/user/my-project"
  }
}
JSON

# 使用开源运行时 + 扁平角色映射
curl -X POST http://localhost:8080/api/v1/execute/async/swe-planner.build \
  -H "Content-Type: application/json" \
  -d @- <<'JSON'
{
  "input": {
    "goal": "Add JWT auth",
    "repo_url": "https://github.com/user/my-project",
    "config": {
      "runtime": "open_code",
      "models": {
        "default": "openrouter/minimax/minimax-m2.5"
      }
    }
  }
}
JSON

# 本地工作区模式（repo_path）+ 定向角色覆盖
curl -X POST http://localhost:8080/api/v1/execute/async/swe-planner.build \
  -H "Content-Type: application/json" \
  -d @- <<'JSON'
{
  "input": {
    "goal": "Refactor and harden auth + billing flows",
    "repo_path": "/path/to/repo",
    "config": {
      "runtime": "claude_code",
      "models": {
        "default": "sonnet",
        "coder": "opus",
        "qa": "opus"
      },
      "enable_learning": true
    }
  }
}
JSON

对于使用 open_code 的 OpenRouter，请在 openrouter/<provider>/<model> 格式中使用模型 ID（例如 openrouter/minimax/minimax-m2.5）。

单次构建流程

• 架构在编码开始前生成并审查
• 问题按依赖关系排序，并在隔离的工作树（worktrees）中并行运行
• 每个问题都会经过专门的编码、测试和审查阶段
• 失败的问题会触发顾问驱动的自适应调整（拆分、重新界定范围或升级）
• 升级操作会触发剩余有向无环图（DAG）的重新规划
• 最终结果会被合并、进行集成测试，并根据验收标准验证

典型运行会在规划、执行、QA（质量保证）和验证阶段启动 400-500+ 个代理实例。对于更大的 DAG 和重复的自适应/重新规划周期，SWE-AF 可以在单次构建中扩展到数百甚至数千次代理调用。

基准测试

使用 haiku 和 MiniMax 达到 95/100：SWE-AF 在使用 Claude haiku 类路由（$20）和通过开放运行时（open runtime）的 MiniMax M2.5（$6）时均获得 95/100 分，在同一次提示下优于 Claude Code sonnet（73）、Codex o3（62）和 Claude Code haiku（59）。

# SWE-AF (Claude runtime, haiku-class mapping) - $20, 30-40 min
curl -X POST http://localhost:8080/api/v1/execute/async/swe-planner.build \
  -H "Content-Type: application/json" \
  -d @- <<'JSON'
{
  "input": {
    "goal": "Build a Node.js CLI todo app with add, list, complete, and delete commands. Data should persist to a JSON file. Initialize git, write tests, and commit your work.",
    "repo_path": "/tmp/swe-af-output",
    "config": {
      "runtime": "claude_code",
      "models": {
        "default": "haiku"
      }
    }
  }
}
JSON

# SWE-AF (MiniMax M2.5 via OpenRouter runtime) - $6, 43 min
curl -X POST http://localhost:8080/api/v1/execute/async/swe-planner.build \
  -H "Content-Type: application/json" \
  -d @- <<'JSON'
{
  "input": {
    "goal": "Build a Node.js CLI todo app with add, list, complete, and delete commands. Data should persist to a JSON file. Initialize git, write tests, and commit your work.",
    "repo_path": "/workspaces/todo-app-benchmark",
    "config": {
      "runtime": "open_code",
      "models": {
        "default": "openrouter/minimax/minimax-m2.5"
      }
    }
  }
}
JSON

# Claude Code (haiku)
claude -p "Build a Node.js CLI todo app with add, list, complete, and delete commands. Data should persist to a JSON file. Initialize git, write tests, and commit your work." --model haiku --dangerously-skip-permissions

# Claude Code (sonnet)
claude -p "Build a Node.js CLI todo app with add, list, complete, and delete commands. Data should persist to a JSON file. Initialize git, write tests, and commit your work." --model sonnet --dangerously-skip-permissions

# Codex (gpt-5.3-codex)
codex exec "Build a Node.js CLI todo app with add, list, complete, and delete commands. Data should persist to a JSON file. Initialize git, write tests, and commit your work." --full-auto

先发布代码，然后审计它： SEC-AF 针对您的代码库运行相同的多人代理架构——250 个代理，94% 噪音减少，每个发现均有据可查。

Docker

cp .env.example .env
# Add your API key: ANTHROPIC_API_KEY, OPENROUTER_API_KEY, OPENAI_API_KEY, or GOOGLE_API_KEY
# Optionally add GH_TOKEN for draft PR workflow

docker compose up -d

提交构建任务：

# Default (Claude)
curl -X POST http://localhost:8080/api/v1/execute/async/swe-planner.build \
  -H "Content-Type: application/json" \
  -d @- <<'JSON'
{
  "input": {
    "goal": "Add JWT auth",
    "repo_url": "https://github.com/user/my-repo"
  }
}
JSON

# With open-source runtime (set OPENROUTER_API_KEY in .env)
curl -X POST http://localhost:8080/api/v1/execute/async/swe-planner.build \
  -H "Content-Type: application/json" \
  -d @- <<'JSON'
{
  "input": {
    "goal": "Add JWT auth",
    "repo_url": "https://github.com/user/my-repo",
    "config": {
      "runtime": "open_code",
      "models": {
        "default": "openrouter/minimax/minimax-m2.5"
      }
    }
  }
}
JSON

# Local workspace mode (repo_path)
curl -X POST http://localhost:8080/api/v1/execute/async/swe-planner.build \
  -H "Content-Type: application/json" \
  -d @- <<'JSON'
{
  "input": {
    "goal": "Add JWT auth",
    "repo_path": "/workspaces/my-repo"
  }
}
JSON

扩展工作节点：

docker compose up --scale swe-agent=3 -d

使用主机控制平面代替 Docker 控制平面服务：

docker compose -f docker-compose.local.yml up -d

GitHub 仓库工作流（克隆 -> 构建 -> 草稿 PR）

传递 repo_url 而非 repo_path，以便 SWE-AF 在运行后克隆仓库并打开一个草稿 PR。

curl -X POST http://localhost:8080/api/v1/execute/async/swe-planner.build \
  -H "Content-Type: application/json" \
  -d @- <<'JSON'
{
  "input": {
    "repo_url": "https://github.com/user/my-project",
    "goal": "Add comprehensive test coverage",
    "config": {
      "runtime": "claude_code",
      "models": {
        "default": "sonnet",
        "coder": "opus",
        "qa": "opus"
      }
    }
  }
}
JSON

Requirements:

• .env 中的 GH_TOKEN 需包含 repo 范围权限
• 该令牌需具有仓库访问权限

API 参考

# Full build: plan -> execute -> verify
POST /api/v1/execute/async/swe-planner.build

# Plan only
POST /api/v1/execute/async/swe-planner.plan

# Execute a prebuilt plan
POST /api/v1/execute/async/swe-planner.execute

# Resume after interruption
POST /api/v1/execute/async/swe-planner.resume_build

curl http://localhost:8080/api/v1/executions/<execution_id>

{
  "runtime": "claude_code"
}

{
  "runtime": "open_code",
  "models": {
    "default": "minimax/minimax-m2.5",
    "pm": "openrouter/qwen/qwen-2.5-72b-instruct",
    "architect": "openrouter/qwen/qwen-2.5-72b-instruct",
    "coder": "deepseek/deepseek-chat",
    "qa": "deepseek/deepseek-chat",
    "verifier": "openrouter/qwen/qwen-2.5-72b-instruct"
  },
  "max_coding_iterations": 6,
  "enable_learning": true
}

.artifacts/
├── plan/           # PRD, architecture, issue specs
├── execution/      # checkpoints, per-issue logs, agent outputs
└── verification/   # acceptance criteria results

make test
make check
make clean
make clean-examples

同样基于 AgentField 构建

SEC-AF — 原生 AI 安全审计器。每次审计 250 个智能体，降噪 94%，每项发现均被证明可利用。

Contract-AF — 法律合同风险分析器。智能体在运行时生成子智能体。对抗性审查能捕捉到独立 LLM（大语言模型）遗漏的内容。

所有仓库 →

SWE-AF 基于 AgentField 构建，这是从单智能体框架迈向自主软件工程工厂的第一步。查看我们正在构建的其他内容 →

SWE-AF 快速上手指南

SWE-AF 是一个基于 AgentField 构建的自主工程团队运行时。只需一次 API 调用，即可启动包含产品经理、架构师、程序员、测试员在内的完整工程团队，实现从需求到代码交付的全流程自动化。

环境准备

在开始之前，请确保您的开发环境满足以下要求：

• 系统要求: Linux / macOS / Windows (WSL)
• Python 版本: 3.12+
• AI 服务: 拥有有效的 API 密钥（支持 Anthropic, OpenRouter, OpenAI, Google 等）
• 前置依赖: AgentField 控制平面 (af)

提示: 如果您希望快速体验而无需本地配置，可以使用 Railway 一键部署云端版本。

安装步骤

1. 创建虚拟环境并激活

python3.12 -m venv .venv
source .venv/bin/activate

2. 安装项目依赖

python -m pip install --upgrade pip
python -m pip install -e ".[dev]"

3. 启动服务

打开两个终端窗口分别运行以下命令：

终端 1：启动 AgentField 控制平面

af

终端 2：注册 SWE-AF 节点

python -m swe_af

基本使用

服务启动后，默认监听 localhost:8080。您可以通过发送 HTTP POST 请求来触发构建任务。

单仓库模式示例

以下示例将自动为指定仓库添加 JWT 认证功能（默认使用 Claude 模型）：

curl -X POST http://localhost:8080/api/v1/execute/async/swe-planner.build \
  -H "Content-Type: application/json" \
  -d @- <<'JSON'
{
  "input": {
    "goal": "Add JWT auth to all API endpoints",
    "repo_url": "https://github.com/user/my-project"
  }
}
JSON

自定义模型与运行时

您可以根据需要切换不同的 AI 模型或运行时环境（例如使用开源模型）：

curl -X POST http://localhost:8080/api/v1/execute/async/swe-planner.build \
  -H "Content-Type: application/json" \
  -d @- <<'JSON'
{
  "input": {
    "goal": "Add JWT auth",
    "repo_url": "https://github.com/user/my-project",
    "config": {
      "runtime": "open_code",
      "models": {
        "default": "openrouter/minimax/minimax-m2.5"
      }
    }
  }
}
JSON

多仓库协同模式

如果您的项目涉及多个关联仓库（如主应用 + 共享库），可在 config.repos 中定义角色：

curl -X POST http://localhost:8080/api/v1/execute/async/swe-planner.build \
  -H "Content-Type: application/json" \
  -d '{
    "input": {
      "goal": "Add JWT auth across API and shared-lib",
      "config": {
        "repos": [
          {
            "repo_url": "https://github.com/org/main-app",
            "role": "primary"
          },
          {
            "repo_url": "https://github.com/org/shared-lib",
            "role": "dependency"
          }
        ],
        "runtime": "claude_code",
        "models": {
          "default": "sonnet"
        }
      }
    }
  }'

下一步建议：查看官方文档中的 Architecture 了解内部架构，或参考 Benchmark 了解性能表现。