CodeAF CLI
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
- 524 ★ on the repository
- Last commit
- Apache-2.0
Broad access
Why this level
- The agent edits repository files, runs tests and builds and merges checked work into your branch itself
- It works with provider keys and by default sends numeric usage measurements to the model pool
- The `do` mode and schedules run work without you and spend money on models
Install
Manual install
curl -fsSL https://agentfield.ai/get/codeaf | bashPuts the binary in `~/.codeaf/bin`. Pin a version with `VERSION=<tag>` before `bash`. Start it with `codeaf`.
Access and checks
How we reviewBroad accessThe tool can change data, run commands or handle secrets.
- The agent edits repository files, runs tests and builds and merges checked work into your branch itself
- It works with provider keys and by default sends numeric usage measurements to the model pool
- The `do` mode and schedules run work without you and spend money on models
This is third-party code. Review the repository files before installing.
What it does
CodeAF is a coding agent shipped as a single Go binary and built for open models: DeepSeek, Qwen, GLM, Kimi, MiniMax and Ollama. It installs with one command and on first start connects OpenRouter in your browser or takes a key. Codex can be connected through a ChatGPT plan. The `home` screen lists every project and conversation on the machine, and each opens in a tab while the others keep working. Work in the chat goes like this: you write what needs fixing, and the agent splits the message into tasks, running each in its own copy of the repository on its own branch. Work that passes its check lands on your branch by itself, but never on `main`, `dev` or a release branch. When nothing can check the result, it waits under `unread`, where you accept or reject it. Questions that need you collect under `needs you` from all projects. Built-in specialists run by command: `/senior-dev` makes changes and runs the project's tests, `/sec` performs a local security audit with Markdown, JSON and SARIF reports, and `/review` reviews a GitHub pull request. For each task a crew of three models (worker, planner, checker) is chosen for price and kind of work, and `/crew` shows the choice and spending. For CI and scripts there is a no-dialogue mode: `codeaf do "task" --timeout 30m --json`. You can run the conversation on a remote machine with `codeaf chat --host devbox` over your own ssh, and a phone joins the same conversation from a mobile terminal.
Who it is for. For developers who run several projects with agents on cheap open models and want to hand out tasks instead of watching terminals.
Good fit when
- You want to hand off three small tasks in one message: a failing test, a layout wrap and an expiring key
- You want to run an agent on DeepSeek, Qwen, GLM or Ollama instead of expensive closed models
- You need a local security audit with a SARIF report: `/sec changes since main`
- In CI or on a schedule you need to run a task and get JSON and an exit code: `codeaf do`
- The agent runs on a dev box and you drive it from a laptop or phone over ssh
Not a fit when
- You are happy with Claude Code or Codex and do not want to change your workflow
- You need a mature stable system: the project calls itself an early preview
- Model usage data must not be sent out: the model pool is on by default and sends numeric measurements
- You need an agent that merges work into `main` itself: CodeAF does not and stops at your branch
Example request
/senior-dev fix the retry bug and add testsLimitations
The project is an early preview: expect rough edges, and the author asks you to report them on Discord or in an issue. The model pool is on by default: an install sends numeric measurements about models (role, model, a number, day) with no code, prompts, paths or identity, the queue can be viewed with `codeaf pool status` and turned off with `model_pool = off` or `CODEAF_MODEL_POOL=off`. You need a provider: OpenRouter, DeepSeek, GLM, Kimi, MiniMax, Qwen, Codex through a ChatGPT plan, Ollama or any OpenAI-compatible endpoint, and most need a key. The install script is fetched with `curl | bash`. The default spend limit per task is 5 dollars. The DeepSWE benchmark result in the README applies to the senior-dev specialist on a single model.
How to disable. Delete the binary from `~/.codeaf/bin` and the `~/.codeaf` directory. Automations run while CodeAF is open and are listed under `/automations`.
FAQ
How do I install CodeAF?
With `curl -fsSL https://agentfield.ai/get/codeaf | bash`, then run `codeaf`. The script puts the binary in `~/.codeaf/bin`. You can pin a version with the VERSION variable, or build it yourself with `make build`. It runs on darwin, linux and windows.
Which models and providers can I connect?
OpenRouter signs in through the browser or with a key. DeepSeek, GLM, Kimi, MiniMax and Qwen take keys, Ollama needs none, and Codex connects through a ChatGPT plan with `/connect` or `codeaf connect codex`. Any OpenAI-compatible endpoint also works.
What do the senior-dev, sec and review specialists do?
`senior-dev` makes changes and returns the project's build and test results. `sec` runs a local security audit and writes Markdown, JSON and SARIF reports. `review` reviews a GitHub pull request. The last two read source code and do not run your tests, build, app or exploits.
Where does the agent's work land?
Each task runs in its own copy of the repository on its own branch. A result that passes its check lands on your branch, never on main, dev or a release branch. Work with no check waits under `unread`: 1 accepts it, 2 rejects it.
How do I run CodeAF in CI?
With `codeaf do "your brief" --timeout 30m --json`. It takes the brief verbatim, plans, runs and checks it, prints one JSON object and returns an exit code. There is also `exec` for one worker with no plan and `run` for an edited plan.
Discussion
No questions or reviews yet.
Related
CLI toolsLocal coding agent with a terminal UI: it plans, drafts several candidates, tests them in a sandbox and repairs, so compact open models can handle code
A self-hosted runtime for coding agents: each crew in its own Linux container, wrapped in a control plane with roles and audit
A terminal coding agent built on Codex, tuned for low-cost open models like Kimi K3, DeepSeek and Qwen
A team of AI agents from one request: it plans the task, writes code in parallel branches, tests, reviews and opens a pull request
An open source coding agent for the terminal and desktop with build and plan modes
A Go CLI that configures the AI coding agents you already use: it gives them shared memory, a workflow and deterministic steps without replacing the agents them
Comparison with similar tools
Entries that share the main search query, and how they differ.
| Entry | Official | Repository stars | Main difference |
|---|---|---|---|
| CodeAF (this entry) | no | 524 | |
| OpenCode | no | 220,388 | an open coding agent with a terminal interface, while here the focus is tasks per branch, result checks and model choice by price |
| Crush | no | 28,775 | Charm's terminal agent with a single dialogue, while here the chat splits into parallel tasks |
README in short
The README presents CodeAF as a software factory for open models: first the install command and the early preview status, then the idea of one window for all projects and a conversation that turns into tasks. Sections cover the specialists, choosing models per task, the shared measurement pool, automations and the headless mode for CI, and running on a remote machine. It ends with a benchmark on 113 DeepSWE tasks and links to the guide.