CodeAF

A terminal software factory for open models that schedules, checks and merges the work for you.

Stars
★ 812
Last updated
1d ago
License
Apache-2.0
Primary language
Go

At a glance

How it runs
CLI
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
OpenRouter or other provider API key (optional for Ollama)Ollama (optional, for local models)ssh (optional, for remote host usage)Shell / CLINetwork accessLocal filesystem
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

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.

  1. 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.
  2. Teams optimizing coding spend on open models, running /senior-dev against real GitHub issues and comparing cost per solved issue.
  3. CI or cron pipelines that need structured output: codeaf do "..." --timeout 30m --json returns one JSON object plus an exit code.
  4. Security engineers auditing a local repository who want findings with evidence and suggested fixes as Markdown, JSON or SARIF.
  5. Reviewers who want a GitHub pull request examined with file locations, reasons, suggested fixes and review coverage.
  6. 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
codeaf

To pin a release tag from the releases page:

curl -fsSL https://agentfield.ai/get/codeaf | VERSION=<tag> bash

Or build from source with a Go toolchain:

git clone https://github.com/Agent-Field/CodeAF
cd CodeAF
make build
bin/codeaf

On 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 retries

Inspect and pin the model crew and budgets:

/crew
/crew pin checker <model>
/crew models open
/task --best
/task --cheap
/redo stronger

Use the headless entry point from scripts or CI:

codeaf do "bump every dependency whose changelog is worth reading" --timeout 30m --json

Drive a remote work machine over your own ssh:

codeaf chat --host devbox

Keys: 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?

Pros
  • 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.
Limitations
  • 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?

FollowAgents source review · FARS-2.1
Major gaps
41/ 100 5-point scale 2.1 / 5
This review covers the source as of Nov 11, 2026. The project has shipped 1 stable release(s) since, which have not been re-reviewed. The score and verdict describe the reviewed version only. Recent releases ↓
Trust 12/29
Reliability 5/14
Adaptability 8/18
Convention 9/18
Effectiveness 4/13
Verifiability 3/8
Why each dimension lost points
Trust12 / 29 · 2.1/5

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).

Reliability5 / 14 · 1.8/5

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).

Adaptability8 / 18 · 2.2/5

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).

Convention9 / 18 · 2.5/5

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).

Effectiveness4 / 13 · 1.5/5

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).

Verifiability3 / 8 · 1.9/5

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).

Risks and how to mitigate them
  • 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.
Evidence confidence: Low Reviewed Nov 11, 2026 Reviewed revision 0c5fd475a350 New commits since this review; the score may not cover them
See the full review method →
Maintain this project? Add the FARS badge to your README

The badge shows the current review score and verdict and links back to this page. It refreshes about once an hour after a re-review.

FARS

[![FARS review](https://followagents.com/badge/codeaf.svg)](https://followagents.com/en/agents/codeaf)
<a href="https://followagents.com/en/agents/codeaf"><img src="https://followagents.com/badge/codeaf.svg" alt="FARS review"></a>

Recent releases

Latest entries from the project's GitHub Releases. Notes are quoted from upstream as written, not rewritten or tested by FollowAgents.

  1. dev-20261120-12c3656e25d7 codeaf dev-20261120-12c3656e25d7 Pre-release
    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 ↗
  2. 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?
The software is free under Apache 2.0. Costs come from the model providers you connect and are billed per call; local models such as Ollama avoid API charges. Each task has a $5 default limit adjustable in /crew, with an optional daily cap.
Will it merge code into my main branch on its own?
No. Work that passes its check lands on your own branch; the README states it never lands on main, dev or a release branch. Work nothing could check goes under unread for you to accept with 1 or reject with 2.
Do sec and review run my code or tests?
No. Both read source without running your tests, build, app or exploits, and they leave your code unchanged. Posting a review or fixing findings is a separate action you request, and the report's coverage and incomplete analysis should be read first.
Can I use it fully offline?
The repository does not document an offline-only deployment. Models can point at Ollama or any OpenAI-compatible endpoint, but the install script fetches the binary over the network, and telemetry and the Model Pool involve outbound requests unless disabled.
Which operating systems are supported?
The README badges a single binary for darwin, linux and windows. The built-in subharnesses are documented to run on macOS and Linux with no extra specialist installation.
Is CodeAF open source?
Yes. The source code is on GitHub (Agent-Field/CodeAF) under the Apache-2.0 licence.
Is CodeAF safe to use?
FollowAgents' FARS review (Nov 11, 2026) scored CodeAF 12/29 on trust and safety. None of the eight safety controls the review checks for was missing outright. The repository has changed since that review.
Is CodeAF still maintained?
Yes. The latest commit on GitHub is from 2026-11-20, within the last 30 days. The latest release is v0.8.3 (2026-11-19).
Who makes CodeAF?
CodeAF is published on GitHub by the account Agent-Field. FollowAgents has not verified which person or company is behind that account.
What is CodeAF's official website?
The project's GitHub repository lists https://agentfield.ai/codeaf as its website. That link is set by the repository owner; the source code itself is on GitHub (Agent-Field/CodeAF).
Was this page helpful?
View on GitHub ↗ Install ↓

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related concepts