Agency OS Radar

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

Report date: Saturday, October 24, 2026 · Agency OS Edition · Addis Ababa (EAT)

Start Here (plain English)

The problem: you build with AI agents that move fast — but "fast" means nothing to a client if the tests were invented, the keys leaked into a transcript, or nobody supervised what the agent actually did. Trust comes from machine-produced, dated evidence, not agent claims.

The solution in today's radar: five fresh, verified finds. Codex CLI shipped v0.164.0 yesterday with reusable prompt presets and a permission system. munder-difflin is a brand-new open-source "office" that coordinates the coding-agent CLIs you already use. secret-guard intercepts agents before they can read your .env files. tester-army/e2e is an agentic test framework that records what the agent did and replays it without paying the model again. Nuxt UI v4 just made its entire 125+ component catalog free under MIT.

Coverage note: Codex CLI v0.164.0 released Oct 23, 2026 (within 24 hours); the rest of today's picks come from the allowed 7-day window (Oct 17–24, 2026). Prior reports were available (Oct 20: SkillSpector, vercel-labs/skills, OMA, Strix, agent-device; Oct 21: Trivy, OSV-Scanner, Playwright, Orchestrator.inc, Orca; Oct 22: OpenCode 2.0, promptfoo, ai-memory, google/skills, CommitShield; Oct 23: wshobson/agents, agent-fleet-o, Titus, mcp-accessibility-scanner, shadcn-admin) — none of today's picks repeat them. Per your standing preference set Oct 19, the Ethiopia business-opportunity section remains removed.

The Production-Readiness Gap

The criticism: "AI-built apps aren't production-ready" is an evidence problem. "The app works", "the agent didn't touch secrets", and "the tests passed" are worthless as agent claims — they only count when a tool produced an artifact with a date and a pass/fail result the gate engine can read.

Today's answer: e2e turns "the UI works" into recorded, replayable test steps with hard assertions; secret-guard turns "the agent didn't touch secrets" into blocked-operation records and an audit journal; Codex CLI's permission system turns "the agent behaved" into explicit approval records; munder-difflin's mailboxes and memory give every agent action a visible trail.

Why this maps to Agency OS: your governance demands VERIFIED evidence before a gate advances. These tools are external evidence producers your gate engine can consume — none of them replaces the gate engine or project-state.json; they feed it.

Top 5 Discoveries

1. OpenAI Codex CLI — v0.164.0 terminal coding agent TEST NOW

