Agency OS Radar

Daily open-source discoveries for a one-person AI software agency

Report date: Saturday, November 7, 2026 · Agency OS Edition · Addis Ababa (EAT)

Start Here (plain English)

The problem: running an AI agency alone means juggling several agent terminals, remembering which project is in which window, checking whether each task's tests actually passed, and stopping everything the moment you look away. The scheduling, checking and merging all stay with you, and that is exactly where mistakes slip through.

The solution in today's radar: one factory window. CodeAF is an open-source coding harness for open models that does the middle of the work: it splits what you say into tasks, runs each task in its own copy of the repository on its own branch, tests what comes back, merges only what passes its check onto your branch (never main), parks questions in a "needs you" queue and unchecked work in an "unread" queue for your explicit accept/reject.

One featured factory per day, per the format confirmed Nov 5, 2026. Links, license, stars, commits and releases verified from GitHub and the repo's own pages on Nov 7, 2026; project-made claims (benchmarks, performance) are labeled as project claims, not independently verified. The business-opportunity section is retired from this format. Not previously featured in the Nov 3-6 reports (Orkas, dsh-superagent, Betterleaks, Spec Kit).

The Featured Factory: CodeAF INVESTIGATE

Link: github.com/Agent-Field/CodeAF · homepage: agentfield.ai/codeaf
License (verified from the LICENSE file): Apache 2.0.
Verified repo facts (GitHub, Nov 7, 2026): 649 stars, 77 forks, written in Go, created Aug 5, 2026, last push Nov 7, 2026 (today). Self-described "Open-Source Software factory for Open Models", by AgentField AI.
What it does (simple English): one small binary that turns your plain-English requests into parallel coding tasks. Each task works in its own copy of the repo on its own branch; work that passes its check lands on your branch by itself; work nothing could check waits under "unread" for you to accept (1) or reject (2); questions wait under "needs you". It also has specialist sub-agents (e.g. a senior-dev change builder, a PR reviewer, a local-code auditor), runs headless with standing orders, and can drive a remote machine over SSH.
What changed recently (verified): commit today, Nov 7, 2026 ("Show how much sync space is used in /status", #2491), and two dev-channel releases published today by CI (dev-20261107-92bf4744b54a and dev-20261107-9eefa142f18e, GitHub-signed). Earlier this week: team sharing on paired computers (Nov 3), Relay coordination as a Raft group (Oct 26), "Wormhole" sync of your codeaf between computers, on by default (Oct 24).
Why it matters to a vibe coder: it industrializes the vibe. Instead of watching one agent type, you describe work, answer only what needs you, and decide what lands. The "unchecked work waits for human accept" queue is the single best guardrail in any harness this radar has covered: nothing reaches your branch just because the agent felt done.
Costs (verified): the tool is free (Apache 2.0). Models are not: it connects to OpenRouter (browser or key), or takes keys for DeepSeek, GLM, Kimi, MiniMax and Qwen; Codex signs in with a ChatGPT plan; Ollama runs local models with no key (free but needs your hardware). Per-token API costs apply, open source ≠ free model access. Anonymous telemetry is on by default (counts only, no prompts/code/paths; turn off with CODEAF_TELEMETRY=off or DO_NOT_TRACK=1).
Windows compatibility & installation (verified status): the documented install is a bash script (curl … | bash) and the built-in specialists are documented for macOS and Linux. No native Windows path is documented in the README; a Windows binary was not verified. WSL2 is the plausible route on your Windows PC but is UNTESTED, that is why the verdict is INVESTIGATE, not TEST NOW. Hardware: any modern PC for the harness itself; local models via Ollama need a reasonably strong CPU/GPU.

The Factory Map: CodeAF mapped onto the Agency OS lifecycle

Agency OS stage	CodeAF skill/module	Artifact produced	Which gate consumes it
LEAD / DISCOVERY	home dashboard + needs-you queue (all projects on the machine)	machine-wide status: running, unread, costs	Orchestrator intake / discovery scan
PROBLEM_DEFINITION / PROPOSAL	conversation; questions wait under "needs you"	answered question queue	Human answers = approval evidence
DEVELOPMENT	task splitting: each named issue becomes its own task, repo copy and branch; /senior-dev subharness	feature branches with diffs	DEVELOPMENT gate evidence (reviewed diffs)
QA	built-in check: only work that passes its check lands; PR-review subharness	check results per task	QA gate (never replaces your own checks)
CEO_REVIEW	"unread" queue: unchecked work waits for 1 accept / 2 not right	accept/reject decisions	Explicit human approval point
MAINTENANCE	headless mode + standing orders / scheduled work	standing-order execution log	Maintenance review
SECURITY (partial)	"audit local code" subharness	audit findings	SECURITY gate input (no dep/secret scanning)
SPECIFICATION / ARCHITECTURE / REUSABLE_COMPONENT	No direct skill (honest gap)	,	,

CodeAF is the middle of a factory: task splitting through checked merges, with human accept/reject at the end. It complements Spec Kit (Nov 6, specification side) and gate_engine.py, it never replaces governance.

Honest Gaps

Not covered: no specification/clarify step (Spec Kit, featured Nov 6, fills that), no dependency/secret/vulnerability scanning (the audit subharness is code review, not a scanner; Trivy/Gitleaks remain necessary), no persistent project-state authority, no formal gate/rollback engine, and no REUSABLE_COMPONENT harvesting.
Project claims, not independently verified: the "#1 on DeepSWE of ten harnesses" ranking and the performance table (53 MB binary, RAM per session) are the project's own benchmarks. Treat as UNVERIFIED until reproduced.
Maturity: the project labels itself an "early preview" with rough edges; releases on the dev channel are pre-releases published by CI.
Agency OS compatibility: plausible, untested, the needs-you/unread pattern matches your governance philosophy (ask instead of assume, human approval before landing), but there is no evidence it reads project-state.json, and it would sit behind your gates, not inside them.

Why It Fits Agency OS

Ask instead of assume: questions queue under "needs you" from every project at once, the same discipline as your REAL/SIMULATED/ASSUMPTION rules.
Human approval point: unchecked work cannot land; it waits under "unread" for an explicit accept, a built-in CEO_REVIEW-style gate before anything reaches your branch.
Never touches main: passing work lands on your branch, never main, dev or a release branch, rollback boundaries stay clean.
It decides, writes down, and carries on: the project's own description says it records what it decides; those records are exactly the evidence trails Agency OS gates want.

Limitations, Risks & Human Review

No security scanning stage and no gate engine: never treat a merged CodeAF branch as production-ready; run your SECURITY and QA gates unchanged.
Model/API costs per token, or local hardware demands if you use Ollama; set a spend limit per conversation (the tool supports per-conversation spend limits).
Telemetry is on by default, turn it off in /settings if that matters to you or a client.
The install is a curl-pipe-to-bash script: read it before running it; never pipe unreviewed scripts to a shell on a machine with client data.
Young project, pre-release dev channel: pin a version; expect rough edges; human review required before accepting anything from "unread".

Test Today: CodeAF inside WSL2 on your Windows PC (~45 minutes, free with Ollama)

Prerequisites: Windows 10/11 with WSL2 (Ubuntu), Git inside WSL, and either Ollama in WSL with a small coding model (no API key, free) or a small OpenRouter budget. No subscription beyond that.
Official installation steps (from the repo): read the script first: download https://agentfield.ai/get/codeaf and inspect it, then run curl -fsSL https://agentfield.ai/get/codeaf | bash inside WSL, or build from source with git clone + make build. The script puts the binary in ~/.codeaf/bin.
Set up: create a scratch repo in WSL, run codeaf there, connect Ollama (no key) or paste an OpenRouter key, set a spend limit, and turn telemetry off in /settings (or export CODEAF_TELEMETRY=off).
Practical test: in one message, name three tiny issues in the scratch repo (like the README's example). Watch each become its own task on its own branch; answer one "needs you" question; leave one task with no checkable outcome and confirm it waits under "unread".
Expected results: three branches with changes, a task rail per conversation, and at least one item parked in "unread", proof that unchecked work cannot land on your branch.
Safety precautions: scratch repo only, no client data, WSL confines the blast radius, review every diff before pressing 1 (accept), keep telemetry off for the experiment, and pin the version instead of tracking the dev channel.

Agency OS Integration Proposal: CodeAF as a DEVELOPMENT-stage task runner, behind your gates

Problem solved: development tasks are run and merged by hand today; test evidence is assembled manually and nothing stops a half-checked change from being treated as done.
Workflow/agent improved: the dev agent's execution loop, at the DEVELOPMENT stage (tasks handed over from the spec/plan artifacts).
Lifecycle stage: DEVELOPMENT, feeding the existing DEVELOPMENT → QA transition. Additive only.
Inputs: dependency-ordered task list from the spec/plan stage + repo branch. Outputs: per-task branches, per-task check results, and the needs-you/unread queues as evidence artifacts.
How results are validated: unchanged, precommit_check.py and prepush_release_check.ps1 run on every CodeAF branch; an item is marked VERIFIED only after the independent re-run output exists and a human reads the diff. project-state.json stays authoritative.
What happens on failure: a failing or unchecked task stays unmerged in "unread"; the DEVELOPMENT gate simply does not advance (BLOCKED). Nothing auto-advances Agency OS state.
Gate or human approval? It feeds the existing gates; it adds none and replaces none. Accepting unread work is an explicit human decision, your CEO_REVIEW approval requirement is untouched.
Smallest safe experiment: today's WSL2 scratch test, above, zero changes to any Agency OS script; decide adoption only after the unread-queue behavior is confirmed.

Daily Learning: check-gated auto-merge ("work that passes its check lands by itself")

Concept (simple English): a change earns its way into your branch by passing a real check, not by the agent claiming it is done. Merging becomes a reward for evidence, not a default.
How an AI agent might get it wrong: it reports "tests pass" from memory, assumption, or a partial run, so unchecked work gets the same confidence as checked work, the failure CodeAF's unread queue exists to prevent.
How you recognize the failure: no command transcript or output file behind the claim, suspiciously instant "passes", no branch created, or an accept prompt arriving with no check result attached.
What detects it: re-run prepush_release_check.ps1 yourself on the branch; under Agency OS rules the agent's test claim stays UNVERIFIED until your independent run's output exists.

Final Summary

Best discovery today: CodeAF (Apache 2.0, active today Nov 7, 2026), an open-source software factory for open models whose needs-you/unread queues build human approval into the merge itself. Verdict: INVESTIGATE (Windows native unverified; test via WSL2).
Best security/reliability improvement: check-gated auto-merge plus the explicit unread accept/reject queue, it blocks the classic "agent says done" failure at the point of landing. Pair with your existing scanners; CodeAF adds no security scanning of its own.
Best Agency OS integration: run CodeAF headless as the DEVELOPMENT-stage task runner behind your existing gates, branches and check evidence in, your validation scripts and human approvals unchanged.
One practical action today: install CodeAF in WSL2 on a scratch repo with Ollama, name three tiny issues, and verify that unchecked work waits under "unread" instead of landing.