Agency OS Radar

Start Here (plain English)

The problem: a one-person AI agency needs five kinds of help at once — agents that code, orchestration that coordinates them, security checks that prove the work is safe, tests that prove it works, and ready-made UI pieces so client dashboards don't eat your week. Checking all five by hand, every day, is impossible for one person.

The solution in today's radar: five verified open-source finds, one per category. The headline is DeepSeek's dsh-superagent — a just-released (Oct 31) prototype of an agent that watches your GitHub repo, picks up authorized requests, and returns finished pull requests. Alongside it: a computer-use CLI your AI IDE can drive, the Trivy security scanner (updated yesterday and today), Maestro for plain-English E2E tests, and a MIT-licensed React dashboard kit. Every fact below was verified today from the repos' files and commit history; nothing is invented.

Full five-discovery format as requested today. Prior reports were available through Nov 3 (yesterday featured Orkas-AI/Orkas); none of today's five were featured before. Activity numbers are point-in-time snapshots from GitHub at ~14:10 UTC, Nov 4, 2026.

1. dsh-superagent-prototype (DeepSeek) INVESTIGATE

• Link: github.com/deepseek-ai/dsh-superagent-prototype
• What it does (simple English): a proactive coding agent that watches one GitHub repository. When an authorized person asks for work (in GitHub, or optionally Feishu), it opens a work item, does the job in its own isolated session and directory, and answers back in the original conversation — for example with a pull request. A web panel shows what needs a human.
• What changed recently (VERIFIED): brand-new project — repo created Oct 31, 2026, one commit ("feat: add the dsh-superagent research prototype", Oct 31). Snapshot Nov 4: 18,261 stars, 1,994 forks. DeepSeek's own README calls it a research prototype, "not production-ready software", and notes some designs from the article are not implemented.
• Why it matters to a vibe coder: its philosophy — "take as little human attention as possible, give as much value as possible," acting only when asked or when a team-written rule allows — is exactly the Agency OS governance idea (authorized triggers, no unrequested actions), coming from one of the biggest AI labs.
• License & costs (verified): MIT (verified from the LICENSE file today). Free code — but it requires the DeepSeek Harness (dsh) runtime and model access; those costs and subscription terms are not stated in the repo and remain unverified. Open source ≠ free model access.
• Windows compatibility & installation: requirements reported by press coverage include Node.js ≥22.19 or ≥24, Git ≥2.32, Python ≥3.8, GitHub CLI ≥2.48, and tmux — a Linux/macOS tool, so no native Windows path is documented. An unofficial third-party Windows fork exists (Check-mj/dsh-superagent-windows, 5 stars) — unverified, do not trust it. DeepSeek states the agent runs with full OS user access and should be isolated.
• Agency OS fit / agent & stage: could inform the orchestrator's work-intake design (authorized request → work item → session → answer) at DEVELOPMENT. Agency OS compatibility: plausible, untested (and Windows-blocking as documented).
• Evidence/output it would produce: work items with an immutable mandate (why the task may proceed), PRs, a human-attention panel — strong parallels to your REAL/VERIFIED discipline.
• Limitations & risks: research prototype, one commit, unproven reliability; full OS user access = must run sandboxed/VM only; data-confidentiality risks conceded by DeepSeek; human review required before any client use.
• Verdict: INVESTIGATE — study its design docs; do not deploy.

2. agent-desktop (Vercel Labs) TEST NOW

