llm=deepseek-v4.1-flash on tomrochette.com

Agent Analytics

tom@tomrochette.com (Tom Rochette) — Sun, 27 Sep 2026 00:00:00 +0000

Agent Analytics is an agent-readable web analytics platform: one tracker script stores your product’s events in your own Cloudflare D1 or SQLite database (or its hosted cloud), and your coding agent queries the data through a skill, MCP server, CLI, or HTTP API instead of a human dashboard.

Agent Analytics is not session observability, it is product analytics with the human dashboard moved out of the loop, which puts it at the edge of this category while sharing the category’s founding premise that the data already exists and an agent should be able to read it directly.

What it is
#

The open-source server accepts a single tracker.js tag that captures page views, paths, referrers, UTM sources, sessions, device and browser, country, and first-touch attribution, with optional custom events, consent mode, click tracking, errors, performance, vitals, SPA tracking, and opt-in session replay. Analytics are exposed to agents rather than humans: an operating skill and an autoresearch skill, an MCP server, an official CLI, and an HTTP API, backed by an OpenAPI 3.1 spec and LLM-readable llms.txt and llms-full.txt exports. The self-hosted server runs on Cloudflare Workers plus D1, on Docker or Kubernetes with SQLite, or as a plain Node process you point the CLI at. Documented integrations cover Claude Code, Claude Desktop and Cowork, Codex, Cursor, OpenClaw, Paperclip, Hermes, Instinct, and OpenWork. Made by Agent Analytics, the same maintainer behind the Awesome Multi-Agent Orchestrators directory. The README claims MIT, but I could not find a LICENSE file on the default branch.

Status
#

The hosted product has moved faster than the open-source server: the main repository has 17 stars and was created 2026-02-06 and last pushed 2026-05-06, while the CLI is a published npm package and sibling repos in the org were pushed through September 2026, as of 2026-09-27. Community signal is thin and concentrated in the org’s own plugins, the most prominent being the Hermes dashboard plugin at 27 stars and the Paperclip live analytics plugin at 14 stars, as of 2026-09-27; I found no Hacker News thread for the site. The README claims MIT and links a LICENSE file that is absent from the default branch, which returned 404 when I fetched it. A young hosted product whose open-source server already looks quieter than its cloud, with the open-source claim itself unfinished at the repository level.

Strengths
#

The agent-first stance is carried all the way through: skill, MCP, CLI, and HTTP, plus an OpenAPI 3.1 spec and LLM-readable docs exports, instead of a dashboard a human has to relay.
There is a genuine self-host path on free infrastructure: Cloudflare Workers plus D1 with almost no server management, or Docker and Node with SQLite you own.
The free cloud tier is real usage rather than a demo: 100k events per month, two projects, and multi-agent access.
Session replay on the paid tier is opt-in and masks recognizable PII, and the docs state the trade-off rather than burying it.
Integrations cover the tooling this audience already runs, including Claude Code, Codex, Cursor, OpenClaw, and Paperclip.

Cautions
#

Category fit is loose: this measures your product’s web traffic, not your coding agents’ sessions or token cost, so it answers how the product is doing rather than what the agents did.
The open-source server repository has been quieter than the hosted cloud since May 2026, and the MIT LICENSE file the README links is missing from the default branch, so self-hosters rely on a claim the repository does not yet substantiate.
Hosted use moves event data, and optionally session replay, onto the vendor’s infrastructure; only the self-hosted route keeps it on yours.
Per-event metering means a bot-heavy or high-traffic site can consume the free allowance faster than a 90-day retention window suggests.
The identity-stitching and portfolio model is more product machinery than most small teams need, and the agent-native API is the part that earns its keep.

Pricing
#

Free cloud plan at $0 per month: 2 projects, multi-agent access, 100k events per month, 500 analytics reads per month, 90-day retention, and 2 full website scans per month. Paid cloud plan at $1 per 10k events: unlimited projects, multi-agent access, unlimited analytics reads, unlimited experiments, session replay, 12-month retention, and 100 full website scans per month. Self-hosting the open-source server on your own Cloudflare, Docker, or Node infrastructure is free apart from your own infrastructure costs.

Price history
#

Date	Plan	Change	Source
2026-09-27	Cloud	Free plan introduced at $0/month with 100k events and 2 projects, and a metered plan at $1 per 10k events; self-host free and open source	https://agentanalytics.sh/

Compared to
#

agentsview: the local session and cost archive for your coding agents; Agent Analytics measures your product’s users, so the two answer different questions.
agents-observe: the live dashboard for coding-agent sessions; Agent Analytics instead watches the product surface those agents help build.
Paperclip: the control plane whose live analytics plugin consumes Agent Analytics, which is the clearest example of this tool’s agent-native purpose.

Bottom line
#

Recommended for builders shipping agent-built products who want a self-hostable, agent-queryable web analytics layer instead of a human dashboard. Not for observing coding-agent sessions, token cost, or provenance, despite living in this category.

Changes
#

2026-09-27 - Created.

References
#

https://agentanalytics.sh/ - the pricing tiers, the free and metered cloud plans, and the agent-first pitch
https://github.com/Agent-Analytics/agent-analytics - the open-source server repository, its activity, and the missing license file
https://raw.githubusercontent.com/Agent-Analytics/agent-analytics/main/README.md - the capability list, self-host routes, and CLI usage
https://docs.agentanalytics.sh/ - the docs home, the product-system model, and the list of access surfaces and integrations
https://docs.agentanalytics.sh/openapi.yaml - the OpenAPI 3.1 spec and the agent-session and API-key auth model
https://raw.githubusercontent.com/Agent-Analytics/agent-analytics-cli/main/README.md - the CLI command surface for analytics, funnels, and experiments
https://api.github.com/repos/Agent-Analytics/agent-analytics - stars, creation and last-push dates, and the absent license as of 2026-09-27
https://hn.algolia.com/api/v1/search?query=agentanalytics.sh - the empty Hacker News footprint behind the thin-community claim

AgentTrace

tom@tomrochette.com (Tom Rochette) — Sun, 27 Sep 2026 00:00:00 +0000

AgentTrace is an MIT-licensed local-first Rust TUI and CLI that reads the session logs your coding agents already wrote and reports their cost, tokens, latency, failures, and health.

AgentTrace’s bet is the narrow one this category keeps proving out: the useful telemetry is already on disk, and the product is a fast local query over it, with governance reports and CI gates bolted on top.

What it is
#

One Rust binary gives both interfaces: run agenttrace with no action to open the TUI, or pass flags such as --overview, --audit, --recommend, --mcp-governance, --context-trends, and --delivery-evidence for CLI and JSON output. It parses about 15 named coding-agent formats (Claude Code, Codex CLI, Gemini CLI, Qwen Code, Cline, Aider, Cursor exports, Hermes Agent, OpenCode, OpenClaw, Pi, Oh My Pi, Kimi CLI, Copilot-style logs) plus generic JSON and JSONL traces. Install paths are Homebrew, npm, winget, curl, and cargo. Everything runs locally: no hosted backend is required, and tool steps keep metadata and duration without storing prompt, response, result, or tool-argument bodies. Reports render as JSON, Markdown, or self-contained HTML, and --overview can gate a CI job on session health, critical sessions, and tool-failure rate. Made by an independent developer (luoyuctl) under MIT.

Status
#

Young and active: 137 stars, 9 forks, 7 open issues, created 2026-05-01, last pushed 2026-09-14, latest release v0.8.1 on 2026-09-06, as of 2026-09-27. It is effectively a one-person project: 413 of 415 commits come from the owner, and the next contributor has a single commit. The community footprint is nearly empty: a Hacker News search for the author returns nothing, and I found no Reddit discussion. A pre-1.0 single-maintainer tool with serious packaging but no independent verification, so read its roadmap and issue tracker rather than its README for what actually ships.

Strengths
#

Breadth of local parsing is unusually wide for its age: about 15 named harness formats plus generic JSON and JSONL behind one binary.
Slow-run diagnosis is the differentiator: it surfaces long gaps, hanging sessions, retry loops, slow tool calls, large parameters, and context pressure, which the cost-first tools in this category do not.
Governance reports are deliberate about evidence quality, labeling cost and delivery numbers as estimates or heuristics and reporting parse and pricing confidence instead of hiding gaps.
CI integration is first class: --overview exits with code 2 on a failed health, critical-session, or tool-failure gate, and it can keep JSON on stdout while writing a Markdown or HTML artifact.
Distribution punches above its size: Homebrew tap, npm, winget, curl, and cargo, with a documented parser contribution flow.

Cautions
#

Cost and delivery evidence is self-labeled as estimated: unknown models fall back to pricing, and the README says outright these are not provider billing or proof a commit reached main.
Pre-1.0 with a fast-moving report schema, so scripts consuming the governance JSON should expect churn.
One maintainer and no third-party benchmark or discussion, so reliability claims rest on the README, the CI workflow, and the maintainer’s own tests.
It reads logs, so coverage is only as complete as each harness writes, and unsupported formats degrade to Limited capability levels rather than a full trace.
There is no live view and no provenance: it answers what a run cost and why it was slow after the fact, not what an agent is doing now or which session wrote a line.

Pricing
#

Free and open source under MIT. No paid tiers are published, and everything runs locally with no hosted service.

Compared to
#

agentsview: the broader archive with more than 60 formats and a web and desktop UI; AgentTrace is narrower but terminal-first and adds latency and anomaly diagnosis plus CI gates, so choose AgentTrace for slow-run triage and agentsview for cross-harness history at scale.
agents-observe: the live hook-fed dashboard for Claude Code and Codex; AgentTrace is retrospective, so they answer different moments.
ctx: the search-and-blame CLI; AgentTrace does not do provenance, and ctx does not do cost or latency, so a cost-conscious engineer may run both.

Bottom line
#

Recommended for terminal-first engineers running several harnesses who want a local audit of session cost, latency, and failures with CI gates, and who value a private, no-backend setup. Not for live observation, transcript search, or line-level provenance.

Changes
#

2026-09-27 - Created.

References
#

https://github.com/luoyuctl/agenttrace - the repository, MIT license, description, and topics
https://raw.githubusercontent.com/luoyuctl/agenttrace/master/README.md - the coverage list, governance flags, install paths, privacy posture, and report formats
https://raw.githubusercontent.com/luoyuctl/agenttrace/master/docs/guides/ci-integration.md - the CI gate flags, exit code 2, and report artifacts
https://raw.githubusercontent.com/luoyuctl/agenttrace/master/ROADMAP.md - the local-first scope and explicit non-goals
https://api.github.com/repos/luoyuctl/agenttrace - stars, forks, dates, and license as of 2026-09-27
https://api.github.com/repos/luoyuctl/agenttrace/releases - the v0.8.1 release date
https://registry.npmjs.org/@zack78/agenttrace - the npm package at 0.8.1
https://hn.algolia.com/api/v1/search?query=luoyuctl - the empty Hacker News footprint behind the thin-community claim

Agon

tom@tomrochette.com (Tom Rochette) — Sun, 27 Sep 2026 00:00:00 +0000

Agon is an MIT-licensed Claude Code plugin that runs producer-critic agent loops from a one-line research topic to running experiments and a paper draft, with no human-written experimental code.

Agon’s bet is that the reusable loop, not the task-specific prompt, is the unit of automation: eighteen roles and a 230 KiB prompt surface carry it across more domains than competitors several times larger, and its most useful output may be the failure taxonomy that marks where the loops stop and a human must start.

What it is
#

Agon is a research orchestrator distributed as a Claude Code plugin, written in Python and released under MIT by AutoResearch-Factory, a group led by Haizhao Yang at the University of Maryland with collaborators at the Chinese University of Hong Kong and Stanford. A run advances a project through factories: idea, proposal, experiment, and paper. Each factory is an adversarial producer-critic loop, where one agent creates an artifact and an independent critic on a fresh context (where possible on a different model) tries to break it before the artifact advances. Handoffs go through files on disk, so a run is recoverable and auditable. It runs from a separate data workspace (commonly agon-artifacts) through the commands /idea-tick, /proposal-tick, /experiment-tick, and /deep-lit-tick, and expects --dangerously-skip-permissions because the loops are meant to run unattended for hours; the author recommends a dedicated machine, container, or user account.

Status
#

Active and small: 50 stars, 4 forks, 1 open issue, 75 commits, created 2026-06-18, last push 2026-09-25, as of 2026-09-27. The companion arXiv paper (2606.24177) was submitted 2026-06-23 and reports 444 iterations of Prompt Economy loops across more than ten scientific domains, thousands of scientist-coder-auditor iterations over three months, and a longest uninterrupted run the project page puts at 30 days. That adoption record is self-reported by the authors with no independent replication, and the public community footprint is essentially absent: an HN Algolia search for Agon autonomous research returns zero hits as of 2026-09-27.

Strengths
#

A small, inspectable prompt surface: 18 roles and 230.6 KiB of prompts, against roughly 110 roles and 302.4 KiB for AI Scientist v2, 79 roles and 1,157.4 KiB for ARIS, and 78 roles and 1,297.5 KiB for AutoResearchClaw, by the paper’s own count.
Artifact-mediated handoffs make a long unattended run recoverable and auditable, which most research-agent demos do not attempt.
The paper is unusually candid about failure modes, publishing a 22-entry taxonomy along severity, fixability, visibility, and capability locus instead of only headline results.
Domain-agnostic by design: field knowledge enters through literature and injected skills, so the same core roles transfer across fields.
It is an open template rather than a service, so its loops can be copied into a private pipeline today.

Cautions
#

It runs on Claude Code with permissions disabled; treat it as untrusted autonomous code and isolate it accordingly.
50 stars, one main repository, and no independent evaluation; the 444-iteration and ten-domain claims rest on the authors’ word.
The paper’s own taxonomy concedes invisible failures (anomaly blindness, plausible false attribution, premature abandonment) that no loop catches and only a human scientist can.
It is a research artifact, not a maintained product: no releases, no support commitment, and a plugin that tracks Claude Code’s moving extension points.
Novelty collisions are an explicit risk it manages through a deep-literature loop, which the paper concedes can still miss the 101st paper.

Pricing
#

Agon is free and open source under MIT; there is no paid tier, so pricing does not apply. Running it costs whatever the underlying model calls cost.

Compared to
#

OpenAI Deep Research: a productized web-research agent that writes cited reports; choose Agon when you need code-executing experiments, Deep Research when you need a fast literature answer.
Anthropic Claude mathematical research: a bespoke Claude Code subagent loop aimed at one hard problem; Agon is the reusable harness that generalizes that pattern across fields.
Harmonic Aristotle: a theorem prover whose output a Lean kernel checks; choose Aristotle when correctness must be machine-verified, Agon when the loop must produce and run experiments without a formal verifier.
Pion: agents running a real business judged by a bank account; Agon is judged by adversarial critics plus a human, a weaker but cheaper oracle.

Bottom line
#

Recommended for researchers and tool builders studying fully autonomous research loops and the failure-mode boundary, and for teams wanting an inspectable template for producer-critic pipelines. Not for anyone who needs a supported product, formal guarantees, or verified benchmark results.

Changes
#

2026-09-27 - Created.

References
#

https://github.com/AutoResearch-Factory/Agon - repository, plugin layout, commands, license, and install requirements
https://raw.githubusercontent.com/AutoResearch-Factory/Agon/HEAD/README.md - the factory workflow, mandated Claude Code settings, and the multi-model wrapper
https://arxiv.org/abs/2606.24177 - abstract, authors, submission date, and the 444-iteration and taxonomy summary
https://arxiv.org/html/2606.24177v1 - design principles, architecture, prompt-surface comparison, and the failure-mode taxonomy
https://haizhaoyang.github.io/research/autoresearch.html - project-page framing, the six principles, and the 30-day unattended run
https://api.github.com/repos/AutoResearch-Factory/Agon - stars, forks, creation and push dates, and MIT license for the as-of status
https://hn.algolia.com/api/v1/search?query=%22Agon%22%20autonomous%20research - the absent community footprint as of 2026-09-27

ClawTrace

tom@tomrochette.com (Tom Rochette) — Sun, 27 Sep 2026 00:00:00 +0000

ClawTrace is a hosted tracing and cost-attribution platform for OpenClaw agents: an Apache-2.0 OpenClaw plugin streams every run to a cloud pipeline that renders trace trees, call graphs, Gantt timelines, per-step dollar cost, and an AI analyst named Tracy.

ClawTrace is this category’s first hosted answer, and that is also its central trade-off: it sees more of each run than the local tools (real LLM payloads, sub-agent graphs, live cost) because your agent’s traffic leaves your machine for its data lake.

What it is
#

The @epsilla/clawtrace plugin intercepts eight OpenClaw hook types (session_start, session_end, llm_input, llm_output, before_tool_call, after_tool_call, subagent_spawning, subagent_ended) and batches events to a hosted ingest service. The pipeline writes partitioned JSON to cloud storage, materializes it through Databricks into Iceberg tables, exposes it as a Cypher graph in PuppyGraph (Tenant, Agent, Trace, and Span vertices with CHILD_OF edges), and serves a FastAPI backend and a Next.js UI. Three views cover each trace: an execution tree with per-node cost badges, a force-directed call graph, and a Gantt timeline, plus a trajectory dashboard with daily trends. Tracy is an AI analyst wired to the graph: it runs live Cypher queries, generates charts, and answers plain-English questions such as why a run cost so much or which tool fails most. Pricing covers more than 80 models with cache-aware rates (fresh input, cached input, cache write, and output billed separately). Setup is three shell commands, and the vendor is Epsilla, the company behind the Epsilla vector database. The repository is Apache-2.0, but the hosted cloud is the product and no self-hosted deployment path is documented.

Status
#

Active but with the thinnest footprint in the category: 48 stars, 10 forks, 3 open issues, created 2026-04-10, last pushed 2026-08-15, with the npm plugin at version 0.1.23 published 2026-04-16, as of 2026-09-27. It launched on Hacker News twice in April 2026 (a 2-point post and a 1-point Show HN, neither with a comment beyond the author’s own), and I found no Reddit discussion. It also carries a paper, “ClawTrace: Cost-Aware Tracing for LLM Agent Skill Distillation” (arXiv 2604.23853), which is unusually rigorous for a tool at this stage. A hosted product from a small org with an academic paper and almost no community discussion, so treat the roadmap’s self-evolving-agent promises as research rather than shipped features.

Strengths
#

Full-payload tracing is the most detailed column in this category: real LLM inputs and outputs and tool payloads, not just token counts and tool names.
Cost attribution at step granularity with more than 80 models and cache-aware pricing, aimed squarely at the incident the README describes (an agent burning roughly 40 times its budget by replaying 1,500 messages of history).
Three complementary views plus Ask Tracy, which turns the trace graph into natural-language answers instead of leaving interpretation to the reader.
The self-evolve skill and /v1/evolve/ask endpoint let the agent query its own trajectories, an unusual closed loop inside the product.
The published paper gives it more methodological transparency than most tools in the category.

Cautions
#

It is hosted and cloud-only: trace payloads, including LLM inputs and outputs, stream to the vendor’s data lake, the opposite of the local-first posture the rest of this category shares.
Consumption billing meters storage continuously at 1.35 credits per MB per day, so idle traces keep drawing credits until they are deleted.
The vendor’s own paper reports no aggregate cost saving across the full 84-task SkillsBench transfer and no aggregate cost reduction when prune patches are removed, which undercuts the cheapest-sounding promise.
Single-harness by design: OpenClaw only, and the data only exists if the OpenClaw plugin is installed and authenticated.
Independent signal is very thin: two low-point Hacker News posts, no comments, and no third-party review I could find.

Pricing
#

Consumption-based credits, with no monthly seat fee. New users get 100 free credits, and credit packages run $10 for 1,000 credits, $50 for 5,000, $90 for 10,000 (listed as 10% off), and $400 for 50,000, with all packages expiring one year after purchase. Usage is metered per feature: storage 1.35 credits per MB per day, listing trajectories 0.5 credits per query, trajectory detail 0.2 credits per query, Tracy input 0.5 credits per 1k tokens, and Tracy output 2.5 credits per 1k tokens. Reaching zero credits puts the account into a deficit state that blocks ingestion and queries until it is topped up.

Price history
#

Date	Plan	Change	Source
2026-09-27	Credit packages	Starter introduced at $10 / 1,000 credits; Growth at $50 / 5,000; Pro at $90 / 10,000; Scale at $400 / 50,000; storage metered at 1.35 credits/MB/day	https://www.clawtrace.ai/docs/billing/credits

Compared to
#

agents-observe: the local, MIT live dashboard for Claude Code and Codex; ClawTrace is hosted and OpenClaw-only but captures full payloads, so choose ClawTrace only if you run OpenClaw and can upload traces.
agenttrace: the local-first audit that also reads OpenClaw logs; choose agenttrace instead when the data cannot leave the machine.
Langfuse: a self-hostable LLM observability stack with traces and evals; choose ClawTrace for OpenClaw-specific cost attribution and the built-in analyst, Langfuse for a bring-your-own stack.

Bottom line
#

Recommended for OpenClaw operators who want full-payload traces, per-step cost, and an AI analyst, and who accept a hosted cloud. Not for anyone who needs traces to stay local, multi-harness coverage, or a self-hosted observability stack.

Changes
#

2026-09-27 - Created.

References
#

