Learn-skills.dev swe-af

Autonomous engineering team runtime — one API call spins up coordinated AI agents to scope, build, and ship software.

install

source · Clone the upstream repo

git clone https://github.com/NeverSight/learn-skills.dev

Claude Code · Install into ~/.claude/skills/

T=$(mktemp -d) && git clone --depth=1 https://github.com/NeverSight/learn-skills.dev "$T" && mkdir -p ~/.claude/skills && cp -r "$T/data/skills-md/agent-field/swe-af/swe-af" ~/.claude/skills/neversight-learn-skills-dev-swe-af && rm -rf "$T"

manifest: data/skills-md/agent-field/swe-af/swe-af/SKILL.md

source content

SWE-AF Usage Guide

Autonomous engineering team runtime — one API call spins up coordinated AI agents to scope, build, and ship software.

What It Does

SWE-AF creates a coordinated team of AI agents (planning, coding, review, QA, merge, verification) that execute in parallel based on DAG dependencies. Issues with no dependencies run simultaneously; dependent issues run sequentially.

Installation

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

Running

Terminal 1 — Control Plane:

af                  # starts AgentField on port 8080

Terminal 2 — Register Node:

python -m swe_af    # registers the swe-planner node

Triggering a Build

With local repo:

curl -X POST http://localhost:8080/api/v1/execute/async/swe-planner.build \
  -H "Content-Type: application/json" \
  -d '{
    "input": {
      "goal": "Add JWT auth to all API endpoints",
      "repo_path": "/path/to/your/repo",
      "config": {
        "runtime": "open_code",
        "models": {
          "default": "zai-coding-plan/glm-5"
        }
      }
    }
  }'

With GitHub repo (clones + creates draft PR):

curl -X POST http://localhost:8080/api/v1/execute/async/swe-planner.build \
  -H "Content-Type: application/json" \
  -d '{
    "input": {
      "goal": "Add comprehensive test coverage",
      "repo_url": "https://github.com/user/my-project",
      "config": {
        "runtime": "open_code",
        "models": {
          "default": "zai-coding-plan/glm-5"
        }
      }
    }
  }'

Configuration

Key	Values	Description
`runtime`	`"claude_code"` , `"open_code"`	AI backend to use
`models.default`	model ID string	Default model for all agents
`models.coder`	model ID string	Override for coder role
`models.qa`	model ID string	Override for QA role
`repo_path`	local path	Local workspace (new or existing)
`repo_url`	GitHub URL	Clone + draft PR workflow

Role-Specific Model Overrides

{
  "config": {
    "runtime": "open_code",
    "models": {
      "default": "zai-coding-plan/glm-5",
      "coder": "zai-coding-plan/glm-5",
      "qa": "zai-coding-plan/glm-5",
      "verifier": "zai-coding-plan/glm-5"
    }
  }
}

Available roles:

pm

architect

tech_lead

sprint_planner

coder

qa

code_reviewer

qa_synthesizer

replan

retry_advisor

issue_writer

issue_advisor

verifier

git

merger

integration_tester

Multi-Repo Builds

SWE-AF supports coordinated work across multiple repositories in a single build. Pass

config.repos

as an array of repository objects, each with a

repo_url

(or

repo_path

) and a

role

. Single-repo builds remain backward compatible—just use

repo_url

repo_path

at the top level.

Complete Example: Primary App + Dependency

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"
        }
      }
    }
  }'

Repository roles:

```
primary
```
: The main application being built. Changes here drive the build; failures block progress.
```
dependency
```
: Libraries or services that may be modified to support the primary repo. Failures are captured but don't block primary build progress.

Use Cases

Primary App + Shared Libraries: Coordinate changes between a web application and its shared utilities/SDK.
Monorepo Sub-Projects: Define multiple repos in a monorepo structure and orchestrate cross-package changes.
Microservices: When a feature spans an API service and a worker service, define roles to manage interdependencies.

Requirements for open_code Runtime

```
opencode
```
CLI installed and in PATH
Model provider credentials configured in OpenCode (e.g.,
```
OPENAI_API_KEY
```
for z.ai)
Model ID format matches what OpenCode expects

Monitoring

# Check build status
curl http://localhost:8080/api/v1/executions/<execution_id>

Artifacts are saved to:

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

What Happens in a Build

Planning — PM → Architect → Tech Lead → Sprint Planner (generates issue DAG)
Issue Writing — All issues written in parallel
Execution — Issues run level-by-level (parallel within levels)
- Each issue: Coder → QA + Reviewer (parallel) → Synthesizer
- Failures trigger advisor (retry/split/accept with debt/escalate)
Merge — Branches merged to integration branch
Integration Test — Full suite on merged code
Verification — Acceptance criteria checked against PRD

Key Endpoints

POST /api/v1/execute/async/swe-planner.build     # Full build
POST /api/v1/execute/async/swe-planner.plan      # Plan only
POST /api/v1/execute/async/swe-planner.execute   # Execute existing plan
POST /api/v1/execute/async/swe-planner.resume_build  # Resume after crash