codeaf

module
v0.5.1-rc.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 1, 2026 License: Apache-2.0

README

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.

https://github.com/user-attachments/assets/bc87e460-17b1-4d7a-8c69-284b524ea194

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
codeaf
Pin 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 /subharness runs 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.

pool updated

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, or alt+. 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: anonymous usage counts. CODEAF_TELEMETRY=off turns them off. 
codeaf sends anonymous usage counts to AgentField.
  Sent:  version, OS, mode, session counts, errors, and total tokens used.
  Never: anything about you or your work. No prompts, code, file names,
         paths, repo names, keys, email, IP, or machine name.
  What is collected:        codeaf telemetry info
  Turn off:                 CODEAF_TELEMETRY=off

Counts and buckets only, never your work. docs/TELEMETRY.md lists every field and every way to turn it off.

Built by the AgentField team.

Directories

Path Synopsis
bench
bashloop command
lanelab/gosim command
Command gosim replays `bench/lanelab`'s three scenarios against the SHIPPED lane router and prints the ship gate.
 Command gosim replays `bench/lanelab`'s three scenarios against the SHIPPED lane router and prints the ship gate.
cmd
codeaf command
The cache from the command line: what it holds, and the one destructive verb that empties it.
 The cache from the command line: what it holds, and the one destructive verb that empties it.
codeaf-census command
codeaf-census is the instrument the recovery design asks for: it reads the model-call log this build always writes (`~/.codeaf/logs/calls.jsonl`, internal/calllog) and prints, as markdown, the table docs/design/recovery/DESIGN.md §1 argues from.
 codeaf-census is the instrument the recovery design asks for: it reads the model-call log this build always writes (`~/.codeaf/logs/calls.jsonl`, internal/calllog) and prints, as markdown, the table docs/design/recovery/DESIGN.md §1 argues from.
codeaf-changes command
codeaf-changes is the changelog's gate, its scaffold and its typesetter.
 codeaf-changes is the changelog's gate, its scaffold and its typesetter.
codeaf-demo-home command
codeaf-notices command
codeaf-notices builds the third-party notice carried beside every release.
 codeaf-notices builds the third-party notice carried beside every release.
codeaf-release command
codeaf-release resolves release tags and channel retention for the release workflow.
 codeaf-release resolves release tags and channel retention for the release workflow.
codeaf-replay command
codeaf-replay judges a chooser by REGRET ON TEN DAYS OF LOG rather than by a screenshot.
 codeaf-replay judges a chooser by REGRET ON TEN DAYS OF LOG rather than by a screenshot.
codeaf-suite-lock command
codeaf-suite-lock holds the machine-wide heavy-suite lock while a command runs.
 codeaf-suite-lock holds the machine-wide heavy-suite lock while a command runs.
harness-design command
Command harness-design is a development rig, not a shipped surface.
 Command harness-design is a development rig, not a shipped surface.
plandb command
Command plandb is the plan store's command line (docs/design/plandb-cli /DESIGN.md): the coordination verbs a bash-belt worker runs through its one bash tool, over the same store the runtime dispatches from.
 Command plandb is the plan store's command line (docs/design/plandb-cli /DESIGN.md): the coordination verbs a bash-belt worker runs through its one bash tool, over the same store the runtime dispatches from.
relay command
Command relay is the codeaf relay: a blind pipe between a machine that runs codeaf and a machine somebody is sitting at.
 Command relay is the codeaf relay: a blind pipe between a machine that runs codeaf and a machine somebody is sitting at.
internal
approval
Package approval is the consent policy for the v3 session agent: one pure function from a tool call to allow, prompt or deny.
 Package approval is the consent policy for the v3 session agent: one pure function from a tool call to allow, prompt or deny.
buildinfo
Package buildinfo names the source and moment that produced this codeaf.
 Package buildinfo names the source and moment that produced this codeaf.