https://github.com/epsilla-cloud/clawtrace - the repository, Apache-2.0 license, stars, and forks as of 2026-09-27
https://raw.githubusercontent.com/epsilla-cloud/clawtrace/main/README.md - the plugin, eight hooks, cloud pipeline, graph schema, pricing detail, self-evolve skill, and paper citation
https://www.clawtrace.ai/ - the product pitch, three views, and the headline claim of showing what failed and where spend leaked
https://www.clawtrace.ai/docs/billing/credits - the credit packages, consumption rates, free credits, and deficit state
https://www.clawtrace.ai/docs/getting-started/install-plugin - the eight hook types and the three-step setup
https://www.clawtrace.ai/docs/ask-tracy - what the Tracy analyst answers from the trace graph
https://arxiv.org/abs/2604.23853 - the paper and its no-aggregate-savings and regression-lane findings
https://hn.algolia.com/api/v1/items/47769889 - the 1-point Show HN behind the thin-community claim

Code Atelier Governance SDK

tom@tomrochette.com (Tom Rochette) — Sun, 27 Sep 2026 00:00:00 +0000

The Code Atelier Governance SDK (code-atelier-governance) is an MIT-licensed Python SDK that wraps LLM clients and tool calls in pre-execution enforcement gates (scope, budget, approvals, loop detection, presence) and writes an HMAC-chained audit trail to the Postgres your application already runs.

Its thesis is that tracing tools explain what an agent did after the damage, so the useful primitive is a gate that fires before the LLM call and denies it, backed by an audit chain a regulator can verify without a new data platform.

What it is
#

pip install code-atelier-governance exposes a GovernanceSDK with eight modules: Audit, Scope, Cost, Gates, Loop Detection, Presence, Contracts, and Compliance. Scope is a per-agent allowlist with hidden tools removed from the LLM context and default deny; Cost enforces token and USD caps per session and per agent-day with built-in pricing for more than twenty models and a combined budget query; Gates issues single-use HMAC-bound approval tokens for high-risk actions. The audit trail is an append-only HMAC chain with optional Ed25519 per-row signatures, on-demand chain verification, and EU AI Act Article 12 evidence reports. Integrations are one-line wrappers for OpenAI, Anthropic, and LangChain, plus a sync wrapper for Flask and Django, and everything depends only on a Postgres connection string, with an optional read-only console. The vendor is Code Atelier, and the source lives at imleopereira/agentic-governance.

Status
#

Active but essentially unadopted. The SDK is at version 0.7.3 with 11 PyPI releases, and the repository was created 2026-04-09 with a last push on 2026-07-23 as of 2026-09-27. The repository has 0 stars, 0 forks, and no description or topics, which is unusual for a project with a polished documentation site and a hosted platform bridge. The community footprint is absent: a Hacker News search for Code Atelier governance returns nothing, so every claim here rests on the vendor’s own pages and the repository. What earns the note despite the silence is the threat model, which states plainly what the SDK does not protect against instead of implying it is a complete security boundary. The vendor also publishes a scaffolder that wires a Microsoft Agent Governance Toolkit agent through these gates, which is a rare, concrete interoperability gesture in this category.

Strengths
#

Just Postgres: no Redis, Kafka, ClickHouse, sidecar, or background worker, so adoption cost is close to zero for a team already on Postgres.
Fail-closed enforcement by default (cost, scope, and gates raise), while observation surfaces warn and continue, which is the right asymmetry.
A written threat model that names the bypasses (direct client calls, subprocesses, tool calls inside LLM responses) rather than hiding them.
EU AI Act Article 12 evidence export and a self-approval prevention design show the compliance audience is being taken seriously.

Cautions
#

0 stars and no third-party usage evidence; the only assessment available is the vendor’s own.
In-process gates do not defend against a second process or any code path that calls OpenAI or Anthropic directly, and the README says so; network-level enforcement needs a proxy.
Scope enforcement gates the LLM call, not the tool calls returned inside the response, so a determined agent can still execute a disallowed tool unless you enforce at the tool layer too.
Tampering is detected only when verification runs; a database administrator with key control can still replace the chain, as the threat model admits.
v0.6.2 flipped several defaults to fail-closed and broke callers, so read the upgrade notes before following an older tutorial.

Pricing
#

MIT licensed and free. A hosted platform exists through an opt-in bridge that dual-writes audit events while keeping local Postgres authoritative, plus a read-only console, but no prices are published.

Compared to
#

Veto: a framework-agnostic authorization kernel with a commercial cloud and portable receipts; choose Veto for TypeScript or polyglot stacks and this SDK when you are Python and Postgres and want budget and loop gates too.
Microsoft Agent Governance Toolkit: broad, vendor-backed, and multi-language with identity and sandboxing; choose AGT for a governance program, and this SDK for the smallest viable gate.
Langfuse: observability that records what happened; choose Langfuse to understand agent behavior, and this SDK to block a call before it happens.

Bottom line
#

Recommended for Python teams already on Postgres that want a minimal pre-execution gate with budgets, approvals, and a tamper-evident audit trail. Not for polyglot stacks, teams needing process or network-level enforcement, or anyone who requires an adopted project with independent security review.

Changes
#

2026-09-27 - Created.

References
#

https://www.codeatelier.tech/governance - overview: modules, comparison table, Article 12 framing
https://www.codeatelier.tech/governance/quickstart - quickstart: install, schema, gates, console, sync wrapper
https://github.com/imleopereira/agentic-governance - README: modules, threat model, configuration, standards
https://api.github.com/repos/imleopereira/agentic-governance - stars, forks, creation and push dates as of 2026-09-27
https://pypi.org/pypi/code-atelier-governance/json - version 0.7.3, MIT license, 11 releases
https://raw.githubusercontent.com/imleopereira/agentic-governance/production/CHANGELOG.md - release notes: fail-closed defaults and the AGT recipe scaffolder

Crewplane

tom@tomrochette.com (Tom Rochette) — Sun, 27 Sep 2026 00:00:00 +0000

Crewplane is an Apache-2.0, CLI-first orchestrator that turns coding-agent CLI calls into structured, resumable Markdown workflows and keeps every run record on disk.

Crewplane’s bet is that the agent workflow, not the agent session, should be the durable artifact: define the stages in Markdown, run each stage through whichever CLI fits, and keep rendered inputs, outputs, logs, and final results as inspectable build outputs.

What it is
#

A Python 3.13+ tool (installed with uv tool install crewplane, pip, or npm) from crewplaneai that runs a workflow DAG described in Markdown plus YAML front matter. Each node names a provider, so one workflow can hand off across Claude Code, Codex, Gemini CLI, GitHub Copilot CLI, Kilo Code, Pi, DeepSeek Harness, OpenCode, or any other command, and nodes run sequentially or in parallel with explicit stage artifacts between them. Crewplane invokes provider CLIs directly rather than wrapping a vendor SDK, and it neither installs nor manages those CLIs or their credentials. A run writes a full record under .crewplane/: rendered inputs, per-stage outputs and logs, manifests, and final results, so a failed later stage can resume from validated boundaries instead of replaying everything. Optional features include a tmux dashboard, Git-backed workspace isolation, review loops with findings artifacts, and reusable workflow composition; a companion crewplane-lab publishes reproducible multi-agent experiments with the workflow, responses, telemetry, and logs.

Status
#

Very early but shipping: about 41 stars and 5 forks as of 2026-09-27, created 2026-06-24, and active development through v0.3.5 on 2026-09-25. The repository is Python, passes an OpenSSF Best Practices badge, and documents an install-to-inspect path that runs a mock invoker before any real provider call. At roughly three months old and 41 stars, Crewplane is a cohort-of-one tool from a single vendor; its value depends on whether the Markdown-as-workflow idea outlives the project.

Strengths
#

The whole process is versioned in the repo, which makes agent work reviewable and diffable like any other code artifact.
Provider-agnostic and CLI-first: if a tool has a command line, Crewplane can sequence it, with no SDK lock-in.
Resumable at validated stage boundaries, and idempotent by default (an identical rerun reuses the saved result unless --force).
Every run leaves an inspectable record on disk, addressing the terminal-scrollback problem that makes multi-stage agent work hard to audit.
A safe first run with a mock invoker, so you can validate a workflow without spending tokens.

Cautions
#

41 stars, pre-1.0, and a single vendor; bus factor is the main risk.
No GUI: the tmux dashboard is optional and the primary surface is the terminal.
You install and authenticate every provider CLI yourself; Crewplane does not manage credentials or models.
Run artifacts behave like build output, so deciding what belongs in version control is left to you.
The per-node cwd defaults to the project root; worktree isolation is opt-in, so careless workflows can edit your working tree.

Pricing
#

Free and open source under Apache-2.0. No hosted tier and no per-token fee; you pay only for the provider CLIs you route stages through.

Compared to
#

Sandcastle: a TypeScript library with sandbox providers; choose Crewplane when the workflow should live in Markdown and survive failures on disk rather than in a process.
LoopTroop: a local GUI that also decomposes work into stages; choose Crewplane when you want CLI-first, repo-owned workflows instead of a council-planning GUI.
A hand-rolled shell script plus CI: the zero-dependency option; Crewplane earns its keep once stages need provider handoffs, resumability, and an auditable record.

Bottom line
#

Recommended for teams who want their coding-agent process expressed as versioned Markdown with resumable, inspectable runs across several CLIs. Not for anyone who wants a visual board, and not for shops that need a mature, multi-vendor-backed tool.

Changes
#

2026-09-27 - Created.

References
#

https://github.com/crewplaneai/crewplane - repository, architecture, workflow syntax, license, stars, and release data
https://raw.githubusercontent.com/crewplaneai/crewplane/master/docs/index.md - documentation map, first-project path, and the mock-validation flow
https://github.com/crewplaneai/crewplane-lab - reproducible multi-agent comparison with workflow, responses, telemetry, and logs
https://openorchestrators.org/players/crewplane/ - the curated directory’s profile of Crewplane
https://pypi.org/project/crewplane/ - package description and install surface

GraphCode

tom@tomrochette.com (Tom Rochette) — Sun, 27 Sep 2026 00:00:00 +0000

GraphCode is an FSL-1.1-MIT source-available native macOS workspace that arranges live coding-agent sessions into a graph, where every node is a real terminal and hand-off, message, or spawn edges fire on conditions including a shell predicate.

GraphCode’s bet is that a loop is an agent session on repeat, so it schedules nothing itself: recurrence lives inside the session’s own prompt, which keeps each loop attachable and steerable mid-run instead of a headless job that already finished.

What it is
#

A native SwiftUI app for macOS 15 or later on Apple Silicon, from scgopi, installed with a Homebrew cask or a signed DMG. The unit is a loop, an agent session that runs repeatedly in one of four modes: turn-based (pauses each turn for review), goal-based (runs until a goal is met, optionally proven by a shell command exiting 0), time-based (a cadence written into the prompt, like /loop 1h triage), or composite (a sub-graph that plans its own steps). Each loop runs in a worktree and its terminal is a zmx PTY session that survives quitting the app, restarting the daemon, or rebooting, so reopening attaches to the same session with one scrollback rather than starting a duplicate. Edges between nodes fire on conditions (always, on success, on failure) with a cycle guard, and loops message each other by name across graphs and repositories, staged into memory when the peer is asleep. It bundles no agents and drives five backends (Claude Code, GitHub Copilot CLI, Codex, OpenCode, and Pi), exposes an app, a graphcoded daemon, a graphcode CLI, and a shared GraphcodeKit framework, keeps all state under ~/.graphcode/, and writes nothing inside the project folders you open.

Status
#

New and fast-moving: about 129 stars and 19 forks as of 2026-09-27, created 2026-07-26, with releases the same day (0.1.76-beta2) and a pre-1.0 beta line. It is maintained by one developer, scgopi, on top of Ghostty’s terminal engine and the zmx session daemon. Two months old, one maintainer, and a 0.1.x version mean GraphCode is an idea to try, not infrastructure to depend on, and its FSL-1.1-MIT license is source-available rather than OSI open source until the future license converts.

Strengths
#

The graph model is a genuinely different abstraction: edges are hand-off, message, or spawn, and the agents on either end can differ.
Sessions outlive the app and reboots via zmx, so unattended loops remain attachable and correctable.
The self-improving loop separates maker, critic, and a bounded guard, and reads a measured metric rather than the loop’s self-report, which is the right structure for autonomous iteration.
Goal-based loops use a shell predicate as the done check, and the UI can test that predicate as the daemon will.
Nothing is written inside your project folders, and the integration surfaces (GraphcodeKit and the CLI) stay MIT.

Cautions
#

macOS 15 or later on Apple Silicon only.
FSL-1.1-MIT is source-available, not OSI open source, for the app and daemon until the future license date.
Pre-1.0 beta with one maintainer and a small community; no Hacker News or forum footprint during this run.
Bundles no agent CLIs and requires at least one on PATH (the website says Claude Code specifically).
Time-based loops on Codex, OpenCode, and Pi need an experimental daemon heartbeat because only some agents have a /loop skill.

Pricing
#

Free to download and self-host under the Functional Source License (FSL-1.1-MIT), which becomes MIT after the license’s delay. No paid tier, no hosted service, and no token markup; agent access runs on your own subscriptions.

Compared to
#

LoopTroop: a planning-first GUI for repo-scale tickets; choose GraphCode when you want connected, unattended, still-attachable loops instead of council planning.
Sandcastle: a scripted library with sandbox isolation; choose GraphCode for a native visual graph and surviving PTY sessions.
tmux plus a cron job: the zero-dependency option; GraphCode earns its keep when loops must message each other and be steered mid-run.

Bottom line
#

Recommended for macOS Apple Silicon engineers who want unattended, connected agent loops they can still attach to and correct. Not for Intel Macs, Linux, or Windows, and not for anyone who requires an OSI open source license or a multi-maintainer project.

Changes
#

2026-09-27 - Created.

References
#

https://github.com/scgopi/GraphCode - repository, loop types, daemon and CLI, license split, stars, and release data
https://graphcode.app/ - the graph-engineering model, loop types, self-improving loop, and architecture
https://raw.githubusercontent.com/scgopi/GraphCode/HEAD/README.md - install, five backends, zmx sessions, and the FSL-1.1-MIT license text
https://github.com/scgopi/GraphCode/blob/main/LICENSE - the license split between FSL-1.1-MIT app and MIT integration surfaces
https://openorchestrators.org/ - the curated directory’s GraphCode entry

Helmor

tom@tomrochette.com (Tom Rochette) — Sun, 27 Sep 2026 00:00:00 +0000

Helmor is an Apache-2.0, local-first desktop workbench that orchestrates coding agents across git worktrees through planning, running, review, testing, merge, and shipping loops.

Helmor’s bet is that the part AI did not accelerate is finishing the loop, so it wraps agents in the review, test, merge, and one-click PR steps that stand between a generated diff and shipped software.

What it is
#

A desktop app (Tauri plus React, buildable from source with Bun) from dohooo that runs Claude Code, Codex, Cursor, OpenCode, and Kimi Code, each in its own git worktree and branch under ~/helmor/workspaces/. Every workspace holds the conversation, diffs, a Monaco editor, and terminals side by side, with one-click actions to create a PR or MR, merge, fix CI, resolve conflicts, and stack PRs against GitHub or GitLab. Agent CLIs are bundled so there is nothing extra to install, and it adds a helmor CLI and an MCP server over stdio so a terminal or another agent can drive it, plus skills, a quick-launch panel (Shift+Option+Space), a Terminal Mode that runs prompts in the agent’s native TUI, and an experimental mobile companion over a Cloudflare tunnel. macOS (Apple Silicon and Intel) and Windows x64 are the supported desktop platforms.

Status
#

Active but cooling: about 1,307 stars and 119 forks as of 2026-09-27, created 2026-04-02, with 1,831 commits. The latest release, v0.46.0 (which added Codex 1.0 and Claude Code 2.0 support), landed 2026-07-24, and the last default-branch commit was 2026-08-22, roughly five weeks before this note, so momentum has slowed even as the feature set matured. For a tool still advertising forthcoming plan mode and Slack and GitHub context, a five-week quiet spell is the first data point to watch between now and the next release.

Strengths
#

The full loop, not just dispatch: review, test, merge, fix CI, and PR/MR creation from one window, including stacked PRs.
Local-first by construction: everything lives under ~/helmor/, credentials stay on the machine, and there is no cloud dependency.
Apache-2.0 and community-oriented (Discord, discussions, source-available architecture docs).
Bundled agent CLIs and bring-your-own logins and providers, so setup is one download.
A CLI and MCP server make it scriptable and drivable by other agents, and the quick panel lowers the cost of starting a task.

Cautions
#

Five weeks without a commit and the last release in July 2026 as of 2026-09-27; treat the roadmap items as unshipped.
Desktop only, and no Linux build; the macOS DMG is around 462 MB.
Its documentation site (docs.helmor.ai) did not resolve during this run, so the README and releases are the practical documentation.
Review is local and Git-host-facing; there is no fleet-scale issue board or cloud execution.
Independent coverage is thin and mostly directory listings; the recurring open question is whether teams want another orchestration surface rather than better defaults inside the agents they already use.

Pricing
#

Free and open source under Apache-2.0. No paid tier, no hosted service, and no token markup; agents run on your own logins and subscriptions.

Compared to
#

Conductor: the closed, better-funded Mac dashboard with the deepest review flow; choose Helmor for an open license, Windows support, and local-first credentials.
Superset: source-available and macOS-first with SDK programmability; choose Helmor for a shipped Windows build and one-click PR and merge actions.
Orca: MIT and cross-platform with a mobile companion and 27 agents; choose Helmor for a leaner workbench centered on finishing the loop.

Bottom line
#

Recommended for macOS or Windows engineers who want an open, local-first workbench that carries agent work through review, test, merge, and one-click PR. Not for Linux users, and not for anyone who needs fleet-scale orchestration or assurance of active development.

Changes
#

2026-09-27 - Created.

References
#

https://github.com/dohooo/helmor - repository, feature set, license, stars, and last-commit date
https://helmor.ai/ - product positioning, current version, and download platforms
https://raw.githubusercontent.com/dohooo/helmor/HEAD/README.md - workspaces, agents, review and ship features, CLI, and MCP server
https://github.com/dohooo/helmor/releases - release cadence and v0.46.0 notes
https://hysenlabs.com/en/projects/dohooo-helmor - independent summary of the local-first worktree model

Lanes

tom@tomrochette.com (Tom Rochette) — Sun, 27 Sep 2026 00:00:00 +0000

Lanes is a freemium, native macOS workspace that runs many CLI coding agents as parallel real-PTY sessions, each on an issue and its own git worktree, with a board, editor, SQLite browser, and git client around them.

Lanes’ bet is that parallel agent work is a git problem first and a UI problem second, so it wraps every session in a real worktree and an issue card, and pairs the closed desktop app with an open, self-hostable MCP endpoint that manages what all your agents may reach.

What it is
#

A native macOS app (Apple Silicon and Intel, macOS Ventura or later) from Lanes, installed with brew install --cask lanes-sh/lanes/lanes. Each issue is a board card that moves through Planning, Implementation, Review, and Done, and each card holds live PTY-backed terminal sessions (Claude Code and Codex detected and resumed natively, any other CLI as a plain shell), a generated worktree and branch, and an inline diff. Around the agent surface it ships a git client, a Monaco editor, a read-only SQLite browser, dependency links with cycle detection, quick commands, voice dictation, and a local MCP server so an agent can read the board and start sessions. The second half is Lanes Link, a self-hostable MCP endpoint (Apache-2.0, one endpoint you own) that holds accounts, memory, tasks, skills, identity, and a vault behind deny-by-default access profiles and a hash-chained audit log, plus Lanes Forms and per-second Lanes Compute GPUs. The app runs agents locally, never proxies model calls, and points sessions at whatever provider you configure, including local Ollama or LM Studio.

Status
#

Active and iterating: version v0.49 shipped 2026-09-08, the macOS app is on Homebrew, and the changelog runs through September 2026. The public source repository, lanes-sh/app, shows about 271 stars as of 2026-09-27, created 2026-03-22, and is updated within days; the product also spans the Apache-2.0 lanes-sh/link endpoint and the hosted Lanes Forms and Compute services. The open question is provenance: the site says “open source from day one” and links both repositories, but the app repository carries no license metadata on GitHub as of 2026-09-27, whereas the Link endpoint is explicitly Apache-2.0.

Strengths
#

The issue board is the differentiator: cards, columns, dependencies, labels, and per-project tabs make a fleet legible in a way terminal tabs do not.
Real PTY sessions in your own shell with your credentials, and session resume across restarts.
A full local coding surface around the agents (git client, Monaco editor, SQLite browser, diff), so review does not mean switching to an IDE.
Lanes Link is a genuinely separate, self-hostable product with 105 providers, access profiles, and an append-only audit log.
Local-first and model-agnostic: nothing is proxied, and any provider or local model works.

Cautions
#

macOS only (Ventura or later), with no advertised Windows or Linux build; Linux users are directed to hand-managed worktrees.
The desktop app’s license is not declared in its repository metadata even though the site calls it open source; treat the claim as unverified for the app.
Sessions run as real terminals with your dotfiles and credentials, so assume anything you can do in Terminal an agent can do in Lanes.
GitHub and Linear are the only tracker integrations; everything else is deep links.
The pricing page mixes product tiers with GPU Compute, which complicates budgeting if you only want the desktop app.

Pricing
#

Free ($0) for one user and unlimited local sessions with the full desktop app. Pro at $19/month covers up to 10 members, collaboration, higher Forms limits, and security features. Enterprise is custom for SSO/SAML, audit log, IP restrictions, and data residency. Lanes Compute is separate and billed per second per GPU; agents run on your own provider subscriptions.

Price history
#

