Frontier-grade coding on open models, at a fraction of the cost.
CodeAF is a coding harness built for open models, to get the most out of every dollar. It is also a different way to work once more than one thing is going on: instead of three terminals of agents with you in the middle, one window where you hand work off, see what is moving across every project, and step in only where your judgment is needed. A factory, on your own machine, and the more you hand it the more it does.
#1 on DeepSWE of ten coding harnesses on the same model, ahead of Claude Code, Codex, OpenCode, Kilo and DeepSeek's own harness, at the lowest cost per solved issue (benchmarks).
Written in Go as one small binary, with nothing else to install or run. Apache 2.0. By AgentField AI.
Early preview. CodeAF is young and moving fast. Expect rough edges, and tell us where you hit them on Discord or in an issue.
codeaf-demo.mp4
Real speed, with sound. The three tasks run live on DeepSeek V4.1 Flash; the other projects and the large task tree are a seeded demo machine.
Install
curl -fsSL https://agentfield.ai/get/codeaf | bash
codeafPin a version, or build from source
The script puts the release binary for your platform in ~/.codeaf/bin. To
pin a version, give it a tag from the
releases page, where the
assets and checksums also live:
curl -fsSL https://agentfield.ai/get/codeaf | VERSION=<tag> bash
To build it yourself: git clone, make build, bin/codeaf
(guide).
On first start it connects OpenRouter in your browser, or takes a key. Codex signs in
a ChatGPT plan from /connect or codeaf connect codex; DeepSeek, GLM, Kimi, MiniMax
and Qwen take keys; Ollama needs none.
One window for every project
An agent that lives in one folder means a terminal per repository, and a tmux layout to remember which is which. CodeAF is one window.
home lists every project and conversation on the machine. enter opens any
of them in a tab, and the one you left keeps streaming with its tasks still
running. tab flips back. alt+k jumps to any conversation, open or closed.
Each keeps its own approval rules, models and spend limit.
home answers what needs you, what is unread, what is running and what it
cost, for all of them at once. A digit answers a question from its row.
Talk, and it becomes tasks
Say what is wrong the way you would to a colleague. Name three things in one message and each can become its own task, in its own copy of the repository, on its own branch. The conversation stays yours while they run, and the rail beside it shows every task and its subtasks.
› three more while you are on it: the retry test fails one run in five on CI,
the pricing page wraps mid word on phones, and the deploy key expires friday
Work that passes its check lands on your branch by itself, never on main,
dev or a release branch. Work nothing could check waits under unread:
1 accept, 2 not right.
What a factory is
Agents run by hand got fast, but the scheduling, checking and merging stayed with you.
A factory is the third picture: one line out, one line back.
- It does the middle. It sizes the work, splits it, runs the parts where they cannot collide, tests what came back and merges what passed.
- It asks only when it must. A question waits under
needs you, from every project. Everything else it decides, writes down, and carries on.
Subharnesses: specialists built for one job
A general agent does everything a little. The work that matters most comes round
in the same shape: review this pull request, fix this issue, audit these
dependencies. A subharness is a specialist built for exactly that job, with its
own plan, its own checks and the models that suit it. It takes typed input and
returns typed output, so it delivers what it promised or is marked incomplete.
A run is a task like any other, on home, with a room and a stop.
- Coming soon, native: PR-AF, the #1 open-source code reviewer on Martian Code-Review-Bench.
- Native now:
/senior-dev, the developer subharness. First of ten harnesses on DeepSWE, in the benchmark below. - Your own: "make me a harness for triaging flaky tests" designs one, saves
it, and
/subharnessruns it.
Benchmarks
/senior-dev, CodeAF's developer subharness, against nine other coding harnesses
on the same model, DeepSeek V4 Flash: 113 real GitHub issues from DeepSWE, graded
by the official verifiers. It solved the most issues and paid the least for each
one it solved.
Every number, the method and the limits: docs/benchmarks/deepswe.
The right model for each call
One session, many models. The model you talk to is one seat. Every task you hand off runs on a crew of three more, picked for that task from what kind of work it is — a bug fix, a complex fix, open-ended work, or something else:
| seat | what it does |
|---|---|
| worker | does the work. Most of the bill. |
| planner | plans runs and designs subharnesses |
| checker | checks finished work before it lands |
The crew is auto by default. Each seat is scored from its catalog metadata by
learned weights, moved by how this install's own tasks ended, over every model your
connected providers serve. The method is in the paper,
Pareto Crewing. /crew shows it: the seats, the allowed models, the
providers, a per-task limit ($5 unless set) and an optional daily cap, and today's
spend. /crew pin checker <model> pins one seat, /crew models open limits every
seat to open-weight models, and /task --best or /task --cheap moves one task.
Each task says its crew and what it cost against the estimate, and /redo stronger runs it again a step up. Two cheap rows, reflex and small work, take
the small calls you did not type: memory, titles, digests, the safety gate.
Every finished task is graded by the check it already had to pass, and each
request goes to the provider that has been fastest for that kind of call.
codeaf models prints the ratings.
Providers built in: OpenRouter, DeepSeek, GLM, Kimi, MiniMax, Qwen, Codex through a ChatGPT plan, Ollama and any OpenAI-compatible endpoint.
Model Pool
Installs can pool what they have measured about models. It is on by
default: what an install sends is computed, text-free numbers about the models
it ran (role, model, a number, which model judged, door, size bucket, day) under
a per-install nonce, never code,
prompts, paths or an identity, and codeaf pool status shows exactly what is
waiting to go. Turn it off with model_pool = off on the settings sheet or
CODEAF_MODEL_POOL=off; read uses the pool and sends nothing, and
CODEAF_TELEMETRY=off caps it at read along with the usage counts. The relay
publishes a signed index of what the installs measured. The index is mirrored on the model-pool branch at
pool/index.json. The design is Pareto Crewing;
the relay's code is under relay/, with a runbook
that includes running your own.
Standing orders
Rules, reminders and watches are one thing, and you set them up by saying them.
"Never commit straight to main here." "Every Monday, draft the weekly update."
"Tell me when CI goes red." A card asks once; 1 and it stands, in this project
or everywhere, on the same daily spend limit as the rest.
Headless is the other front door
The same factory, with the conversation removed, for CI, cron, scripts and benchmark harnesses.
codeaf do "bump every dependency whose changelog is worth reading" --timeout 30m --json
do takes your brief byte for byte, plans, runs and checks it, and prints one
JSON object and an exit code. Where the conversation would ask, it takes its
best answer and records the assumption. exec runs one worker with no plan;
run executes a plan you edited. The contract.
Run it on your dev box, drive it from anywhere
Most agents on a remote box mean ssh, tmux, and a terminal that lags on every
key. CodeAF splits in two instead. The screen runs on the machine in front of
you. The conversation runs on the machine that owns the work, and home shows
that machine: its projects, tasks and standing orders.
codeaf chat --host devbox # your own ssh: config, keys, jump hosts. nothing to install there but codeaf- Typing never waits on the network. Drawing the screen makes no round trip. Pressing enter makes one.
- Close the lid, the work keeps going. The conversation lives on devbox. A dropped link redials for five minutes, a question asked while you were away is still waiting when you come back, and desk and laptop can watch the same turn.
- Files cross both ways. Paste a screenshot or drop a file and it lands on devbox. Click a path in a reply and it opens here, in your own editor.
On your phone there is no app to install. ssh in from any mobile terminal, run
codeaf in the project, and it joins the same live conversation, folded to fit
the screen.
Still local over a connection: spend, search and memory. Reaching a machine with no ssh at all, through a relay and a pairing code, is built and switches on when the hosted relay does. How it works.
What a copilot does, and what CodeAF does
| a copilot | CodeAF | |
|---|---|---|
| where you work | one window, one repository | every project on the machine, from one control room |
| what you do | watch it type | describe work, answer what needs you, decide what lands |
| what runs | one model, one thread | six seats chosen per call, and subharnesses built for one job |
| how long it lasts | one session | conversations, tasks and standing orders that outlive the window |
| without you | it stops | headless, standing orders, a phone in your pocket |
Performance benchmark
One Go binary, 53 MB on disk: up to 21x smaller than the field.
| CodeAF | claude | heaviest rival measured | |
|---|---|---|---|
| On disk | 53 MB | 224 MB, 4x | 1.1 GB, 21x (omp) |
| RAM per added session | 27 MB | 216 MB, 8x | 653 MB, 24x (opencode) |
| 16 idle sessions | 507 MB | 3.5 GB, 7x | 10.5 GB, 21x (opencode) |
| Peak during one turn | 122 MB | 421 MB, 3.4x | 1.0 GB, 8x (opencode) |
| Resume a 50-turn session | 145 ms | 392 ms, 2.7x | 3.0 s, 20x (opencode) |
Sixteen of ours fit in half a gigabyte; claude's fourth tab alone needs more.
Harness, method and every table: docs/benchmarks/performance.
Docs
codeaf manual, oralt+.for the key map. The manual ships in the binary and the chat reads it too.- Guide: every flag, key, slash command and exit code.
- docs/: architecture, headless, remote, limits.
Telemetry
codeaf sends anonymous usage counts to AgentField, on by default.
- Sent: version, OS, mode (chat or task), session counts, errors, and total tokens used — as counts and bands, under a random per-install id.
- Never: anything about you or your work. No prompts, code, file names, paths, repo names, keys, email, IP address, machine name, or model names.
- Turn off: the
telemetryswitch in the chat's/settings,CODEAF_TELEMETRY=off, orDO_NOT_TRACK=1. Any one of them stops every stream, the Model Pool's rows included. The/settingsswitch stops sending immediately; turning it back on takes effect the next time codeaf starts.
This page and docs/TELEMETRY.md are the whole disclosure: the product itself prints no notice and has no telemetry command. The document lists every field, when it is sent, and every way to turn it off, and a test holds it to the code.
Built by the AgentField team.