SWE-AF workflow
A team of AI agents from one request: it plans the task, writes code in parallel branches, tests, reviews and opens a pull request
- 1,036 ★ on the repository
- Last commit
- Apache-2.0
Broad access
Why this level
- It launches hundreds of agent calls that edit code, commit and merge branches in your repository
- With `GH_TOKEN` it clones private repositories, pushes branches and opens pull requests in your name
- It uses provider keys and a Claude or Codex subscription, so a long build spends API balance or plan limits
Install
- Works in
Manual install
af install https://github.com/Agent-Field/SWE-AFRequires a running AgentField control plane. Then af run swe-planner; the provider key is asked for on first run.
Access and checks
How we reviewBroad accessThe tool can change data, run commands or handle secrets.
- It launches hundreds of agent calls that edit code, commit and merge branches in your repository
- With `GH_TOKEN` it clones private repositories, pushes branches and opens pull requests in your name
- It uses provider keys and a Claude or Codex subscription, so a long build spends API balance or plan limits
This is third-party code. Review the repository files before installing.
What it does
SWE-AF is a Python node that runs on top of the AgentField platform and turns a goal statement into finished repository changes. You send a request: `af call swe-planner.build --in '{"goal": "Add JWT auth", "repo_url": "https://github.com/user/my-repo"}'`, or the same call over HTTP to port 8080 of the control plane. The node then builds a chain of agents itself: a product manager, an architect, coders, testers and reviewers. The architecture is written and reviewed first, then tasks are sorted by dependency and picked up in parallel, each in its own git worktree. Every task gets a coder, a tester and a reviewer. If a check fails, the coder retries with feedback. When attempts run out, a task advisor tries another approach, splits the work or accepts the result with debt. If that fails too, a replanner restructures the remaining tasks and their dependencies. At the end branches are merged, integration tests run and a verifier checks the outcome against the acceptance criteria. Execution keeps checkpoints, so after a crash `resume_build` continues the build. Three runtimes are supported: Claude Code, OpenCode (OpenRouter, OpenAI, Google and Anthropic models) and Codex, and each role can get its own model, for example `opus` for `coder` and `haiku` for `qa`. For work across several repositories there is a `config.repos` mode with `primary` and `dependency` roles. The repository itself contains a `delegate-issue` skill for Claude Code: the main agent hands the node fully specified tasks through `swe-planner.implement_issue` and collects the finished branches to merge.
Who it is for. For teams that want to hand a large or well-specified coding task to an autonomous system and get a pull request, and are ready to pay for hundreds of model calls.
Good fit when
- You need a new feature or a refactor, for example JWT authentication, and want a branch with tests and an open pull request
- The main agent in Claude Code needs to save tokens: through the `delegate-issue` skill it hands fully specified independent tasks to cheaper models and gets branches back
- A task spans several repositories, such as an app and a shared library: `config.repos` mode sets the `primary` and `dependency` roles
- You want to compare models by role: assign `opus` to `coder` and `haiku` to `qa`, with a cheap path through OpenRouter
- A long build may be interrupted: checkpoints let you continue it with `resume_build`
Not a fit when
- The requirement is vague: the `delegate-issue` skill itself warns that a garbage spec gives a garbage branch, and for vague requests the author recommends `swe-planner.build`
- You cannot run an AgentField control plane: the node works only on that platform, and a run outside Docker needs Python 3.12 or newer
- You need a one-off fix in a single file: hundreds of agent calls on such a task waste money
- The repository is private and you cannot hand out a GitHub token: without `GH_TOKEN` the node does not clone private repositories or open pull requests
Example request
Send SWE-AF the task "add JWT authentication to all endpoints" for my repository and give me a command to follow progressLimitations
- The project is in public beta. A typical run spins up 400–500 or more agent instances, and large builds reach thousands of calls, so the model bill grows fast. The author's example: a pull request build with ten tasks and 79 calls cost $19.23 on `claude-haiku-4-5`.
- All of the author's figures, including 95 points out of 100 against 73 for Claude Code with sonnet, come from one toy assignment (a todo app) and his own scoring scale.
- Exactly one provider key is needed. Any non-empty `ANTHROPIC_API_KEY` forces the `claude_code` runtime even if you wanted `OPENROUTER_API_KEY`, so keep unneeded keys commented out in `.env`.
- Codex in the `workspace-write` sandbox needs Linux user namespaces through `bwrap`; on WSL2 and hardened environments the launch may fail.
- Web search in the OpenCode runtime is switched on separately with `OPENCODE_ENABLE_EXA=1` and `EXA_API_KEY`, and it is not wired for the Claude runtime yet.
How to disable. Stop the node and the control plane: for Docker that is `docker compose down`, for a venv run stop the `python -m swe_af` process. A node installed through `af install` is removed with AgentField's own tools. Provider keys and `GH_TOKEN` live in `.env` or in AgentField's encrypted store, and you delete or revoke them separately.
FAQ
How does `swe-planner` differ from `swe-fast`?
`swe-planner` builds the full loop with planning, architecture and checks, while `swe-fast` is meant for quick narrow changes. Both share the same `implement_issue` interface, and there are also twins with a `-go` suffix. For vague requests the author recommends `swe-planner.build`.
How do I set a model for each role?
In `config.models` set `default` and role keys such as `coder`, `qa` and `architect`: `{"default": "sonnet", "coder": "opus", "qa": "opus"}`. The runtime is chosen with the `runtime` key: `claude_code`, `open_code` or `codex`. OpenRouter identifiers are written as `openrouter/<provider>/<model>`.
What does the `enable_learning` parameter do?
With `enable_learning=true`, conventions and failure patterns found in the first tasks of a build are injected into later tasks. That keeps coders from repeating the same mistake.
How do I deploy the node without installing Python?
Through Docker: copy `.env.example` to `.env`, uncomment one provider key and run `docker compose up -d`. The number of workers changes with `docker compose up --scale swe-agent=3 -d`. There is also a Railway deploy button that brings the control plane and PostgreSQL along.
What is the `delegate-issue` skill and when does it fit?
The main agent writes a fully specified task with a title, description and acceptance criteria and sends it with an asynchronous `swe-planner.implement_issue` call. The node returns a branch, and the main agent reviews and merges it. The skill does not suit tasks that touch files you are editing right now.
Discussion
No questions or reviews yet.
Related
WorkflowsA workflow layer for AI-assisted coding: specs, tasks and session journals live in the repository and are injected into the agent's context
A multi-agent harness that verifies results by artifacts: stop hooks, an independent judge and an event log for Claude Code, Codex, Cursor and more
A self-hosted runtime for coding agents: each crew in its own Linux container, wrapped in a control plane with roles and audit
A Go coding agent for open models: it turns a chat into tasks on separate branches, checks and merges the result and runs all projects in one window
A self-hosted AgentOS for one workspace: plan-mode chat, private knowledge base, MCP tools, skills, memory and a sandbox
Ten AI agents in tmux panes: a manager hands tasks to seven workers, progress shows on a dashboard, with Claude Code, Codex, Cursor and OpenCode supported
Comparison with similar tools
Entries that share the main search query, and how they differ.
README in short
The description starts with a one-command call and the modes for one or several repositories, followed by a compiler build example, a pull request cost table, a diagram of three control loops and three ways to run: `af install`, Railway and Docker. It includes a comparison test against Claude Code and Codex with reproduction steps, a section on OpenRouter, MiniMax and Infron keys, and web search instructions. The repository holds architecture documentation, agent comparison examples and a security policy.