• Link: github.com/vercel-labs/agent-desktop
• What it does (simple English): a Rust CLI that lets an AI agent use a real computer — clicking, typing, reading windows — via the operating system's accessibility tree instead of guessing from screenshots. Because it uses stable accessibility references, actions stay retry-safe.
• What changed recently (VERIFIED): commit Nov 3, 2026 (#519): a new agent-desktop mcp mode that serves every CLI command as an MCP tool your AI IDE can call — with a cap of 8 concurrent calls, a 4 MiB message limit, proper cancellation, and held input released on cancel (Windows paths explicitly handled in the code). Trending on GitHub Nov 3–4. Snapshot Nov 4: 14,205 stars, 970 forks.
• Why it matters to a vibe coder: MCP support means Claude Code / Copilot-style IDEs can drive a desktop directly through bounded, documented tools — far safer than free-form "computer use", and ideal for testing desktop or Android-emulator apps your agency builds.
• License & costs (verified): Apache-2.0 (verified from the LICENSE file today). Free and local; you pay only your IDE's model subscription. No hosting or external API required.
• Windows compatibility & installation: the code handles Windows paths, but the repo's topics and Homebrew install docs lean macOS/Linux — Windows support: untested; verify on your machine before relying on it.
• Agency OS fit / agent & stage: QA agent — UI-E2E on desktop apps (and Android via emulator) at the QA stage. Compatibility: untested.
• Evidence/output: structured command results, MCP tool-call logs with bounded concurrency — usable as QA evidence artifacts.
• Limitations & risks: computer-use tooling can act on your real desktop — scope it to test machines, never give it unrestricted access; per-call concurrency limits reduce but do not remove this.
• Verdict: TEST NOW (on a non-critical machine or test VM).

3. Trivy (Aqua Security) TEST NOW

• Link: github.com/aquasecurity/trivy
• What it does (simple English): one binary that scans your code, dependencies, containers and infrastructure files for known vulnerabilities, leaked secrets, and misconfigurations — and can produce an SBOM (a machine-readable list of everything your software contains).
• What changed recently (VERIFIED): commits on Nov 3, 2026 — "report private keys from PKCS#12 and JKS keystores" (#11524) and "categorize MIT-0 as unencumbered" (#11498) — and Nov 4 documentation clarifying cryptographic asset scanning limits (#11378). Actively maintained, updated daily.
• Why it matters to a vibe coder: "tests pass" says nothing about security. Trivy turns "is this safe?" into a repeatable, evidence-producing command — exactly what Agency OS's SECURITY stage needs before RELEASE.
• License & costs (verified): Apache-2.0 (verified from the LICENSE file today). Free; the vulnerability DB downloads free from GitHub on first run; optional paid enterprise/Aqua platform exists but is not needed.
• Windows compatibility & installation: Windows binaries are published on the official GitHub releases page; it is a single trivy.exe — no server, no API key. Verify the latest version on the releases page when you download.
• Agency OS fit / agent & stage: security agent, SECURITY stage (dependencies, secrets, config, deployment targets — four of your security domains in one tool). Compatibility: plausible, untested with your gate_engine.py.
• Evidence/output: JSON report (--format json) with CVE IDs and severities, plus an exit code — directly consumable by your gate scripts.
• Limitations & risks: can't reason about your business logic (authn/authz design still needs human review); findings include false positives — every waiver needs human approval per your governance rules.
• Verdict: TEST NOW — today's test pick, see below.

4. Maestro (mobile-dev-inc) INVESTIGATE

• Link: github.com/mobile-dev-inc/maestro
• What it does (simple English): end-to-end testing without code: you describe a user flow as a short YAML file ("open app, tap login, expect 'Welcome'"), and Maestro runs it against real apps — Android, iOS, React Native, Flutter, and web. The README notes your AI agent can write these flows too, and they stay in your repo as deterministic CI tests.
• What changed recently (VERIFIED): release v2.12.1 prepared Nov 2, 2026 (commit #3723), plus a Nov 2 analytics fix (#3724) and an Oct 30 fix evaluating a flow's appId before tapping (#3722).
• Why it matters to a vibe coder: YAML flows are the format an AI dev agent writes most reliably — deterministic, reviewable, CI-runnable tests for the Android apps your agency delivers.
• License & costs (verified): Apache-2.0 (verified from the LICENSE file today). Free local use; a paid cloud device fleet exists but is not required.
• Windows compatibility & installation: install docs target macOS/Linux; Android flows on Windows are untested by this report — verify before relying on it (an Android emulator and JDK are needed for mobile flows).
• Agency OS fit / agent & stage: QA agent — UI-E2E/UAT for mobile clients at the QA stage. Compatibility: untested.
• Evidence/output: JUnit XML reports and exit codes per flow — gate-consumable test evidence.
• Limitations & risks: mobile toolchains are heavyweight; platform-specific flakiness; human review of any generated flow that touches real accounts.
• Verdict: INVESTIGATE — strong if you take Android client work.

5. TailAdmin Free React Dashboard INVESTIGATE

• Link: github.com/TailAdmin/free-react-tailwind-admin-dashboard
• What it does (simple English): a ready-made admin dashboard — charts, tables, forms, calendar, kanban, auth and error pages — built with React and Tailwind CSS, so a small-business back-office UI starts 80% done.
• What changed recently (VERIFIED): commits Oct 28–29, 2026 — a 404 page added to the sidebar (Oct 29, df1e9f3) and sidebar-refactor/cleanup commits Oct 28. Snapshot Nov 4: 1,295 stars; actively maintained.
• Why it matters to a vibe coder: your REUSABLE_COMPONENT stage needs a vetted dashboard base; an AI agent customizing a known MIT template is faster and safer than generating an entire admin UI from scratch.
• License & costs (verified): MIT (verified from LICENSE.md today) — commercial client use permitted with attribution per the license; verify attribution wording per project. A paid "Pro" tier exists but is not needed. No external API dependencies.
• Windows compatibility & installation: plain Node/npm project — clone, npm install, npm run dev. Works on Windows (standard npm toolchain).
• Agency OS fit / agent & stage: dev + spec/UX agents, REUSABLE_COMPONENT and DEVELOPMENT stages. Compatibility: plausible, untested.
• Evidence/output: a running dashboard your client can click — plus its components feed your reusable library.
• Limitations & risks: template code inherited by clients needs the same security review as any code (dependencies, auth); verify the React/Tailwind versions fit your stack before adopting.
• Verdict: INVESTIGATE — best candidate for your reusable-component library.

Test Today: Trivy on Windows (~20 minutes, no subscription)

• Why this one: one free binary, Apache-2.0, runs 100% locally, no API key, and produces the exact evidence your SECURITY stage lacks.
• Prerequisites: Windows PC, ~2 GB free disk for the vulnerability DB, internet only for the first DB download.
• Official installation steps: on github.com/aquasecurity/trivy/releases download the latest Windows 64-bit ZIP, extract trivy.exe to a tools folder, and add that folder to PATH.
• Practical test: in a scratch project folder (with a requirements.txt or package.json you control, plus one intentionally fake secret like AKIAIOSFODNN7EXAMPLE): trivy fs --scanners vuln,secret,misconfig . then trivy fs --scanners vuln --format json --output trivy-report.json .
• Expected results: a findings table with CVE IDs and severities, the fake secret flagged, and a JSON report you can hand to a gate script. Zero findings should still produce a clean report — that is your evidence.
• Safety precautions: scan only code you own; never paste real secrets into the test; trivy reads files — it does not modify them; keep reports private (they describe weaknesses).

Agency OS Integration Proposal: Trivy as SECURITY-gate evidence

• Problem solved: your security stage currently has no machine-checkable proof that dependencies, secrets, and config were scanned before RELEASE.
• Workflow/agent improved: security agent's scan step, feeding — never replacing — gate_engine.py and prepush_release_check.ps1.
• Lifecycle stage: SECURITY → RELEASE.
• Inputs: the project folder path and a pinned scanner config. Outputs: trivy-report.json (vuln + secret findings) and the exit code.
• How results are validated: the gate script parses the JSON, counts critical/high findings, and records the run in project-state evidence. Only VERIFIED scan output counts; an agent's claim of "scan passed" without the artifact does not.
• What happens on failure: findings present (or scanner error) → marked BLOCKED, report attached, no transition to RELEASE.
• Gate or human approval? blocks the gate automatically on critical/high findings; accepting any finding as a waiver always requires human approval per your governance.
• Smallest safe experiment: add one trivy invocation with JSON output to prepush_release_check.ps1 in a scratch project, plant one known-vulnerable dependency, and confirm the check blocks. Do not change any existing gate logic — only add the evidence step.

Business Opportunity: website security health-checks for Addis Ababa small businesses

• Customer problem: hotels, importers, clinics and shops in Addis have websites and admin panels built years ago on unmonitored plugins and dependencies. Nobody has ever checked whether they contain known vulnerabilities or leaked credentials — until the site is defaced or a payment page is tampered with.
• Minimum viable service: a one-day "security health check": with the owner's written permission, scan their site's codebase/deployment files with Trivy (secrets, dependencies, misconfigurations), manually verify the top findings, and deliver a plain-language Amharic/English report with a prioritized fix list and a rescan date. No revenue projections — price it against a day of your time and local rates.
• Delivery workflow: DISCOVERY (intake + permission form) → SECURITY (Trivy scan) → human verification of each finding → CEO_REVIEW (your review of the report) → client briefing. Every claim in the report traces to scan output you personally checked.
• Main risks: clients without code access (limits scanning to deployment files); false positives damage trust — verify before reporting; never scan systems you lack written authorization for; reports describe weaknesses — deliver them privately.

Daily Learning: known vulnerabilities (CVEs) and why a scanner beats an opinion

• Concept (simple English): when a security flaw is discovered in a library, it gets a public ID (a CVE) and a severity. Your app inherits every CVE of every library it uses — a scanner matches your dependency list against that public database.
• How an AI agent might get it wrong: it confidently declares "this dependency is safe" from memory — because it recalls no issue, or confuses versions — without ever consulting the CVE database or the right version.
• How you recognize the failure: the agent gives a safety verdict with no scan artifact behind it, or cites a CVE ID that doesn't match the installed version.
• What detects it: today's test — run Trivy and compare its JSON findings against the agent's claim. In Agency OS terms: security claims are UNVERIFIED until a scan artifact exists.

Final Summary

• Best discovery today: deepseek-ai/dsh-superagent-prototype — MIT, released Oct 31, one of the most-watched agent releases of the year (18.2k stars by Nov 4); a governance-shaped proactive coding agent worth studying, not yet deploying. Verdict: INVESTIGATE.
• Best security/reliability improvement: Trivy (Apache-2.0, updated Nov 3–4) — one local command that turns security claims into checkable evidence.
• Best Agency OS integration: Trivy JSON as SECURITY-stage evidence consumed by the existing gate engine before RELEASE — additive only, waivers stay human-approved.
• One practical action today: install trivy.exe and run a vuln+secret scan on a scratch project — then wire the JSON report into prepush_release_check.ps1 as a blocking evidence step.