Link: github.com/openai/codex
What it does (simple English): OpenAI's terminal coding agent, written in Rust: it reads your repository, edits files, and runs commands inside a sandbox, guided by AGENTS.md instruction files you version in the repo.
What changed recently and when: v0.164.0 released Oct 23, 2026 — ten /presets slots for reusable prompts, inline /model and /permissions arguments, enterprise-managed MCP sign-in, and a Bedrock setup wizard on by default. Mid-response steering (redirecting the agent while it is still generating) became the default in v0.163.0 on Oct 15. (VERIFIED from release coverage this week.)
Why it matters to a vibe coder: your dev agent needs a harness with sandboxing and versionable instructions; the new preset system is close to your "specialist agent prompts as files" idea, and the permission system records what the agent was and wasn't allowed to do.
License & costs: Apache-2.0 (VERIFIED from the repo). Model access is NOT free: ChatGPT Plus from $20/mo or API-key billing; GPT-5.5 retired from Codex on Oct 14, 2026. Open source code ≠ free model access.
Windows & install: the Linux sandbox uses bubblewrap, so WSL2 is required on Windows (per OpenAI's Windows docs). npm install, sign in with ChatGPT or API key.
Agency OS fit: DEVELOPMENT stage, dev agent harness — plausible — untested with your orchestrator/gate engine.
Evidence/output: session transcripts, permission and approval records.
Limitations/risks/human review: WSL dependency; usage costs on every run; never grant unrestricted approval modes on client repos — human approval stays required for commercial decisions and releases.
Verdict: TEST NOW — if you already have a ChatGPT plan, try /presets with one of your agent prompt files.

2. munder-difflin — open-source "office of agents" orchestrator INVESTIGATE

Link: github.com/HarnessMD/munder-difflin
What it does (simple English): takes the terminal agent CLIs you already run (claude, codex, gemini, opencode, grok, kimi, qwen, crush, pi, copilot and more) and turns them into a self-coordinating team: each agent gets long-term memory, a mailbox, and a desk on a 2D office floor, while a router ("Michael") assigns work between them.
What changed recently and when: launch week — v0.5.6 is current; the Pro tier is free for everyone only until Saturday, October 24, 2026 (today), then $150 USD/year, purchasing-power adjusted down to about $100/year. (VERIFIED from the repo README.)
Why it matters to a vibe coder: it is the closest off-the-shelf match to your orchestrator-coordinated specialist-agents design — worth studying for routing, memory, and mailbox patterns even if you don't adopt it.
License & costs: open-source core, but Pro is a paid subscription — the exact free/Pro feature boundary was NOT verified today; check before relying on any feature.
Windows & install: Node.js 18+ and npm, plus a C/C++ toolchain for node-pty's native addon (Visual Studio Build Tools on Windows), and at least one supported agent CLI on PATH. Requirements VERIFIED from the repo; Windows behavior untested.
Agency OS fit: orchestrator pattern reference, DEVELOPMENT stage — plausible, untested.
Evidence/output: agent memory and mailbox logs, routing and coordination records.
Limitations/risks/human review: brand-new project (expect rough edges); paid tier boundary unverified; it coordinates multiple agent CLIs on your machine — scope each CLI's permissions first and review what "Michael" can dispatch.
Verdict: INVESTIGATE — study the design; do not put a week-old launcher in your production path.

3. secret-guard — blocks agents from reading your .env files INVESTIGATE

Link: github.com/JohnXu22786/secret-guard
What it does (simple English): a security plugin for DeepSeek Harness (dsh) that intercepts agent reads and writes of sensitive files (.env, credentials, key material) BEFORE the agent's file tools execute, masks secret-shaped values that slip through into tool results, keeps a JSONL audit journal, and provides sg_* inspection tools that never print raw values.
What changed recently and when: new project — listed in the dsh plugin registries on Aug 17, 2026, and surfacing in this week's ecosystem roundups; no new release verified in the last 7 days.
Why it matters to a vibe coder: prevention beats detection: the most common leak is an agent reading a real key into its context. This stops that path at the tool layer and journals every attempt — the enforcement layer your "agents must never invent facts or expose secrets" rule wants.
License & costs: MIT (VERIFIED from the repo LICENSE). Free; no external API.
Windows & install: pure TypeScript source, zero build steps — but it requires DeepSeek Harness (dsh) as its host. Dependency VERIFIED; the combination is untested on Windows.
Agency OS fit: SECURITY stage plus a runtime guard for every agent stage — plausible, untested.
Evidence/output: JSONL audit journal entries and blocked-operation records — exactly the artifact type a gate can read.
Limitations/risks/human review (from the repo's own Security Notes): transformed content (base64, rev, split lines) defeats the shape rules; symlinks and ".." path aliases are known limitations. It stops the most common path, not everything — pair with a repo/history scanner, don't treat it as complete protection.
Verdict: INVESTIGATE — high-value pattern; gated on whether you adopt dsh as a harness.

4. tester-army/e2e — agentic E2E testing with deterministic replay TEST NOW

Link: github.com/tester-army/e2e
What it does (simple English): you write ordinary TypeScript tests with locators and assertions — and where a selector would be brittle, you write a goal in plain English (agent.act('upgrade to the Pro plan')). An AI agent drives the app to reach the goal; once a later assertion confirms the result, the actions are recorded, and the next run replays them WITHOUT calling a model until the app changes.
What changed recently and when: releases shipped Oct 9 (v0.19.0, with @e2e-dev/web 0.14.0 and @e2e-dev/mobile 0.11.0), Oct 13, and Oct 15–16, 2026; ~11.5k stars as of Oct 20 with roughly +120/day growth. (VERIFIED from release pages and independent reviews this week.)
Why it matters to a vibe coder: AI-coded UIs break in ways brittle selectors miss. This gives your QA agent natural-language test authoring PLUS deterministic, near-zero-cost replay — the UI-E2E evidence your QA gate needs, produced by a real browser, not an opinion.
License & costs: Apache-2.0 (VERIFIED from the repo). The framework is free; you bring a model — an API key, a gateway, an existing ChatGPT/Copilot/OpenCode subscription via npx e2e login, or a LOCAL Ollama model at zero cost. The replay cache is what keeps cost flat after the first green run.
Windows & install: Node.js 24.8+ (or 22.22.3+); mobile testing needs Xcode or the Android SDK; Windows users run it inside WSL. Pre-1.0: APIs can change between minor releases. The CLI sends anonymous usage telemetry (commands and failure points, no test content or credentials) — opt out with npx e2e telemetry disable or E2E_TELEMETRY_DISABLED=1.
Agency OS fit: QA stage, QA agent — plausible — untested with your pipeline.
Evidence/output: test run reports and traces, plus automatic PR comments via @e2e-dev/github; recorded replay steps are themselves reviewable artifacts.
Limitations/risks/human review: young project (repo created July 22, 2026) and pre-1.0 churn; agent-driven tests still need real assertions — a goal without a check is not evidence; WSL prerequisite on Windows.
Verdict: TEST NOW — with a local Ollama model in WSL, this is today's highest-value experiment.

5. Nuxt UI v4 — entire 125+ component catalog now free under MIT INVESTIGATE

Link: github.com/nuxt/ui
What it does (simple English): a Vue 3 / Nuxt component library for business web apps — buttons, tables, forms, navigation, modals, dashboards — with accessibility built in. In v4, all 125+ components previously locked behind the paid Pro tier became completely free under the MIT license.
What changed recently and when: the v4 license change (Pro components → MIT) is the meaningful update, verified via an October 2026 template survey. The exact v4 release date was NOT independently verified today — check the repo's releases page before citing one.
Why it matters to a vibe coder: a full, accessible, MIT dashboard component set means near-zero license risk when reusing components across client projects — a direct REUSABLE_COMPONENT asset for your library.
License & costs: MIT for the formerly-Pro components (VERIFIED for the change via the October 2026 survey). Free; no subscription; no external API.
Windows & install: standard Node.js/Vite toolchain — runs natively on Windows, no WSL needed.
Agency OS fit: REUSABLE_COMPONENT stage plus spec/UX stage — plausible, untested.
Evidence/output: the vendored component code itself — diffable, reviewable, reusable.
Limitations/risks/human review: Vue/Nuxt only — useless for React projects; verify the installed package's LICENSE file before commercial reuse; still run your full QA/SECURITY gates on anything built with it.
Verdict: INVESTIGATE — high-value if you adopt a Vue stack; zero-risk to evaluate.

Test Today: Nuxt UI v4 on Windows (~30–45 min)

Why this one: the only pick today that runs natively on Windows with zero subscriptions, zero API keys, and zero WSL — and the MIT change makes it safe to evaluate for client reuse.
Prerequisites: a Windows PC; Node.js 18+ LTS; any editor (an AI IDE helps but isn't required).
Official installation steps: create a project with npm create nuxt@latest, then install the UI package (npm install nuxt ui) and add it to your Nuxt modules per the official Nuxt UI docs; run npm run dev.
Practical test: build one page with a dashboard layout — buttons, cards, a data table, a sidebar navigation menu, and the dark-mode toggle. Let your AI IDE generate it from the official v4 docs, then verify accessibility basics yourself in the browser: keyboard tab order, visible focus states, and readable contrast in dark mode.
Expected results: a working, accessible dashboard page in under an hour, all MIT-licensed — a candidate template for your REUSABLE_COMPONENT library.
Safety precautions: do this in a scratch project, never a client repo; don't paste real API keys into example env files; confirm the LICENSE file in the installed package before any commercial use; review AI-generated component code before keeping it.

Agency OS Integration Proposal: e2e reports as QA-gate UI-E2E evidence

Problem solved: your QA stage covers UI-E2E, but today "the UI works" is an agent claim unless a real browser run produced a report.
Exact workflow/agent it improves: the QA agent's UI-E2E check, complementing (not replacing) your Python validation utilities.
Where in the lifecycle: QA stage — run on every entry to QA; re-run at RELEASE as regression evidence.
Inputs: the staged web app's local URL; test goals in plain English plus TypeScript assertions; a model — a local Ollama model keeps cost at zero.
Outputs: dated test run reports and traces; optional PR comments via @e2e-dev/github; recorded replay steps as reviewable artifacts, referenced from project-state.json as VERIFIED evidence.
How results are validated: the report is produced by the external tool, not authored by the agent; the agent may attach and summarize it, never substitute its own verdict; a pass counts only if all assertions are green AND the report file exists — otherwise the claim stays UNVERIFIED.
What happens on failure: any failed assertion blocks QA advancement → fix → re-run. Cache invalidation on failure forces a fresh agent pass, so stale replays cannot mask regressions. This adds one evidence type to your existing gate engine — no replacement of the gate engine or governance is proposed.
Blocks a gate or needs human approval? Rule-based gate-blocking on assertion failures; human approval remains required for UAT, client acceptance, and release — exactly as in your governance.
Smallest safe experiment: in WSL2, install Node 24.8+, run npx e2e init in a scratch repo with a tiny demo page, write one natural-language step plus one hard assertion, run it with a local Ollama model, then re-run and confirm the replay uses no model. Nothing client-facing until that works.

Daily Learning: replay caching in agent-driven tests

Concept (simple English): when an agent successfully performs a UI action, the framework saves the exact steps. On the next run it replays them like a normal script — no model call, no cost, no randomness. If the app changed and the replay no longer works, the cache is invalidated and the agent drives it fresh.
How an AI agent might get it wrong: it "remembers" a test passing and reports PASS without running anything — or a stale cached path silently skips a step that now leads somewhere else, and the agent reports success anyway.
How you recognize the failure: a PASS claim with no run report or trace; a "test passed" that references no dated artifact; results that cannot be reproduced on a second run.
Which tool/test detects it: e2e's replay cache plus its assertion layer — failures invalidate the cache and show up in the report; the missing artifact is exactly what turns an agent's claim back to UNVERIFIED in project-state.json.

Final Summary

Best discovery today: tester-army/e2e — agentic E2E testing with deterministic, near-zero-cost replay and real browser evidence.
Best security/reliability improvement: secret-guard's tool-layer secret-interception pattern (plus Codex CLI's permission records for dev-time guardrails).
Best Agency OS integration: e2e reports as QA-gate UI-E2E evidence — deterministic blocking on assertion failures, human approval untouched, gate engine unchanged.
One practical action today: run the Nuxt UI v4 scratch test on Windows and save the result as your next REUSABLE_COMPONENT candidate.