CodeAF
A terminal software factory for open models that schedules, checks and merges the work for you.
- Source repo
- Agent-Field/CodeAF
- Stars
- ★ 812
- Last updated
- 1d ago
- License
- Apache-2.0
- Primary language
- Go
- FA score
- 41/100 · Major gaps
At a glance
- How it runs
- Works with
- Universal · cross-platformChatGPT · Codex · OpenAI API
- Cost
- Free software; you pay for model usage
- Setup effort
- Low · running in minutes
- You'll need
- Typical use
- Developers juggling several repositories who want one window showing what needs them, what is unread, what is running and what it cost across all projects.
- Not a fit if
- Organizations locked to a single closed vendor stack and unwilling to use open models
- Users who cannot accept anonymous usage telemetry sent to AgentField
- Website
- agentfield.ai/codeaf ↗ set on GitHub
- Maintenance
- Commits in the last 30 dayslast commit 2026-11-20latest release v0.8.3 (2026-11-19)+12.7 ★/day over 7 days
- Source review
- 41/100 · Major gaps
What does this agent do, and when should you use it?
CodeAF is a Go single-binary coding harness from AgentField AI built to squeeze more value out of open models such as DeepSeek, Qwen, GLM, Kimi, MiniMax and Ollama. Its centerpiece is one terminal control room: home lists every project and conversation on the machine, enter opens any of them in a tab, and parallel tasks each run in their own repository copy and branch. You describe problems in natural language; CodeAF splits them into a task tree and dispatches each to a worker/planner/checker crew selected from connected providers. Work that passes its check lands on your branch, never on main, and anything unverifiable waits under unread for a 1 accept or 2 reject. Three built-in subharnesses handle coding changes (/senior-dev), local security audits (/sec) and GitHub pull request reviews (/review), while codeaf do provides a headless JSON-and-exit-code path for CI and scripts. The UI renders locally while the conversation lives on the work machine, reachable over ssh from a laptop or phone. It is Apache 2.0 licensed and self-described as an early preview.
Reads natural-language requests from the terminal and turns them into a task tree; each task runs in a private repository copy on its own branch. For every task it picks models for three seats — worker, planner, checker — scored from catalog metadata over all connected providers: OpenRouter, DeepSeek, GLM, Kimi, MiniMax, Qwen, Codex via a ChatGPT plan, Ollama and any OpenAI-compatible endpoint. Subharnesses are invoked by slash commands: /senior-dev submits a change with build and test results, /sec produces security findings with Markdown, JSON and SARIF reports from local code, and /review reviews a GitHub pull request identified as owner/repo#123. Passed work merges onto your branch automatically; unverifiable work lands under unread for manual accept or reject. Headless mode runs codeaf do with a byte-exact brief, plans, executes, checks, then prints one JSON object and an exit code; codeaf exec runs a single worker and codeaf run executes a plan you edited. codeaf chat --host devbox separates the local screen from a conversation that stays on the remote host.
- Developers juggling several repositories who want one window showing what needs them, what is unread, what is running and what it cost across all projects.
- Teams optimizing coding spend on open models, running /senior-dev against real GitHub issues and comparing cost per solved issue.
- CI or cron pipelines that need structured output: codeaf do "..." --timeout 30m --json returns one JSON object plus an exit code.
- Security engineers auditing a local repository who want findings with evidence and suggested fixes as Markdown, JSON or SARIF.
- Reviewers who want a GitHub pull request examined with file locations, reasons, suggested fixes and review coverage.
- Users working on a remote dev box who attach from a laptop or phone over ssh and keep the same live conversation.
Key setup facts
Pulled from the install and usage notes below. The project README has the current values.
- Install / run
curl -fsSL https://agentfield.ai/get/codeaf | bash
- Config files
~/.codeaf/bin
How do you install or deploy this agent?
Run the install script, which places the release binary for your platform in ~/.codeaf/bin:
curl -fsSL https://agentfield.ai/get/codeaf | bash
codeafTo pin a release tag from the releases page:
curl -fsSL https://agentfield.ai/get/codeaf | VERSION=<tag> bashOr build from source with a Go toolchain:
git clone https://github.com/Agent-Field/CodeAF
cd CodeAF
make build
bin/codeafOn first start it connects OpenRouter in your browser or accepts a key; Codex signs in with a ChatGPT plan from /connect or codeaf connect codex; DeepSeek, GLM, Kimi, MiniMax and Qwen take keys; Ollama needs none.
How do you use this agent?
Run codeaf inside a project, then describe what is wrong as you would to a colleague; naming three things in one message can create three tasks. Call built-in specialists with slash commands:
/senior-dev fix the retry bug and add tests
/sec changes since main
/review owner/repo#123 focus on retriesInspect and pin the model crew and budgets:
/crew
/crew pin checker <model>
/crew models open
/task --best
/task --cheap
/redo strongerUse the headless entry point from scripts or CI:
codeaf do "bump every dependency whose changelog is worth reading" --timeout 30m --jsonDrive a remote work machine over your own ssh:
codeaf chat --host devboxKeys: home lists projects, enter opens one, tab flips back, alt+k jumps to any conversation, alt+. shows the key map, and codeaf manual opens the bundled manual.
What are this agent's strengths and limitations?
- One small Go binary with nothing else to install: the README measures 53 MB on disk and 27 MB RAM per added session, well below claude and opencode.
- Cost-oriented for open models; the README reports the highest solve rate and lowest cost per solved issue on 113 DeepSWE GitHub issues against nine other harnesses on the same model.
- Provider-agnostic by design: OpenRouter, DeepSeek, GLM, Kimi, MiniMax, Qwen, Codex, Ollama and any OpenAI-compatible endpoint, with /crew models open restricting every seat to open-weight models.
- Ships the scheduling, checking and merging layer, not just generation: parallel tasks on independent branches, auto-merge only after a check passes and never onto main, dev or release branches.
- Two front doors share one engine: interactive chat plus a headless codeaf do that returns a single JSON object and an exit code for CI, cron and benchmark harnesses.
- Screen and conversation are split, so a dropped ssh link redials and a question asked while you were away is still waiting.
- Self-declared early preview; the README warns of rough edges and there is no long-term stability or compatibility record yet.
- Anonymous telemetry is on by default and must be turned off explicitly via /settings, CODEAF_TELEMETRY=off or DO_NOT_TRACK=1.
- Cloud model calls and third-party API keys are the default path; fully offline operation is not documented beyond pointing at Ollama-style endpoints.
- sec and review read source without running your tests, build or exploits, so coverage notes and incomplete analysis must be read before acting, and no findings cannot guarantee no vulnerabilities.
- Relay-based remote access without ssh is built but only switches on when the hosted relay does.
- Several capabilities (saved subharness designs, model pool) require understanding scattered configuration switches documented across docs/ and the bundled manual.
How does this agent compare with similar options?
The README names the harnesses it benchmarks against on the same model: Claude Code, Codex, OpenCode, Kilo, DeepSeek's own harness, mini-swe-agent, pi, muse-code and omp, and compares disk and memory footprint against claude and opencode. Against a typical copilot it differs by centering a cross-project control room, a multi-seat model crew and a headless entry point rather than single-repository, single-thread completion.
Key facts side by side with the most closely related agents.
| Agent | Source review | Form / cost | Stars | Updated | Language | Full support on |
|---|---|---|---|---|---|---|
| CodeAF This agent | 41 · Major gaps | CLIFree + model costs | ★ 812 | 1d ago | Go | ChatGPT · Codex · OpenAI API |
| UNCUT | 57 · Major gaps | — | ★ 101 | 6d ago | Go | OpenAI API |
| Maestro Orchestration Platform | 64 · Some gaps | Agent plugin / skillFree + model costs | ★ 489 | 19d ago | JavaScript | Codex · Claude Code |
| Codewhale Terminal Coding Agent | 79 · Good | CLIFree + model costs | ★ 41k | today | Rust | OpenAI API · Claude API |
How does FollowAgents rate this agent?
Why each dimension lost points
The README discloses telemetry on by default and Model Pool off by default with field-level detail and opt-out paths, so data-flow transparency is decent (2). Least privilege is only visible in CI workflows (contents: read); the product itself runs as a single binary on the user's machine with cross-project task execution and automations, and no permission boundary or sandbox is described (1). User confirmation is limited to the narrative that checked work lands on a branch and never on main, plus a needs-you queue; there is no evidence of enforced confirmation for destructive actions such as commit, push or release (1). Sensitive data handling asserts that prompts, code and paths are never sent, but there is no implementation evidence for key storage or log redaction (1). Dependency security shows pinned versions and a reviewed raft replace patch, but no vulnerability scanning or SBOM (1). External effects (auto-commit, scheduled jobs, headless execution) are described without a rollback or undo mechanism (1). Rollback is limited to not overwriting a running executable; task-level rollback is absent (1). Source attribution is good: PR-AF/SEC-AF imports are labelled and their benchmark results are explicitly stated not to measure codeaf's review specialist (2).
Self-consistency has pointable contradictions: the README names DeepSeek V4 Flash as the benchmark model while the video caption says DeepSeek V4.1 Flash; the README says six seats but the table lists worker/planner/checker plus reflex and small rows, which does not add up cleanly (1). Dependency availability relies on many pseudo-versions and a local replace, with a recent go 1.26.5 requirement and no vendor or checksum notes (1). Failure messages appear in AGENTS.md and the census tool (an explicit error when no call log exists), but product-level error handling is not shown (1).
Audience and scenarios are well covered: terminal, server, phone over ssh, CI/headless and automations (2). Capability boundaries are partly stated (sec/review read source without running tests and cannot guarantee absence of vulnerabilities), but the overall boundary of what writes to disk, pushes or reaches the network is not systematically listed (1). Trigger precision is weak: slash commands and natural-language triggers are mixed with no description of trigger conditions or ambiguity handling (1). Environment fit claims one binary for darwin/linux/windows, yet built-in specialists run only on macOS and Linux, leaving a Windows gap (1).
Information architecture is clear: sectioned README, docs index, and a manual compiled into the binary (2). Install notes are complete with a curl script, version pinning and source build (2). Naming stability is enforced by internal/namelaw with a legacy-name rule (2). Examples exist but lean on marketing screenshots; copyable end-to-end workflows and an FAQ are missing (1). Known limitations are one line about early preview and rough edges, with no concrete list (1). The license is the full Apache-2.0 text (2). Versioning has releases and a docs/changes/unreleased process, but no CHANGELOG file in the packet (1). Maintenance responsibility points to the AgentField team, Discord and issues, but the publisher is unverified by the FollowAgents registry, so the accountable party is unclear (1).
Output usability: headless mode emits one JSON object and an exit code, and task output is a branch change plus reports, which is usable, but no complete output schema example is given (1). Marginal value: single-window multi-project work, a model pool and subharnesses are differentiating, yet the coding-harness field is crowded and the core benchmark is self-reported (1). Cost benefit: the lowest cost per solved issue is claimed, but the benchmark is the project's own and reproduction details are thin; /crew limits exist but the default $5 per-task cap is not justified (1).
Claim traceability is moderate: the benchmark cites 113 DeepSWE issues graded by official verifiers, but no result files or reproduction commands are in the repository (1). Cross-source corroboration: README and docs/model-usage-accounting.md agree on telemetry fields, but benchmark numbers have no second source (1). Fact/inference separation: the README correctly distinguishes PR-AF's original benchmark from codeaf's imported specialist, which is good practice, but marketing claims such as '#1 on DeepSWE' sit alongside measured evidence without clear separation (1).
- Telemetry is on by default and Model Pool can optionally report model measurements; explicitly disable CODEAF_TELEMETRY and model_pool before use in regulated or sensitive code environments.
- The product runs as a single binary executing tasks across projects, auto-committing to branches and running scheduled automations, with no described sandbox or permission boundary; run it in an isolated environment or dedicated account.
- The '#1 on DeepSWE' and cost claims are self-reported, with no result files or reproduction scripts in the repository; do not treat them as the sole basis for adoption.
- The README is internally inconsistent about model names (V4 Flash vs V4.1 Flash) and seat counts, suggesting docs and implementation may drift.
- Built-in specialists run only on macOS and Linux, so the advertised single-binary cross-platform story does not fully hold for Windows users.
- Publisher identity is unverified by the FollowAgents registry; verify maintenance responsibility and the update path independently.
Recent releases
Latest entries from the project's GitHub Releases. Notes are quoted from upstream as written, not rewritten or tested by FollowAgents.
-
Release notes excerpt
Install this dev build: ```sh curl -fsSL https://raw.githubusercontent.com/Agent-Field/CodeAF/12c3656e25d780375aded88ae12e74481a9382d0/scripts/install.sh | bash -s -- --dev curl -fsSL https://raw.githubusercontent.com/Agent-Field/CodeAF/12c3656e25d780375aded88ae12e74481a9382d0/scripts/install.sh | VERSION=dev-20261120-12c3656e25d7 bash ``` This installs this dev channel as devaf beside codeaf: ```sh curl -fsSL https://agentfield.ai/get/devaf | bash ```View on GitHub ↗ -
v0.8.3 codeaf v0.8.3
Release notes excerpt
Fixed - A slow local model gets ten times the wait, and response.patience changes it — [#2854](https://github.com/Agent-Field/codeaf/pull/2854) · engine chat docs <details><summary>4 things that are no longer true</summary> - A model on your own machine or network (Ollama, LM Studio, llama.cpp, a box on the LAN or Tailscale) was held to the hosted figures: 2 minutes for response headers, 10 seconds of silence after headers, 45 seconds quiet mid-reply, a 5-minute reply wall, 150 seconds for a non-streamed reply, and a 2-minute compaction summary. Under the default `response …View on GitHub ↗
FAQ
What does it cost to run?
Will it merge code into my main branch on its own?
Do sec and review run my code or tests?
Can I use it fully offline?
Which operating systems are supported?
Is CodeAF open source?
Is CodeAF safe to use?
Is CodeAF still maintained?
Who makes CodeAF?
What is CodeAF's official website?
Thanks — we use this to improve the page.