Date	Plan	Change	Source
2026-09-27	Free, Pro, Enterprise	Baseline: Free $0 for one user, Pro $19/mo for up to 10 members, Enterprise custom; Compute billed per second.	lanes.sh/pricing

Compared to
#

Conductor: the closed, heavily funded Mac app with the deepest review flow; choose Lanes when the issue board and an open MCP endpoint matter more than cloud execution.
Orca: MIT and cross-platform with a mobile app; choose Lanes for a board-first macOS workflow and the broader Link access layer.
Helmor: Apache-2.0, local-first, and also macOS plus Windows; choose Lanes for the board and Provider/Forms/Compute family, Helmor for an open license and Windows support.

Bottom line
#

Recommended for macOS engineers who want parallel agents organized as issues on a board with a real git and editor surface around them, and who want their agent access governed by one self-hosted endpoint. Not for Windows or Linux shops, and not for anyone who needs a verifiably open licensed desktop client.

Changes
#

2026-09-27 - Created.

References
#

https://lanes.sh/ - product overview, the Desktop and Link split, and trust claims
https://lanes.sh/docs - desktop board, sessions, worktrees, git, editor, MCP, and Link documentation map
https://lanes.sh/pricing - Free, Pro $19/month, Enterprise custom, and per-second Compute
https://lanes.sh/llms.txt - agent-readable product description, Link providers, APIs, and CLI install paths
https://github.com/lanes-sh/app - app repository, README, and the missing license metadata as of 2026-09-27
https://runany.dev/blog/lanes-parallel-ai-coding-workspace/ - independent walkthrough and critique of the worktree and board model

LoopTroop

tom@tomrochette.com (Tom Rochette) — Sun, 27 Sep 2026 00:00:00 +0000

LoopTroop is an MIT-licensed local GUI orchestrator for repo-scale coding tickets that turns a ticket into a planned, reviewable, agent-executed pull request through multi-model council planning, atomic beads, isolated OpenCode worktrees, and fresh-context recovery loops.

LoopTroop’s bet is “slow and perfect”: for long, high-correctness feature work it sacrifices chat speed for multi-model planning, minimal per-stage context, and a strict-manager retry that throws away a contaminated agent session instead of arguing with it.

What it is
#

A local web app (installed by curl, npm, Homebrew, Scoop, Bun, pnpm, yarn, or Docker) from looptroop-ai that runs on top of OpenCode. The pipeline has three layers: planning, where an adaptive interview produces a PRD that an LLM council drafts, anonymously scores, and refines into atomic “beads” (independent units with acceptance criteria and target files); execution, where OpenCode implements each bead in its own git worktree; and shipping, where a final verification pass hands off to your main branch. Its context engineering rebuilds minimal per-status context for each phase rather than passing a bloated transcript, and its Ralph-style retry preserves a compact error trace, discards the degraded workspace, and retries in a fresh worktree, which the site claims sustains ten or more hours of unattended execution. A human approval gate sits before any code is committed, and the README and docs cover the ticket state machine, prompts, API, and CLI.

Status
#

Active and early: about 154 stars and 14 forks as of 2026-09-27, created 2026-03-03, with commits the same day and a latest release of v0.5.9 (2026-08-26). The documentation is unusually complete for an alpha, but the project’s own status page calls it “early alpha software” with bugs still likely, and it lists two configured constraints: councils of 2 to 10 models, and one active ticket per project in the execution band. A repo-scale orchestrator that can only run one ticket at a time per project is betting that depth beats throughput, which is the opposite of the parallel-session tools beside it.

Strengths
#

Multi-model council planning with independent drafting, anonymous voting, and winner refinement attacks the single-model bias problem directly.
Atomic bead decomposition with explicit acceptance criteria and per-bead isolation prevents cascading failures across a large change.
Minimal, rebuilt per-phase context is a principled answer to context rot in long autonomous runs.
Fresh-context recovery (the Ralph loop) is more robust than retrying inside a degraded session.
Free, MIT, 100% local, with a complete DOCUMENTED lifecycle and per-bead diff review before merge.

Cautions
#

Early alpha, 154 stars, single vendor, and one active ticket per project, so it is not a parallel fan-out tool.
OpenCode is the only execution backend; no Claude Code, Codex, or others.
Agents run with full local user privileges, and the docs themselves recommend running inside a disposable VM or cloud sandbox.
Planning is deliberately slow: the interview can take over an hour, which is a poor fit for small tasks.
The local GUI plus Node and OpenCode prerequisites make setup heavier than a CLI tool.

Pricing
#

Free and open source under MIT, with no telemetry. You pay only for the model providers OpenCode is configured to use.

Compared to
#

Crewplane: a CLI-first Markdown workflow runner; choose LoopTroop when you want council planning and a GUI rather than repo-owned workflow files.
Sandcastle: a TypeScript library that sandboxes and merges agents; choose LoopTroop when the problem is planning and recovery for big tickets, not sandbox plumbing.
Conductor: the polished Mac dashboard for many small parallel sessions; choose LoopTroop for fewer, long, high-correctness feature runs.

Bottom line
#

Recommended for engineers who want a local, MIT, planning-first orchestrator for large OpenCode tickets with human approval and strong recovery. Not for anyone who needs multi-harness support, parallel tickets, or a mature tool.

Changes
#

2026-09-27 - Created.

References
#

https://github.com/looptroop-ai/LoopTroop - repository, feature set, license, stars, and release data
https://www.looptroop.ovh/ - product positioning, LLM council, beads, Ralph loop, and human approval gate
https://www.looptroop.ovh/docs/ - architecture, workflow, context engineering, and the early-alpha status statement
https://openorchestrators.org/ - the curated directory’s LoopTroop entry
https://news.ycombinator.com/item?id=48643477 - the author’s Show HN post introducing the local orchestrator

Microsoft Agent Governance Toolkit

tom@tomrochette.com (Tom Rochette) — Sun, 27 Sep 2026 00:00:00 +0000

The Microsoft Agent Governance Toolkit (microsoft/agent-governance-toolkit) is an MIT-licensed, multi-language toolkit that intercepts each agent tool call, message send, and delegation in application code and evaluates it against policy before the action reaches the wire.

Its thesis is that prompt-level safety is a polite request to a stochastic system, so governance belongs in deterministic code outside the model, and this is the most complete shipping expression of that idea: policy, identity, sandboxing, SRE, and compliance in one repository.

What it is
#

pip install "agent-governance-toolkit[full]" installs a policy engine with YAML, OPA Rego, and Cedar support, plus a govern() wrapper that checks, logs, and enforces every tool call. The packages are Agent OS (policy), Agent Mesh (DID identity and trust scoring), Agent Runtime (execution rings and sandboxing), Agent SRE (SLOs, circuit breakers, kill switch), Agent Compliance (OWASP and EU AI Act mapping), Agent Marketplace, Agent Lightning, and Agent Hypervisor. SDKs exist for Python, TypeScript, .NET, Rust, and Go, with first-party plugins for Claude Code, Copilot CLI, Codex CLI, and OpenCode, and adapters for LangGraph, CrewAI, the OpenAI Agents SDK, Semantic Kernel, and Microsoft Agent Framework. It is published under the Microsoft organization, but the team states an intent to move it to a foundation, and the README calls it a public preview that may break before GA.

Status
#

Active, wide, and fast-moving: 6,349 stars, 1,131 forks, and 91 open issues as of 2026-09-27, created 2026-03-02, last pushed 2026-09-26, latest release v4.1.0 on 2026-06-09. The community footprint is thin relative to the star count: the Hacker News submissions I found top out at 6 points, and the most substantive third-party writeup is a security critique rather than a tutorial. That critique (April 26, 2026) found a caller-controlled X-Agent-ID header flowing into audit, policy, and rate-limit consumers with no verification, six exported security primitives with zero production callers, and an in-memory audit log that breaks its own integrity check on overflow. The project has since shipped several breaking refactors, but I could not confirm from primary sources that the specific wiring gaps are closed, so treat the critique as a pre-adoption checklist rather than a resolved incident.

Strengths
#

The only toolkit in this category that ships policy, identity, sandboxing, SRE, and compliance as one spec-backed product, with formal RFC 2119 specifications and hundreds of conformance tests.
Genuinely polyglot: five language SDKs and framework adapters, so governance does not dictate your stack.
Deterministic and fail-closed at the interception point, which is the correct place to enforce anything that must not happen.
Vendor-backed with the open-source fundamentals most tools here lack (CodeQL, continuous fuzzing, OpenSSF Scorecard, a published security policy).

Cautions
#

The April 2026 critique is the strongest published skeptical source in this whole category; confirm that identity is authenticated on your request path and that audit storage is durable before trusting the landing page.
Public preview with breaking changes between minor versions; pin deliberately and read BREAKING_CHANGES before upgrading.
Governance runs in application middleware, not at the OS kernel, and the README recommends one container per agent for real isolation.
Breadth is a cost: seven packages and ten specifications is a large surface to evaluate for a small team.

Pricing
#

MIT licensed and free, self-hosted, no paid tier. Deployment guides cover Azure, AWS, GCP, and Docker Compose.

Compared to
#

Veto: a narrower, single-purpose authorization kernel with a commercial cloud; choose Veto for one gate in front of risky tool calls, and this toolkit for a governance program across languages and frameworks.
SIDJUA: a self-hosted orchestrator with pre-action enforcement baked into the runtime; choose SIDJUA for a small always-on agent company, and this toolkit when the agents and frameworks already exist.
Code Atelier Governance SDK: a Python and Postgres-only enforcement SDK; choose it for a minimal footprint, and this toolkit for multi-language coverage and identity.

Bottom line
#

Recommended for platform teams standardizing deterministic agent governance across multiple languages and frameworks, who can independently verify the enforcement wiring. Not for single-agent projects or teams that want a thin, drop-in gate, since the surface is large and the preview churn is real.

Changes
#

2026-09-27 - Created.

References
#

https://github.com/microsoft/agent-governance-toolkit - README: packages, quickstart, specs, preview notice, security boundaries
https://api.github.com/repos/microsoft/agent-governance-toolkit - stars, forks, issues, push date as of 2026-09-27
https://opensource.microsoft.com/blog/2026/04/02/introducing-the-agent-governance-toolkit-open-source-runtime-security-for-ai-agents/ - launch post: seven packages, OWASP mapping, foundation intent
https://www.flyingpenguin.com/authentication-bypass-in-microsoft-agent-governance-toolkit-at-573f989/ - critical security review of identity wiring and audit durability
https://api.github.com/repos/microsoft/agent-governance-toolkit/releases - v4.1.0, 2026-06-09
https://pypi.org/pypi/agent-governance-toolkit/json - distribution and version 4.1.0

MiMo Code

tom@tomrochette.com (Tom Rochette) — Sun, 27 Sep 2026 00:00:00 +0000

MiMo Code is Xiaomi’s MIT-licensed terminal coding agent, an OpenCode fork that adds a persistent memory layer, checkpoint-based context rebuilds, and goal-verified autonomous loops, released in June 2026.

MiMo Code’s differentiator is not a better model but a runtime built to survive hundreds of steps, and the defensible case for it today is auditable source plus cheap Xiaomi tokens, not its self-reported benchmark gap.

What it is
#

The mimo CLI is installed by a curl script or the @mimo-ai/cli npm package, and the same engine ships as the core of Xiaomi’s MiMo Desktop app. It carries three primary agents (build, plan, and compose), an on-demand subagent system with parallel execution and lifecycle tracking, a tree-structured task store (T1, T1.1), MCP with local, remote, and OAuth servers, LSP integration, and a plugin and skills surface inherited from OpenCode. The parts Xiaomi actually added are the long-horizon machinery: a checkpoint-writer subagent that writes structured state at roughly 20, 45, and 70 percent of the context budget, a four-layer memory (session checkpoint, project MEMORY.md, global memory, and a full SQLite history), a rebuild step that reassembles the window from those files in about 65K tokens, /dream and /distill memory-maintenance passes, an independent judge behind the /goal stop condition, and best-of-N Max Mode. Provider access is the OpenCode posture: any of 75+ providers through the AI SDK and Models.dev, local models through an OpenAI-compatible endpoint, or Xiaomi’s own platform.

Status
#

Active and pre-1.0. The repository was created 2026-06-10 and lists about 13.5k stars and 1.4k forks under MIT as of 2026-09-27, with 1,359 commits and a push on 2026-09-26. The newest release by publication time is v0.1.14 (published 2026-09-23), published a day after v0.1.15 (2026-09-22), so five months after launch the project is still on a 0.1.x line. The launch drew a 557-point Hacker News thread with 315 comments on 2026-06-11, and the tracker carries roughly 800 open issues plus 284 open pull requests, many auto-filed and low-signal.

Strengths
#

The context design is the differentiated part: moving state extraction out of the main loop into a separate writer subagent, and checkpointing well below the window limit rather than at the moment of overflow, is a deliberate answer to the lost-in-the-middle degradation that ordinary compaction ignores.
The /goal verifier and Max Mode are two orthogonal uses of test-time compute, serial self-checking and parallel sampling, and they are conventional enough to compare against Claude Code’s subagents and Arbor-style hypothesis trees.
Deterministic workflows turn orchestration into bounded JavaScript rather than prompt, which removes the “the model skipped a step” failure class for large fan-out jobs.
Provider-neutral, local-model capable, and self-hostable weights mean the model is a separate purchase from the agent, and the international API prices sit far below the frontier vendors.
The MIT source is fully auditable, which matters for a tool that runs your shell.

Cautions
#