cachedir
Package cachedir owns the one directory under codeaf's state root that holds nothing but caches: ~/.codeaf/cache, where every task worker's toolchain caches live (internal/exec's sweCacheRoot puts go-mod, go-build, cargo, npm and pip under it).
 Package cachedir owns the one directory under codeaf's state root that holds nothing but caches: ~/.codeaf/cache, where every task worker's toolchain caches live (internal/exec's sweCacheRoot puts go-mod, go-build, cargo, npm and pip under it).
calllog
Package calllog is codeaf's always-on record of the model calls it makes.
 Package calllog is codeaf's always-on record of the model calls it makes.
callrows
Package callrows reads the model-call log this build always writes (`~/.codeaf/logs/calls.jsonl`, internal/calllog) back into rows.
 Package callrows reads the model-call log this build always writes (`~/.codeaf/logs/calls.jsonl`, internal/calllog) back into rows.
cas
Package cas stores immutable blobs by their SHA-256 digest.
 Package cas stores immutable blobs by their SHA-256 digest.
catalog
Package catalog owns OpenRouter model discovery across every modality.
 Package catalog owns OpenRouter model discovery across every modality.
ci
Package ci holds the laws about the repository's own gate — the tests that read .github and the Makefile rather than the product, and refuse the shapes that let dev go red unseen on 2026-09-02 (#372).
 Package ci holds the laws about the repository's own gate — the tests that read .github and the Makefile rather than the product, and refuse the shapes that let dev go red unseen on 2026-09-02 (#372).
ci/cmd/testreport command
ci/testreport
Package testreport turns go test's JSON event stream into a durable timing report.
 Package testreport turns go test's JSON event stream into a durable timing report.
codexauth
Package codexauth signs a codeaf profile in to a ChatGPT plan in the same way the Codex CLI does, and adapts that plan's Responses API for codeaf's provider client.
 Package codexauth signs a codeaf profile in to a ChatGPT plan in the same way the Codex CLI does, and adapts that plan's Responses API for codeaf's provider client.
config
Package config holds the harness's process-wide defaults.
 Package config holds the harness's process-wide defaults.
connect
Package connect is the accounts layer: it holds the keys that let codeaf act on a person's own SaaS accounts — their mail, their calendar — and hands the rest of the program one ready, self-refreshing http.Client per account.
 Package connect is the accounts layer: it holds the keys that let codeaf act on a person's own SaaS accounts — their mail, their calendar — and hands the rest of the program one ready, self-refreshing http.Client per account.
connect/ampcatalog
Package ampcatalog is codeaf's own copy of the parts of the amp-labs provider catalog that this program reads.
 Package ampcatalog is codeaf's own copy of the parts of the amp-labs provider catalog that this program reads.
connect/ampcatalog/gen command
Command gen writes internal/connect/ampcatalog/providers.json from the amp-labs catalog.
 Command gen writes internal/connect/ampcatalog/providers.json from the amp-labs catalog.
consent
Package consent is the price before the purchase.
 Package consent is the price before the purchase.
craft
Package craft is codeaf's learned know-how: workflows, skills, verifiers, and exemplars, versioned in a git repository the resident owns.
 Package craft is codeaf's learned know-how: workflows, skills, verifiers, and exemplars, versioned in a git repository the resident owns.
credits
Package credits reads the default model service's account balance without sending a completion or keeping a dollar amount on disk.
 Package credits reads the default model service's account balance without sending a completion or keeping a dollar amount on disk.
crewroute
Package crewroute picks the crew for one task: which model sits the worker, the planner and the checker seat, on which provider's route, for this piece of work and nothing longer.
 Package crewroute picks the crew for one task: which model sits the worker, the planner and the checker seat, on which provider's route, for this piece of work and nothing longer.
ctxbudget
Package ctxbudget is the one place that turns a model's context window into byte and token budgets.
 Package ctxbudget is the one place that turns a model's context window into byte and token budgets.
delegate
Package delegate is what codeaf needs of the programs it carries and can hand a whole task to — senior-dev first (docs/design/delegate/PROTOCOL.md): what one IS (a Go value in the build's list, internal/delegate/builtin), the command line every one of them answers (`codeaf <name> …`), the records a running one writes on its stdout and the one reader over them, the model API that is its only road to a model, the log of the conversation it holds over that road, and the launch of it as a child process that streams, stops on SIGTERM and ends with one terminal record.
 Package delegate is what codeaf needs of the programs it carries and can hand a whole task to — senior-dev first (docs/design/delegate/PROTOCOL.md): what one IS (a Go value in the build's list, internal/delegate/builtin), the command line every one of them answers (`codeaf <name> …`), the records a running one writes on its stdout and the one reader over them, the model API that is its only road to a model, the log of the conversation it holds over that road, and the launch of it as a child process that streams, stops on SIGTERM and ends with one terminal record.
delegate/builtin
Package builtin is the list of programs this build carries — the one place a program becomes part of codeaf (internal/delegate).
 Package builtin is the list of programs this build carries — the one place a program becomes part of codeaf (internal/delegate).
effort
Package effort is the reasoning-depth ladder: five named rungs, one resolver, and nothing else.
 Package effort is the reasoning-depth ladder: five named rungs, one resolver, and nothing else.
enginehost
Package enginehost is the process that keeps a conversation alive between connections.
 Package enginehost is the process that keeps a conversation alive between connections.
env
Package env is the one door for environment variables owned by codeaf.
 Package env is the one door for environment variables owned by codeaf.
exec
Package exec runs the leaves of a plan.
 Package exec runs the leaves of a plan.
exec/bare
Package bare — edit matching logic, pinned to pi's edit-diff.js.
 Package bare — edit matching logic, pinned to pi's edit-diff.js.
filedoor
Package filedoor is the loopback door: a 127.0.0.1 HTTP listener, owned by one chat surface, that turns files on the FAR machine into things this machine's own programs can open — a browser tab, cmd+click on an OSC 8 link, the platform opener.
 Package filedoor is the loopback door: a 127.0.0.1 HTTP listener, owned by one chat surface, that turns files on the FAR machine into things this machine's own programs can open — a browser tab, cmd+click on an OSC 8 link, the platform opener.
filelock
filememo
Package filememo is the one answer to "a file read at most once per change".
 Package filememo is the one answer to "a file read at most once per change".
furrow
Package furrow is codeaf's seam onto `furrow`, a separate program codeaf carries inside itself (Agent-Field, Apache-2.0, https://github.com/Agent-Field/furrow).
 Package furrow is codeaf's seam onto `furrow`, a separate program codeaf carries inside itself (Agent-Field, Apache-2.0, https://github.com/Agent-Field/furrow).
furrowbin
Package furrowbin carries furrow inside codeaf and puts it on disk the first time anything wants it.
 Package furrowbin carries furrow inside codeaf and puts it on disk the first time anything wants it.
furrowbin/cmd/fetch command
Command fetch puts the pinned furrow release where `go:embed` will find it.
 Command fetch puts the pinned furrow release where `go:embed` will find it.
fuzzy
Package fuzzy is the one quick-search scorer for every picker on the chat surface: fzf's FuzzyMatchV2 — a modified Smith-Waterman local alignment — with the corrections helix's nucleo documents for the same algorithm.
 Package fuzzy is the one quick-search scorer for every picker on the chat surface: fzf's FuzzyMatchV2 — a modified Smith-Waterman local alignment — with the corrections helix's nucleo documents for the same algorithm.
gitidentity
Package gitidentity holds what a run's commits carry and leave out: the signature shared by codeaf's own commits and the commands a program runs on its behalf, the identity senior-dev's engine commits under, and the caches a run's own tests leave behind.
 Package gitidentity holds what a run's commits carry and leave out: the signature shared by codeaf's own commits and the commands a program runs on its behalf, the identity senior-dev's engine commits under, and the caches a run's own tests leave behind.
guard
Package guard is the one place a panic stops being fatal.
 Package guard is the one place a panic stops being fatal.
head
Package head turns durable thread messages into immediate conversational replies and asynchronous graph commands.
 Package head turns durable thread messages into immediate conversational replies and asynchronous graph commands.
history
Package history is the input-history store: the lines the person typed, kept across sessions so a surface can walk them back with the up arrow.
 Package history is the input-history store: the lines the person typed, kept across sessions so a surface can walk them back with the up arrow.
home
Package home resolves the one directory codeaf owns: its state root.
 Package home resolves the one directory codeaf owns: its state root.
jsrun
Package jsrun is THE JavaScript runtime for subharnesses — one generic Go runner parameterized by a bundle.
 Package jsrun is THE JavaScript runtime for subharnesses — one generic Go runner parameterized by a bundle.
lane
Package lane is what this build believes about the machines behind a model.
 Package lane is what this build believes about the machines behind a model.
lane/control
Package control decides WHEN a wait has gone on long enough to act on, and it is the only thing in this build that decides that.
 Package control decides WHEN a wait has gone on long enough to act on, and it is the only thing in this build that decides that.
lane/lanestub
Package lanestub is a fake router with lanes of a scripted speed: the shared measuring instrument for everything in `internal/lane`.
 Package lanestub is a fake router with lanes of a scripted speed: the shared measuring instrument for everything in `internal/lane`.
lease
Package lease elects the one process currently serving as a resident for a durable codeaf store.
 Package lease elects the one process currently serving as a resident for a durable codeaf store.
leave
Package leave is the one road out of a process somebody outside it asked to stop.
 Package leave is the one road out of a process somebody outside it asked to stop.
manual
Package manual is what codeaf knows about itself, embedded in the binary.
 Package manual is what codeaf knows about itself, embedded in the binary.
manual/asked
Package asked is the questions a STRANGER asks, and the page each one is about.
 Package asked is the questions a STRANGER asks, and the page each one is about.
modelsource
Package modelsource describes the places models come from without reading the machine or opening the network.
 Package modelsource describes the places models come from without reading the machine or opening the network.
modelsource/sourcestub
Package sourcestub provides a small OpenAI-shaped service for source-routing tests.
 Package sourcestub provides a small OpenAI-shaped service for source-routing tests.
offpath
Package offpath holds the two shapes of work that must happen but must not happen HERE — on the path a person is waiting on.
 Package offpath holds the two shapes of work that must happen but must not happen HERE — on the path a person is waiting on.
opener
Package opener hands a link or path to the desktop without waiting for the application that receives it.
 Package opener hands a link or path to the desktop without waiting for the application that receives it.
openrouterauth
Package openrouterauth connects a local codeaf profile to OpenRouter without asking the person to make and copy an API key by hand.
 Package openrouterauth connects a local codeaf profile to OpenRouter without asking the person to make and copy an API key by hand.
orchestrate
Package orchestrate is the adaptive runner: a planner model and a frontier scheduler, married.
 Package orchestrate is the adaptive runner: a planner model and a frontier scheduler, married.
orientation
Package orientation builds a compact repo digest that a leaf's first prompt carries so orientation costs zero turns: a bounded directory tree, code-file declaration/signature outlines (NOT bodies), test-file names, and — when the run already knows it — the failing-test summary.
 Package orientation builds a compact repo digest that a leaf's first prompt carries so orientation costs zero turns: a bounded directory tree, code-file declaration/signature outlines (NOT bodies), test-file names, and — when the run already knows it — the failing-test summary.
packed
Package packed ships a folder of embedded text compressed, and unpacks it on the first read.
 Package packed ships a folder of embedded text compressed, and unpacks it on the first read.
packed/cmd/pack command
Command pack writes the archive a packed corpus ships as.
 Command pack writes the archive a packed corpus ships as.
pair
Package pair is how two machines come to trust each other without ssh, and the encrypted tunnel they talk through afterwards.
 Package pair is how two machines come to trust each other without ssh, and the encrypted tunnel they talk through afterwards.
pair/cpace
Package cpace implements the CPace password authenticated key exchange (PAKE) instantiated with the ristretto255 group.
 Package cpace implements the CPace password authenticated key exchange (PAKE) instantiated with the ristretto255 group.
patch
Package patch is the exact-match text editor behind `codeaf patch`: one old text in, the file with its single occurrence replaced out.
 Package patch is the exact-match text editor behind `codeaf patch`: one old text in, the file with its single occurrence replaced out.
paymentrefusal
Package paymentrefusal recognises the narrow response shape that proves a key authenticated but its account cannot fund a request.
 Package paymentrefusal recognises the narrow response shape that proves a key authenticated but its account cannot fund a request.
pdfx
Package pdfx is the LOCAL RUNG of the document ladder: PDF text, extracted in this process, out of this binary, with no service to call and nothing to install.
 Package pdfx is the LOCAL RUNG of the document ladder: PDF text, extracted in this process, out of this binary, with no service to call and nothing to install.
plan
Package plan builds and revises the task graph for a goal.
 Package plan builds and revises the task graph for a goal.
plandb
pool/index
Package index reads a schema-versioned JSON document of per-model measurements into a value every reader in a process can share.
 Package index reads a schema-versioned JSON document of per-model measurements into a value every reader in a process can share.
pool/index/cmd/seedgen command
Command seedgen regenerates the seed index the binary carries from the live relay.
 Command seedgen regenerates the seed index the binary carries from the live relay.
pool/judge
Package judge scores a finished run seat by seat, independently of the crew that produced it.
 Package judge scores a finished run seat by seat, independently of the crew that produced it.
pool/outbox
Package outbox keeps small measurement rows in a local append-only file and hands them to a destination: an HTTP endpoint that takes newline-delimited JSON, or another file.
 Package outbox keeps small measurement rows in a local append-only file and hands them to a destination: an HTTP endpoint that takes newline-delimited JSON, or another file.
pool/poolcfg
Package poolcfg resolves how the measurement pool behaves from two stored settings — the mode word and the trusted key — and an environment handed in as a function.
 Package poolcfg resolves how the measurement pool behaves from two stored settings — the mode word and the trusted key — and an environment handed in as a function.
pool/poolkey
Package poolkey is the one place the binary's trusted pool key lives.
 Package poolkey is the one place the binary's trusted pool key lives.
pool/pull
Package pull fetches a signed JSON document, checks its signature against keys it was handed, and keeps the last good copy on disk so that the next run has something to work with when the fetch does not go through.
 Package pull fetches a signed JSON document, checks its signature against keys it was handed, and keeps the last good copy on disk so that the next run has something to work with when the fetch does not go through.
pool/record
Package record turns a judge's seat scores into the two records an install keeps of them: additive cells in a tally sheet on disk, and one row per score in an outbox.
 Package record turns a judge's seat scores into the two records an install keeps of them: additive cells in a tally sheet on disk, and one row per score in an outbox.
pool/tally
Package tally keeps additive sufficient statistics for observations so that two sheets recorded on different machines can be merged by addition, in any order, and give the same answer as one sheet that saw everything.
 Package tally keeps additive sufficient statistics for observations so that two sheets recorded on different machines can be merged by addition, in any order, and give the same answer as one sheet that saw everything.
processgroup
profile
Package profile records what tasks actually cost this model, and uses it to recalibrate the ruler the planner sizes tasks with.
 Package profile records what tasks actually cost this model, and uses it to recalibrate the ruler the planner sizes tasks with.
programguide
Package programguide holds the model-facing descriptions of programs codeaf carries.
 Package programguide holds the model-facing descriptions of programs codeaf carries.
provider
Package provider is codeaf's model adapter: the one place in the process that speaks to an OpenAI-compatible endpoint.
 Package provider is codeaf's model adapter: the one place in the process that speaks to an OpenAI-compatible endpoint.
provider/modelapi
Package modelapi is the model API codeaf serves each run of a program it carries (internal/delegate): an OpenAI-style chat-completions endpoint on this machine, opened by one token, whose every call goes through codeaf's own model funnel — refused at the run's ceiling, priced, logged, and written down as one turn of the program's conversation with codeaf.
 Package modelapi is the model API codeaf serves each run of a program it carries (internal/delegate): an OpenAI-style chat-completions endpoint on this machine, opened by one token, whose every call goes through codeaf's own model funnel — refused at the run's ceiling, priced, logged, and written down as one turn of the program's conversation with codeaf.
provider/pool
Package pool is the surface's provider seam: the model-switchable client a slot holds, the per-model clients a pinned job is served by, and the billing that makes every structuring call land on the same rail its leaves land on.
 Package pool is the surface's provider seam: the model-switchable client a slot holds, the per-model clients a pinned job is served by, and the billing that makes every structuring call land on the same rail its leaves land on.
redact
Package redact takes the SHAPE of a secret out of text before anything keeps it, shows it, or sends it to a model.
 Package redact takes the SHAPE of a secret out of text before anything keeps it, shows it, or sends it to a model.
reflex
Package reflex is the per-turn tier's client: the small structured calls a conversation makes AROUND an exchange rather than in it.
 Package reflex is the per-turn tier's client: the small structured calls a conversation makes AROUND an exchange rather than in it.
registry
Package registry is the one command registry established by the August 2026 chat-rebuild audit's 5.22 (no longer in the tree; "Discoverability: no typed-only actions"): every action lives on a visible object, and typing is an accelerator, never the only door.
 Package registry is the one command registry established by the August 2026 chat-rebuild audit's 5.22 (no longer in the tree; "Discoverability: no typed-only actions"): every action lives on a visible object, and typing is an accelerator, never the only door.
relay
Package relay is the blind pipe between a machine that runs codeaf and a machine somebody is sitting at.
 Package relay is the blind pipe between a machine that runs codeaf and a machine somebody is sitting at.
release
Package release tests the release workflow and installer as one public distribution surface.
 Package release tests the release workflow and installer as one public distribution surface.
remote
Package remote is the wire between a surface on one machine and an engine on another.
 Package remote is the wire between a surface on one machine and an engine on another.
resident
Banking: what an attempt that died on the clock hands to the one that takes over from it.
 Banking: what an attempt that died on the clock hands to the one that takes over from it.
revision
Package revision is the engine half of a job's second thoughts: the gate that decides whether a deliverable is done, the citation invariant that decides whether a named gap may buy more work, the judgements that decide who takes a retry and whether an exhausted leaf left anything behind, and the sentinel pass that edits a job's remaining plan in light of what just landed.
 Package revision is the engine half of a job's second thoughts: the gate that decides whether a deliverable is done, the citation invariant that decides whether a named gap may buy more work, the judgements that decide who takes a retry and whether an exhausted leaf left anything behind, and the sentinel pass that edits a job's remaining plan in light of what just landed.
roles
Package roles is the model-role registry: one name for every auxiliary LLM call the surface makes, and one rule for which model answers it.
 Package roles is the model-role registry: one name for every auxiliary LLM call the surface makes, and one rule for which model answers it.
router
Package router turns one model into a panel of them.
 Package router turns one model into a panel of them.
rtk
Package rtk puts a compressor between a leaf's shell and the work model's context.
 Package rtk puts a compressor between a leaf's shell and the work model's context.
run
Package run is the run: one supervisor that launches every ready task of a plan store and owns the lifecycle from first dispatch to the root's completion.
 Package run is the run: one supervisor that launches every ready task of a plan store and owns the lifecycle from first dispatch to the root's completion.
sanitize
Package sanitize is the one output chokepoint for terminal-unsafe text (the August 2026 chat-rebuild audit, no longer in the tree, Part 10.2 items 6-7).
 Package sanitize is the one output chokepoint for terminal-unsafe text (the August 2026 chat-rebuild audit, no longer in the tree, Part 10.2 items 6-7).
search
Package search is the web-search layer the v3 session agent calls through: one Provider that answers a query with a list of links, one Fetcher that turns a link into readable text, and an OPEN registry that decides which implementation of each the surface actually gets.
 Package search is the web-search layer the v3 session agent calls through: one Provider that answers a query with a list of links, one Fetcher that turns a link into readable text, and an OPEN registry that decides which implementation of each the surface actually gets.
seniordev
Package seniordev is senior-dev: an autonomous coding agent codeaf carries and runs, and nothing else can.
 Package seniordev is senior-dev: an autonomous coding agent codeaf carries and runs, and nothing else can.
seniordev/app
This file is where the run's records go: the stage and step records the run reports to codeaf, and the run's own log of every record and bus payload for the tests that read one.
 This file is where the run's records go: the stage and step records the run reports to codeaf, and the run's own log of every record and bus payload for the tests that read one.
seniordev/baked
Package baked embeds the agent document the run executes.
 Package baked embeds the agent document the run executes.
seniordev/bus
Package bus is the in-process event bus.
 Package bus is the in-process event bus.
seniordev/config
Package config is the configuration layer: project config files, the SENIOR_DEV_* environment surface and their merge.
 Package config is the configuration layer: project config files, the SENIOR_DEV_* environment surface and their merge.
seniordev/core
Application filesystem.
 Application filesystem.
seniordev/engine/calc
Package calc holds the pure token and cost arithmetic that runs between an OpenRouter response and a persisted assistant message: it normalises the provider usage block, prices a call from the model catalog, and derives the compaction budget and its watermarks from the model limits and the compaction config.
 Package calc holds the pure token and cost arithmetic that runs between an OpenRouter response and a persisted assistant message: it normalises the provider usage block, prices a call from the model catalog, and derives the compaction budget and its watermarks from the model limits and the compaction config.
seniordev/engine/msgmodel
Cursor encoding: a pagination cursor is `{id, time}` encoded as unpadded RFC 4648 URL-safe base64.
 Cursor encoding: a pagination cursor is `{id, time}` encoded as unpadded RFC 4648 URL-safe base64.
seniordev/engine/orclient
Package orclient is the OpenRouter streaming client: it assembles the chat-completions request body and headers, decodes the SSE response into stream parts (text, reasoning, tool calls, usage, finish), validates and repairs tool calls against the registered tool set, and registers the outcome of each call with the adaptive router.
 Package orclient is the OpenRouter streaming client: it assembles the chat-completions request body and headers, decodes the SSE response into stream parts (text, reasoning, tool calls, usage, finish), validates and repairs tool calls against the registered tool set, and registers the outcome of each call with the adaptive router.
seniordev/engine/retrysched
Package retrysched classifies the errors a model call can end in: the parsed Err shape, the timeout and context-overflow predicates the step loop consults, and the StatusError a failed provider response becomes.
 Package retrysched classifies the errors a model call can end in: the parsed Err shape, the timeout and context-overflow predicates the step loop consults, and the StatusError a failed provider response becomes.
seniordev/engine/steploop
Package steploop drives one turn of the agent.
 Package steploop drives one turn of the agent.
seniordev/format
Formatter service
 Formatter service
seniordev/id
Package id generates prefixed, time-ordered identifiers.
 Package id generates prefixed, time-ordered identifiers.
seniordev/jsonutil
Package jsonutil wraps encoding/json for the two encodings senior-dev uses everywhere: compact and two-space indented, both without HTML escaping so that `<`, `>` and `&` inside model-visible text stay readable.
 Package jsonutil wraps encoding/json for the two encodings senior-dev uses everywhere: compact and two-space indented, both without HTML escaping so that `<`, `>` and `&` inside model-visible text stay readable.
seniordev/modelsdev
Package modelsdev loads the models.dev provider/model catalog used to price and describe models.
 Package modelsdev loads the models.dev provider/model catalog used to price and describe models.
seniordev/netpolicy
Package netpolicy makes senior-dev aware of runs where agent-initiated network access is unavailable, so agents stop wasting cycles attempting it.
 Package netpolicy makes senior-dev aware of runs where agent-initiated network access is unavailable, so agents stop wasting cycles attempting it.
seniordev/patch
Package patch implements the apply_patch format: the patch parser, fuzzy chunk matching, direct filesystem application, and detection of apply_patch invocations inside shell commands.
 Package patch implements the apply_patch format: the patch parser, fuzzy chunk matching, direct filesystem application, and detection of apply_patch invocations inside shell commands.
seniordev/permission
Package permission evaluates tool permission rules.
 Package permission evaluates tool permission rules.
seniordev/project
Package project resolves the directory and project a tool call runs against.
 Package project resolves the directory and project a tool call runs against.
seniordev/question
Question lifecycle service
 Question lifecycle service
seniordev/router/adaptive
Package adaptive is the adaptive model router: it picks a model for each call from the configured pool for the caller's tier (high, low, frontier) by sampling a score from each candidate's recorded reliability, speed, price and current load, and it learns from every registered outcome (latency, throughput, rate limits and other failures, each with its own cooldown).
 Package adaptive is the adaptive model router: it picks a model for each call from the configured pool for the caller's tier (high, low, frontier) by sampling a score from each candidate's recorded reliability, speed, price and current load, and it learns from every registered outcome (latency, throughput, rate limits and other failures, each with its own cooldown).
seniordev/router/state
Package state holds the process-wide adaptive router singleton and the route-event fan-out: every route decision is written to stderr as one `[router] <json>` NDJSON line and delivered to the process-local subscribers.
 Package state holds the process-wide adaptive router singleton and the route-event fan-out: every route decision is written to stderr as one `[router] <json>` NDJSON line and delivered to the process-local subscribers.
seniordev/session/compaction
Controller adapts the compaction service to the step-loop task seam.
 Controller adapts the compaction service to the step-loop task seam.
seniordev/session/evidenceharvest
Package evidenceharvest extracts the lines worth preserving from tool output before a compaction: command outcomes, exact error signatures and paths referenced across messages.
 Package evidenceharvest extracts the lines worth preserving from tool output before a compaction: command outcomes, exact error signatures and paths referenced across messages.
seniordev/session/fullverification
Package fullverification discovers the project-wide build and test entrypoints that form the session-end machine verification floor.
 Package fullverification discovers the project-wide build and test entrypoints that form the session-end machine verification floor.
seniordev/session/instruction
Package instruction discovers the project's instruction files (AGENTS.md and the files named in config, local or remote) and tracks which ones a session has already loaded, so each is injected into the prompt once.
 Package instruction discovers the project's instruction files (AGENTS.md and the files named in config, local or remote) and tracks which ones a session has already loaded, so each is injected into the prompt once.
seniordev/session/llmcall
Package llmcall resolves adaptive-router choices and assembles one OpenRouter call.
 Package llmcall resolves adaptive-router choices and assembles one OpenRouter call.
seniordev/session/loopguard
Package loopguard is a pure repetition and budget guard for agent action loops: it stops a run that repeats the same action, cycles through a short sequence of actions, or exceeds a cost or action budget, and warns once before a budget runs out.
 Package loopguard is a pure repetition and budget guard for agent action loops: it stops a run that repeats the same action, cycles through a short sequence of actions, or exceeds a cost or action budget, and warns once before a budget runs out.
seniordev/session/outputoffload
Package outputoffload keeps large tool outputs out of the context window: the full text is written to a file under .senior-dev/tool-output and the model sees a bounded extract (head, tail and diagnostic-looking lines) plus the path.
 Package outputoffload keeps large tool outputs out of the context window: the full text is written to a file under .senior-dev/tool-output and the model sees a bounded extract (head, tail and diagnostic-looking lines) plus the path.
seniordev/session/overflow
Package overflow is the session-layer view of the compaction budget.
 Package overflow is the session-layer view of the compaction budget.
seniordev/session/projectors
The SQLite cold-start retry policy.
 The SQLite cold-start retry policy.
seniordev/session/runbudget
Package runbudget resolves the optional run-level cost and wall-clock budget from flags and environment and tracks spend against it.
 Package runbudget resolves the optional run-level cost and wall-clock budget from flags and environment and tracks spend against it.
seniordev/session/sessioncore
Package sessioncore owns the durable session lifecycle: sessions, messages and parts are written to the flat JSON storage and every change is published on the bus.
 Package sessioncore owns the durable session lifecycle: sessions, messages and parts are written to the flat JSON storage and every change is published on the bus.
seniordev/session/system
Package system builds the environment block of a turn's system prompt: the model in use, the working directory and the date.
 Package system builds the environment block of a turn's system prompt: the model in use, the working directory and the date.
seniordev/storage
Package storage is the flat-file JSON store.
 Package storage is the flat-file JSON store.
seniordev/tool
The apply_patch tool: a multi-file patch envelope (add, update, move, delete) validated up front and applied after one permission check that covers every file it touches.
 The apply_patch tool: a multi-file patch envelope (add, update, move, delete) validated up front and applied after one permission check that covers every file it touches.
seniordev/util
Eager per-write git checkpoint
 Eager per-write git checkpoint
session
artifacts.go is the global deliverables index (docs/CHAT-V3.md, Decision 26): one append-only JSONL file under the v3 home, one row per thing the harness produced FOR the person — a generated image, an export, a finished document.
 artifacts.go is the global deliverables index (docs/CHAT-V3.md, Decision 26): one append-only JSONL file under the v3 home, one row per thing the harness produced FOR the person — a generated image, an export, a finished document.
shaped
Package shaped is the one place the harness asks a model for an answer of a stated shape and reads what comes back.
 Package shaped is the one place the harness asks a model for an answer of a stated shape and reads what comes back.
skills
Package skills discovers agent skills where foreign harnesses keep them.
 Package skills discovers agent skills where foreign harnesses keep them.
splitgate
Package splitgate is the enumeration evidence gate: does a piece of work name enough independent items for dividing it to beat one worker doing them in order?
 Package splitgate is the enumeration evidence gate: does a piece of work name enough independent items for dividing it to beat one worker doing them in order?
standing
Package standing is the ambient side of v3: the things a conversation leaves behind that keep working after the window is closed — a reminder, a watch, a rule, an overnight job — and the small, honest machinery that wakes them.
 Package standing is the ambient side of v3: the things a conversation leaves behind that keep working after the window is closed — a reminder, a watch, a rule, an overnight job — and the small, honest machinery that wakes them.
store
Package store owns codeaf's durable, append-only task graph.
 Package store owns codeaf's durable, append-only task graph.
subharness
Package subharness is the registry of node kinds a sub-harness is built from, and the durable home of the sub-harnesses themselves.
 Package subharness is the registry of node kinds a sub-harness is built from, and the durable home of the sub-harnesses themselves.
subharness/prompts
Package prompts is where the designer's brief LIVES, as prose, so that the hardest writing in this system is edited as writing rather than as a builder full of Fprintf calls.
 Package prompts is where the designer's brief LIVES, as prose, so that the hardest writing in this system is edited as writing rather than as a builder full of Fprintf calls.
substore
Package substore is where subharness bundles live on disk.
 Package substore is where subharness bundles live on disk.
taxonomy
Package taxonomy is the response boundary: the one place in this build that answers "what kind of failure was that?" and hands back what to do about it.
 Package taxonomy is the response boundary: the one place in this build that answers "what kind of failure was that?" and hands back what to do about it.
teams
Package teams is the one store for teams: named sets of conversations, the file they live in, each member's short handle, a team's manager and the Traffic log a team's members and manager write to.
 Package teams is the one store for teams: named sets of conversations, the file they live in, each member's short handle, a team's manager and the Traffic log a team's members and manager write to.
telemetry
Package telemetry implements codeaf's anonymous usage counting exactly as docs/TELEMETRY.md spells it: four typed events, an allowlisted property set, a local spool, and one deadline-bounded flush.
 Package telemetry implements codeaf's anonymous usage counting exactly as docs/TELEMETRY.md spells it: four typed events, an allowlisted property set, a local spool, and one deadline-bounded flush.
thread
Package thread owns the single door for durable conversation writes.
 Package thread owns the single door for durable conversation writes.
trace
Package trace is the record of everything one run did, kept only when somebody asked for it.
 Package trace is the record of everything one run did, kept only when somebody asked for it.
tui2/modelui
Package modelui holds the words a model's name is spelled with.
 Package modelui holds the words a model's name is spelled with.
tui2/prose
Package prose renders model-written markdown into styled terminal rows.
 Package prose renders model-written markdown into styled terminal rows.
tui2/reltime
Package reltime is the one relative-time formatter in the product.
 Package reltime is the one relative-time formatter in the product.
tui2/tokens
Package tokens is the shared token layer for the chat surfaces: the one place a colour, a glyph, or a formatted live cell is named.
 Package tokens is the shared token layer for the chat surfaces: the one place a colour, a glyph, or a formatted live cell is named.
tui3
Package tui3 is the v3 chat surface in its first, linear form: a try-out door onto internal/session and nothing else.
 Package tui3 is the v3 chat surface in its first, linear form: a try-out door onto internal/session and nothing else.
update
Package update finds, installs, and restarts onto codeaf releases.
 Package update finds, installs, and restarts onto codeaf releases.
verify
Package verify discovers the project-wide build and test entrypoints that form the session-end machine verification floor, runs one of them, and reads the failing test names out of what it printed.
 Package verify discovers the project-wide build and test entrypoints that form the session-end machine verification floor, runs one of them, and reads the failing test names out of what it printed.
video
Package video is the LOCAL half of codeaf's video work: the things done to files that already exist, on this machine, with ffmpeg — as against the renders bought from a provider a clip at a time (internal/session/tools_video.go).
 Package video is the LOCAL half of codeaf's video work: the things done to files that already exist, on this machine, with ffmpeg — as against the renders bought from a provider a clip at a time (internal/session/tools_video.go).
watchdog
Package watchdog keeps standing watches available when no codeaf terminal is open.
 Package watchdog keeps standing watches available when no codeaf terminal is open.
wirelog
Package wirelog counts what the surface actually puts on the wire.
 Package wirelog counts what the surface actually puts on the wire.
workspace
Package workspace retains logical organization independently of the records it groups.
 Package workspace retains logical organization independently of the records it groups.
test
remote/stub command
Command modelstub is a scripted, deterministic stand-in for the model endpoint, so that the two-machine harness in internal/e2e/remote_test.go can drive a REAL turn without an API key and without a network.
 Command modelstub is a scripted, deterministic stand-in for the model endpoint, so that the two-machine harness in internal/e2e/remote_test.go can drive a REAL turn without an API key and without a network.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.