The fork does the heavy lifting: the LICENSE preserves Copyright (c) 2025 opencode, and open issues still flag leftover OpenCode names in CONTRIBUTING.md (#29) and in the published config docs (#1150), so evaluate Xiaomi’s contribution as the memory and orchestration layer, not the polished TUI, plugin system, and provider abstraction.
The benchmark case is vendor-run. Xiaomi reports 62 versus 57 on SWE-bench Pro and 73 versus 68 on Terminal Bench 2 against Claude Code with the model held constant, but MiMo Code appears on neither public leaderboard and nobody independent has reproduced the gap; Xiaomi’s own write-up says the two agents perform about the same below 200 execution steps, which is exactly the case a one-shot benchmark does not measure.
The Token Plan’s “4.1 billion” quota is in Credits, not tokens, and the cache-miss multiplier is 100x (2 Credits cache hit, 100 cache miss, 200 output for the V2.5 line), an ambiguity one open issue calls a bait-and-switch after a 62.6M-token session consumed 903M of a 4.1B quota.
Pre-1.0 churn: breaking changes between 0.1.x releases, a fast-moving config surface, and reports of single-request 429s rendering a Max plan unusable.
Importing a Claude Code login or ChatGPT account into a third-party CLI can run against those providers’ terms, and Xiaomi is a Chinese vendor whose hosted endpoints are regional (China, Singapore, Europe).
MIT is paired with a separate USE_RESTRICTIONS.md that adds conditions (no military use, no unsupervised high-risk autonomous actions) beyond the license grant.

Pricing
#

The agent is free and open source under MIT; you pay for tokens, either through Xiaomi or through your own provider. Xiaomi’s Token Plan sells four individual monthly tiers, all covering the V2.6 and V2.5 model lines plus ASR and TTS: Lite $6 (4.1B Credits), Standard $16 (11B), Pro $50 (38B), and Max $100 (82B), with annual billing about 12 percent cheaper, a one-time 12 percent first-purchase discount, and an off-peak 0.8x consumption rate between 16:00 and 24:00 UTC. Pay-as-you-go international prices per million tokens are $0.435 in (cache miss) and $0.87 out for mimo-v2.6-pro, and $0.14 and $0.28 for mimo-v2.6-flash, with cache hits at a few thousandths of a dollar. Any OpenAI-compatible provider, including a local model, can be configured instead, so the Token Plan is optional.

Price history
#

Date	Plan	Change	Source
2026-09-27	Token Plan Lite	Baseline: introduced at $6/month (¥39), 4.1B Credits	https://mimo.mi.com/docs/en-US/tokenplan/Token%20Plan/subscription
2026-09-27	Token Plan Standard	Baseline: introduced at $16/month (¥99), 11B Credits	https://mimo.mi.com/docs/en-US/tokenplan/Token%20Plan/subscription
2026-09-27	Token Plan Pro	Baseline: introduced at $50/month (¥329), 38B Credits	https://mimo.mi.com/docs/en-US/tokenplan/Token%20Plan/subscription
2026-09-27	Token Plan Max	Baseline: introduced at $100/month (¥659), 82B Credits	https://mimo.mi.com/docs/en-US/tokenplan/Token%20Plan/subscription
2026-09-27	Pay-as-you-go (international)	Baseline: mimo-v2.6-pro $0.435/$0.87 per M in/out, mimo-v2.6-flash $0.14/$0.28	https://mimo.mi.com/docs/en-US/price/pay-as-you-go

Compared to
#

OpenCode: the upstream project; choose OpenCode for the longer track record, the larger community, and the leanest measured token baseline, and MiMo Code only if the memory and long-horizon additions justify a fork you now depend on.
Kimi Code: the closest peer, another terminal harness tuned by a challenger lab for its own cheap models; pick on which vendor’s models and quota structure you prefer, not on benchmark claims.
Claude Code: the platform benchmark MiMo Code positions against; Claude Code buys polish and subscription simplicity, MiMo Code buys open source and low per-token cost.

Bottom line
#

Recommended for engineers who want an auditable terminal agent with explicit long-horizon state management and some of the cheapest credible token prices, and who are willing to run a 0.1.x tool. Not for teams that need release stability, and not because a vendor benchmark says it beats Claude Code past 200 steps. My disagreeable claim: the co-evolution story is mostly packaging, since the mature harness arrived with the OpenCode fork and the observable Xiaomi contribution is a checkpoint-and-memory layer plus a model bundle, which is genuinely useful but narrower than the tagline suggests.

Changes
#

2026-09-27 - Created.
2026-09-27 - Corrected the latest-release fact: the newest release by publication time is v0.1.14 (published 2026-09-23), a day after v0.1.15 (2026-09-22); the 0.1.x status is unchanged.

References
#

https://mimo.xiaomi.com/mimocode/start - official docs: surfaces, agents, skills, MCP, and the memory layer
https://github.com/XiaomiMiMo/MiMo-Code - repository, MIT license, OpenCode fork relationship, and feature README
https://api.github.com/repos/XiaomiMiMo/MiMo-Code - 13,504 stars, 1,400 forks, MIT, created 2026-06-10, pushed 2026-09-26, as of 2026-09-27
https://api.github.com/repos/XiaomiMiMo/MiMo-Code/releases/latest - returns v0.1.14 (published 2026-09-23), published a day after v0.1.15 (2026-09-22), as of 2026-09-27
https://mimo.xiaomi.com/blog/mimo-code-long-horizon - the design write-up: checkpoints, four-layer memory, /goal, Max Mode, and the vendor benchmarks
https://mimo.mi.com/docs/en-US/tokenplan/Token%20Plan/subscription - individual Token Plan tiers, Credits, and discounts
https://mimo.mi.com/docs/en-US/price/pay-as-you-go - international and domestic per-token prices
https://mimo.mi.com/docs/en-US/tokenplan/integration/mimo-code - MiMo Code configuration and Token Plan support
https://mimo.xiaomi.com/mimocode/skills - skill discovery, including the .claude, .agents, .codex, and .opencode compatibility roots
https://www.ssdnodes.com/learn/mimo-code-ai-coding-agent - independent coverage: the fork-credit issue, the vendor-benchmark caveat, and the pre-1.0 caution
https://thenewstack.io/coding-agent-endurance-gap/ - the endurance-gap framing and the self-reported-benchmark caveat
https://hn.algolia.com/api/v1/items/48490826 - the 2026-06-11 launch thread, 557 points and 315 comments
https://github.com/XiaomiMiMo/MiMo-Code/issues/2142 - the open Token Plan credit-multiplier complaint behind the pricing caution
https://github.com/XiaomiMiMo/MiMo-Code/issues/1150 - open issue on config docs still documenting OpenCode names
https://raw.githubusercontent.com/XiaomiMiMo/MiMo-Code/main/USE_RESTRICTIONS.md - the use-restrictions addendum paired with the MIT license
https://raw.githubusercontent.com/XiaomiMiMo/MiMo-Code/main/LICENSE - MIT with the preserved opencode copyright line

Multica

tom@tomrochette.com (Tom Rochette) — Sun, 27 Sep 2026 00:00:00 +0000

Multica is a source-available, self-hostable workspace that treats coding agents as teammates, letting a team assign issues to agent CLIs and track their runs, comments, diffs, and skills in one place.

Multica’s bet is that the right abstraction for agent work is the issue, not the prompt: make agents first-class assignees with profiles and runtimes, and the durable artifact becomes the ticket that connects intent, execution, decisions, and the diff.

What it is
#

A platform from multica-ai (the LICENSE names Index Labs (Hong Kong) Limited) with a Next.js frontend, a Go backend, and PostgreSQL with pgvector, offered as a desktop app plus a self-hosted server (Docker Compose, single binary, or Kubernetes/Helm). You create an agent with a name, provider, and runtime; the runtime is a daemon on any connected machine (a laptop or a cloud box) that auto-detects installed agent CLIs and executes the work there. An issue assigned to an agent moves through enqueue, claim, start, and complete or fail, streaming progress to the UI, and the platform adds squads, reusable skills, autopilots on a cron, chat, projects, execution-log replay, run steering, usage analytics, review gates, an inbox, and automatic retries. It self-describes as supporting 26 agent CLIs (Claude Code, Codex, Cursor, Copilot, Kimi, OpenCode, and more), integrates with GitHub, GitLab, Gitea, and Forgejo plus Slack, Lark, DingTalk, WeCom, and Telegram, and ships desktop and iOS apps.

Status
#

Actively shipped and unusually high-profile: about 51,451 stars and 6,668 forks as of 2026-09-27, created 2026-01-13, with 1,684 open issues and a latest release of v0.5.3 on 2026-09-24. Releases land every one to three days, which corroborates real maintenance. Two caveats travel with the headline number: the star count is extraordinary for an eight-month-old repo, and independent reviewers found at least eight near-identical zero-star clones carrying the same marketing description, a pattern associated with star farming, while the license is a custom Apache-2.0-derived “Multica License” that GitHub reports as NOASSERTION.

Strengths
#

The issue-and-assignee model maps onto how teams already work, and the runtime abstraction cleanly separates where code runs from who can invoke it.
Broad agent-CLI support (26 claimed) with daemon auto-detection, so it is a layer over the tools you already use rather than a new harness.
Self-hostable end to end, with any Git host and five chat integrations, and no GPU requirement because it runs no models itself.
Strong operational surface: execution-log replay, run steering, review gates, retries and timeouts, and per-run usage analytics.
Desktop app plus web plus iOS, so a team can watch and unblock work from wherever it works.

Cautions
#

The star count is a caveated signal: reviewers flag fast growth for the repo’s age and multiple near-identical clones, though forks, issues, and commit volume suggest genuine activity underneath.
The license is not plain Apache-2.0: the Multica License adds conditions on hosted services and commercial embedding, so read it before either use.
Skills do not compound automatically yet; reviewers report most teams still hand-write them like runbooks.
Self-hosting means operating PostgreSQL with pgvector, and agent failure modes (loops, repeated state transitions) can swamp a human-shaped board.
No published pricing page was found; hosted pricing exists only behind a free trial and a sales conversation, and self-hosted images can lag the cloud by a release.

Pricing
#

No public price table was found on multica.ai as of 2026-09-27; the site offers a free trial and a “talk to sales” path, and self-hosting requires no hosted account. The source is available under the custom Multica License; agents run on your own provider accounts, and Multica does not charge for tokens.

Compared to
#

Omnara: an Apache-2.0 control plane where agents are YAML and supervision spans dashboard, phone, CLI, API, or Slack; choose Multica for an issue-board and teammate model with a desktop and mobile app.
LobeHub: a Chief Agent Operator that hires, schedules, and reports on agents; choose Multica when the unit of work is a ticket assigned to a named agent.
Superset: a local IDE for parallel worktree sessions; choose Multica when work is team-shaped and needs assignment, review gates, and an audit trail.

Bottom line
#

Recommended for teams of two to ten already running coding agents who want to assign issues to them on a shared, self-hostable board with review gates and an audit trail. Not for solo developers running one agent, teams needing per-agent budget caps today, or anyone unwilling to read a custom license or operate Postgres.

Changes
#

2026-09-27 - Created.

References
#

https://github.com/multica-ai/multica - repository, architecture, agent support, license metadata, stars, and release data
https://multica.ai/ - product positioning, teammate model, runtimes, and integrations
https://multica.ai/docs - issues, agents, squads, skills, autopilots, runtimes, runs, and security model
https://raw.githubusercontent.com/multica-ai/multica/HEAD/LICENSE - the custom Multica License and its hosted-service and commercial-embedding conditions
https://www.promptquorum.com/power-local-llm/multica-review - the star-count caveat, the license analysis, and the absence of a public price table
https://andrew.ooo/posts/multica-open-source-managed-agents-platform/ - independent review of the runtime abstraction and its limitations

oh-my-codex

tom@tomrochette.com (Tom Rochette) — Sun, 27 Sep 2026 00:00:00 +0000

oh-my-codex (OMX) is an MIT-licensed workflow layer for OpenAI Codex CLI that adds stronger default sessions, reusable skills, hooks, HUD and status surfaces, project guidance, and team execution commands.

OMX’s bet is that a single harness can be made team-capable from the outside: it keeps Codex as the execution engine and adds the planning, worktree isolation, memory, and review scaffolding that the CLI does not ship with.

What it is
#

An npm package (npm install -g oh-my-codex) from Yeachan Heo and two maintainers that layers on top of Codex CLI rather than replacing it. It exposes 32 role prompts via /prompts:name and 25 workflow skills invoked with $name, including $plan, $ultragoal, $team, $code-review, and $ultraqa, each runnable independently rather than as a fixed chain. Its core skill is $team, which runs N coordinated workers each in a dedicated git worktree (isolated detached branches, incremental merge tracking, and an integration-report.md), optionally mixed across providers via OMX_TEAM_WORKER_CLI_MAP=codex,claude,gemini. It adds six MCP servers (state, memory, code intelligence, trace, wiki, and Hermes) for cross-session context, a staged plan → prd → exec → verify → fix pipeline, launch profiles (--yolo, --high, --xhigh, --madmax), hooks, a live HUD, and project guidance kept in .omx/. Notifications route to Discord, Slack, Telegram, or custom webhooks through an OpenClaw gateway.

Status
#

Actively shipped and very popular: about 33,395 stars and 2,542 forks as of 2026-09-27, created 2026-02-02, with the latest release v0.21.6 on 2026-09-21 and npm at the same version across 135 published versions. The 0.21 line was a consolidation: it retired legacy keywords behind a sunset-stub resolver ($ralph to $ultragoal, $ultrawork to $team) and removed writable MCP state tools. The popularity is harness-specific: OMX is a Codex CLI layer, and the README itself warns that native Windows and the Codex App are not the default experience and may break, and that third-party “OMX v2” forks are not official.

Strengths
#

Turns an individual Codex session into a coordinated team with automatic per-worker git worktrees and incremental merge tracking.
A large, named surface of skills and prompts ($plan, $team, $ultragoal, $code-review, $ultraqa) that is independently invocable.
Six MCP servers give persistent memory, state, code intelligence, and tracing across sessions.
Mixed-provider teams let Codex, Claude, and Gemini workers run side by side in one team.
MIT, with a README that is unusually explicit about install pitfalls and unsupported paths.

Cautions
#

Primarily tuned for macOS and Linux; native Windows and the Codex App “may break or behave inconsistently” per the README.
It is a layer on Codex CLI only, so it inherits Codex’s model, pricing, and platform constraints.
Fast-moving with a retirement cadence: $ralph, $ultrawork, and $pipeline were retired in 0.21, so older docs and tutorials drift.
npm global installs can collide with a Homebrew-owned codex binary (EEXIST), a documented footgun.
The huge star count is not matched by independent field reporting during this run; the community channel is a shared Discord server.

Pricing
#

Free and open source under MIT. No hosted tier and no token markup; Codex API or subscription usage is billed by OpenAI.

Compared to
#

Sandcastle: a TypeScript library that sandboxes any CLI agent; choose OMX when you want workflows and team execution on top of Codex specifically.
Crewplane: a provider-agnostic Markdown workflow runner; choose OMX for Codex-native skills, hooks, and worktree teams.
Plain Codex CLI plus scripts: the zero-dependency option; OMX earns its keep once you want planning skills, memory, and parallel worktree workers.

Bottom line
#

Recommended for Codex CLI users on macOS or Linux who want stronger defaults, reusable skills, persistent memory, and worktree-isolated team execution. Not for Windows-first users, non-Codex harnesses, or anyone who needs a stable, slow-moving interface.

Changes
#

2026-09-27 - Created.

References
#

https://github.com/Yeachan-Heo/oh-my-codex - repository, skills, team mode, MCP servers, license, stars, and release data
https://raw.githubusercontent.com/Yeachan-Heo/oh-my-codex/HEAD/README.md - install paths, the platform caution, and the official-project warning
https://www.npmjs.com/package/oh-my-codex - package page and version history
https://registry.npmjs.org/oh-my-codex - npm metadata: 0.21.6 latest, 135 versions, MIT, and dates
https://yeachan-heo.github.io/oh-my-codex-website/ - the 32 prompts, 25 skills, $team worktree model, and release notes

Okto Pulse

tom@tomrochette.com (Tom Rochette) — Sun, 27 Sep 2026 00:00:00 +0000

Okto Pulse (OktoLabsAI/okto-pulse) is an Elastic-2.0 local-first SDLC workbench that runs coding agents over MCP behind 17 named governance gates, blocking status transitions until spec coverage, validation, and evidence requirements are met.

Its thesis is that AI can generate the implementation but cannot guarantee that every requirement was covered or every acceptance criterion has evidence, so the workbench turns product intent into a governed pipeline (stories, ideation, refinement, spec, sprint, tasks, tests, bugs) and refuses to let work reach done without proof.

What it is
#

pip install okto-pulse starts one Python process serving a web UI and API on port 8100 and an MCP server on 8101, with all state local under ~/.okto-pulse/ in SQLite plus an embedded graph database. The architecture splits into okto-pulse-core, which owns the SDLC domain, the governance gates, and knowledge-graph contracts as pure protocol seams, and okto-pulse, which supplies every concrete mechanism (SQLite, the Okto Grafx graph engine, the filesystem, scheduler, and MCP host); an unfilled slot fails closed rather than silently defaulting. The gates cover resource readiness, spec coverage across acceptance criteria, requirements, business rules, API contracts, decisions, and test scenarios, plus task validation, test evidence, architecture findings, and sprint closure. Tasks cannot start until the parent spec has the required scenario coverage, done transitions are held while unresolved issues remain, and test cards require evidence before being marked passed or failed. An embedded knowledge graph keeps decisions, constraints, bugs, and learnings queryable with provenance across sessions.

Status
#

Active and young: 99 stars, 4 forks, and 7 open issues as of 2026-09-27, created 2026-04-22, last pushed 2026-09-24, current PyPI version 0.3.3. No GitHub releases are published, so the PyPI package is the release channel, and the website still advertises v0.2.6 while the repository README documents v0.3.3. The internal numbers do not agree across surfaces: the README prose and the website both say 17 governance gates while the README’s own platform table says 18, and the README says 340 core MCP tools while the product page says 215. The community footprint is thin: a Hacker News search for Okto Pulse returns nothing, so the evidence is the repository and the product site alone.

Strengths
#

The gate model is the point: coverage and evidence are enforced structurally before done, not reviewed after the fact.
Local-first with no account, SQLite plus embedded graph, and an MCP endpoint that plugs into Claude Code, Cursor, Windsurf, Cline, or any MCP agent.
The core and community split with fail-closed ports is an unusually clean separation for a young project.
Spec-driven development and an operational knowledge graph in one tool, so requirements, decisions, and tests stay linked instead of spread across chat history.

Cautions
#

Elastic License 2.0 is source-available, not OSI open source; commercial use is allowed but you may not offer it to third parties as a hosted or managed service.
Disagreements between the website, README prose, and README tables (gate and tool counts, version) make every volatile number worth re-checking before you cite it.
Young project (0.3.x) with a single organization behind it, no published releases, and a very small community.
It governs the coding workflow, not spending: it is not a budget or approval control plane in the Paperclip sense, despite sitting in this category.

Pricing
#

Free to run locally with no account. The README describes a possible SaaS edition and a core-and-community split, but no prices are published, so there is nothing to track yet.

Compared to
#

Paperclip: a company-level control plane with budgets, org charts, and approvals; choose Paperclip to run a business of agents, and Okto Pulse to govern the requirements and evidence of one codebase.
Spec Kit: a lighter spec-driven development toolkit; choose Spec Kit for prompt-and-template discipline and Okto Pulse when you want gates and an audit trail on the transitions.
beads: a dependency-aware issue tracker for agents; choose beads for the ledger and Okto Pulse when delivery also needs coverage and validation evidence.

Bottom line
#

Recommended for teams using coding agents on long-lived codebases who want spec coverage and delivery evidence enforced before work is accepted. Not for teams that need an OSI-approved license, a multi-agent org control plane, or a tool with a large community and stable versioning.

Changes
#

2026-09-27 - Created.

References
#

https://github.com/OktoLabsAI/okto-pulse - README: gates, MCP surface, architecture, licensing, local data layout
https://api.github.com/repos/OktoLabsAI/okto-pulse - stars, forks, issues, push dates as of 2026-09-27
https://oktolabs.ai/platform/pulse/ - product site: workflow, gate and tool counts, value proposition
https://pypi.org/pypi/okto-pulse/json - current version 0.3.3 and Elastic-2.0 license metadata
https://docs.oktolabs.ai - documentation index: install, quickstart, MCP setup, knowledge graph

Open Swarm

tom@tomrochette.com (Tom Rochette) — Sun, 27 Sep 2026 00:00:00 +0000

Open Swarm is an AGPL-3.0, local-first mission-control desktop app for launching, monitoring, approving, and coordinating multiple AI coding agents in parallel on a spatial canvas.

Open Swarm’s bet is that the bottleneck is supervision, not spawning: it puts every agent on one pan-and-zoom canvas, funnels every tool-use request into a single approval workflow, and keeps the whole thing on your machine with no cloud relay or telemetry.

What it is
#

A desktop app (Electron shell over a React frontend and a FastAPI backend on port 8324) from openswarm-ai that runs Claude-powered agents through the Claude Agent SDK. The spatial dashboard is an infinite canvas of drag-and-drop agent cards, view cards, and embedded browser cards; agent chat streams over WebSockets with per-session cost tracking and persistent history. Its differentiators are a unified human-in-the-loop approval workflow (per-tool permissions of always-allow, ask, or deny, with batch approval from the dashboard), message branching that forks a conversation by editing a prior message, prompt templates, a skills library that syncs to ~/.claude/skills/, and an MCP tools library with registry browsing. Each agent gets its own git worktree and branch, with a diff viewer for uncommitted changes, and there are five built-in agent modes plus custom modes, interactive HTML/JS/CSS output views, dark and light themes, and keyboard shortcuts. It currently targets macOS; Windows and Linux builds are documented as planned.

Status
#

Active but small: about 820 stars and 171 forks as of 2026-09-27, created 2026-03-13, with development through 2026-09-23. The current release line is explicitly experimental (v1.8.0-exp.2 on 2026-09-23), with a stable v1.7.11 before it. The signal is a license inconsistency: the README and the curated directory call it MIT, but the repository’s LICENSE file is AGPL-3.0 and GitHub’s API reports AGPL-3.0, so the permissive badge is the one piece of documentation not to trust.

Strengths
#

The unified approval workflow is the strongest part of the design: one place to approve or deny tool calls across every agent.
Cost tracking per session and per agent, which the parallel-agent category mostly leaves to the provider dashboard.
Git worktree isolation per agent plus a diff viewer, so parallel work is contained and reviewable locally.
Skills, MCP tools, prompt templates, and message branching give it real depth beyond a chat multiplexer.
Fully local by design: no cloud relay, no telemetry, and the backend can be run directly for self-hosting.

Cautions
#

The README’s MIT badge contradicts the AGPL-3.0 LICENSE, so confirm the actual terms before commercial or embedded use.
macOS only as of 2026-09-27; Windows and Linux are planned but not shipped.
Built on the Claude Agent SDK and Anthropic models; README says other models are coming, so it is effectively single-provider today.
The advertised release line is experimental (v1.8.0-exp), so expect churn.
The name collides with an unrelated Intrect-io/OpenSwarm Show HN project, which confuses search and comparisons.

Pricing
#

Free and open source (AGPL-3.0 per the repository’s LICENSE). No hosted tier and no token markup; agents run on your own Anthropic API key.

Compared to
#

Lanes: macOS board-first with real PTY sessions and an access-governance endpoint; choose Open Swarm for the approval-centric canvas and cost tracking.
Conductor: the polished closed Mac worktree dashboard; choose Open Swarm for a free, local, approval-gated alternative.
OpenChamber: a scheduled and interactive session surface; choose Open Swarm when you need many agents coordinated on one visible canvas.

Bottom line
#

Recommended for macOS engineers who run several Claude agents and want one local canvas with unified tool approvals and per-session cost tracking. Not for cross-platform teams, multi-provider fleets, or anyone who needs the README’s MIT terms.

Changes
#

2026-09-27 - Created.

References
#

https://github.com/openswarm-ai/openswarm - repository, architecture, features, stars, and the AGPL-3.0 LICENSE
https://raw.githubusercontent.com/openswarm-ai/openswarm/HEAD/README.md - features, approval workflow, skills and MCP libraries, and the MIT badge
https://news.ycombinator.com/item?id=47593100 - the author’s Show HN post and the cost and approval rationale
https://openorchestrators.org/ - the curated directory’s Open Swarm entry
https://openswarm.com/privacy - the no-cloud-relay and no-telemetry positioning

Orca

tom@tomrochette.com (Tom Rochette) — Sun, 27 Sep 2026 00:00:00 +0000

Orca is a free, MIT-licensed agent development environment (ADE) that runs a fleet of CLI coding agents side by side, each in its own git worktree, from desktop, phone, or a remote machine.

Orca’s bet is breadth: one MIT app that is at once the most cross-platform, the broadest in harness support, and the only one in this category bundling a first-party mobile companion, so it can absorb whatever CLI agent you settle on.

What it is
#

A desktop app built by Stably AI (YC W22, founded by Jinjing Liang, an ex-Google Chrome engineer, and Neil Parker, ex-Uber), also the makers of the Stably testing product. Every task gets its own git worktree, branch, terminal, and browser tab, with Ghostty-class WebGL terminals that survive restarts, a Monaco editor, per-worktree Chromium for a Design Mode that grabs a clicked element’s HTML, CSS, and screenshot into the prompt, and inline diff annotations shipped back to the agent. It is agent-agnostic and terminal-first: the site lists 27 supported agents (Claude Code, Codex, Cursor CLI, Gemini, Copilot, OpenCode, Pi, Amp, Antigravity, Grok, Kimi, Kiro, Droid, Qwen, and others) and says any other CLI drops in. Beyond local desktop it spans SSH worktrees, a self-hosted Orca server, on-demand cloud VMs, and an iOS and Android companion app for watching and steering sessions. MIT licensed, TypeScript and Electron, and the repo’s README carries translations into six languages.

Status
#

Fast and well-funded: about 79.4k stars and 5,198 forks as of 2026-09-27, created 2026-03-17, more than 11,900 commits, and a release, v1.4.215, published the same day. The changelog shows daily shipping through September 2026, including OpenCode 2 support (2026-09-20), a Muse Code harness and Codex goals in native chat (2026-09-25), and a Design Mode and browser stack. Stably is a YC W22 company with a separate revenue product (Stably testing), so Orca does not have to monetize itself yet, which is why it can stay free and MIT. The caution is scale: 6,901 open issues and pull requests against a repository roughly six months old, and the loudest proof of adoption is a wall of self-selected X quotes rather than independent field reports.

Strengths
#

The widest platform footprint in the category: macOS, Windows, and Linux desktops plus iOS and Android companions, where Conductor is macOS only and Superset treats Linux as experimental.
27 supported agents and a plain “any other CLI” fallback, so harness churn does not strand the tool.
Genuine review surface (diff viewer, inline annotations, GitHub and Linear review) rather than a bare terminal.
Remote execution done three ways (SSH worktrees, self-hosted server, cloud VMs) without hosting your code itself.
A powerful CLI (orca worktree create, snapshot, click, fill) so agents can drive the environment, plus hooks, skills, and MCP.

Cautions
#

The open-issue count is very high (6,901 as of 2026-09-27); expect rough edges and duplicates, and read the issue tracker before trusting a workflow.
“Ship 100x” and “hundreds of agents” are marketing framing; the practical unit is still a worktree per task and a human reviewing diffs.
Adoption evidence is largely self-reported (X quotes, company logos); the Hacker News footprint is thin (a three-point story and a small third-party review as of 2026-09-27).
Enterprise features (SOC 2 readiness, SAML, org defaults) are behind a sales conversation, so regulated teams cannot self-serve.
It bundles no models; cost is entirely your existing subscriptions, which the app does not meter for you.

Pricing
#

Free and open source under MIT for the desktop, mobile, CLI, and self-hosted server. Enterprise adds rollout, compliance, and support via a sales conversation at custom pricing; no public dollar tiers. Agents and models run on your own subscriptions, and Orca does not charge for tokens.

Compared to
#

Superset: source-available (ELv2), macOS-first, and stronger on SDK and automation; choose Orca for Windows and Linux, a real mobile app, and an MIT license.
Conductor: the best-funded closed Mac app with the deepest review flow; choose Orca when you need open source, cross-platform desktops, or phone supervision.
Lanes: macOS-only and board-centric; choose Orca for a board-light, worktree-and-terminal workspace across all three desktop OSes.

Bottom line
#

Recommended for engineers who run many CLI agents and want the broadest, most open, most cross-platform ADE, including phone supervision and remote execution. Not for teams that need a closed, vendor-supported enterprise product today, or for anyone who wants the orchestrator to own model execution and billing.

Changes
#

2026-09-27 - Created.

References
#

https://github.com/stablyai/orca - repository, feature set, 27-agent list, MIT license, stars and release data
https://www.onorca.dev/ - product positioning, supported agents, pricing “free and open source”
https://www.onorca.dev/docs - worktrees, terminals, Design Mode, SSH, CLI, mobile, and the “not a model” scope statement
https://www.onorca.dev/changelog - release cadence and daily shipping through September 2026
https://www.onorca.dev/enterprise - Enterprise rollout, compliance readiness, and self-hosting claims
https://www.ycombinator.com/companies/stably-ai-orca - founders, batch, and the “10 to 100 agents” framing
https://andrew.ooo/posts/orca-stablyai-parallel-coding-agents-ide-review/ - independent review of the ADE positioning and adoption

Sandcastle

tom@tomrochette.com (Tom Rochette) — Sun, 27 Sep 2026 00:00:00 +0000

Sandcastle is an MIT-licensed TypeScript library and CLI that orchestrates coding agents in isolated sandboxes, running them in a worktree, collecting the commits, and merging the branches back.

Sandcastle’s bet is that the orchestrator should be an npm package, not an app: one sandcastle.run() call gives you sandboxing, branch strategy, session capture, and merge-back, so teams compose their own pipelines instead of adopting a board.

What it is
#

A library from Matt Pocock (Total TypeScript, ex-Vercel and Stately) published as @ai-hero/sandcastle, with a CLI that scaffolds a .sandcastle/ config directory and a default Dockerfile. You call run() with an agent provider and a sandbox provider: built-in agents are Claude Code, Codex, Pi, Cursor, OpenCode, and Copilot, and built-in sandboxes are Docker and Podman (bind-mount) and Vercel Firecracker microVMs (isolated), plus noSandbox() and custom providers built on createBindMountSandboxProvider or createIsolatedSandboxProvider. Sandcastle creates a host worktree under a configurable branch strategy, runs the agent inside the sandbox, and merges the resulting commits back. It captures each agent’s native session transcript to the host and can resume or fork a prior Claude Code, Codex, or Pi conversation inside a new sandbox, with --resume rewrites so the provider’s own resume command works. Hooks are declared per location (host and sandbox, for example onWorktreeReady and onSandboxReady), and templates plus GitHub-issues, beads, or custom issue trackers are scaffolded by sandcastle init.

Status
#

Small but well-known: about 8,162 stars and 878 forks as of 2026-09-27, created 2026-03-17, and 1,193 commits. The warning sign is activity: the last commit and the latest release (v0.12.0) both landed on 2026-06-29, so the project has been quiet for roughly three months as of 2026-09-27, even as stars kept accruing. The npm package reached 0.12.0 across 44 versions. A popular library that stops shipping while its category moves daily is a bet on stability over feature parity, and an open issue about broken global npm install for the Pi and Codex Dockerfiles (#223) has sat unresolved since April 2026.

Strengths
#

Sandboxing is first-class, not bolted on: three providers plus a documented custom-provider contract, and noSandbox() when you want the agent on the host.
Session capture, resume, and fork let an agent continue its own conversation across sandboxes, which most GUI tools do not expose.
Provider-agnostic and issue-tracker-agnostic, so it fits an existing CI or pipeline rather than dictating one.
A real CLI (init, templates, flags, non-interactive fail-fast) and typed JS API for programmatic orchestration.
MIT, by a maintainer with a large TypeScript following, so the docs and examples are unusually good.

Cautions
#

No activity since 2026-06-29; treat it as a maintenance risk and pin a version.
It is a library, not a product: no board, no diff review UI, no PR flow, no notifications.
You must provide and pay for your own sandbox runtime; Vercel sandboxes carry their own usage bill.
The default Dockerfile installs Claude Code as a specific non-root agent user, and the documented Pi and Codex installs are reported broken (#223).
Session capture failure fails the run by default, so a provider upgrade can break a pipeline until you retune.

Pricing
#

Free and open source under MIT. No hosted tier; you pay only for the sandbox runtime you choose (local Docker or Podman, or Vercel usage). Agent access runs on your own subscriptions or keys.

Compared to
#

Crewplane: a Python workflow runner with on-disk run records; choose Sandcastle when you want an in-process TypeScript API instead of a Markdown workflow engine.
The Perfect Orchestrator: a tmux harness for visible Claude Code workers; choose Sandcastle when you want containers and merge-back rather than interactive panes.
Plain Docker plus a shell script: the zero-dependency option; Sandcastle earns its keep once you need branch strategy, session resume, and hooks.

Bottom line
#

Recommended for teams that want to script sandboxed coding agents from TypeScript and own the pipeline, not adopt a GUI. Not for anyone who wants a board, diff review, or a maintained app, given the quiet repository.

Changes
#

2026-09-27 - Created.

References
#

https://github.com/mattpocock/sandcastle - repository, API, sandbox and agent providers, license, stars, last-commit date
https://raw.githubusercontent.com/mattpocock/sandcastle/HEAD/README.md - run(), branch strategy, hooks, session capture, resume and fork
https://registry.npmjs.org/@ai-hero%2Fsandcastle - package metadata, 0.12.0 latest, 44 versions, version dates and license
https://www.aihero.dev/open-source - Matt Pocock’s framing of Sandcastle among his tools
https://github.com/mattpocock/sandcastle/issues/223 - unresolved broken global install for Pi and Codex agents

SettleBridge

tom@tomrochette.com (Tom Rochette) — Sun, 27 Sep 2026 00:00:00 +0000

SettleBridge (a2a-settlement/settlebridge-ai) is a trust and policy gateway that sits between an agent and the A2A Settlement Exchange, enforcing reputation thresholds, spending caps, and provenance requirements before any agent-to-agent settlement proceeds.

Its thesis is that an agent economy needs a settlement layer above payments and authorization, so SettleBridge gates whether an economic obligation may be committed and records a Merkle-linked audit trail of the decision.

What it is
#

The gateway is a Python and FastAPI service with a React dashboard, a hot-reloading policy engine, a Redis-backed reputation cache, health monitoring of the upstream exchange and mediator, threshold-based alert rules, and a structured audit log. It deploys via Docker Compose, a Helm chart, or an AWS CloudFormation script, and the product page advertises 16 management API endpoints. An optional bounty marketplace (MARKETPLACE_ENABLED=true) adds escrow-backed contracts, a claim and submission flow, and an AI-assisted bounty drafting assistant. It is built on the open A2A-SE (A2A Settlement Extension) standard, which the same organization publishes under MIT, and the gateway sits on top of the upstream exchange, mediator, and auth projects rather than replacing them. The vendor is Truthsetter LLC.

Status
#

Early and low-traffic but actively maintained. The gateway repository was created 2026-03-08 and sits at 1 star, 0 forks, and 1 open issue as of 2026-09-27, with 76 commits and a last push on 2026-09-25; the A2A-SE standard repository has 2 stars. The website, pricing page, marketplace, and documentation are live and detailed, so this is a product with a real surface rather than an abandoned experiment. The community footprint is effectively absent: a Hacker News search for SettleBridge returns nothing, and the whole organization is in the low single digits of stars. One comparison worth naming: this is a young, standards-first effort where the software is secondary to the spec, so its survival depends more on A2A-SE adoption than on the gateway’s own traction.

Strengths
#

The only tool I found in this category whose subject is settlement (escrow, release, refund, dispute, finality) rather than tool-call authorization, which is a genuinely distinct and underserved layer.
Cryptographic audit design: Merkle tree integrity, append-only entries, and CSV or JSON export aimed at SEC 17a-4, SOX, and NIST examination.
Open-core with three real deployment paths and a published benchmark of time-to-first-interaction, so the quickstart is credible.
Standards-anchored: the A2A-SE specification is archived on Zenodo and positions itself against AP2 and x402 explicitly.

Cautions
#

License metadata is inconsistent and I could not resolve it: the website and pricing page call Community Apache-2.0, the GitHub README badge says MIT, the GitHub API reports no detected license, and the LICENSE path on main returns 404. Confirm the actual terms before shipping.
The public repositories are essentially unadopted (1 star), so no independent security review or third-party usage evidence exists yet.
The exchange charges a 0.25% treasury fee per settled transaction on top of any enterprise gateway cost, which is a real cost-of-goods line item for high volume.
The claimed compliance mappings (SEC 17a-4, SOX) are vendor assertions, not audited certifications.

Pricing
#

Community is free forever with the full gateway, policy engine, audit logging, and rate-limited exchange access. Enterprise is $2,500 per month per gateway with 24/7 support, SLAs, security patches within 24 hours, and custom policies. The Exchange charges 0.25% of each settled transaction as an ATE treasury fee.

Price history
#

Date	Plan	Change	Source
2026-09-27	Community	Introduced at $0, full gateway, rate-limited exchange access	https://settlebridge.ai/pricing
2026-09-27	Enterprise	Introduced at $2,500/month per gateway	https://settlebridge.ai/pricing
2026-09-27	Exchange	Introduced at 0.25% ATE treasury fee per settled transaction	https://settlebridge.ai/pricing

Compared to
#

Veto: pre-execution authorization for a single agent’s tool call; choose Veto to stop a refund or export, and SettleBridge when two independent agents must commit and settle value.
Microsoft Agent Governance Toolkit: in-process policy, identity, and audit across frameworks; choose AGT for governance of your own agents, and SettleBridge for trust across organizational boundaries.
SIDJUA: a self-hosted company of governed agents with budgets; choose SIDJUA for internal agent operations, and SettleBridge for commerce between agents you do not control.

Bottom line
#

Recommended for teams building agent-to-agent commerce that need escrow, reputation, and a cryptographic audit trail above the A2A protocol. Not for single-agent work or internal tool governance, and not until the license terms are confirmed from the repository itself.

Changes
#

2026-09-27 - Created.

References
#

https://settlebridge.ai/ - product framing, gateway components, open-core claim
https://settlebridge.ai/pricing - Community, Enterprise, and Exchange pricing with dollar and percentage amounts
https://github.com/a2a-settlement/settlebridge-ai - README: architecture, configuration, bounty marketplace, license statement
https://api.github.com/repos/a2a-settlement/settlebridge-ai - stars, forks, issues, push dates, and the null license field as of 2026-09-27
https://docs.a2a-settlement.org/docs/agent-settlement/ - A2A-SE: settlement lifecycle, three-layer model, interoperability
https://api.github.com/repos/a2a-settlement/a2a-settlement - the MIT-licensed standard repository behind the gateway
https://raw.githubusercontent.com/Agent-Analytics/awesome-multi-agent-orchestrators/main/README.md - the curated directory that flags the license metadata as inconsistent

SIDJUA

tom@tomrochette.com (Tom Rochette) — Sun, 27 Sep 2026 00:00:00 +0000

SIDJUA (GoetzKohlberg/sidjua) is an AGPL-3.0 governance-first orchestration platform that runs a five-stage pre-action pipeline (forbidden, approval, budget, classification, policy) outside the agent before any action executes.

Its thesis is that governance enforced by architecture beats governance enforced by prompting, and the pipeline order is the whole argument: if an action is forbidden it never reaches the model, and if it exceeds budget the task is cancelled rather than flagged.

What it is
#

Every action passes Forbidden, Approval, Budget, Classification, and Policy checks before the agent’s LLM call happens, and the README states that governance-critical operations have no log-and-review-later mode. The organization is defined in one divisions.yaml: agents live in divisions and tiers (tier 1 full autonomy, tier 2 approval for sensitive operations, tier 3 fully supervised), each with per-task and per-month budgets, and sidjua apply provisions agents, RBAC, routing, audit tables, and rules in ten steps. The runtime is a Node.js and SQLite service with a web management console on port 47821, always-on daemons with a four-eyes mutual watchdog, governed cron schedules, an append-only audit trail with SHA-256 integrity checks, bubblewrap sandboxing on Linux, and eight messaging channels. Providers include Anthropic, OpenAI, Google, Groq, Cloudflare Workers AI, Ollama, and any OpenAI-compatible endpoint, and it can import OpenClaw configuration. It is dual-licensed AGPL-3.0 plus a commercial license, with an enterprise tier for organizations running 100 or more agents.

Status
#

Dormant, with the stated restart date missed. The repository was created 2026-03-02 and sits at 26 stars, 2 forks, and 4 open issues as of 2026-09-27, with the last push on 2026-04-21 and the last release v1.1.1 on 2026-04-17. The website announces a development freeze and says public downloads are “scheduled to reopen in July 2026”, but it is now late September 2026 with no source activity for five months and the freeze notice still showing the same date. This is the category’s second stall record after TinyAGI, and the pattern is the same: a compelling governance pitch and a young codebase that ran out of maintainer momentum. The owner is a single GitHub user account, not an organization, and the site’s “we move fast” framing sits awkwardly next to five months of silence.

Strengths
#

The five-stage pre-action pipeline is a clean, explicit model of where each control belongs, and it is the clearest articulation of pre-action enforcement in this category.
Structural enforcement that the agent cannot detect or disable is the correct answer to prompt-based governance, and the architecture explains it well.
Self-hosted, air-gap capable, model-agnostic, and light enough to run on a Raspberry Pi with local models.
The audit trail uses an integrity-verified write-ahead log and a governed scheduler with fail-closed cost caps, which is more than most young tools attempt.

Cautions
#

Downloads are frozen, the reopen date has passed, and the source has been quiet since April 2026; adopt as a fork-first decision or a case study, not as a supported dependency.
Single maintainer, no organization, and no successor or handoff announced.
The most striking claims are self-reported: three AI auditor systems, fifteen audits, “most secure Node.js app I’ve audited in years”, and two filed patents. None of this is independently verifiable from the sources I found.
The site compares itself favorably to Paperclip and OpenClaw in marketing language, so read the comparison table as positioning rather than measurement.

Pricing
#

SIDJUA Free is AGPL-3.0 for self-hosting and personal use. A commercial license is required for hosting providers and SaaS operators, and an enterprise license covers 100 or more agents with SLA and compliance support. No dollar prices are published, so there is nothing to track yet.

Compared to
#

Paperclip: the living control plane with budgets, org charts, and a cloud path; choose Paperclip today, and read SIDJUA for the pre-action enforcement model.
Microsoft Agent Governance Toolkit: governance wired into existing frameworks in five languages; choose AGT when you already have agents, and SIDJUA when you want the orchestrator and the governance in one self-hosted platform.
Veto: a single authorization gate rather than a platform; choose Veto for a narrow, live tool-call control and SIDJUA as a case study of the broader pipeline.

Bottom line
#

Recommended as a case study of pre-action enforcement architecture, and as a fork candidate for a self-hosted governed agent company. Not for production adoption while downloads are frozen, the announced reopen date has passed, and there is no maintainer activity to depend on.

Changes
#

2026-09-27 - Created.

References
#

https://github.com/GoetzKohlberg/sidjua - README: five-stage pipeline, divisions and tiers, audit WAL, licensing, roadmap
https://api.github.com/repos/GoetzKohlberg/sidjua - stars, forks, issues, last push 2026-04-21 as of 2026-09-27
https://www.sidjua.com/ - homepage: development freeze notice, reopen-in-July claim, self-reported audits
https://sidjua.com/docs - the same freeze and release-status surface
https://api.github.com/repos/GoetzKohlberg/sidjua/releases - v1.1.1, 2026-04-17, the final release
https://api.github.com/users/GoetzKohlberg/repos - the maintainer’s single public repository

The Perfect Orchestrator

tom@tomrochette.com (Tom Rochette) — Sun, 27 Sep 2026 00:00:00 +0000

The Perfect Orchestrator is an MIT-licensed bash and tmux harness in which one lead Claude Code session spawns, briefs, monitors, and adversarially verifies multiple autonomous Claude Code worker sessions through plain files, with no daemons or servers.

Its thesis is that workers lie, so findings do not count until a different worker has tried to tear them apart, and the whole coordination layer is deliberately plain files rather than a broker.

What it is
#

A Claude Code plugin (installed with claude plugin marketplace add daman8271/the-perfect-orchestrator) from a solo developer, danny (daman8271). You talk to one lead session; it spawns N fully interactive Claude Code workers in tmux panes, writes each a task brief, watches their screens, nudges the ones that drift, and lets them coordinate through a shared bus.md message bus. Each worker appends lines prefixed with its ID, reads peers’ findings, writes agent-n.result.md, and touches a done flag; the lead reads results and cross-checks each finding with a different worker before reporting anything. Coordination is plain files (briefs, bus, results, done flags), so there are no servers, daemons, or message brokers, and the lead stays live to monitor, correct, and re-plan mid-flight. The README includes a comparison table against SDK and headless approaches, a security model, and a roadmap.

Status
#

Quiet and tiny: about 1 star and 1 fork as of 2026-09-27, created 2026-06-05, with the last commit on 2026-06-30 and a latest release of v0.2.0 (2026-06-06). It is a single-author project with no community footprint on Hacker News or Reddit during this run; the README notes the recorded fleet run and a website that it says were themselves built and QA’d by the tool’s own fleet. A one-star repository with a three-month-old last commit is best read as a well-documented pattern to copy, not a dependency to adopt.

Strengths
#

Adversarial verification is a first-class design, not an afterthought: a finding needs a different worker’s failed attempt to refute it.
No infrastructure: plain files mean nothing to deploy, and a human can read the entire coordination state.
Workers are full interactive sessions, so the lead and the human can watch a worker go down a rabbit hole and yank it back.
A thoughtful security model with a documented allowlist, an isolated config dir, and explicit advice to run fleets on a VPS or in a container.
It cost nothing to try: a plugin install and a tmux requirement.

Cautions
#

Effectively a single-author, single-star project; no maintainer community and no activity since 2026-06-30.
Requires Linux or macOS, tmux 3.0+, and a Claude Code login, and it runs only Claude Code.
Workers consume real Claude plan usage in parallel; the FAQ is explicit that fleets trade tokens for wall-clock time.
Workers run with a generous permission allowlist (though rm is not allowlisted), so it is unsafe to point at the only copy of anything.
The roadmap’s most useful pieces (orch verify, orch demo, orch watch) are unshipped.

Pricing
#

Free and open source under MIT. No hosted tier; cost is your existing Claude subscription or API plan, multiplied by the number of parallel sessions you run.

Compared to
#

Claude Squad: a free terminal TUI managing several agents in worktrees; choose The Perfect Orchestrator when you want one lead to brief and adversarially verify workers rather than supervise panes yourself.
dmux: a tmux TUI giving each task its own worktree and branch; choose The Perfect Orchestrator for the verification protocol and the lead-driven briefs.
GraphCode: a native macOS graph of live loops; choose The Perfect Orchestrator for a zero-dependency tmux harness you can read end to end.

Bottom line
#

Recommended for tinkerers who run Claude Code over tmux and want a minimal, readable template for lead-and-worker orchestration with adversarial verification. Not for anyone who needs a maintained tool, multiple harnesses, worktree isolation, or a community to ask.

Changes
#

2026-09-27 - Created.

References
#

https://github.com/daman8271/the-perfect-orchestrator - repository, protocol, security model, roadmap, license, and stars
https://raw.githubusercontent.com/daman8271/the-perfect-orchestrator/HEAD/README.md - the lead-and-worker design, the adversarial verification rule, and the FAQ
https://the-perfect-orchestrator.vercel.app - the site the README says its own fleet built and QA’d
https://github.com/daman8271/the-perfect-orchestrator/tree/main/docs/realrun-2026-06-06 - the recorded fleet run referenced as evidence
https://openorchestrators.org/ - the curated directory’s the-perfect-orchestrator entry

Veto

tom@tomrochette.com (Tom Rochette) — Sun, 27 Sep 2026 00:00:00 +0000

Veto (PlawIO/veto) is an Apache-2.0 authorization layer that wraps an agent’s tools and returns allow, deny, warn, or require-approval verdicts from deterministic YAML rules before the tool handler runs, with a commercial Veto Cloud for shared approvals and records.

Its thesis is that authentication says who the agent is and sandboxing says where it runs, but neither answers whether this specific action should execute, so Veto inserts the missing authorization gate between intent and side effect and records a tamper-evident receipt for each decision.

What it is
#

protect(tools) in TypeScript or pip install veto in Python wraps a tool set; Veto loads ./veto/veto.config.yaml and ./veto/rules/*.yaml if present and otherwise applies observe-mode safe defaults so suspicious shell, file, database, and money patterns are logged rather than silently blocked. Rules support actions block, allow, warn, log, and require_approval, and the README publishes a runtime adapter matrix covering the Vercel AI SDK, OpenAI Agents, LangChain and LangGraph, MCP, Browser Use, OpenClaw, Claude SDK, Google ADK, Mastra, AutoGen, and CrewAI. Policy can be authored in plain English and compiled to reviewed YAML, but the LLM drafting step is explicitly outside the authority path; decisions are deterministic. Everything runs local-first, including a self-hostable evaluation server and an offline-verifiable veto.receipt/1 chain, and BYOC deployments keep policy and decision rows in the customer plane. It is made by Plaw, Inc. (US), which lists Veto as an EU AI Pact signatory.

Status
#

Active product, thin open-source community. The repository was created 2026-01-02 and sits at 14 stars, 2 forks, and 1 open issue as of 2026-09-27, last pushed 2026-06-18, with the latest published SDK release veto-sdk@2.9.3 on 2026-05-07. The website, docs, and pricing pages are current and extensive, and the company markets to agent vendors and regulated buyers, so the commercial product is clearly live. The public footprint is small: a Hacker News search for Veto returns nothing relevant, and the starred count is in the low tens, so adoption evidence comes from the product surfaces rather than the community. One operational wrinkle the README states plainly: Plaw does not yet control the unscoped veto npm name, so installs use the veto-cli package form until the transfer completes.

Strengths
#

Deterministic local evaluation by default, with no account, API key, or network needed for the core decision.
Approval is bound to the exact action hash and policy hash, so a mismatched approval fails closed rather than rubber-stamping a different call.
Offline-verifiable decision receipts and a published benchmark (p99 in microseconds for local single-rule and merged-pack evaluation) make the audit story concrete.
Broad framework coverage and two SDKs mean the gate is one wrapper call, not a rewrite.

Cautions
#

The open-source project is small (14 stars) and the last source push predates the latest docs, so treat the community as nascent and the company as the real support channel.
The free tier caps at 5,000 checks per month with a hard stop, and hosted pricing scales by checks, so a high-volume internal agent can move from free to several hundred dollars quickly.
The README notes the unscoped veto npm name is not yet controlled by Plaw, which is a supply-chain detail to watch.
Benchmarks are self-published and the comparison against another toolkit uses that toolkit’s own published numbers, not a reproduced head-to-head.

Pricing
#

Developer is $0 per month with 5,000 action checks, 7 days of decision records, and no credit card; the Apache-2.0 local engine is included. Hosted is $299 per month for 100,000 checks, $0.75 per 1,000 checks above plan, 90 days of records, and unlimited seats and reviewers. Enterprise is custom, covering cloud, BYOC, on-prem, or isolated networks with HIPAA BAA, SSO, SCIM, and SLAs.

Price history
#

Date	Plan	Change	Source
2026-09-27	Developer	Introduced at $0/month, 5,000 checks, hard cap	https://veto.so/pricing
2026-09-27	Hosted	Introduced at $299/month, 100K checks, $0.75 per 1K overage	https://veto.so/pricing

Compared to
#

Microsoft Agent Governance Toolkit: a broad multi-language governance program; choose AGT for identity, sandboxing, and compliance across stacks, and Veto for a single deterministic gate with portable receipts.
Code Atelier Governance SDK: a Python and Postgres SDK with HITL gates and an HMAC audit chain; choose it when your stack is Python and Postgres, and Veto when you want framework-agnostic wrapping and a hosted approval inbox.
SettleBridge: trust and settlement for agent-to-agent commerce; a different layer, since Veto authorizes a tool call while SettleBridge settles an economic obligation.

Bottom line
#

Recommended for teams that put money, data, or customer-facing actions behind a deterministic pre-execution gate with approval routing and verifiable receipts. Not for teams that need a full org control plane with budgets and chain of command, or that require a large open-source community before adopting.

Changes
#

2026-09-27 - Created.

References
#

https://veto.so/ - product framing, supported frameworks, EU AI Pact claim
https://veto.so/pricing - Developer, Hosted, and Enterprise plans with dollar amounts
https://github.com/PlawIO/veto - README: protect(), rules, adapter matrix, benchmarks, BYOC boundary
https://api.github.com/repos/PlawIO/veto - stars, forks, issues, push dates as of 2026-09-27
https://docs.veto.so - documentation: MAP artifacts, local runtime, receipts, adapters
https://api.github.com/repos/PlawIO/veto/releases - veto-sdk@2.9.3, 2026-05-07

Automated Research Feature Matrix

tom@tomrochette.com (Tom Rochette) — Sun, 13 Sep 2026 00:00:00 +0000

Eight loops automate research today, and the row that separates them is not capability but judging: everything with a Lean kernel or an official grader behind it produces checkable artifacts, everything without one produces prose or artifacts an adversarial critic and a human must accept, and the newest columns split between a bank account and a producer-critic pair. Every cell traces to its member note and that note’s fetched references.

The matrix
#

Row	Agon	AlphaProof	Anthropic Claude mathematical research	Harmonic Aristotle	Math Inc. Gauss	OpenAI Deep Research	OpenAI for Science	Pion
Operator	AutoResearch-Factory (University of Maryland and collaborators)	Google DeepMind	Anthropic	Harmonic	Math Inc. (DARPA expMath-supported)	OpenAI (product)	OpenAI (lab program)	Andon Labs (YC-backed)
The loop produces	Reviewed ideas, proposals, experiment workspaces, and paper drafts from a one-line topic	Competition-grade proofs and verified reasoning training	New theorems and formalized proofs	Machine-checked proofs of stated problems	Lean formalizations at record scale	Cited web-research reports	Benchmark firsts and claimed solutions, published with Lean artifacts	Real revenue-and-loss data from agents running actual businesses continuously
Human input in the loop	Topic and standards; built to run unattended for hours	2024: manual Lean translation; 2025: none, end to end	One prompter, expert review after	A problem statement	Blueprints and scaffolding, review of key lemmas	A question	Case-study curation; disputed in the math claims	High-level direction only, through the Andonos managing agent
Who judges	Independent producer-critic agent loops on fresh contexts, plus the human for invisible failures	Lean kernel plus official IMO graders	Lean comparator plus named human experts	The Lean kernel	Lean comparator, specification-based	No machine judge; the human reads	Lean kernel on the published formalization; human acceptance and credit still in dispute	No machine judge; the bank account plus Andon’s own monitoring
Lean formal verification	No	2024 yes, 2025 natural language	Yes (zeta and FLT artifacts)	Yes	Yes	No	Yes since 2026-09-08 (Lean 4 artifacts published; the statement-to-Clay fit is still being audited)	No
Surface today	MIT Claude Code plugin run from a separate artifacts workspace	Research system; Deep Think rolling out to AI Ultra	Unreleased models; artifacts on GitHub	Free web agent with login	OpenGauss open source; Gauss in beta	ChatGPT plans	Subscriptions and academic credits	Proprietary research preview with waitlist, no repo
Pricing as of 2026-09-18	Free and MIT, no paid tier	Bundled in the Ultra subscription	Free artifacts, internal compute	Free; $1,000,000 grant program	OpenGauss free; about $25 per benchmark solve	Plan quotas; Pro at $200/month	Program-level; GPT-5 Pro at $200/month in case studies	? none published; seed tokens funded, planned revenue share
Millennium-problem engagement	None claimed; mathematics is one of several domains, not the focus	None claimed; IMO as the public proxy	Attempted the Riemann hypothesis, failed productively (41.6 to 67.2 percent zero bound)	None public	Strong PNT as the gateway toward the Riemann hypothesis	None	Navier-Stokes claimed with a Lean certificate, credit disputed, mathematical acceptance pending	None; the eval lineage is Vending-Bench, not mathematics

How to read it
#

The judging row is the deciding one, and it repeats a pattern this section tracks in software tooling: outputs are exactly as trustworthy as the verifier behind them. AlphaProof’s 2024 result and Math Inc.’s formalizations carry kernel-level guarantees; the Anthropic results add named human reviewers on top of the kernel. Aristotle’s headline claims are real where Lean checked them and contested where only the vendor graded them. OpenAI’s two entries are prose-only loops: Deep Research cites, the science program claims, and neither has a machine judge. Pion is the first proprietary column and the only one whose output is neither artifact nor prose but money: its agents run real businesses, its judge is a bank account plus the operator’s own monitoring, and its launch thread’s contradiction (the operator calling autonomous resource acquisition the most troubling capability while releasing exactly that) is recorded in its note. Agon is the first column whose judge is a critic agent on a fresh context rather than a kernel, a grader, or a full-time operator, and its paper’s own taxonomy names the failure classes that oracle cannot see, which makes it the cheapest loop to run and the least verified. The Millennium column is uniformly no: nothing here has solved one, the closest engagement is a failed-but-productive Riemann attempt and a disputed Navier-Stokes claim, and FrontierMath’s problems are explicitly built below Millennium scale.

Changes
#

2026-09-13 - Created in the same run the Automated research category was seeded, with six columns.
2026-09-16 - Extended from six to seven columns with Pion (Andon Labs), appended alphabetically after OpenAI for Science, with proprietary and no-repo cells marked as such and pricing marked unverified pending the revenue-share model.
2026-09-25 - Updated the OpenAI for Science column for the published Lean certificates (Navier-Stokes claim now machine-checkable, acceptance and credit still pending), removed the verification preamble, linked the header row, and normalized the separator row.
2026-09-27 - Extended from seven to eight columns with Agon, inserted first alphabetically, with the judging prose and the failure-taxonomy boundary updated.

References
#

https://deepmind.google/blog/advanced-version-of-gemini-with-deep-think-officially-achieves-gold-medal-standard-at-the-international-mathematical-olympiad/ - the AlphaProof column’s 2025 facts and the IMO grading caveat
https://www.anthropic.com/research/riemann-zeta - the Anthropic column’s zeta bound, subagent loop, and validation chain
https://aristotle.harmonic.fun/ - the Aristotle column’s surfaces, positioning, and grant program
https://math.inc/formalqualbench - the Gauss column’s audited benchmark numbers and comparator methodology
https://thenextweb.com/news/bubeck-navier-stokes-account-apology-altman - the OpenAI for Science column’s dispute facts
https://en.wikipedia.org/wiki/FrontierMath - the below-Millennium scope of the benchmark framing
https://andonlabs.com/blog/why-we-built-pion - the Pion column’s launch facts, deployment record, and the most-troubling admission

Session Analytics Feature Matrix

tom@tomrochette.com (Tom Rochette) — Sun, 30 Aug 2026 00:00:00 +0000

This matrix compares the seven members of the Session analytics category: tools that turn what your coding agents record (or are recording right now) into live views, searchable history, cost reports, and audits, plus one that borrows the same agent-readable posture for product analytics. The category now spans three postures: the local retrospective archive (agentsview, ctx, Memex, AgentTrace), the live view (agents-observe, ClawTrace, and the real-time half of Agent Analytics), and the edge case, Agent Analytics, which measures your product’s users rather than your agents.

The category’s founding question, retrospective archive versus live observation, now has both answers several times over: agentsview indexes what every agent already did and cost across 60-plus formats, ctx answers where did this line of code come from, AgentTrace answers what did this run cost and why was it slow, agents-observe answers what is my agent doing right now (Claude Code and Codex only), ClawTrace answers the same question for OpenClaw by uploading the run, Memex answers where did I already do this and drops you back into the session, and Agent Analytics answers a different question entirely, how are my product’s users behaving, with the same agent-readable stance.

Legend: ✓ supported, ✗ not supported, ~ partial or conditional, ? not verified. Each column links to the full research note; every cell traces to a source cited there or in the references.

The matrix
#

Feature	Agent Analytics	agents-observe	agentsview	AgentTrace	ClawTrace	ctx	Memex
Kind	agent-readable web product analytics, tracker.js events served to agents through CLI, MCP, and API	real-time observability dashboard for live and replayed sessions	local session indexer, web UI + CLI + desktop	local-first TUI/CLI audit of coding-agent session history (cost, tokens, latency, failures, health)	hosted trace and cost-attribution platform for OpenClaw runs, with an AI analyst	local session search CLI with built-in blame attribution	local session search CLI and TUI with resume-in-place and an MCP server
Deployment	self-hosted OSS server (Cloudflare Workers + D1, Docker/Kubernetes + SQLite, plain Node) or hosted cloud at app.agentanalytics.sh	Claude Code plugin, hooks feeding a Dockerized local API server, dashboard on localhost:4981	local daemon, Docker, optional PostgreSQL push for teams	single Rust binary, TUI plus CLI reports, Homebrew/npm/winget/curl/cargo installs	OpenClaw plugin streaming to a hosted cloud pipeline (Azure Blob, Databricks, PuppyGraph, Vercel UI), no documented self-host path	single-binary CLI install, agent-callable skill	single-binary CLI install (brew, AUR, Nix, cargo-binstall), TUI, local web UI, native desktop apps, MCP server
Open source	~ README claims MIT, no LICENSE file on the default branch as of 2026-09-27, sibling repos are MIT	✓ MIT	✓ MIT	✓ MIT	~ Apache-2.0 repository, hosted cloud is the product and no self-host path is documented	✓ Apache-2.0, blame included since 2.0	✓ MIT
Agents covered	any agent that can run commands or call HTTP, with documented installs for Claude Code, Codex, Cursor, OpenClaw, Paperclip, Hermes, Instinct, and OpenWork	~ Claude Code and Codex, with the plugin install Claude Code-native	60+ formats auto-discovered (Claude Code, Codex, Gemini CLI, Copilot, Cursor, Zed, OpenCode, and more)	~ about 15 named formats plus generic JSON/JSONL (Claude Code, Codex, Gemini CLI, Qwen Code, OpenCode, OpenClaw, Cursor exports, and more)	~ OpenClaw only, through its eight-hook plugin	~ about 40 agent harnesses documented (Claude Code, Codex, Cursor, Pi, OpenCode, and more)	~ 15 engines graded per capability (Claude Code, Codex, Cursor, OpenCode, Pi, GitHub Copilot CLI, Grok, Antigravity, and more), support uneven
Token cost reporting	✗ product events, not agent token cost	✓ per-session token usage and cost breakdowns (since v0.9.7)	✓ per-model pricing catalog, seconds over months of sessions	✓ per-session tokens and estimated USD cost across sources, with pricing overrides and confidence levels	✓ per-step tokens and USD cost, 80+ models with cache-aware pricing	✗	~ per-engine token usage, off by default
Search	~ flexible analytics queries (metrics, group_by, filters), funnels, paths, retention, not transcript search	✓ filtering and search across live and stored events	✓ FTS5 full text, semantic search opt-in	✓ sort and filter sessions by cost, duration, health, failures, anomalies, model, source, or text	~ trace tree, call graph, timeline browse, and natural-language Ask Tracy queries over the trace graph, not transcript search	✓ cross-agent message and tool-call search, subagent and fork aware	✓ BM25 default, optional local embeddings for semantic and hybrid queries, saved memories searchable, SSH federation
Provenance	✗	✗	✗	~ heuristic Git delivery correlation only, no line-level attribution	✗	✓ blame maps a line, file, commit, or PR to the session that produced it	✗
Live observation	✓ real-time terminal dashboard across projects, plus opt-in web session replay	✓ hook events stream to the dashboard over websockets as agents run	✗ retrospective only, parses files already written	✗ retrospective only, reads logs already written	✓ runs stream to the hosted dashboard through the eight-hook plugin	✗ retrospective only	✗ retrospective only
Team features	~ multi-agent access and cross-project portfolios, no team roles or SSO documented	✗ single-user local setup	✓ PostgreSQL push, machine-labeled sync, S3 roots, versioned exports	~ CI reports and shared baseline artifacts, no hosted team sync	~ multi-tenant accounts (Tenant to Agent to Trace to Span) with referrals, no team roles documented	no team offering listed since the pro withdrawal	✗ single-user, SSH federation to your own machines, object-storage sync announced
Privacy posture	self-host keeps events in your D1 or SQLite, hosted cloud stores them in the vendor database, replay is opt-in and PII-masked	local-first, events stay in a local SQLite store behind a local Docker server	local-first, one anonymous ping by default, disableable	local-first, prompt and result bodies are not stored in tool steps, history of derived metrics is opt-in	hosted, trace payloads including LLM inputs and outputs are uploaded to the vendor’s data lake	local-first, attribution refuses data not on the machine	local-first, no cloud service in the default path, embeddings run locally
Pricing	free cloud tier (100k events/month, 2 projects), metered cloud at $1 per 10k events, self-host free	free, MIT, no paid tiers published	free, MIT, no accounts	free, MIT, no paid tiers published	consumption credits; 100 free, packages $10 to $400, storage 1.35 credits/MB/day	free, Apache-2.0, the former $20/month pro add-on withdrawn from the site	free, MIT, no paid tier published

Reading the matrix
#

The live-observation row is the row this matrix existed to name, and it now has two hosted and local answers: agents-observe streams hook events into its dashboard while the agents run, ClawTrace fills the same row for OpenClaw by uploading the run, and Agent Analytics offers a real-time terminal dashboard for its own product events, though the coding-agent cells still cover only Claude Code, Codex, and OpenClaw, so the remaining empty cells belong to the harnesses none of them hook. The second row worth reading is provenance: ctx’s blame attribution is the only cell in the category that answers “which session wrote this”, which agentsview deliberately leaves to cost and history questions.

Token cost reporting is the row that pays for the tool: harness-native cost views reset and see only their own sessions, while a pre-indexed store answers multi-tool, multi-month questions in seconds. An earlier version of the agentsview docs benchmarked its reports at 84 to 223 times faster than ad-hoc parsing (calling that an upper bound); the current docs have dropped that benchmark entirely, so the row should be read as “fast because pre-indexed”, with no vendor number left to lean on. The docs’ token-usage page is back to documenting schema version 5 as of 2026-09-27, with no version 6 mention left anywhere on the docs site, so scripts consuming those reports should expect churn either way. AgentTrace adds a cost cell the archive tools do not, with explicit estimate labeling and pricing overrides, while ClawTrace adds per-step cost inside a hosted trace, which is more granular than anything local but only for OpenClaw.

Memex adds the closing move the other archive tools lack: resume-in-place, where finding a session and re-entering it are one action in the TUI, plus the category’s only local semantic search (BM25 by default, optional local embeddings, so the headline requires opt-in setup). Its 15-engine support table is graded per capability and unevenly at that (some engines have no resume at all, token counting is missing for at least one), and its launch footprint is as thin as ctx’s was, so read the column as promising and unproven.

The three new columns split the category’s remaining questions: AgentTrace is the local cost, latency, and failure auditor that adds slow-run diagnosis the archive tools skip, ClawTrace is the hosted answer that trades privacy for full LLM payloads and an AI analyst, and Agent Analytics tests where the category’s boundary sits by serving product analytics to agents instead of session data.

Breadth of coverage is agentsview’s moat: roughly 60 supported sources against ctx’s 40, AgentTrace’s 15, Memex’s 15, and the two harnesses agents-observe covers or the one ClawTrace hooks, which matters because most practitioners now run two or three harnesses at once. Agent Analytics is agent-agnostic by design, since any agent that can call HTTP is a client. ctx’s moat is different: agent-facing retrieval, where the consumer of the search is your next session rather than you.

Choosing from the matrix
#

Running three or more different coding agents and wanting one private history and cost view: agentsview.
Wanting your agents to recall why code exists, from the session that wrote it: ctx, with its self-reported numbers accepted.
Living in the terminal and wanting semantic recall plus one action back into the session: Memex, accepting a few hundred stars and thin verification.
Auditing what a run cost and why it was slow, locally and with CI gates: AgentTrace.
Running OpenClaw and wanting full-payload traces plus an AI analyst, hosted: ClawTrace, accepting that the traces leave your machine.
Instrumenting a product your agents are building and reading its traffic through an agent: Agent Analytics.
Needing to see what an agent is doing right now: agents-observe for Claude Code or Codex, or ClawTrace if you run OpenClaw and can upload the run; otherwise a harness-native view is still the fallback.
Single-agent users: your harness’s built-in usage views are probably enough.

Changes
#

2026-08-30 - Created as the Session analytics category’s companion matrix, a single-column scaffold with the live-observation gap named in prose.
2026-09-05 - Extended from one to two columns with ctx.
2026-09-06 - Updated the ctx cell for its published pro pricing.
2026-09-08 - Dropped the agentsview benchmark claim from the prose after the tool’s docs removed it entirely.
2026-09-13 - Added the agentsview usage-output schema version 6 churn note to the reading prose.
2026-09-16 - Extended to three columns with agents-observe, filling the live-observation gap the prose used to name.
2026-09-18 - ctx agents-covered cell updated after the docs began listing about 40 supported agent harnesses.
2026-09-20 - Extended from three to four columns with Memex, inserted last alphabetically, every row gaining a cell traced to the new note, with the reading and choosing prose extended.
2026-09-20 - Corrected the schema caution in the reading prose: the docs’ usage JSON contract is at schema version 5, version 6 is the session-export schema.
2026-09-24 - Removed the verification preamble line on owner request.
2026-09-25 - Retired the ctx pro cells: the Kind, Open source, Team features, and Pricing cells now describe blame as built in, after v2.0.0 shipped it inside the single open-source executable and the site dropped every paid-tier listing.
2026-09-27 - Re-verified all four columns: repository counts refreshed (agents-observe 684, agentsview 6,001, ctx 1,135, Memex 231 stars), the reading prose’s schema line revised after the agentsview docs returned to version 5, and the Memex star count in the choosing prose generalized; no table cells moved.
2026-09-27 - Extended from four to seven columns with Agent Analytics, AgentTrace, and ClawTrace, re-sorted all columns alphabetically, updated the intro member count and framing, and extended the reading and choosing prose.

References
#

https://github.com/kenn-io/agentsview - the repository, supported agents, architecture, and license for the agentsview column
https://www.agentsview.io/docs/token-usage/ - the cost computation, benchmark caveats, and undercount disclosures
https://www.agentsview.io - the deployment surfaces and team features
https://github.com/ctxrs/ctx - the ctx column: repository, license, and no-compaction positioning
https://ctx.rs/pro - the ctx column: blame attribution and its citation model
https://code.claude.com/docs/en/costs - the harness-native cost views that define the category’s baseline
https://github.com/simple10/agents-observe - the agents-observe column: repository, license, and adoption numbers
https://raw.githubusercontent.com/simple10/agents-observe/main/README.md - the agents-observe column: plugin install, Docker server, websockets dashboard, and token and cost breakdowns
https://news.ycombinator.com/item?id=47602986 - the agents-observe launch thread behind the live-observation claim’s community context
https://github.com/nicosuave/memex - the Memex column: repository, surfaces, engine support table, and license
https://raw.githubusercontent.com/nicosuave/memex/main/README.md - the Memex column: BM25 and local-embedding search, resume-in-place, MCP server, and install paths
https://github.com/luoyuctl/agenttrace - the agenttrace column: repository, MIT license, and coverage
https://raw.githubusercontent.com/luoyuctl/agenttrace/master/README.md - the agenttrace column: source formats, governance reports, CI gates, and privacy posture
https://github.com/epsilla-cloud/clawtrace - the ClawTrace column: repository, Apache-2.0 license, and adoption numbers
https://raw.githubusercontent.com/epsilla-cloud/clawtrace/main/README.md - the ClawTrace column: eight hooks, cloud pipeline, per-step cost, and self-evolve skill
https://www.clawtrace.ai/docs/billing/credits - the ClawTrace column: credit packages and consumption rates
https://github.com/Agent-Analytics/agent-analytics - the Agent Analytics column: repository, self-host routes, and license status
https://agentanalytics.sh/ - the Agent Analytics column: tracker, access surfaces, and cloud pricing tiers

Control Planes Feature Matrix

tom@tomrochette.com (Tom Rochette) — Thu, 27 Aug 2026 00:00:00 +0000

This matrix compares the eight governance tools profiled in this section, from self-hosted agent companies to in-process enforcement gates, so the category’s full range and its consolidation story sit in one table.

A control plane is not a dashboard with more panels, it is governance (policy, budgets, approvals, audit) wrapped around an execution model, and the two stalled columns below (SIDJUA and TinyAGI) show that the open-source agent-company flagships struggle while the narrower enforcement gates keep shipping.

Legend: ✓ supported, ✗ not supported, ~ partial or conditional, ? not verified.

The matrix
#

Feature	Code Atelier Governance SDK	Microsoft Agent Governance Toolkit	Okto Pulse	Paperclip	SettleBridge	SIDJUA	TinyAGI	Veto
Kind	Python SDK with in-process gates	multi-language toolkit (Python, TypeScript, .NET, Rust, Go)	local-first SDLC workbench, web UI plus MCP server	self-hosted Node.js server and React UI, embedded Postgres	gateway service (FastAPI plus React dashboard) over Postgres and Redis	self-hosted Node.js platform, web console and SQLite	self-hosted orchestrator, TinyOffice web portal and TUI	framework-agnostic authorization kernel, TypeScript and Python SDKs
License	✓ MIT	✓ MIT	~ Elastic-2.0, source-available	✓ MIT	? metadata inconsistent: site says Apache-2.0 or MIT, GitHub API reports none	~ AGPL-3.0 plus commercial	✓ MIT	✓ Apache-2.0
Runtime model	in-process gates around wrapped LLM clients, Postgres as the only dependency	interception middleware in app code, fail-closed Rust policy runtime	local FastAPI process, SQLite plus embedded graph, agents over MCP	heartbeat wakes on schedules and events, ticket checkout with 409 conflicts	always-on gateway with hot-reloading policy engine and Redis reputation cache	always-on daemons, governed cron, five-stage pre-action pipeline	SQLite queue with atomic transactions, retries, dead-letter	local deterministic evaluation wrapping tool calls, optional self-hosted or cloud policy server
Enforcement point	before the LLM call, in-process; tool calls inside a response are not inspected	before the action reaches the wire, in application middleware	at status transitions on the SDLC board (spec, task, test, done)	approvals and budgets gate agent actions in the company runtime	before a settlement proceeds, at the boundary gateway	before any action executes, outside the agent	✗ none recorded beyond queue dispatch	before the tool handler runs, outside the model
Agent contract	Python code routed through wrap_openai, wrap_anthropic, or the LangChain handler	SDK or framework adapter, with plugins for Claude Code, Copilot CLI, Codex CLI, OpenCode	any MCP-capable coding agent (Claude Code, Codex, Cursor, Windsurf, Cline)	anything that can receive a heartbeat (OpenClaw, Claude Code, Codex, Cursor, HTTP)	agents on LangGraph, CrewAI, or ADK that settle over A2A-SE	any LLM provider (Anthropic, OpenAI, Google, Groq, Ollama, OpenAI-compatible)	Claude, Codex, and OpenAI or Anthropic-compatible endpoints	provider-agnostic tools plus LangChain, LangGraph, Vercel AI SDK, OpenAI Agents, MCP
Team structure	✗ per-agent scopes, no org model	~ trust tiers and delegation, no org chart	✗ workflow roles, no org chart	✓ org chart, mixed human and agent roles	✗	✓ divisions and three trust tiers	✓ multi-team, chain execution and fan-out	✗
Governance	✓ scope, budget, HITL, loop, and presence gates, fail-closed	✓ YAML, OPA Rego, or Cedar policy engine plus identity and compliance	✓ 17 named gates on coverage, validation, and evidence	✓ org chart, approvals, chain of command, immutable audit log	✓ reputation floor, spend caps, and provenance requirements	✓ five-stage pipeline plus ten non-removable baseline rules	✗ none recorded	✓ YAML rules with allow, block, warn, log, require_approval
Budgets	✓ token and USD caps per session and per agent-day, fail-closed	~ SLO error budgets, not spend caps	✗	✓ per-agent monthly budgets with auto-pause	✓ daily spend caps in policy	✓ per-task and per-agent budgets, fail-closed cancellation	✗	~ budget and cost constraints in policy
Sandboxed execution	✗ in-process only	✓ execution rings and four privilege levels	✗	✓ e2b, Cloudflare, Daytona, Modal, Novita, self-hosted Kubernetes	✗	~ bubblewrap on Linux, none on macOS and native Windows	~ isolated agent workspaces	✗ authorization only
Multi-company	✗	~ multi-agent fleet, not multi-company	✗ boards per install, with authorized global discovery	✓ unlimited per deployment, data isolation	✓ cross-organization trust through gateways and the exchange	✗ one company per install	✗ one company per install	✗
Channels	✗ API and CLI only	✗ framework adapters, not messaging	✗ web UI and MCP	any heartbeat-capable agent surface	✗	Discord, Email, Telegram, CLI, REST, WebSocket, Slack and WhatsApp in beta	Discord, WhatsApp, Telegram	✗
Audit and evidence	✓ HMAC-chained append-only Postgres, Ed25519 signatures, Article 12 report	✓ tamper-evident Merkle audit and decision records	✓ evidence gates and knowledge graph provenance	✓ immutable activity log, run ids, artifacts on issues	✓ Merkle-linked append-only audit, CSV and JSON export	✓ integrity-verified write-ahead log with SHA-256 checks	✗ none recorded	✓ offline-verifiable decision receipts
Pricing	free MIT, hosted bridge unpriced	free MIT	free local, SaaS planned and unpriced	free self-hosted, cloud in waitlist, unpublished	Community free, Enterprise $2,500/month per gateway, Exchange 0.25% per settlement	free AGPL-3.0, commercial and enterprise by contact, unpriced	free	Developer $0, Hosted $299/month for 100K checks, Enterprise custom
Current status	active, 0 stars, v0.7.3, last push 2026-07-23	active, 6,349 stars, 91 open issues, v4.1.0 (2026-06-09), public preview	active, 99 stars, v0.3.3, last push 2026-09-24	active, about 87.9k stars since 2026-03-02, 5,776 open issues, v2026.916.1 (2026-09-21)	early, 1 star, 76 commits, last push 2026-09-25	dormant, 26 stars, downloads frozen since April 2026, reopen date missed	stalled March 2026, 3,621 stars, 75 open issues	active product, 14 stars, veto-sdk@2.9.3 (2026-05-07)

Reading the matrix
#

The rows that separate a control plane from the orchestration category are governance, budgets, and multi-company isolation; the new enforcement rows (enforcement point and audit and evidence) are what separate the governance gates from the planes, and the tables show two live planes at most. Paperclip fills governance, budgets, and multi-company isolation; SIDJUA and TinyAGI filled some team rows and none of the surviving ones, so both are stall records; the four gates (Code Atelier, the Microsoft toolkit, Veto, Okto Pulse) fill enforcement and audit while leaving team structure and multi-company empty. The category now has two centers of gravity: one open-source agent company (Paperclip) and a cluster of narrower enforcement gates, which is the more durable half because a gate can be adopted without replatforming. SettleBridge is the outlier, governing settlement between organizations rather than tool calls inside one.

The un-profiled long tail stays in prose until something clears the bar: claw-empire (1,378 stars, also stalled since March), desplega-ai’s agent-swarm (781 stars, active, self-described company agentic operating system), multigent (66 stars), Cabinet (a knowledge-base product compared to Paperclip in its launch thread, a different problem), and OtoDock (scanned 2026-09-10: a 44-point Show HN on 2026-09-09 for its self-hosted company OS, but 111 stars, one maintainer, and a non-OSI license keep it below the bar for now). Two governance slices surfaced earlier, kastra and Blue, now fit the category’s stated scope and stay unprofiled candidates for a later run. The employee side has its own category, Assistant runtimes, anchored by OpenClaw, the -claw variants, and Hermes.

Choosing from the matrix
#

Multiple agents toward business goals with cost ceilings and audit needs: Paperclip.
Stopping or holding a risky tool call before it runs: Veto, the Microsoft Agent Governance Toolkit, or Code Atelier Governance SDK.
Enforcing spec coverage and delivery evidence on coding agents: Okto Pulse.
Settling value between independent agents: SettleBridge.
Repo-scale parallel coding agents instead: the Orchestration matrix is the right shelf.
Studying the category’s consolidation: TinyAGI and SIDJUA, accepting they are stall records, not tools.

Changes
#

2026-08-27 - Created as a single-column Paperclip scaffold, extended to two columns with TinyAGI, and its un-profiled-neighbors paragraph redirected to Assistant runtimes.
2026-09-07 - Paperclip issues cell and long-tail prose updated.
2026-09-10 - OtoDock added to the long tail on rejection.
2026-09-18 - Paperclip status cell refreshed (about 81k stars, 5,497 open issues) and Blue added to the long tail on rejection.
2026-09-21 - Paperclip and TinyAGI status cells refreshed (5,566 open issues; stall record unchanged).
2026-09-24 - Removed the verification preamble line on owner request.
2026-09-25 - Refreshed the Paperclip status cell (about 82.7k stars, 5,643 open issues, v2026.916.1 of 2026-09-21).
2026-09-27 - Refreshed the Paperclip status cell (about 87.9k stars, 5,776 open issues) and the TinyAGI star count (3,621).
2026-09-27 - Added columns for Code Atelier Governance SDK, Microsoft Agent Governance Toolkit, Okto Pulse, SettleBridge, SIDJUA, and Veto; re-sorted all columns alphabetically; added enforcement-point and audit-and-evidence rows; rewrote the intro and reading-the-matrix prose for eight members.

References
#

https://github.com/paperclipai/paperclip - pillars, heartbeat model, sandbox providers, roadmap
https://paperclip.ing - homepage, release cadence, testimonials
https://docs.paperclip.ing - official documentation
https://github.com/TinyAGI/tinyagi - team model, queue, TinyOffice for the TinyAGI column
https://api.github.com/repos/TinyAGI/tinyagi - the stall dates grounding the status row
https://github.com/microsoft/agent-governance-toolkit - the Microsoft toolkit column’s packages, policy, and audit rows
https://github.com/PlawIO/veto - Veto’s rules, adapter matrix, and receipts
https://github.com/imleopereira/agentic-governance - Code Atelier gates, threat model, and Postgres audit chain
https://github.com/OktoLabsAI/okto-pulse - Okto Pulse gates, MCP surface, and local-first runtime
https://github.com/a2a-settlement/settlebridge-ai - SettleBridge gateway components and settlement boundary
https://github.com/GoetzKohlberg/sidjua - SIDJUA five-stage pipeline, divisions, and audit log

Orchestration Feature Matrix

tom@tomrochette.com (Tom Rochette) — Mon, 24 Aug 2026 00:00:00 +0000

This matrix compares the thirty-one orchestration tools profiled in this section, the parallel-agent dashboards, worktree managers, control planes, mobile clients, a coordination protocol, a cluster-scale agent fleet orchestrator, JetBrains’ standalone agent environment, two conversational multi-agent frameworks, a dormant role-play framework, hosted agent platforms, the one agent town, and the newer wave of workflow runners, a graph workspace, a sandbox library, a tmux harness, an issue-board platform, a Codex workflow layer, and a mission-control canvas, feature by feature, so the shortlisting step does not require reading thirty-one notes.

Parallelism is already the free commodity in this category: the only things anyone pays for are review ergonomics and remote execution, and I expect more of these thirty-one to die or pivot before any of them becomes durable infrastructure.

Legend: ✓ supported, ✗ not supported, ~ partial or conditional, ? not verified. Each column links to the full research note; every cell below traces to a source cited there or in the references.

The matrix
#

Feature	AutoGen	AutoGPT	AX	Claude Squad	cmux	Conductor	Crewplane	Crystal	dmux	Emdash	Foremerge	Gas Town	GraphCode	Happy Coder	Helmor	JetBrains Air	Lanes	LobeHub	LoopTroop	MetaGPT	Multica	oh-my-codex	Omnara	Open Swarm	Orca	Paseo	Sandcastle	Superset	The Perfect Orchestrator	Vibe Kanban	Worktrunk
Kind	conversational multi-agent framework	agent workflow platform	Kubernetes agent-fleet orchestrator	terminal TUI	native macOS terminal	native Mac app	Python CLI workflow runner	Electron app	terminal TUI	Electron app	coordination protocol above Git, CLI plus MCP server	tmux town, workspace manager	native macOS graph workspace, daemon plus CLI	native mobile and macOS client, wraps the agent CLI	Tauri desktop workbench	standalone agent environment, desktop app plus org web	native macOS workspace, CLI plus self-hostable MCP endpoint	agent hiring and scheduling platform	local GUI web app	SOP multi-agent software-company framework	self-hostable workspace plus daemon	Codex CLI workflow layer, npm package	Go control plane, web, CLI, API, mobile, Slack	Electron desktop app plus FastAPI backend	Electron agentic IDE, desktop plus mobile	daemon plus desktop, web, mobile clients	TypeScript library plus CLI	Electron agentic IDE	bash plus tmux harness, Claude Code plugin	web UI, Rust backend	CLI worktree manager
Platforms	Python, any OS	Docker self-host, hosted cloud, web builder	Kubernetes clusters; Linux or macOS CLI (Go)	macOS, Linux (tmux, no Windows)	macOS only	macOS only (local)	Python 3.13+, any OS	macOS first, Linux later	macOS, Linux (tmux)	macOS, Windows, Linux	macOS, Linux, Windows binaries; local, single machine	macOS, Linux, Windows, Docker	macOS 15+ Apple Silicon only	iOS, Android, macOS, web	macOS, Windows x64 (no Linux)	macOS, Windows, Linux desktop; org-only web	macOS Ventura+ (Apple Silicon, Intel); Link on macOS/Linux	desktop app, web, cloud	any OS with Node 24+; requires OpenCode	Python, any OS	web, server (Docker/Helm/binary), desktop (macOS/Windows/Linux), iOS	macOS/Linux primary; native Windows and Codex App unsupported default	web, iOS, Android, Slack; self-host or Omnara Cloud	macOS only (Windows/Linux planned)	macOS, Windows, Linux; iOS and Android companions	macOS, Windows, Linux, iOS, Android, web, Docker	any OS with Node plus Docker, Podman, or Vercel	macOS, Linux experimental	Linux, macOS (tmux 3.0+)	any OS with Node	macOS, Linux, Windows
Open source	✓ MIT packages, repo root detected CC-BY-4.0	~ Polyform Shield for the platform, MIT for classic	✓ Apache-2.0	✓ AGPL-3.0	~ GPL-3.0, open core	✗ closed	✓ Apache-2.0	✓ MIT	✓ MIT	✓ Apache-2.0	✓ Apache-2.0	✓ MIT	~ FSL-1.1-MIT (source-available; app and daemon FSL, integration surfaces MIT)	✓ MIT	✓ Apache-2.0	✗ closed	~ app source published, license undeclared; Link Apache-2.0	~ community license, Apache 2.0 plus conditions	✓ MIT	✓ MIT	~ custom Multica License (Apache-2.0 plus hosted and commercial conditions, GitHub NOASSERTION)	✓ MIT	✓ Apache-2.0	✓ AGPL-3.0 (README badge says MIT)	✓ MIT	✓ Apache-2.0	✓ MIT	~ Elastic License 2.0	✓ MIT	✓ Apache-2.0	✓ MIT OR Apache-2.0
Price model	free, open source	free self-host, hosted Pro $42.50/mo, Max $272/mo billed annually	free, open source	free, no tier	free, Pro $50/mo, Max $200/mo	free local, Pro $50/mo	free, open source	free (Nimbalyst sells teams)	free	free core, cloud contact-sales	free, open source	free, BYOK runtime	free, source-available	free, donations	free, open source	included with JetBrains AI Pro/Ultimate, BYOK supported	free (1 user), Pro $19/mo (10 seats), Enterprise custom; Compute per-second	free self-host, cloud $9.9-$39.9/mo billed yearly	free, open source	free, open source (the MGX hosted sibling is separate)	free to start; hosted cloud paid (no public price table)	free, open source	free self-host, cloud usage-priced	free, open source	free and open source; Enterprise custom	free, Hub hosted €15/seat/mo	free, open source	free local, Pro $15-20/user/mo	free, open source	free (subs terminated)	free
Per-task worktree isolation	✗ in-memory agent conversations, no worktrees	✗ block-based workflows, not repo tasks	~ sandboxed tasks with pre-wired git workspaces, not worktrees	✓	?	✓ own branch	~ optional Git-backed worktrees and snapshots; default edits the project root	✓	✓ AI-named branch	✓	~ assumes the worktrees you already run	✓ worktree hooks	~ per-loop worktree under a project	✗ existing paths only	✓ one worktree and branch per workspace	✓ worktree, Docker, or cloud per task	✓ one issue, branch, and worktree per task	✗ chat and scheduled agent tasks, not repo tasks	✓ isolated OpenCode worktree per bead, fresh worktree per retry	✗ role conversations, no worktrees	~ runtime is a machine you connect; per-issue worktree not a documented primitive	✓ $team workers each get a dedicated git worktree by default	?	✓ each agent gets its own worktree and branch	✓ every task in its own worktree and branch	✓	✓ creates a host worktree and merges the branch back	✓ own branch	✗ workers share a workspace; ownership rules and lock-guarded commits instead	✓ own branch	✓ core purpose
Harnesses it can drive	~ its own assistant agents, not external CLIs	~ its own blocks and agents, not external CLIs	any agent container, bring-your-own runner image	any CLI via profiles	any CLI agent	4 (Claude Code, Codex, Cursor, OpenCode)	any CLI (Claude Code, Codex, Gemini CLI, Copilot CLI, Kilo, Pi, DeepSeek, OpenCode)	2 (Claude Code, Codex)	11 CLIs	25+ CLIs, auto-detected	any MCP client plus CLI and JSON API; setup auto-wires Claude Code, Codex, Cursor	5 runtimes, Claude Code default	5 (Claude Code, Copilot CLI, Codex, OpenCode, Pi)	2 (Claude Code, Codex)	5 (Claude Code, Codex, Cursor, OpenCode, Kimi Code)	4 built-in (Claude Agent, Codex, Gemini CLI, Junie) + any ACP agent	any CLI via PTY; Claude Code and Codex first-class	~ its own agents plus 10,000+ skills and MCP plugins	1 (OpenCode)	~ its own role agents, not external CLIs	26 agent CLIs (Claude Code, Codex, Cursor, Copilot, Kimi, OpenCode, and more)	1 primary (Codex CLI); mixed-provider teams codex, claude, gemini	? agent underneath unspecified	~ its own Claude Agent SDK agents	27+ CLI agents (Claude Code, Codex, Cursor CLI, Gemini, Copilot, OpenCode, Pi, and more)	4 native + ~36 via ACP	6 agent providers (claude-code, codex, pi, cursor, opencode, copilot)	any CLI, 21 presets	1 (Claude Code)	10+ agents	any CLI via -x, one program name since v0.76
Remote or SSH execution	~ distributed actor runtime, self-hosted	✓ cloud-native by design	✓ cluster-native, ax ssh into sandboxes	?	~ SSH sessions	?	✗ local only	?	✗ local only	✓ SSH-first	✗ local, single machine	~ Docker compose	✓ remote repos over SSH	✓ E2E-encrypted relay	~ experimental Cloudflare-tunnel mobile companion, no SSH	✓ JetBrains cloud, org web	✗ local execution; Link self-hostable	✓ cloud-native	✗ local only	✗ local runs	✓ daemon runtimes on any connected machine	✗ local only	✓ machine pools	✗ local only	✓ SSH worktrees, self-hosted server, cloud VMs	✓ encrypted relay, self-host	~ Vercel isolated sandboxes, no SSH	~ remote workspaces beta	✗ local tmux session	~ Docker self-host	✗ local git
Built-in review tooling	✗ no review surface	~ runs dashboard and logs, no code review	~ watch, logs, and ssh, no review surface	~ diff preview tab	?	✓ diffs, checks, PR, review	~ review loops and findings artifacts, no diff surface	~ diff viewer, rebase, squash	~ merge and PR menu	✓ diffs, PRs, CI checks	~ advisory conflict findings, verification-gated ChangeSets, no diff surface	✓ Refinery merge queue	~ attach to any live terminal; no diff or PR review surface	~ diffs and terminals beside conversations	✓ diffs, Monaco editor, one-click PR/MR, merge, fix CI, stacked PRs	✓ language-aware diffs, Agent Review (agent reviews agent)	✓ diffs, Monaco editor, git client, SQLite browser, GitHub/Linear write-back	✗ none	~ per-bead diff review and human approval gate, no PR checks	✗ none, code lands in the repo	✓ review gates, execution-log replay, issue comments and diffs	~ code-review and ultraqa skills, merge tracking via integration-report.md	~ approvals, questions, events, artifacts	~ diff viewer for uncommitted changes, no PR flow	✓ diff viewer, inline annotations back to the agent, GitHub/Linear review	~ agent output and diffs	~ logs and per-iteration results, no review UI	✓ diffs, browser previews	~ adversarial cross-verification of findings, no diff or PR surface	✓ diffs, comments, PR	~ status table and merge pipeline
Cloud execution option	✗ none first-party	✓ the hosted platform is the product	✓ is the cloud execution layer	✗ no hosting	✓ Pro, up to 50 cloud VMs	✓ Vercel sandboxes	✗ none	?	✗	~ contact-sales	✗ local only	✗ self-host, Wasteland federation	~ your own SSH hosts, no vendor cloud	✗ your machine only	✗ local-first	✓ JetBrains-managed cloud environments	✗ local-first; Compute is GPU rental, not agent hosting	✓ LobeHub Cloud	✗ local execution (Docker possible)	~ the MGX hosted sibling	✓ Multica Cloud or self-host	✗ none	✓ Omnara Cloud, or self-host	✗ local only	✓ self-hosted servers or your own cloud VMs	~ self-host anywhere, no vendor cloud	✓ Vercel Firecracker sandboxes	~ remote workspaces beta	✗ none (run on your own VPS)	✗ services removed	✗
Current status	maintenance mode, successor Microsoft Agent Framework at 13.8k stars	active, platform beta v0.8.1, 187.6k stars	active, Google team, v0.3.1, pre-stable	active, slow burn	active, fast	active, $22M raised	active, early, 41 stars as of 2026-09-27, v0.3.5	deprecated Feb 2026	active	active, YC W26	active, 507 stars, pre-1.0, v0.5.0	shut down Sept 2026, repo kept as death record	active, v0.1.76-beta2 (2026-09-27), 129 stars as of 2026-09-27, created 2026-07-26	active, 23.9k stars, community team	active but cooling, v0.46.0 (2026-07-24), last commit 2026-08-22, 1.3k stars	active, public preview, v262.834.41	active, v0.49 (2026-09-08), 271 stars on lanes-sh/app as of 2026-09-27	active, daily canary releases, 82.8k stars	active, early alpha, v0.5.9 (2026-08-26), 154 stars as of 2026-09-27	quiet since v0.8.2 (2025-03), org energy moved to OpenManus	active, v0.5.3 (2026-09-24), 51.5k stars as of 2026-09-27, star count caveated	active, v0.21.6 (2026-09-21), 33.4k stars as of 2026-09-27	active, YC S25, 2,871 stars	active, experimental release line, v1.8.0-exp.2 (2026-09-23), 820 stars as of 2026-09-27	active, v1.4.215 (2026-09-27), 79.4k stars as of 2026-09-27	active, v0.9.2, solo maintainer	appears dormant, v0.12.0 (2026-06-29), no push since, 8.2k stars as of 2026-09-27	active, YC P26, $11M raised	quiet, v0.2.0 (2026-06-06), last commit 2026-06-30, 1 star as of 2026-09-27	orphaned, community commits resumed 2026-09-16, v0.1.45 prerelease on GitHub, npm still 0.1.44	active, pre-1.0 fast

Reading the matrix
#

The platform rows tell you who these tools are for: Mac-first GUI shops and unix terminal people, with Emdash the only GUI covering all three desktop OSes and the tmux pair unable to follow anyone to Windows. cmux and Conductor are macOS only, and Crystal was macOS first with Linux later. Vibe Kanban’s web UI goes anywhere Node goes, which is the one structural advantage of the board design.

Worktree isolation is the entry ticket, not the differentiator: every session-oriented tool here except cmux, Foremerge, and The Perfect Orchestrator gives each task its own worktree and branch, so the real spread is harness breadth, from LoopTroop’s one and Crystal’s two to Emdash’s 25+. cmux’s “?” is structural rather than a gap: it is a terminal built for attention routing, not a session manager, and its note records no worktree feature. Foremerge’s tilde is the opposite of a gap: it assumes the worktrees you already run and coordinates plans across them, the one column whose unit of work is the intent rather than the task. The wrapping pattern dominates (Emdash auto-detects installed CLIs, Claude Squad launches anything through profiles, dmux lists eleven), which means new harness features arrive without waiting for the orchestrator to reimplement them.

Where your code lives is the quiet differentiator, and Emdash is alone in treating it as a design decision with SSH-first execution and credentials in the OS keychain. Cloud execution exists only where a subscription or usage bill is attached, cmux Pro, Conductor Cloud, Omnara Cloud, and JetBrains-managed cloud tasks; dmux is explicitly local-only, Claude Squad ships no hosting at all, and Vibe Kanban’s remote services were removed thirty days after its shutdown announcement.

The status row is the most instructive one in the matrix: of thirty-one tools, one is deprecated, one lost its vendor, one is a cluster-scale platform entrant, one new column attacks the failure worktrees cannot see, and the counterexamples run on venture rounds and a very loud founder. Crystal was deprecated in February 2026 in favor of Nimbalyst, the clearest signal yet that a pure worktree-session manager can be a feature rather than a product. Bloop shut down in April 2026 and Vibe Kanban is orphaned, local workspaces intact, ten commits on the default branch since the shutdown (the first a 2026-09-15 version bump by a former Bloop maintainer, nine more with substantive fixes through 2026-09-19), a v0.1.45 prerelease published on GitHub on 2026-09-19 with npm still serving 0.1.44 as latest, and nobody paid to fix bugs. Conductor staying a pure session manager and raising money is what keeps the feature-versus-product question contested instead of settled. The three 2026 columns sharpen the funding split: Superset raised $11M, Paseo is a solo maintainer with a planned business, and Worktrunk is a single author with no company at all, which is the whole sustainability spectrum in one row. Omnara is the tenth column and the only one that wants to own execution and state: agents become YAML configs in your repo, machine pools separate where code runs from who can invoke it, and supervision reaches you from a dashboard, phone, CLI, REST API, or Slack, the open-source counterpoint to Claude Managed Agents. Happy Coder is the purest thin client in the table: two harnesses, no worktrees, no hosting, yet 23.8k stars, second only to cmux among maintained tools, because phone access to the sessions you already run is what people actually install. JetBrains Air is the vendor entry, and it is the only column whose price model is a bundle: no standalone fee, four agent families unlocked by a JetBrains AI Pro or Ultimate subscription, with the deepest isolation menu in the table (worktree, Docker, or cloud per task) and org governance behind it, which makes it the strongest evidence yet that this layer is a feature incumbents will attach to existing subscriptions. AX is the scale outlier at the front of the table: Google’s Kubernetes-based fleet orchestrator treats agents as a datacenter workload class with sandboxing, network fencing, and checkpoint-resume, which makes every other column here look like what it is, a desktop tool. Foremerge is the newest column and the only one that coordinates plans instead of hosting sessions: agents publish intents with semantic scopes before they edit, and a deterministic detector flags destructive-versus-additive collisions that git merges cleanly, which names the residue every worktree column here leaves behind. The four framework columns are this category’s museum wing and its adjacent business park: AutoGen is in maintenance mode and MetaGPT dormant while AutoGPT and LobeHub run active hosted platforms, which is why I weight the parallel-agent columns as where the daily engineering work is.

The eleven new columns split into three families, and the split says more than any single feature cell. Four are process engines that own a workflow rather than a session: Crewplane sequences a Markdown DAG across CLIs and keeps the run record on disk, Sandcastle exposes the same instinct as a TypeScript library over Docker, Podman, or Vercel sandboxes, LoopTroop wraps OpenCode in council planning and fresh-context recovery, and oh-my-codex adds skills, memory, and worktree teams to Codex CLI. Three are visual surfaces: GraphCode arranges live sessions into a graph whose hand-off, message, and spawn edges fire on shell predicates, Helmor is a local-first workbench that carries a task through review, test, merge, and one-click PR, and Open Swarm is a mission-control canvas with unified tool approvals and per-session cost tracking. Four are platforms or boards: Lanes puts parallel PTY sessions on a macOS issue board and pairs it with a self-hostable agent-access endpoint, Orca is the MIT, cross-platform ADE with a mobile companion and 27+ agents, Multica assigns issues to agents as teammates on a self-hostable board, and The Perfect Orchestrator is a one-star tmux harness whose adversarial verification of workers is the most interesting idea of the batch.

The new entrants sharpen the category’s two fault lines: openness and maintenance. Orca, Helmor, Lanes, and Open Swarm stay free or freemium on venture or solo funding, while Multica’s 51.5k stars and custom, non-OSI license are exactly the caveated popularity signal this matrix exists to flag. Sandcastle and The Perfect Orchestrator last committed in June 2026, GraphCode is two months old with one maintainer, and LoopTroop and Crewplane are early with tiny star counts, so the feature-versus-product question the earlier columns raised now has a shorter runway. The one new capability claim worth taking seriously is adversarial verification: The Perfect Orchestrator will not count a finding until a different worker fails to refute it, which is a sharper answer to worker overconfidence than any review surface in the table.

Review is the bottleneck this category actually sells, and delivery tracks funding: Conductor has the deepest review surface (diffs, checks, PR page, code review), Emdash and Vibe Kanban carry full PR flows, and the terminal tools stop at diff tabs and merge menus. Claude Squad’s preview tab and dmux’s pane-menu PR cover the dispatch, wait, review, merge loop, but nobody should expect checks or inline comments there. Gas Town is the exception that proves the row: its Refinery is a Bors-style merge queue with verification gates, review as infrastructure rather than review as a pane.

Choosing from the matrix
#

Want the deepest GUI review flow on a Mac and accept a closed client: Conductor.
Want an auditable client, Windows or Linux support, or agents running next to remote code: Emdash.
Live in the terminal: Claude Squad for the smallest footprint, dmux for multi-agent fan-out and resumable panes.
On macOS and drowning in sessions that need attention: cmux’s notification rings and unread panel.
Want planning-first and vendor-less: Vibe Kanban, accepting that it is orphaned, with community commits resumed but no stable release since April 2026.
Want to supervise agents from your phone over an encrypted relay, self-hosted and FOSS: Paseo.
Want your existing Claude Code or Codex sessions on a phone, end-to-end encrypted, and nothing more: Happy Coder.
Want a control plane that owns agent execution and state behind one API, on your own hardware: Omnara.
Want declarative fleet-scale orchestration on Kubernetes instead of a desktop app: AX, accepting pre-stable churn and cluster operations.
Want a macOS agentic IDE around your existing subscriptions, five or more parallel sessions: Superset, accepting the ELv2 license and beta Linux.
Already pay for JetBrains AI Pro or Ultimate and want isolation choice plus org governance around four agent families: JetBrains Air, accepting the preview status and credits-only cloud.
Want the worktree lifecycle automated inside your own shell with no app at all: Worktrunk.
Run several agents in parallel worktrees on one repo and fear clean merges that break the design: Foremerge, advisory and local-first.
Supervising 20 or more agents with agent watchers and a merge queue, credits and churn accepted: Gas Town.
Want your agent process versioned as Markdown with resumable, inspectable runs across several CLIs: Crewplane.
Want to script sandboxed agents from TypeScript and own the pipeline: Sandcastle, accepting a repository quiet since June 2026.
Want one lead to brief and adversarially verify workers over tmux, no daemons: The Perfect Orchestrator, a one-star template rather than a maintained tool.
On Apple Silicon and want connected, unattended loops you can still attach to: GraphCode, accepting the FSL license and 0.1.x beta.
Want an open, local-first workbench that finishes the loop through review, test, and one-click PR: Helmor, on macOS or Windows.
Want parallel PTY sessions organized as issues on a macOS board, with a self-hosted agent-access layer: Lanes.
Want the broadest, most open ADE, across all three desktop OSes plus phone and remote: Orca.
Want to assign issues to agents as teammates on a board you can self-host: Multica, accepting the custom license and the star-count caveat.
Want one local canvas to launch, approve, and cost-track several Claude agents: Open Swarm.
Want planning-first, high-correctness runs over OpenCode with human approval at every merge: LoopTroop.
Want Codex CLI to behave like a team with worktrees, memory, and skills: oh-my-codex.
Do not adopt Crystal today; if its idea appeals, evaluate Nimbalyst on its own merits.

Changes
#

2026-08-24 - Created with seven tools and the death and orphan stories carried into the reading section.
2026-08-27 - Extended from seven to eight columns with Gas Town and canonicalized the emdash reference.
2026-08-30 - Added Paseo, Superset, and Worktrunk columns, reaching eleven, with a funding-spectrum sentence.
2026-09-06 - Extended from twelve to thirteen columns with Happy Coder.
2026-09-13 - Corrected the Happy Coder and JetBrains Air columns, whose body cells had been transposed since the Air column was added on 2026-09-12.
2026-09-13 - Reframed Gas Town’s status to active but cooling (no default-branch commit since 2026-07-23, no release since v1.2.1 in June).
2026-09-20 - Moved Gas Town’s status cell to shut down (September 2026, Yegge’s admission per Dan Luu via AINews), matching the note’s death record.
2026-09-13 - Corrected the Vibe Kanban orphan wording to no default-branch commit since 2026-04-24, named Omnara Cloud and JetBrains cloud tasks in the cloud-execution prose, and qualified Happy Coder’s star ranking as second among maintained tools.
2026-09-16 - Re-verification: recorded Vibe Kanban’s first post-shutdown default-branch commit (2026-09-15), refreshed the Omnara star count to 2,851, and updated the JetBrains Air release to 262.834.41.
2026-09-18 - Re-verification: recorded Vibe Kanban’s community commits resuming (eight on the default branch since 2026-09-15, still no release), moved the cmux price cell to the new monthly-only Pro $50 and Max $200 tiers, refreshed the Omnara star count to 2,857, and corrected the stale Air changelog version in the references.
2026-09-20 - Re-verification: moved the Vibe Kanban status cell to the community’s 0.1.45 tag, which npm and the release list do not publish yet, and refreshed the Omnara star count to 2,861.
2026-09-21 - Extended from fourteen to fifteen columns with AX (Google’s cluster-scale agent fleet orchestrator, added sorted into the first position), refreshed the Happy Coder star count to 23.9k, and moved the Paseo status cell to v0.8 with 0.9 betas.
2026-09-22 - Extended from fifteen to sixteen columns with Foremerge (Nick Woodhead’s coordination protocol for parallel agents, added sorted after Emdash), moved the Paseo status cell to v0.9.1, and refreshed the Omnara star count to 2,863.
2026-09-24 - Removed the verification preamble line on owner request.
2026-09-24 - Refreshed the Vibe Kanban status cell to the GitHub v0.1.45 prerelease (npm still 0.1.44), moved Paseo’s status cell to v0.9.2, and refreshed Foremerge’s star count to 505.
2026-09-27 - Extended from sixteen to twenty columns with AutoGen, AutoGPT, LobeHub, and MetaGPT, the multi-agent frameworks and hosted platforms, and updated the prose counts and the reading section to match.
2026-09-27 - Extended from twenty to thirty-one columns with Crewplane, GraphCode, Helmor, Lanes, LoopTroop, Multica, oh-my-codex, Open Swarm, Orca, Sandcastle, and The Perfect Orchestrator (a batch of workflow runners, a graph workspace, a sandbox library, a tmux harness, an issue-board platform, a Codex workflow layer, and a mission-control canvas), re-sorted all columns, and added the three-family reading section and the new choosing entries.

References
#

https://github.com/smtg-ai/claude-squad - profiles, worktrees, packaging for the Claude Squad column
https://github.com/google/ax - repository, primitives, license, and status for the AX column
https://agentexecutor.io - the Task, Workspace, Gateway, and Model model for the AX column
https://cmux.com/pricing - tiers, the 50-VM cloud cap, CodeRouter removal for the cmux column
https://conductor.build/pricing/ - tiers, sandbox specs, local versus cloud privacy for the Conductor column
https://github.com/stravu/crystal - deprecation notice and feature history for the Crystal column
https://github.com/standardagents/dmux - supported agent list, hooks, local-only scope for the dmux column
https://emdash.com/ - agent support, SSH model, downloads for the Emdash column
https://github.com/BloopAI/vibe-kanban - sunset banner and feature list for the Vibe Kanban column
https://github.com/gastownhall/gastown - architecture, runtimes, Refinery, Docker setup for the Gas Town column
https://github.com/slopus/happy - repository, stars, license, and monorepo layout for the Happy Coder column
https://paseo.sh/alternatives/happy-coder - the provider, worktree, and platform limits for the Happy Coder column
https://news.ycombinator.com/item?id=44904039 - launch thread and donation-IAP context for the Happy Coder pricing cell
https://maggieappleton.com/gastown - the field analysis grounding the Gas Town status and cost cells
https://github.com/omnara-ai/omnara - control plane, license, and stars for the Omnara column
https://www.vibekanban.com/blog/shutdown - shutdown date, service removal, refunds for the status row
https://github.com/getpaseo/paseo - platforms, agent catalog, relay, and license for the Paseo column
https://github.com/superset-sh/superset - worktree model, presets, ELv2 license, and funding for the Superset column
https://github.com/max-sixty/worktrunk - commands, hooks, license, and release cadence for the Worktrunk column
https://air.dev/ - supported agents, isolation options, and pricing FAQ for the JetBrains Air column
https://air.dev/changelog - current version 262.834.41 and platform dates for the JetBrains Air status cell
https://www.jetbrains.com/help/air/execution-environments.html - the worktree, Docker, and cloud isolation model for the JetBrains Air isolation cells
https://www.jetbrains.com/help/air/cloud-tasks.html - the JetBrains-managed cloud environments for the JetBrains Air cloud cell
https://github.com/stablyai/orca - repository, worktrees, 27-agent list, MIT license, and stars for the Orca column
https://www.onorca.dev/docs - worktrees, review, remote, and the “not a model” scope for the Orca cells
https://github.com/mattpocock/sandcastle - sandbox providers, branch strategy, hooks, and license for the Sandcastle column
https://registry.npmjs.org/@ai-hero%2Fsandcastle - Sandcastle package version and license
https://lanes.sh/pricing - tiers, seats, and Compute billing for the Lanes price cell
https://github.com/lanes-sh/app - board, sessions, worktrees, and the undeclared license for the Lanes column
https://github.com/crewplaneai/crewplane - Markdown workflows, resumable runs, and license for the Crewplane column
https://helmor.ai/ - local-first workbench, agents, and ship actions for the Helmor column
https://github.com/dohooo/helmor - worktrees, one-click PR and merge, CLI and MCP, and the cooling commit cadence for Helmor
https://github.com/openswarm-ai/openswarm - canvas, approvals, worktrees, and the AGPL-3.0 LICENSE for the Open Swarm column
https://www.looptroop.ovh/docs/ - council planning, beads, Ralph loops, and alpha status for the LoopTroop column
https://graphcode.app/ - loop types, graph edges, and the FSL license for the GraphCode column
https://github.com/daman8271/the-perfect-orchestrator - lead-and-worker harness, adversarial verification, and license for the column
https://github.com/multica-ai/multica - issue assignment, runtimes, license metadata, and stars for the Multica column
https://www.promptquorum.com/power-local-llm/multica-review - the star-count caveat and the custom-license analysis for the Multica cells
https://github.com/Yeachan-Heo/oh-my-codex - skills, worktree teams, MCP servers, and license for the oh-my-codex column

llm=deepseek-v4.1-flash on tomrochette.com

Agent Analytics

What it is #

Status #

Strengths #

Cautions #

Pricing #

Price history #

Compared to #

Bottom line #

Changes #

See also #

References #

AgentTrace

What it is #

Status #

Strengths #

Cautions #

Pricing #

Compared to #

Bottom line #

Changes #

See also #

References #

Agon

What it is #

Status #

Strengths #

Cautions #

Pricing #

Compared to #

Bottom line #

Changes #

See also #

References #

ClawTrace

What it is #

Status #

Strengths #

Cautions #

Pricing #

Price history #

Compared to #

Bottom line #

Changes #

See also #

References #

Code Atelier Governance SDK

What it is #

Status #

Strengths #

Cautions #

Pricing #

Compared to #

Bottom line #

Changes #

See also #

References #

Crewplane

What it is #

Status #

Strengths #

Cautions #

Pricing #

Compared to #

Bottom line #

Changes #

See also #

References #

GraphCode

What it is #

Status #

Strengths #

Cautions #

Pricing #

Compared to #

Bottom line #

Changes #

See also #

References #

What it is
#

Status
#

Strengths
#

Cautions
#

Pricing
#

Price history
#

Compared to
#

Bottom line
#

Changes
#

See also
#

References
#

What it is
#

Status
#

Strengths
#

Cautions
#

Pricing
#

Compared to
#

Bottom line
#

Changes
#

See also
#

References
#

What it is
#

Status
#

Strengths
#

Cautions
#

Pricing
#

Compared to
#

Bottom line
#

Changes
#

See also
#

References
#

What it is
#

Status
#

Strengths
#

Cautions
#

Pricing
#

Price history
#

Compared to
#

Bottom line
#

Changes
#

See also
#

References
#

What it is
#

Status
#

Strengths
#

Cautions
#

Pricing
#

Compared to
#

Bottom line
#

Changes
#

See also
#

References
#

What it is
#

Status
#

Strengths
#

Cautions
#

Pricing
#

Compared to
#

Bottom line
#

Changes
#

See also
#

References
#

What it is
#

Status
#

Strengths
#

Cautions
#

Pricing
#

Compared to
#

Bottom line
#

Changes
#

See also
#

References
#

What it is
#

Status
#

Strengths
#

Cautions
#

Pricing
#

Compared to
#

Bottom line
#

Changes
#