Approaches to Agentic Coding

Deep dives into the major systems and frameworks driving autonomous software engineering — from enterprise-internal platforms to open-source tools and model-provider managed agents.

A deep dive into the major systems and frameworks driving autonomous software engineering — from enterprise-internal platforms to open-source tools.

For the model layer powering these systems (which Anthropic / Google / OpenAI / xAI models to pick, plus the open-weights options like DeepSeek, Qwen, Llama, Kimi, GLM, MiniMax, and Mistral), see Models. For the surrounding disciplines that make any of these approaches reliable, see Harness Engineering, Context Engineering, Tool Design, and Skills.

Index

Commercial / proprietary

Stripe Minions — 1,300+ PRs/week, blueprints, devboxes, Toolshed MCP
Claude Managed Agents — Anthropic's vertically integrated harness, $0.08/agent-hour
OpenAI Symphony — 25K stars, 6-layer orchestration, work management over agent supervision
Vercel Open Agents — MIT reference template, durable workflows + Vercel Sandbox + GitHub App
PostHog Code — desktop app + open agent framework, swarm driven by production analytics, beta May 2026

Open-source agents

Ordered by GitHub stars (descending).

OpenClaw — 374K stars, self-hosted assistant with messaging integration
OpenCode — 165K stars, provider-agnostic with GitHub agent mode
Hermes Agent — 165K stars, Nous Research's self-improving personal agent
OpenHands — 75K stars, most mature open-source autonomous engineer
DeerFlow — 69K stars, ByteDance's long-horizon SuperAgent harness, LangGraph-based
Cline — 62K stars, plan-then-act with explicit user approval at every step
OhMyOpenAgent — 59K stars, named specialist agents, hash-anchored edits
Goose — 46K stars, MCP-native, the ancestor Stripe forked for Minions
Letta Code — 23K stars, memory-first coding agent built on the MemGPT lineage
SWE-agent — 19K stars, Princeton/Stanford, pioneered issue-to-PR paradigm
Open SWE (LangChain) — 9.8K stars, multi-agent async coding agent
Composio Agent Orchestrator — 7.2K stars, best multi-agent parallelization
AgentField — 2K stars, open-source control plane with three nested failure loops
Patchwork — 1.6K stars, patchflows, closest open-source analog to Stripe's blueprints

Frameworks & SDKs

DSPy + GEPA — 34.6K stars, Stanford NLP's programmatic LLM framework + Pareto-genetic prompt/topology optimizer
Smolagents — 27.5K stars, HuggingFace's ~1K-LOC hackable code-agent reference
OpenAI Agents SDK — 27K stars, first-party OpenAI framework; production successor to Swarm
Mastra — 24K stars, TypeScript framework for building custom agent systems
Deep Agents (LangChain) — 23.3K stars, the LangGraph-based opinionated open harness
Google ADK — 20K stars, Google's first-party Gemini-native framework
Claude Agent SDK — 7K (Python) + 1.5K (TS), Anthropic's first-party SDK — the same harness that powers Claude Code
Strands Agents — 5.9K stars, AWS-incubated SDK with Bedrock / Lambda / Fargate deploy templates
Rivet Sandbox Agent — universal API for running agents in sandboxes

Harness & skill packs

GStack — Garry Tan's 23-skill Claude Code setup, CEO / Designer / Eng Manager / QA personas
GBrain — Garry Tan's persistent-memory companion to GStack
Superpowers — Jesse Vincent's skills framework + design-then-implement methodology
Everything Claude Code — Affaan M.'s multi-harness operator system: 63 subagents, 249 skills, hooks, MCP, AgentShield security audit
AgentHub — Electron harness-engineering control plane on top of Claude Code CLI

The Steinberger ecosystem

Crabbox — ephemeral test-box control plane with diff sync
Clawpatch — automated code review via semantic feature slicing
ClawSweeper — conservative issue/PR triage bot

Cross-cutting

Terminal coding CLIs — the 28-CLI comparison table
Skills, Plugins & Marketplaces — Cursor Rules · SKILL.md · Continue · plugins
Browser-Use & Computer-Use Frameworks — Browser Use, Stagehand, Magnitude, Skyvern, Operator

Stripe Minions

Type: Enterprise / Internal
Scale: 1,300+ PRs merged per week
Based on: Goose fork
Blog: https://stripe.dev/blog/minions-stripes-one-shot-end-to-end-coding-agents

Stripe's homegrown coding agents are the industry benchmark for unattended, one-shot agentic coding at enterprise scale. Engineers invoke minions from Slack, internal tools, or CLI, and receive a complete pull request with no human-written code. This is the canonical example of the Stripe School — see also Benchmarks for how its 1,300+ PRs/week metric compares to leaderboard scores.

Architecture

Blueprints — Hybrid state machines interleaving deterministic nodes (git, linting, push) with agentic subtasks (implementation, CI fixes)
Devboxes — Isolated EC2 environments pre-warmed in ~10 seconds, identical to human dev machines
Toolshed MCP — Centralized MCP server with ~500 tools for internal systems and SaaS platforms
Conditional rules — Cursor-format rule files applied by subdirectory to avoid context bloat
Pre-hydration — Deterministic MCP tool runs on linked URLs before agent loop starts

Key Properties

One-shot design — Task in, PR out, no interaction in between
Max 2 CI rounds — Local lint first, then at most two CI iterations
Production isolation — Devboxes cut off from production and internet
Parallel execution — Engineers routinely spin up multiple minions simultaneously
Same tools as humans — If it's good for humans, it's good for LLMs
Auto-fixes — Many test failures have autofixes that are applied automatically

Flow

Slack / CLI → Devbox → Pre-hydrate Context → Blueprint Loop → Local Lint → CI (x2 max) → PR

AgentField

Type: Open Source (Apache 2.0)
Role: Control Plane + Orchestration Framework
GitHub: https://github.com/Agent-Field/agentfield
Blog: https://agentfield.ai/blog/beyond-vibe-coding

AgentField is both a control plane for managing AI agents as production services and an orchestration framework (SWE-AF) for multi-agent coding workflows. It addresses the infrastructure gap that Stripe solved internally.

Control Plane

Agent registration & routing — REST APIs, WebSocket connections, execution queues (PostgreSQL-backed)
Canary & blue-green deploys — Per-version health tracking and traffic routing
Cryptographic identity — W3C DIDs per agent with verifiable credentials
Memory system — KV storage + vector search across four scopes
SDKs — Python, Go, TypeScript

SWE-AF Orchestration

Two primitives — .ai() for cheap routing calls, .harness() for full coding environments (up to 150 turns)
Three failure loops — Inner (per-issue retries, up to 5), Middle (typed recovery: retry, split, escalate, accept-with-debt), Outer (replanner for cascading failures)
Git worktree isolation — Each issue gets its own branch and working directory
Checkpoint-based execution — Resumes from failure point, never restarts
Intent-aware merging — Merger agent resolves conflicts between parallel branches
Typed debt tracking — Downstream agents work around known gaps

Results

Diagrams-as-code Rust CLI: 15 issues, 200+ invocations, $116 total
Go SDK feature: 10 issues, 80+ invocations, $19 total
Architecture quality > model capability: scored 95/100 with both Haiku and MiniMax M2.5

OpenHands

Type: Open Source (MIT)
Stars: 75K
GitHub: https://github.com/OpenHands/OpenHands

Formerly OpenDevin, OpenHands is the most mature open-source autonomous software engineer. It clones repos, runs terminal commands, executes tests, debugs errors, and produces PRs — all inside a sandboxed Docker container.

Architecture

Docker sandboxing — Full OS-level isolation per agent run
Planning Mode — Added in v1.6.0 for structured task decomposition
Web GUI + CLI + SDK — Multiple interfaces for different workflows
Kubernetes support — Scalable deployment for enterprise use

Key Properties

50%+ SWE-bench — Solves over half of real GitHub issues in benchmarks
GitHub issue trigger — Can be invoked directly from issue comments
CI feedback — Runs tests and iterates on failures
$18.8M Series A — Well-funded with active development
Gap: No built-in blueprint/workflow DSL or multi-agent parallelization

Open SWE (LangChain)

Type: Open Source
Stars: 9.8K
GitHub: https://github.com/langchain-ai/open-swe

LangChain's cloud-native async coding agent, explicitly modeled on patterns from companies like Stripe, Ramp, and Coinbase. Uses a multi-agent architecture built on LangGraph.

Architecture

LangGraph orchestration — Graph-based workflow engine, closest open-source analog to Stripe's blueprints
Multi-agent decomposition — Manager, Planner, Programmer, Reviewer agents
Cloud sandbox — Isolated cloud execution environments
Async-first — Designed for unattended background execution

Key Properties

Automatic PR creation — End-to-end from issue to pull request
Self-review — Reviewer agent checks code before PR creation
Enterprise patterns — Designed to capture patterns from production agentic systems
Gap: Newer project, less battle-tested than OpenHands

OhMyOpenAgent

Type: Open Source
Stars: 59K
GitHub: https://github.com/code-yeongyu/oh-my-openagent

A multi-agent orchestration harness with named specialist agents, hash-anchored edits for reliability, and automatic multi-model routing. Focuses on solving the practical failure modes that generic agent frameworks overlook.

Architecture

Named agents — Sisyphus (orchestrator), Hephaestus (deep worker), Prometheus (strategic planner), Oracle (debugger), Librarian (docs)
Hash-anchored edits (Hashline) — Each line carries a content hash for verification before applying changes (improved success from 6.7% to 68.3%)
Multi-model routing — Auto-routes tasks to appropriate models (visual, reasoning, quick fix, ultrabrain)
LSP + AST-Grep — IDE-precision refactoring and AST-aware code search

Key Properties

ultrawork command — Single-word activation triggering full agent team
Ralph Loop — Self-referential iteration until task completion
Todo Enforcer — Pulls agents back from idle states
Comment validation — Prevents AI-generated prose in code
/init-deep — Auto-generates hierarchical AGENTS.md files across projects
Built-in MCPs — Exa search, Context7 docs, Grep.app

OpenCode

Type: Open Source
Stars: 165K
GitHub: https://github.com/anomalyco/opencode

The most-starred open-source coding agent, featuring a TUI, client/server architecture, and a GitHub agent mode for unattended repository automation via GitHub Actions.

Architecture

Client/server model — Separates UI from execution for flexibility
GitHub agent mode — Triggered by GitHub events, runs in Actions
Provider-agnostic — Claude, OpenAI, Google, local models
TUI interface — Rich terminal UI for interactive use

Key Properties

Massive adoption — 165K stars, largest coding agent community
Event-driven — GitHub agent mode mirrors Minions' event-driven model
Extensible — Plugin architecture for custom tools
Gap: Primarily interactive; GitHub agent mode is newer

SWE-agent

Type: Open Source (MIT)
Stars: 19K
Origin: Princeton / Stanford
GitHub: https://github.com/SWE-agent/SWE-agent

Pioneered the "GitHub issue in, pull request out" paradigm. Published at NeurIPS 2024 by John Yang and collaborators including Shunyu Yao. Also produced mini-swe-agent, a 100-line agent scoring 74%+ on SWE-bench.

Architecture

Docker isolation — Sandboxed execution environment per run
Issue-to-PR pipeline — Takes a GitHub issue URL and produces a fix
Custom agent interface — Optimized shell commands for LLM interaction

Key Properties

Research-grade — NeurIPS 2024 publication with rigorous evaluation
mini-swe-agent — 100-line minimal version scoring 74%+ on benchmarks
Gap: No workflow orchestration, limited CI integration, single-agent only

Composio Agent Orchestrator

Type: Open Source
Stars: 7.2K
GitHub: https://github.com/ComposioHQ/agent-orchestrator

The best open-source match for Stripe's multi-agent parallelization pattern. Decomposes tasks, spawns parallel agents, and autonomously handles CI fixes and merge conflicts.

Architecture

Task decomposition — Plans and breaks work into parallel subtasks
Parallel agent spawning — Multiple agents working simultaneously
CI feedback loop — Automatically handles test failures
Merge conflict resolution — Handles conflicts from parallel work

Key Properties

Best parallelization — Closest match to "spin up many minions"
Code review — Automated review before PR creation
Gap: Orchestration layer, not a complete standalone agent

Patchwork

Type: Open Source
Stars: 1.6K
GitHub: https://github.com/patched-codes/patchwork

Framework for patching code repos using LLMs. Its "patchflows" — reusable workflows combining atomic actions with LLM prompts — are the closest open-source analog to Stripe's blueprint pattern.

Architecture

Patchflows — Deterministic steps (create PR, commit, lint) + LLM prompts, similar to blueprints
Built-in flows — AutoFix, PRReview, GenerateDocstring
CI/CD integration — Runs in pipelines natively

Key Properties

Blueprint analog — Closest match to Stripe's hybrid orchestration
Composable — Mix and match atomic actions
Gap: Smaller community, no sandbox isolation, less sophisticated agent loops

Goose

Type: Open Source (Apache 2.0)
Stars: 46K
GitHub: https://github.com/block/goose (also https://github.com/aaif-goose/goose)

The general-purpose AI agent framework from Block that Stripe forked in late 2024 to build Minions. Now maintained by the Agentic AI Foundation (AAIF) under the Linux Foundation.

Architecture

Rust core — Native desktop, CLI, and API interfaces
MCP-native — 70+ tool extensions via Model Context Protocol
15+ LLM providers — Anthropic, OpenAI, Google, Ollama, and more
General purpose — Code, research, writing, automation, data analysis

Key Properties

Minions ancestor — Stripe's Minions were literally built from a Goose fork
Linux Foundation — Transitioned from Block to AAIF for community governance
Gap: Interactive, not unattended. No sandbox isolation, CI loops, or blueprint orchestration

Cline

Type: Open Source (Apache 2.0)
Stars: 62K
GitHub: https://github.com/cline/cline

Originally the most-installed autonomous coding extension in VS Code; in 2026 also ships as a standalone CLI (cline-cli). Cline's design center is plan-then-act with explicit user approval at every step — the inverse of Claude Managed Agents' one-shot autonomy. That makes it the right harness for teams that want the agent's velocity but aren't ready to trust unattended PRs.

Architecture

Plan / Act modes — explicit gate between proposing a change and applying it; every tool call surfaces for approval by default
Multi-provider — Claude, GPT, Gemini, local via Ollama; bring-your-own-key
MCP-native — Cline was an early adopter; ships with discoverable MCP server support
Diff-based edits — atomic patches with previews rather than free-form rewrites

Key Properties

Roo Code (RooCodeInc/Roo-Code, 24K stars) is a Cline fork with multi-mode orchestration and broader model support; teams pick one or the other, rarely both
Direct competition with Aider in the IDE-extension category; Cline wins on UI polish, Aider on terminal purity
Gap: by design, not an unattended autonomy harness — every action waits for human approval, which kills throughput for production agent fleets

Letta Code

Type: Open Source (Apache 2.0)
Stars: 23K (Letta core)
GitHub: https://github.com/letta-ai/letta
Origin: Letta (formerly MemGPT), the lab behind the 2023 MemGPT paper

The reference implementation of memory-first agentic coding. Where Claude Code / Codex / Aider treat the conversation as a buffer that ends at compaction, Letta agents are persistent entities with a typed memory hierarchy (core / archival / recall / message buffer) that the agent itself reads, writes, and consolidates between sessions. The same agent that fixed a bug yesterday remembers the fix today — without CLAUDE.md plumbing, without a GBrain-style markdown corpus, without manual context engineering.

Architecture

Letta server — REST API; every agent is a long-lived resource you address by ID
Memory blocks — labelled, agent-editable text regions (human, persona, project-specific); the agent calls core_memory_replace like any other tool
Archival storage — Postgres + pgvector; the agent decides what to evict from core to archival
Letta Code CLI — the coding-agent surface; sub-agents, skills, MCP

Key Properties

The MemGPT design is the canonical academic answer to context-window limits; Letta is what happens when you ship it as a server with a CLI on top
Pairs naturally with Tavily for live retrieval and Inngest for durable tool calls
Listed in Agent Memory infrastructure as the memory layer; this entry is the coding-agent surface
Gap: the memory abstraction is the whole product — for harnesses where you want the agent to be stateless on purpose (CI runners, ephemeral sandboxes), this is the wrong tool

Mastra

Type: Open Source (Apache 2.0 + Enterprise)
Stars: 24K
GitHub: https://github.com/mastra-ai/mastra
Origin: YC W25, from the team behind Gatsby

A TypeScript framework for building AI-powered applications and autonomous agents. Mastra provides the building blocks for production agent systems — model routing, workflow orchestration, memory, and MCP support — in a developer-friendly package.

Architecture

Model routing — Unified interface to 40+ LLM providers (OpenAI, Anthropic, Gemini, etc.)
Workflow engine — Graph-based orchestration with .then(), .branch(), .parallel() API
Agent system — Autonomous agents that reason through goals and select tools
Human-in-the-loop — Pause agents for user approval with persistent state across suspension
Memory — Conversation history, working memory, and semantic memory for coherent behavior

Key Properties

TypeScript-native — 99.3% TypeScript, integrates with React, Next.js, Node.js
MCP servers — Author and consume MCP tools via standard interfaces
Evaluations — Built-in eval framework for measuring agent quality
Production-ready — Observability, error handling, state persistence
Role in agentic engineering: Mastra is a framework for building custom agent systems, not a pre-built coding agent. Teams would use it to build their own Minions-like system in TypeScript, with the workflow engine serving a similar role to Stripe's blueprints.

OpenAI Agents SDK

Type: Open Source (MIT)
Stars: 27K (Python) + 3.1K (JS)
GitHub: https://github.com/openai/openai-agents-python
Origin: OpenAI, March 2025; production successor to the educational Swarm library

OpenAI's official agent framework. Swarm was the napkin sketch; Agents SDK is the production article. The core abstractions are unchanged — Agent (instructions + tools + handoffs), Runner (the loop), Handoff (transfer control to another agent) — but tracing, guardrails, sessions, MCP, sandbox agents (v0.14+), and async-first execution are all first-class. Provider-neutral via the Responses API; works against any OpenAI-compatible endpoint (Anthropic via the LiteLLM shim, Gemini, local vLLM).

Architecture

Agent — instructions + tools + handoffs; the unit of behavior
Runner — the conversation loop; runs an agent until completion or handoff
Handoff — transfer control to another agent, optionally with a structured payload
Sessions — persistent thread state across runs
Tracing — every step logged to OpenAI's dashboard (or your own backend)

Key Properties

Three of the four major model labs now ship a first-party agent framework — Anthropic Claude Managed Agents, Google ADK, and OpenAI Agents SDK. The convergence on the handoff primitive is striking: rather than rebuild LangGraph, the labs all settled on "agents that hand off to other agents, with the loop being unsurprising"
For teams not invested in the LangChain or Microsoft Agent Framework ecosystems, this is the de-facto OpenAI-shaped path
Gap: opinionated about the handoff model; teams that need a richer state-machine or graph topology will reach for LangGraph or Mastra instead

Google ADK (Agent Development Kit)

Type: Open Source (Apache 2.0)
Stars: 20K (Python) + 9.4K (samples)
GitHub: https://github.com/google/adk-python
Origin: Google, 2025

Google's official agent framework. Same Agent / Tool / Session shape as OpenAI Agents SDK and Strands, but with deep Gemini + Vertex AI integration and first-class Agent Engine / Cloud Run deployment templates.

Architecture

Agent — instructions, tools, sub-agents; same triad as the other first-party frameworks
Session / State — persistent context across turns and runs
Tools — first-party Vertex AI Search, BigQuery, Gemini code execution; user-defined Python tools; MCP support
Deployment templates — one-command deploy to Agent Engine, Cloud Run, or GKE

Key Properties

Samples repo (adk-samples, 9.4K stars) is unusually polished — production-grade reference agents for customer-service, RAG, code-review, and multi-agent decomposition
The right pick if you're already on GCP, paying for Gemini 3.x, or want Vertex AI Vector Search as the memory backend
Gap: Gemini-centered; provider-agnostic use is possible but the deployment ergonomics are the actual selling point and they're GCP-shaped

Strands Agents

Type: Open Source (Apache 2.0)
Stars: 5.9K
GitHub: https://github.com/strands-agents/sdk-python
Origin: AWS-incubated; model-driven agent SDK released 2025

AWS's answer to OpenAI Agents SDK and Google ADK. Strands ships 13+ model providers, native MCP, multi-agent composition, and an experimental bidirectional voice-streaming mode.

Architecture

Agent + tools + sessions — same model-driven shape as the other first-party SDKs
Multi-agent composition — agents-as-tools, agent graphs, supervisor patterns
Bidirectional voice streaming — early-access full-duplex audio path
Deployment templates — Lambda, Fargate, Bedrock AgentCore, EC2 with sane IAM defaults

Key Properties

The differentiator vs the OpenAI / Google SDKs is the deployment side — Strands templates deploy cleanly across the AWS surface with IAM wired by default
The natural choice for teams committed to AWS that would otherwise build on Bedrock Agents but want to avoid the lock-in
Gap: smaller community than OpenAI Agents SDK or ADK (5.9K vs 27K / 20K); third-party ecosystem (samples, blog posts, troubleshooting threads) is still catching up

Claude Agent SDK

Type: Open Source (MIT, Python) + Anthropic Commercial Terms (TypeScript)
Stars: 7K (Python) + 1.5K (TS)
GitHub: anthropics/claude-agent-sdk-python · anthropics/claude-agent-sdk-typescript
Origin: Anthropic, 2025 (formerly Claude Code SDK); renamed Sep 2025 once it was clear teams wanted the same harness without the coding-product framing

Anthropic's first-party agent SDK — the exact same harness that ships inside Claude Code, exposed as a library you can import into your own apps. Where OpenAI Agents SDK, Google ADK, and Strands Agents converge on the handoff primitive, Claude Agent SDK converges on the Claude Code primitives: a CLAUDE.md system-prompt loader, Skills (SKILL.md progressive disclosure), PreToolUse / PostToolUse / Stop / SessionStart hooks, the Task tool for sub-agent spawning, and built-in permission prompts for irreversible actions. The framing Anthropic uses internally: model = CPU, context = RAM, harness = OS, your app = the userspace program. Same model in two harnesses produces wildly different scores — Opus 4.5 hit 78% on CORE inside Claude Code and 42% inside Smolagents.

Architecture

CLAUDE.md — system-prompt assembly with path-glob matching and progressive loading
Skills — SKILL.md folders with metadata frontmatter; loaded on demand, ~50 tokens of metadata in context until invoked
Hooks — PreToolUse / PostToolUse / PreCompact / Stop / SessionStart for guardrails, formatters, telemetry
Sub-agents — Task tool spawns isolated-context children; only compressed summaries return to the parent
Permission prompts — first-class HITL gate on destructive actions; programmable via hooks for autonomous mode
MCP-native — every Skill or tool can be backed by an MCP server

Key Properties

The reference harness in 2026. Every other harness in this section is either explicitly modeled after these primitives (Deep Agents, Superpowers, GStack) or reimplements the same set under different names
The right pick if you're staying on Anthropic models and want Anthropic-shaped ergonomics. The CLAUDE.md / SKILL.md / hooks pattern is the most-copied design in agentic engineering
See Harness Engineering for the conceptual layer underneath this SDK — what a harness decomposes into and why Claude Code's harness wins on CORE
Gap: Anthropic-locked. The SKILL.md format itself is portable (Vercel Skills installs the same format into 51+ agents), but the SDK assumes Anthropic API conventions. Provider-neutral teams reach for Deep Agents instead

Deep Agents (LangChain)

Type: Open Source (MIT)
Stars: 23.3K
GitHub: langchain-ai/deepagents
Origin: LangChain, August 2025; v0.5 alpha April 2026 (async sub-agents, expanded multi-modal filesystem)

The closest open-source analog to Claude Code's harness, but model-agnostic and built on the LangGraph runtime. Where Claude Agent SDK is the Anthropic-shaped harness, Deep Agents is the batteries-included harness anyone can adopt on top of LangGraph 1.0: planning, virtual filesystem, sub-agents, summarization, and skills, all as composable middleware. The thesis is that harness engineering, not model selection, is the lever in 2026 — Vivek Trivedy's Feb 2026 post reports going from rank 30 to rank 5 on Terminal-Bench 2.0 holding GPT-5.2-codex fixed and only changing the harness.

Architecture

LangGraph runtime — state graph of nodes and edges; PostgresSaver checkpointer for durability, time-travel debugging, rewind/fork
Middleware — before_agent, wrap_model_call, before_tools, after_tools hooks compose like Express middleware. SummarizationMiddleware and FilesystemMiddleware are the headline ones
Sub-agents — isolated-context children spawned via the planning loop; compressed summaries returned to the parent
Virtual filesystem — tool results over ~20K tokens get offloaded to file paths, leaving a path + 10-line preview in context
Skills — SKILL.md format, same as Claude Code; loaded by description match

Key Properties

Pair with create_agent (LangChain 1.0 default factory, Oct 2025; supersedes the deprecated create_react_agent) to compose agent + middleware in idiomatic LangGraph
The right pick if you want Claude-Code-shaped ergonomics but need model neutrality, durable checkpointing, time-travel debugging, or first-class observability via LangSmith
The reference work for harness engineering as a discipline — read alongside The Anatomy of an Agent Harness (LangChain) and Trivedy's Better Harness hill-climbing recipe
Gap: LangGraph weight. You get durability, time-travel, and middleware for free, but the conceptual surface area is larger than Claude Agent SDK or Smolagents. Teams that just want "claude.messages.create with hooks" should start lighter

DSPy + GEPA

Type: Open Source (MIT, both)
Stars: 34.6K (DSPy) + 1.6K (GEPA)
GitHub: stanfordnlp/dspy · gepa-ai/gepa
Origin: Stanford NLP (Omar Khattab et al.), 2023; DSPy 3.0 in 2025; GEPA paper at ICLR 2026 (oral)

The "programming, not prompting" framework. DSPy treats LLM systems as programs with signatures, modules, and optimizable parameters (instructions, demos, weights), then uses an optimizer to compile them against your metric. GEPA — Genetic-Pareto — is the 2026 optimizer that put this approach back on the map: integrated as dspy.GEPA, it uses reflective evolutionary search over text parameters and beats RL-based optimization by 6 points with 35× fewer rollouts. The pitch is straightforward: if you have a metric (eval score, downstream accuracy, latency cost), you can programmatically improve the prompts and the agent topology that produced it. No vibes.

Architecture

Signature — typed input/output spec (question -> answer: str); the program's contract
Module — ChainOfThought, ReAct, custom — composed into programs like layers
Optimizer — compiles a program against your metric. BootstrapFewShot, MIPROv2, and now GEPA are the canonical ones
GEPA loop — reflect on rollouts → mutate text parameters → keep the Pareto frontier → repeat. Optimizes whole-program text, not just a single prompt
DSPy 3.0 — adds streaming, async, type-safe outputs, MCP, and the dspy.GEPA integration

Key Properties

The most rigorous answer to "how do I know my prompt is good?" — write a metric, compile against it, ship the artifact
GEPA's reflective-evolution approach is general: it optimizes whole programs (multiple prompts, control flow, sub-agent topologies) — not just a single prompt template
See Inspect AI for the eval-side counterpart; DSPy needs a metric, and Inspect is one place to get one with rigor
Gap: Activation energy. The mental model (programs + signatures + optimizers) is foreign to engineers used to writing prompts directly. The teams that benefit most are the ones already doing rigorous eval work — and most teams aren't there yet

Smolagents

Type: Open Source (Apache 2.0)
Stars: 27.5K
GitHub: huggingface/smolagents
Origin: HuggingFace, December 2024

A deliberately small code-agent framework. The whole library is ~1,000 lines of Python — designed to be hackable, readable, and used as a teaching tool for how a code-execution agent actually works. The differentiator vs JSON-tool-calling frameworks: smolagents agents write their actions as Python code snippets and execute them, which is closer to how frontier code agents (Claude Code, Codex) actually behave under the hood. Multi-modal, MCP-native, and works with any LLM that supports tool calling — but production-weak compared to Claude Agent SDK or Deep Agents.

Architecture

CodeAgent — the headline agent; writes Python code, executes it in a sandbox, observes results
ToolCallingAgent — fallback for JSON-mode-only models
Sandboxing — local Python execution by default; integrations for E2B, Docker, and HuggingFace Spaces
Model neutrality — any HuggingFace model, OpenAI, Anthropic, local via Ollama / vLLM

Key Properties

The fastest way to understand what a code-execution agent does — the codebase is short enough to read end-to-end in an afternoon
The Anthropic harness-comparison study used Smolagents as the floor (42% on CORE vs Claude Code's 78%, same Opus 4.5) — a useful reference for what "minimal harness" means in numbers
Bundled course: HuggingFace Agents Course walks through smolagents, MCP, and evals end-to-end with a free certificate
Gap: intentionally production-weak. No durable execution, no checkpointing, no observability beyond logs, minimal sub-agent orchestration. Treat it as a learning tool, then graduate to a real harness

OpenClaw

Type: Open Source
Stars: 374K (fastest-growing open-source project on GitHub)
GitHub: https://github.com/openclaw/openclaw
Origin: Created by Peter Steinberger (Austria), originally named Clawdbot (Nov 2025)

A self-hosted personal AI assistant platform that connects LLMs to real software via messaging platforms. Not a coding agent per se, but a general-purpose agent framework that can execute coding tasks among many other capabilities.

Architecture

Local-first Gateway — WebSocket-based control plane running locally, coordinating all connections
Multi-channel — WhatsApp, Telegram, Slack, Discord, Signal, Teams, Matrix, and 15+ more messaging platforms
Skills platform — Bundled, managed, and workspace-level skills for extensibility
Agent-to-agent coordination — Session tools for multi-agent communication
Device nodes — macOS, iOS, Android companion apps with system access
Browser control — Dedicated Chrome instance for web automation

Key Properties

Self-hosted — Runs entirely on your infrastructure, privacy-first
Messaging-native — Use your existing chat platforms as the interface (like Stripe uses Slack)
Voice capabilities — Wake words, continuous voice mode, ElevenLabs integration
A2UI (Agent-to-UI) — Live Canvas for agent-driven visual workspaces
NemoClaw — Nvidia-built security add-on with OpenShell sandboxing (released March 2026)
Role in agentic engineering: OpenClaw's messaging-platform integration mirrors how Stripe engineers invoke minions from Slack. Its self-hosted nature and multi-agent coordination make it a potential foundation for building an agentic engineering workflow, though it requires more custom configuration than purpose-built coding agents. The skills platform and agent-to-agent tools could power a Minions-like system where coding tasks are dispatched through familiar messaging channels.

The OpenClaw Ecosystem

OpenClaw has spawned a family of derivative projects and an entire hosting market:

Project	Language	Stars	Key Differentiator
OpenClaw	TypeScript	~355K	Dominant personal AI agent, multi-channel, multi-model
NemoClaw	Python/CUDA	N/A (NVIDIA)	Enterprise OpenShell, GPU guardrails, NVIDIA NIM
Hermes Agent	Python	~24.6K	Self-improving skill loop, RL fine-tuning via Atropos (now an independent project at 165K stars — see dedicated section)
IronClaw (NEAR AI, in OpenClaw ecosystem)	Rust	~2.7K	TEE-isolated agent runtime, encrypted credential vault, WebAssembly tool sandbox, sub-30s attestation, runs on NEAR AI Cloud's Confidential GPU Marketplace
ZeroClaw	Rust	20K+	Edge-first, 3.4-5MB binary, <50ms startup, container isolation
NanoClaw	TypeScript	Growing	~500 lines, auditable in 8 min, Agent Swarms, container-per-group

Hosting ecosystem: 30+ vendors now offer OpenClaw-compatible hosting across six tiers — from turnkey platforms (ZenClaw AI, KlausAI, Coral) to self-hosted infrastructure. See the Hosting & Execution Infrastructure page for the full vendor landscape.

The Steinberger School

"How would we build software in the future if tokens don't matter?" — Peter Steinberger

OpenClaw's founder runs the project as a deliberate experiment in token-unbounded agentic engineering — what he calls his AI Software Factory. The methodology has consolidated into a recognizable school with its own toolchain, idioms, and operational assumptions, distinct from the Stripe School (large-org devbox + blueprints), the Tan School (one-engineer skill packs + parallel worktrees), and the Walking Labs / Mastery School (validator-first methodology). Reported spend is around $1.3M/month across roughly 100 Codex instances in the cloud, operated by a team of ~3. That cost is the point of the experiment, not a bug — it's a working answer to "what's possible if inference cost stops being the binding constraint?"

The pattern is worth studying as a real-world counterpart to Stripe Minions. Steinberger's setup runs a Codex (or equivalent) agent on essentially every event in the project lifecycle:

Every PR is reviewed by Codex for quality, security, consistency
Every commit is scanned for security regressions (Vercel Deepsec + Codex Security)
Every new issue is read, classified, and — if it fits the documented vision — auto-converted into a PR (then reviewed by another Codex)
Every fix on main triggers a sweep to close old issues with exact commit references — that's what ClawSweeper does
Every meeting is monitored by an agent that proactively opens PRs for features being discussed as they're being discussed
Every comment is scanned for spam; offenders are auto-blocked
Performance benchmarks run on every change with regression alerts pushed to Discord
Setup recreation spins up ephemeral cloud machines via crabbox.sh, can log into Telegram, record a before/after fix video, and post it on the PR
Functional-unit code review via clawpatch.ai — semantic slicing rather than file-by-file linting

The supporting ecosystem (all open source, all by Steinberger / the OpenClaw org):

Project	What it does
crabbox.sh	Ephemeral test boxes — leased cloud capacity or BYO SSH host with diff sync, remote run, output streaming, evidence collection
clawpatch.ai	Automated code review via semantic feature slicing + explicit fix loop
ClawSweeper	Conservative issue/PR triage — six narrow close cases, never touches maintainer items
Discrawl (discrawl.sh)	Discord search & archive to SQLite, so a corpus of conversation is searchable from agents
CodexBar (github.com/steipete/CodexBar)	macOS menu-bar app showing AI coding limits + costs across providers
fs-safe (github.com/openclaw/fs-safe)	Root-bounded filesystem safety — agents physically cannot write outside the project root
peekaboo (peekaboo.sh)	macOS screen/control toolkit so AI agents can see and drive native desktop apps

The factory runs on a mix of model providers — Codex, Claude, Cursor, OpenCode, Kiro, Hermes Agent — picked per task. This is the inference-strategy pattern from Inference Strategy for Agents operating at production scale: cheap models for triage and routing, expensive ones for reasoning and code generation.

The lesson isn't "spend $1.3M/month" — it's that a small team with a comprehensive harness can run a project the size and quality of a much larger company. The token cost is the harness's externality; what's compounding is the operational leverage. See Harness Engineering for the principles; the Steinberger School is the most aggressive public example of those principles in production.

Crabbox

Type: Open Source
GitHub: https://github.com/openclaw/crabbox · Docs: https://crabbox.sh
Origin: OpenClaw org, Peter Steinberger maintains
Tagline: "Crabbox: warm a box, sync the diff, run the suite."

An agent workspace control plane for maintainers and AI agents. Crabbox sits between your dirty checkout and a remote runner — lease fast managed cloud capacity, BYO SSH host, or use any agent sandbox provider; sync the diff; run commands remotely; stream output; collect evidence; release the box. Native OpenClaw plugin: crabbox_run, crabbox_warmup, crabbox_status, crabbox_list, crabbox_stop.

Architecture

Go CLI on your laptop — local control surface
Cloudflare Worker broker — owns provider credentials and lease state, so secrets don't sit on your laptop
Managed or delegated runners — Blacksmith, AWS, Azure (Windows desktop + WSL2), Proxmox, Tensorlake, or any SSH host
GitHub Actions wrap — crabbox actions hydrate registers a leased box as an ephemeral Actions runner, so the repo's own workflow installs runtimes, services, and secrets — you get repo-faithful environments without rebuilding them in Crabbox

What's notable

Diff sync, not full clone — agents push only the changed files, so a 100-MB repo doesn't pay the 100-MB cost on every spawn
Failed boxes stick around for SSH — when a run breaks, the box is preserved so a human or an agent can shell in and debug
Durable run events — every phase emits a structured event; crabbox attach lets you live-replay a run that was launched headlessly
Cloudflare Access as the auth front door, so a single CF identity controls who can lease what
Active development — v0.3 added remote Linux + GitHub browser login + Blacksmith wrap; v0.12 added Azure Windows desktop, Proxmox, Tensorlake, preflight, failure bundles, phase timing

When to Pick Crabbox

You want reproducible ephemeral test environments without committing to one cloud vendor
You're already running OpenClaw or want a native plugin for agent box lifecycle
You need Windows desktop + WSL2 environments (most agent sandboxes are Linux-only)
You're hitting GitHub Actions runner pain (slow boots, missing tools, secret-management headaches) and want a faster, reproducible alternative
You want failed boxes preserved for SSH debugging rather than torn down

When to Pick Something Else

Pure short-lived code execution → E2B, Sprites.dev, Blaxel
You need git-style branching of sandboxes → Contree
Multi-tenant SaaS isolation guarantees → enterprise Northflank / Runloop

Clawpatch

Type: Open Source
GitHub: https://github.com/openclaw/clawpatch · Site: https://clawpatch.ai
Origin: OpenClaw org, Peter Steinberger
Tagline: "Review code. Patch bugs. Land PRs."

Automated code review built around semantic feature slicing rather than file-by-file linting. The premise: AI reviewers do better when the unit of review is a feature (with its entrypoints, owned files, nearby tests, and trust boundaries) than when it's a diff against main.

How the slicing works

Clawpatch maps a repo into semantic feature slices — bounded units of functionality with explicit entrypoints, owned files, adjacent tests, and trust boundaries. Each slice is reviewed by a provider with bounded context, findings are persisted, and an explicit fix loop attempts patches one finding at a time with validation.

This is the same principle as Harness Engineering § Unit tests are not verification: cross-component defects don't surface in file-by-file review for the same reason they don't surface in isolated unit tests. Reviewing a feature slice — entrypoint plus owned files plus adjacent tests — catches the interaction defects that file-by-file scanning misses.

Workflow

Map repo → feature slices
  → For each slice, review with provider (Codex / Claude / etc.)
  → Persist findings (slice → finding ledger)
  → Fix loop: pick one finding → propose patch → validate → land or reject

The fix loop is one finding at a time, with validation — that's a WIP=1 discipline applied to bug remediation.

Key Properties

Slicing > diffing — review surface area maps to functionality, not file boundaries
Persistent finding ledger — review state survives across runs; the same bug isn't re-reported every time
Validation-gated fixes — patches only land if validation passes, mirroring feature-list-as-primitive passing-state gating
Provider-agnostic — the slicer is the value; the model is swappable
Pairs with Crabbox — Clawpatch can validate fixes inside ephemeral Crabbox runners

When to Pick Clawpatch

You're shipping enough volume that file-by-file PR review is missing cross-component bugs
You want a review tool that improves with the codebase (the slice graph is what compounds) rather than starting from scratch each PR
You want the explicit per-finding fix loop, not just commentary
You're already in the OpenClaw ecosystem

When to Pick Something Else

You want a single-CLI in-terminal reviewer → CodeRabbit CLI, Continue
You need code review baked into CI pipelines without standing up another service → GitHub-native review tools

ClawSweeper

Type: Open Source
GitHub: https://github.com/openclaw/clawsweeper · Site: https://clawsweeper.bot
Origin: OpenClaw org, Peter Steinberger
Tagline: "Conservative maintenance bot for OpenClaw repositories."

A purpose-built issue / PR triage bot that scans every open item against the current main and proposes closures with explicit references. It's small but worth its own entry because it's the cleanest public example of a conservative maintenance automation pattern — one that maintainers can actually trust on a 7,000-issue repo.

The six narrow close cases

ClawSweeper will only propose closing an issue or PR if it falls into one of:

Implemented — an exact commit reference on main resolves it
Not reproducible — fresh attempts can't surface the reported behavior
Duplicate — a cluster references the same root cause
Out-of-scope — sits outside the documented project vision
Incoherent — incomplete, malformed, or ambiguous beyond rescue
Stale — older than 60 days with no engagement

Maintainer-authored items, items with open referencing PRs, and items with protected labels are never auto-closed. The bar is "Codex returned a structured decision and the decision survives a live GitHub re-fetch."

The apply lane

Normal mode is proposal-only — Codex makes a structured decision, the bot writes it to items/<number>.md, and a human can read the ledger before anything happens.

The apply lane runs every 15 minutes. Before commenting or closing, it re-fetches live GitHub state, checks labels, maintainer authorship, paired issue/PR state, snapshot drift, and repository profile rules. "Most cycles produce zero closes" — the design center is restraint, not throughput. Refuses to apply any change if the underlying review left junk in the working tree.

Key Properties

Conservatism as a feature — most automation closes too aggressively and erodes maintainer trust; ClawSweeper closes ~nothing per cycle and that's correct behavior
Codex-backed but git-grounded — Codex makes the call, but the final gate is a live GitHub re-fetch and a working-tree-clean check
Persistent decision ledger at items/*.md — every decision is auditable, reversible, and re-runnable
Specifically built for the Steinberger School pattern — when 100 Codex agents are landing fixes on main, you need something proactively closing the old issues those fixes resolve, with exact references

When to Pick ClawSweeper

You have a long-running OSS repo with 1,000+ open issues, most of which are probably stale or implemented
You want triage that maintainers actually trust (the design assumes they don't)
You want issue closures that reference the commit that closed them — searchable institutional memory
You're running OpenClaw or any project that adopts the same automation patterns

When to Pick Something Else

You need PR triage specifically (review, merge automation) — Clawpatch is closer to that
You want a hosted SaaS — ClawSweeper is built to run from your own repo as a GitHub workflow

Hermes Agent

Type: Open Source (MIT)
Stars: 165K (released February 25, 2026; crossed 95K in seven weeks, 165K by mid-May — the fastest-growing OSS agent framework of 2026)
GitHub: https://github.com/NousResearch/hermes-agent
Docs: https://hermes-agent.nousresearch.com/docs/
Origin: Nous Research — the lab behind the Hermes language-model series, Atropos, Nomos, and Psyche
Tagline: "The agent that grows with you."

Hermes is the rare agent project shipped by a model lab, which is what gives it its particular shape. Nous Research already trains the Hermes 3/4 model line, the Atropos RL framework, and a distributed-training stack. Hermes Agent is what they get when they assemble those pieces into a runtime that compounds across sessions: an agent that distills its own skills, curates them on a cadence, builds a model of its operator, and feeds its own trajectories back into model training.

It also matters as the inverse-twin of OpenClaw and GBrain. All three share a "personal agent with persistent memory" framing, but Hermes is the one where the model line and the agent are vertically integrated. That integration shows up in concrete places: the Curator's rubric design, the Atropos environments shipped with the agent, the RL training loop available out of the box.

The closed-loop skill learning system

Most agents are static — same harness, same skills, same behavior on day 1 and day 100. Hermes runs two nested learning loops:

Inner loop (per turn). After every turn, a rubric-driven self-improvement step decides what memories and skills to save, update, or discard. The threshold isn't time-based — it's complexity-based. When a task crosses ~5 tool calls or a configurable complexity threshold, Hermes writes a Markdown skill document automatically: the procedure followed, pitfalls encountered, and verification steps used. Next time a similar task fires, Hermes starts from that file rather than reasoning from scratch.

Outer loop (the Curator, every 7 days). v0.12 (April 30 2026) added an autonomous background agent that runs on the gateway's cron ticker and does library-wide maintenance:

Grades skills by usage — what's actually been called, what's been ignored
Consolidates overlapping skills — merges near-duplicates with a model + heuristic
Prunes dead skills — classified consolidated-vs-pruned via model + heuristic; archived rather than deleted, so nothing is destructive
Patches active skills — refines the markdown of frequently-used skills based on the rubric
Writes per-run reports to ~/.hermes/logs/curator/<timestamp>/REPORT.md — human-readable summary showing which skills transitioned, what the reviewer said, and which skills it patched

The agent's behavior drifts toward what it's been doing well and away from what it's been doing badly, without explicit human curation. Most "self-improving" claims in the agent space are loose; Hermes is the rare implementation with an explicit cadence, a rubric, persisted decisions, and an audit log.

Three-layer memory architecture

Hermes splits memory into three layers, each living in a specific file and serving a different purpose:

Layer	Storage	Purpose
Frozen identity	`~/.hermes/SOUL.md`, `~/.hermes/memories/MEMORY.md`, `~/.hermes/memories/USER.md`	Persona + frozen facts. Loaded into every system prompt. Rewritten rarely, by the operator or the soul-audit skill.
Episodic (skills)	`~/.hermes/skills/*.md`	Procedural memory — one markdown file per learned skill, with description, triggers, steps, verification. Surfaced via FTS5.
Session search	`~/.hermes/state.db` (SQLite + FTS5)	Every message ever sent in any session, full-text searchable. Agent calls `session_search` to retrieve past conversations.

Sub-10ms retrieval even at 10,000+ skill documents. The architecture maps almost exactly onto the Harness Engineering § State subsystem pattern: durable cross-session knowledge in plain text, indexed for retrieval, separable from the conversation history.

The user model is the real differentiator vs Mem0/Letta/Zep. Hermes builds a drift-adjusting representation of the operator's preferences — what topics matter, what language patterns to mirror, what's been tried before and rejected. Honcho (the user-modeling provider) runs a three-agent pipeline that builds a persistent "dialect" of each user. This is the layer most simpler memory frameworks omit, and it's the layer that makes Hermes feel like an agent that knows you after a month, not just one that remembers what you said.

The 70+ built-in tools (28 toolsets)

Hermes ships an unusually large standard library. v0.10 bundled 40+ tools as portable markdown; current ships ~70 across 28 toolsets covering MLOps, GitHub, research, scraping, code execution, and more. The point of bundling so much: the agent's "blank-slate" capability surface should be wide enough that it can be useful immediately on day 1, not after weeks of skill accumulation. The Curator then narrows and refines that surface based on what the operator actually uses.

The tool surface is portable markdown — not Python tool definitions — so the agent can read, modify, and version its own toolset the same way it reads, modifies, and versions its own skills. This is unusual: most frameworks treat tools as code, skills as data; Hermes treats both as markdown and lets the same loops manage both.

Six terminal backends, six layers of trust

Hermes abstracts code execution behind a terminal backend interface with six implementations:

Backend	Use case	Trust / cost
Local	Cheapest, fastest, no isolation	Trusted local work
Docker	Container isolation on the same host	Mostly trusted, fast
SSH	Run on a remote server you control	Trusted operator-managed infra
Daytona	Managed agent sandbox	Untrusted code, sub-100ms cold start
Singularity	HPC-style container	Research compute clusters
Modal	Serverless GPU sandbox	Heavy compute, GPU work

The agent picks the right backend per task. This is the executable version of Harness Engineering § Environment subsystem — instead of choosing one sandbox and committing, Hermes treats the choice as a tool-call parameter. The same agent can shell into your local dev machine for cheap edits and spawn a Modal A100 for a fine-tune.

Multi-platform gateway

A single gateway process exposes Hermes through six channels — Telegram, Discord, Slack, WhatsApp, Signal, CLI — with shared state across them. The same conversation can start in Slack, continue in Telegram, and resolve in the CLI without losing context. This is operationally significant: it makes Hermes a viable replacement for a human assistant who's also reachable wherever you are.

The pattern echoes OpenClaw's messaging-native design: both treat messaging surfaces as first-class agent interfaces, not afterthoughts. The difference is that Hermes does it as a single Python process rather than a federation of device nodes.

The Atropos / RL connection

This is where the model-lab origin shows. Hermes Agent ships with Atropos — Nous Research's distributed RL framework — wired in by default:

Every task execution emits a trajectory: tools used, what failed, what succeeded, the outcome
Trajectories are stored as training data
Atropos provides a trajectory API server + Tinker training service + Python environment classes defining tasks, scoring, and reward functions
An integrated RL training pipeline (Tinker-Atropos with GRPO + LoRA adapters) lets you train an LLM on the actual environment Hermes is running in

In Hermes 4 training, Atropos drives rejection sampling across ~1,000 task-specific verifiers to filter for high-quality reasoning trajectories. The same machinery is exposed to operators — you can fine-tune your local model on the trajectories your agent has produced. Most agent frameworks treat the model as fixed; Hermes treats the model as another component the agent maintains.

Pairing with GBrain

Hermes is one of GBrain's two reference host platforms (alongside OpenClaw). The relationship is straightforward: Hermes is the agent; GBrain is the brain. Hermes handles the run loop, the platform gateway, the skill library, the terminal backends, and the user model. GBrain handles the knowledge graph, the persistent markdown corpus, the typed entity relationships, and the Postgres-native Minions job queue.

If you only run Hermes: you get cross-session memory and self-improving skills, but no structured knowledge graph and no durable background job system.

If you only run GBrain: you get the knowledge graph and job queue, but you're picking your own host agent.

Run them together — Garry Tan's documented setup — and Hermes's per-turn skill learning compounds with GBrain's per-write graph extraction. Skills point at brain pages; brain pages reference skills; the user model adapts based on what's in both.

Comparison vs OpenClaw

Both are personal AI agent platforms with messaging-native interfaces, multi-model support, and a "you run it yourself" assumption. The differences:

	OpenClaw	Hermes Agent
Origin	Independent OSS (Peter Steinberger)	Model lab (Nous Research)
Architecture	WebSocket gateway + federated device nodes	Single Python gateway process
Memory	Skill marketplace (ClawHub) + per-workspace storage	Three-layer memory baked in (SOUL/MEMORY/USER + skills + SQLite session search)
Self-improvement	Plugin-based (e.g., NemoClaw)	First-party Curator running on a 7-day cycle, with rubric and audit log
Model loop	Bring-your-own-model	Hermes 3/4 + Atropos RL training built in (any model still works)
Communities	374K stars, sprawling skill marketplace, 30+ hosting vendors	165K stars, tight model-lab-driven release cadence, awesome-hermes-agent tracks the ecosystem
Best fit	Maximum extensibility, multi-device companion apps	Vertically-integrated stack, RL-curious operators, model-training-as-feedback

They're complements as often as alternatives — Steinberger's own setup runs Hermes Agent as one of the underlying engines for OpenClaw work.

When to Pick Hermes Agent

You want a long-running personal agent with cross-session memory and skill accumulation, not a per-task coding tool
You want the agent to improve over time without explicit skill engineering — and you want an audit log of how it improved
You operate in Telegram / Discord / Slack and want the agent reachable there
You're invested in the Nous Research model line and want the agent's trajectories to feed model training
You want a single-process operational footprint rather than a federated mesh of device nodes
You want to pair with GBrain for structured knowledge + durable background jobs

When to Pick Something Else

You need a coding-specific harness → Claude Code + GStack / Superpowers, OpenHands, or Vercel Open Agents
Multi-tenant production where the operator isn't a single trusted user → Claude Managed Agents or a custom harness
Strong audit / compliance requirements — single-operator framing isn't the design center
You want the maximum-extensibility skill marketplace and don't care about the model-loop integration → OpenClaw
You're not running a model lab and don't need the Atropos RL machinery — Hermes still works without it, but the model loop is a chunk of the value you'd be ignoring

Mental model: an agent that the model lab uses on itself

Strip away the implementation details and the cleanest framing of Hermes is this: it's what a model lab builds when they want an agent whose own behavior is a data source for training the next model in the line. Skills are the medium for cross-session learning; trajectories are the medium for cross-version learning; the user model is the medium for cross-deployment learning. Each of the three feeds back into the others, and Atropos feeds the whole system into model training.

Whether that vertical integration matters to you depends on whether you want an agent that runs your model, or an agent that exists to make models better. Hermes is the second thing first, and an excellent personal agent second — but the things that make it interesting as a personal agent (the Curator, the user model, the trajectory capture) are exactly the things the model-training side needs to function.

Claude Managed Agents

Type: Commercial / Managed Service (Public Beta)
Launched: April 8, 2026
Vendor: Anthropic
Docs: https://platform.claude.com/docs/en/managed-agents/overview
Pricing: Model tokens + $0.08 per agent runtime hour
Early adopters: Notion, Rakuten, Asana

Anthropic's vertically integrated agent platform. Bundles the agent harness, sandboxed container, built-in tools, memory, and state persistence into a REST API — eliminating the need to build your own agent loop, tool execution layer, or runtime.

Architecture

Claude Managed Agents is built around four concepts:

Agent — The model, system prompt, tools, MCP servers, and skills (created once, referenced by ID across sessions)
Environment — A configured container template with pre-installed packages (Python, Node.js, Go, etc.), network access rules, and mounted files
Session — A running agent instance within an environment, performing a specific task and generating outputs
Events — Messages exchanged between your app and the agent (user turns, tool results, status updates), streamed via Server-Sent Events

Built-In Tools

Bash — Run shell commands in the container
File operations — Read, write, edit, glob, grep
Web search and fetch — Search the web and retrieve content from URLs
MCP servers — Connect to external tool providers

Key Properties

Long-running autonomy — Agents can run for hours in the cloud without human interaction
Stateful sessions — Persistent file systems and conversation history across multiple interactions
Built-in prompt caching and compaction — Performance optimizations baked into the harness
Steerable mid-execution — Send additional user events to guide or interrupt the agent
Research-preview features — Outcomes, multi-agent, and memory capabilities (gated access)
Rate limits — 60 create requests/min and 600 read requests/min per organization

Why This Is a New Category

Claude Managed Agents represents a fundamentally new market layer (see Sandboxes: Market Structure for the four-layer model). Where previous agent platforms required you to assemble inference + sandbox + harness + memory separately, Claude Managed Agents bundles all four into a single API — with the model provider as the operator.

This is disruptive to the Layer B agent-sandbox market: teams that would have used E2B + LangGraph + Pinecone + their own loop can now make one API call instead. The trade-off is vendor lock-in: moving off Claude Managed Agents to a self-built stack requires re-implementing session management, memory, tool execution, and sandbox lifecycle.

When to Pick Claude Managed Agents

You want the fastest time-to-market for a coding or task agent
Your workflow is a good fit for the built-in tools (bash, file ops, web search, MCP)
You don't need GPU-heavy execution (not exposed)
You're OK with multi-tenant SaaS (not for heavily regulated data)
You don't need custom branching / tree-search / best-of-N semantics

When to Pick Something Else

You need specialized branching semantics → Contree
You need GPU in the sandbox → Modal, Daytona, Northflank
You need enterprise VPC → Northflank, Runloop, or self-hosted
You're building an agent infrastructure product → Layer B sandbox + custom harness

Related Offerings

Messages API — Direct model access for custom agent loops with full control
Claude Code — Anthropic's own coding agent using the harness internally
Claude Cowork — Enterprise collaboration tier with managed agents

Vercel Open Agents

Type: Open Source Template (MIT)
Stars: 5.5K
GitHub: https://github.com/vercel-labs/open-agents
Demo: https://open-agents.dev
Template: https://vercel.com/templates/template/open-agents

Vercel's reference architecture for building cloud coding agents. Open Agents is not a hosted product — it's a forkable, customizable MIT-licensed template that ships a complete cloud agent system: web UI, durable workflow runtime, sandbox orchestration, and GitHub App integration. Deploy it to Vercel in minutes, then modify it to fit your use case.

Architectural Principle: "The Agent Is Not the Sandbox"

The most important design decision in Open Agents: the agent executes outside the sandbox, not within it. The agent runs as a durable workflow on Vercel's Workflow SDK. The sandbox is only the execution environment for code the agent wants to run.

This separation matters because:

Agent execution decouples from request lifecycles — Chat turns can span many persisted workflow steps that survive request timeouts
Sandbox hibernates and resumes independently — Sandbox goes to sleep without killing the agent
Model/provider flexibility — Swap models without touching the sandbox
Sandbox stays single-purpose — It's an execution environment, not a control plane

Three-Layer Architecture

Web Layer — Next.js app handling auth, sessions, chat UI, streaming. Built on Vercel AI SDK + Chat SDK.
Agent Workflow — Durable workflow execution via Vercel Workflow SDK. Streaming, cancellation, persistent state across multi-step runs. Reconnectable streams.
Sandbox VM — Vercel Sandbox (Firecracker microVM) with filesystem, shell, git, dev servers. Exposes ports 3000, 5173, 4321, 8000. Snapshot-based resume. Hibernates after inactivity.

Repo Structure

apps/web         — Next.js, workflows, auth, chat UI
packages/agent   — agent loop, tools, subagents, skills
packages/sandbox — sandbox abstraction + Vercel integration
packages/shared  — utilities

Agent Capabilities

Tool suite — File read/write/edit, grep/glob search, shell commands, task management, web fetch, skill invocation
Skills system — Modular agent skills in .agents/skills with a skills-lock.json for versioning (compatible with vercel-labs/skills npx skills)
Subagents — Multi-agent coordination built in
Repo cloning — Clone any GitHub repo into the sandbox, work on branches
Auto-commit / auto-PR — Optional, preference-driven (not always on). Can open PRs with summaries.
Session sharing — Read-only share links for audit/review
Voice input — ElevenLabs transcription for spoken commands
MCP tool support — Connect external tools via Model Context Protocol

Stack

Frameworks: Next.js, Tailwind CSS
SDKs: Vercel Workflow SDK, Vercel AI SDK, Vercel Chat SDK
Database: PostgreSQL (required) — works with Neon by default
Cache: Redis/Upstash KV (optional, for metadata)
Package manager: Bun (local dev)
Runtime: 99.3% TypeScript

Deployment Environment Variables

Minimum: POSTGRES_URL, JWE_SECRET
Recommended: ENCRYPTION_KEY + Vercel OAuth credentials
Full-featured: GitHub App (ID, client secret, private key, webhook secret)
Optional: Redis/KV, ElevenLabs API, custom sandbox snapshots

GitHub App Integration

Uses the GitHub App's user authorization flow:

Repository access via installation
Private repo cloning
Branch pushing
PR creation with automated summaries
Webhook events for status updates

Organization-level installations require the app to be public.

Why This Matters

Open Agents is significant because it codifies a production-ready cloud agent architecture in an MIT-licensed template. Teams that would otherwise spend weeks assembling a web UI + durable workflow + sandbox + GitHub integration can fork Open Agents and customize it. It's the "reference implementation" for the Vercel Agents platform (AI Gateway + Workflow + Sandbox) and a pragmatic starting point for building Claude Managed Agents / Stripe Minions-style systems on Vercel infra.

When to Pick Open Agents

You want a production-ready starting point instead of building from scratch
You're already on Vercel or want to be
You want full control over the agent harness (unlike Claude Managed Agents)
You want the "agent outside the sandbox" architectural pattern
You need durable multi-step workflows with streaming
You want GitHub App integration out of the box

When to Pick Something Else

Fastest time-to-market with zero infra → Claude Managed Agents
Tree-search / branching-heavy workflows → Contree + custom harness
Non-Vercel deployment target → AgentField or a custom stack
Heavy GPU requirements → Modal-based harness instead

Related Vercel Agent Products

Open Agents is the community template. Vercel also ships a broader Vercel Agents platform that includes:

AI Gateway — Unified endpoint for model routing, provider failover, embeddings (see Inference)
Vercel Sandbox — Firecracker microVM execution (see Sandboxes)
Vercel Workflow SDK — Durable execution primitives
Vercel AI SDK — TypeScript toolkit for streaming, tool use, structured outputs
Vercel Agent — Stack-aware agent for the Vercel platform itself

Open Agents stitches these together into a reference application — it's both a product demonstration and a production-ready template.

OpenAI Symphony

Type: Open Source (Apache 2.0)
Stars: 25K
GitHub: https://github.com/openai/symphony
Origin: OpenAI, released as engineering preview
Reference: https://www.latent.space/p/harness-eng

Symphony transforms project work into isolated, autonomous implementation runs. Rather than supervising coding agents, teams manage work at a strategic level — agents autonomously complete tasks, collect proof of work, and manage PR lifecycles.

Architecture

Symphony has a 6-layer architecture built on Elixir/BEAM:

Policy layer — Enforcement rules (e.g., "CI must pass before merge")
Configuration layer — Environment setup and agent provisioning
Coordination layer — Work distribution, task queuing, agent assignment
Execution layer — Agent runtime with isolated worktrees per task
Integration layer — External system connections (Linear, GitHub, Slack)
Observability layer — Tracing, metrics, logging across all agent activity

Key Properties

Work queue monitoring — Watches task boards (e.g., Linear) and spawns agents for new assignments
Proof of work — Agents produce CI status, PR feedback, complexity metrics, and walkthrough videos
Rework state — If a PR isn't mergeable, trash the worktree and restart from scratch
Daily improvement loops — Agents analyze session logs to identify areas for improvement
Self-ticketing — Agents cut their own follow-up tickets
Spec-driven — Distributed as a formal specification (SPEC.md) that teams implement in any language
Elixir reference implementation — BEAM runtime chosen for process supervision, gen servers, and resumability
Human role shift — From code review to 1-2x daily yes/no decisions on batched PRs

Harness Engineering Context

Symphony assumes codebases have adopted "harness engineering" — robust test suites, CI/CD, and safety mechanisms that give agents the feedback loops they need. It represents the next evolution: from agent supervision to work-level management.

Results (from Latent Space interview)

1M+ lines of code, 1,500+ PRs, zero manually written code over 5 months
Team of 3 managing output equivalent to much larger teams
Before GPT-5.2: 3.5 PRs/engineer/day; after: 5-10 PRs/engineer/day
500 NPM packages in codebase (described as "10,000 engineer level architecture")

PostHog Code

Type: Commercial — beta May 2026, GA Spring 2026
Form factor: Desktop app + agent framework (public monorepo)
Vendor: PostHog
Page: https://posthog.com/code
Docs: https://posthog.com/docs/posthog-code
GitHub: https://github.com/PostHog/code
Models: OpenAI (GPT-5.x), Anthropic (Claude Sonnet / Opus / Haiku)
Integrations: GitHub, Linear, Slack, CRM/billing — and PostHog itself via MCP

PostHog's bet is that the missing context for autonomous coding isn't more of the codebase — it's production. PostHog Code is a local desktop app that connects to your repos and runs a swarm of coding agents reading in-app events, error logs, session recordings, funnel analytics, experiment results, and support tickets from a running PostHog install. "Obvious" fixes ship automatically; everything else lands on a prioritized to-do list so engineers steer the high-impact decisions. The pitch: "the only AI devtool that understands your product, not just your codebase." It's the explicit centerpiece of PostHog's "self-driving products" thesis — agents that ship while you sleep.

Architecture

Desktop app — Runs locally, connects to repos; not a hosted SaaS agent
Public monorepo — posthog/code ships both the desktop apps and the underlying agent framework
Production-data ingestion — Signals pulled directly from PostHog: events, errors, replays, funnels, experiments, support tickets
Swarm topology — One agent writes code, another writes tests, another reviews PRs, another manages tickets (per PostHog leadership's "machine team" framing)
Prioritized work queue — Auto-ships fixes that meet a confidence threshold; surfaces the rest as a ranked to-do list
Self-instrumenting PRs — Generated diffs include PostHog event-capture, error boundaries, feature flags, and experiment scaffolding so the next iteration has even more signal
MCP-fronted integrations — GitHub for PRs, Linear for tickets, Slack for routing, CRM/billing for revenue impact; PostHog also exposes itself via MCP so external agents (editor, chat) can query analytics and create experiments

Key Properties

Product-first context — First coding agent to treat product analytics, not just the repo, as primary context
Closed feedback loop — Each shipped PR adds instrumentation that feeds the next agent run
Proactive vs. prompted — Surfaces bugs from production telemetry rather than waiting for an engineer to file them
Auto-ship vs. queue split — Confidence-gated automation, with humans kept in the loop for the non-obvious work
Local-first — Desktop form factor (vs. cloud-only agents); the framework is also runnable standalone
Multi-provider — Frontier models from OpenAI and Anthropic side-by-side
Bring-your-own-PostHog — Value proportional to how well-instrumented the existing product already is

Where it fits

Within the commercial coding agents cohort, PostHog Code is the analytics-native counterpart to Stripe Minions (internal-tools-native via Toolshed MCP) and OpenAI Symphony (work-queue-native via Linear). Claude Managed Agents and Vercel Open Agents operate purely from the repo and CI; PostHog Code is the first entrant whose primary feedback signal is the deployed product itself. Its swarm topology (code / tests / review / tickets) and confidence-gated auto-ship loop also put it close to OpenAI Symphony's work-management posture, but with a desktop app rather than a BEAM-based hosted runtime.

Rivet Sandbox Agent

Type: Open Source
Stars: 1.4K
GitHub: https://github.com/rivet-dev/sandbox-agent

Universal HTTP API to run any coding agent (Claude Code, Codex, OpenCode, Amp) in isolated sandboxes. The infrastructure layer for building a Minions-like system.

Architecture

Universal agent API — Single HTTP interface for any coding agent
Multi-runtime — E2B, Daytona, Modal, Docker support
Session management — Persistent sessions with event streaming
Audit logging — Full audit trail for compliance

Key Properties

Devbox equivalent — Best open-source match for Stripe's sandbox infrastructure
Composable — Combine with any agent and orchestrator
Gap: Infrastructure layer only, not a complete autonomous agent

DeerFlow

Type: Open Source
Stars: 69K
GitHub: https://github.com/bytedance/deer-flow
Origin: ByteDance; DeerFlow 1.0 in 2025, DeerFlow 2.0 launched March 2026
Description: "An open-source long-horizon SuperAgent harness that researches, codes, and creates."

ByteDance's bet on the SuperAgent pattern: a lead agent decomposes a request, spawns parallel subagents into their own sandboxes with their own context, and aggregates results. Comparable in spirit to OpenAI Symphony and AgentField, but built on LangGraph and provider-agnostic via LangChain (OpenAI, Anthropic, Gemini, DeepSeek, ByteDance Doubao, OpenRouter).

Architecture

SuperAgent + subagents — lead receives the goal, decomposes into subtasks, spawns parallel subagents in isolated sandboxes
LangGraph-based workflow — stateful graph orchestration; integrates web search, crawling, Python execution, RAG retrieval, and MCP tool invocation
Docker / Jupyter sandboxes — agent-generated code runs isolated from the host (see Sandboxes)
Skill system (added in 2.0) — reusable agent capabilities composable across runs: web research, data analysis, content generation, image creation, custom
Persistent state memory — structured memory store beyond the LLM context window
Message gateway — subagent communication and coordination

Key Properties

Big Tech OSS — backed by ByteDance, comparable scale to Alibaba's OpenSandbox; demonstrates that the SuperAgent + sandbox + memory + skills pattern is converging cross-vendor
Long-horizon focus — designed for tasks that take minutes to hours, not single-turn responses
Multi-model out of the box via LangChain, so the same harness can mix cheap routers and expensive reasoners (see Inference Strategy for Agents)
Not coding-specific — handles research, creative work, and coding from the same harness; closer to OpenAI Symphony than to Claude Managed Agents in scope

When to Pick DeerFlow

You want a single open-source SuperAgent that handles mixed research / coding / content work
You're invested in the LangGraph / LangChain ecosystem
You want a Big-Tech-backed OSS framework rather than a startup project
You need long-horizon execution (hours) with subagent coordination and persistent memory in one package

When to Pick Something Else

Pure coding workflow on Claude → GStack + Conductor
Vertically integrated managed offering → Claude Managed Agents
You want an Elixir/BEAM-backed reference architecture → OpenAI Symphony
Strong typed-state agent supervision with three nested failure loops → AgentField

GStack

Type: Open Source (MIT)
Stars: 102K
GitHub: https://github.com/garrytan/gstack
Origin: Garry Tan (President & CEO, Y Combinator), released March 2026
Companion site: https://gstacks.org/

Garry Tan's exact Claude Code setup, open-sourced as a SKILL.md pack. Installing it gives Claude Code 23 specialist personas — CEO, Designer, Eng Manager, Release Manager, Doc Engineer, QA — each as a SKILL.md file with an explicit workflow and verification standard. This is the most-cited public example of harness engineering packaged as a one-command install, and one of the fastest-growing OSS AI repos of the year.

Install

git clone --single-branch --depth 1 https://github.com/garrytan/gstack.git \
  ~/.claude/skills/gstack && cd ~/.claude/skills/gstack && ./setup

Requires a Claude Pro or Team subscription (Claude Code itself).

The 23 skills

Workflow-defining: /office-hours (YC-style forcing-question reframe + builder-mode brainstorm), /plan-ceo-review, /plan-eng-review, /plan-design-review, /design-consultation, /design-shotgun, /design-html, /design-review, /review, /qa, /qa-only, /ship, /land-and-deploy, /canary, /benchmark, /browse, /open-gstack-browser, /setup-browser-cookies, /setup-deploy, /setup-gbrain, /sync-gbrain, /retro, /investigate, /document-release, /document-generate, /codex, /cso, /autoplan, /pair-agent, /careful, /freeze, /guard, /unfreeze, /gstack-upgrade, /learn.

Recommended workflow loop

/office-hours (reframe the product) → /plan-ceo-review + /plan-eng-review (architecture, data flow, failure modes, tests) → build → /review (find production bugs) → /qa (open a real browser, iteratively fix bugs, commit each fix atomically) → /ship (sync with main, run tests, open PR) → /retro.

Key Properties

YC-CEO-grade prompts — each skill is a battle-tested SKILL.md with explicit verification standards. The intellectual content (not just the structure) is the differentiator.
Persona-first — every command is bound to a specialist role with permission boundaries and a definition-of-done.
Pairs with Conductor — Garry's reported workflow is gstack inside Conductor, running 10–15 parallel sprints across Claude Code worktrees on a single Mac. He reports 600K production LOC in 60 days using this combination.
Browser policy — /browse replaces direct Chrome DevTools MCP usage; the skill encodes how to use it correctly so the agent doesn't reinvent the wheel.
Skills standard — uses the cross-agent SKILL.md format documented in Skills, Plugins & Marketplaces, so it also works in Codex, Cursor, OpenCode, etc. via npx skills add.

When to Pick GStack

You want a working harness today, not a framework to build one
Your work is product/web-application development (where the personas were tuned)
You're willing to adopt one opinionated workflow rather than wire your own
You want to pair with parallel-worktree runners like Conductor or Superset

When to Pick Something Else

Highly novel algorithms, hardware-adjacent code, or heavily regulated domains — Garry himself notes the gains are much smaller here
You need a runtime control plane with hooks, gates, and a GUI → AgentHub instead, or wire the harness yourself per Harness Engineering
Non-Claude-Code agent → Mostly portable via SKILL.md, but some commands assume Claude Code's tool set

Superpowers

Type: Open Source (skills framework)
Stars: 205K (one of the fastest-growing OSS AI projects of 2026)
GitHub: https://github.com/obra/superpowers
Origin: Jesse Vincent (creator of Request Tracker, ex-Perl-5 release manager, co-founder Keyboardio) and Prime Radiant. Built the first version in October 2025, the same week Anthropic shipped the Claude Code plugin system.

A software-development-methodology shipped as a skills framework. Where GStack is "Garry's exact setup" optimized for product/web work, Superpowers is the opposite framing: "Instead of making the agent smarter, enforce the discipline that human developers spent decades building."

What it actually enforces

Brainstorming-first — A brainstorming skill activates before code is written: refines rough ideas through dialogue, explores alternatives, presents the design in sections for human validation, and saves a design document. The agent isn't allowed to skip this.
Bite-sized tasks — After design approval, work is broken into 2–5-minute units with exact file paths, complete code context, and verification steps. This is the WIP=1 / feature-list-as-primitive discipline from Harness Engineering, packaged as a workflow.
TDD enforcement — Tests come before implementation, enforced as a skill, not just documented.
Autonomous subagents — Long execution is delegated to subagents that report back; the main session stays focused on direction.

Key Properties

Composable skills + an initial instruction set that ensures the agent actually uses them
Works across Claude Code, Codex, and Cursor via per-host plugin manifests in the repo (.cursor-plugin/, .codex-plugin/)
Methodology, not just templates — the design-then-implement gates are the differentiator
Authored by someone who's been shipping production OSS for 25+ years, which is unusual signal in this space

When to Pick Superpowers vs GStack

Superpowers when the team is shipping novel/research-y software and benefits from forcing-function design gates and TDD
GStack when the team is shipping product/web apps and benefits from YC-CEO-grade prompts tuned for that domain
They can run side-by-side — both install as skills in ~/.claude/skills/, and a skill router can pick per-task

Everything Claude Code

Type: Open Source (MIT)
Stars: 190K
GitHub: https://github.com/affaan-m/ECC
npm: ecc-universal (full pack) · ecc-agentshield (security audit standalone)
Origin: Affaan M., shipped at the Cerebral Valley × Anthropic Claude Code Hackathon (Feb 2026); reached v2.0.0-rc.1 April 2026
Also known as: ECC (the repo was renamed from everything-claude-code to ECC in 2026; the README now describes ECC as the brand, with no canonical acronym expansion)

Positioned by the README as "the harness-native operator system for agentic work." Where GStack / Superpowers / GBrain / AgentHub each pick a single angle (product workflow, design discipline, persistent memory, GUI control plane), ECC is the everything-bundle: subagents + skills + hooks + MCP configs + language rules + a security-audit subsystem, with installer adapters across Codex, Claude Code, Cursor, OpenCode, Gemini, Zed, and GitHub Copilot.

Scope

The pack ships, per the v2.0 README:

63 subagents for delegated tasks (planning, review, refactor, security, language specialists)
249 skills — SKILL.md-style workflow definitions
Hook automations across 8+ event types (PreToolUse, PostToolUse, Stop, SessionStart, SessionEnd, etc.)
14 MCP server configurations — GitHub, Context7, Exa, Playwright, and others, pre-wired
34 language/framework rule packs — TypeScript, Python, Go, Swift, PHP, ArkTS, plus common rules
AgentShield — the security-audit subsystem, now distributed standalone as ecc-agentshield

AgentShield: security audit as a first-class subsystem

The differentiator the previous version of ECC was best known for — now its own npm package. AgentShield scans your CLAUDE.md, settings.json, MCP configs, hooks, agent definitions, and skills across five categories:

Secrets detection (14 patterns) — API keys, tokens, credentials accidentally committed to harness config
Permission auditing — overly-broad allowlists, missing denylists, dangerous default scopes
Hook injection analysis — Pre/PostToolUse hooks that could be exploited
MCP server risk profiling — untrusted MCP servers, missing auth, scope creep
Agent config review — agent definitions that over-grant capabilities

Run --opus for a red-team / blue-team / auditor pipeline using three Opus 4.6 agents: attacker finds exploit chains, defender evaluates protections, auditor synthesizes a prioritized risk assessment.

Key Properties

Multi-harness installer — single source of truth deploys to .claude/, .cursor/, .opencode/, .codex/, .gemini/, .zed/, and Copilot .github/ skill directories
Skills-first methodology — pattern extraction, continuous learning, and token-optimization framing taken from the SKILL.md / Claude Code Plugin tradition
Pairs with Agent Identity, Auth & Secrets — AgentShield audits the configuration that runtime governance enforces
Composable with single-angle packs — install AgentShield alongside GStack or Superpowers if you want their workflow opinions plus ECC's audit layer

When to Pick It

You want a batteries-included starting harness across multiple coding agents, not just Claude Code
You manage .claude/ (or equivalent) installs across a team and want secrets / permission / hook auditing as a discoverable command, not a custom script
You want red-team / blue-team / auditor patterns for harness security without building them yourself — install just ecc-agentshield for the security slice alone

GBrain

Type: Open Source (MIT)
Stars: 19K
GitHub: https://github.com/garrytan/gbrain
Origin: Garry Tan, 2026; the persistent-memory companion to GStack
Tagline: "Your AI agent is smart but forgetful. GBrain gives it a brain."

The other half of the Garry Tan stack. Where GStack is coding skills, GBrain is everything-else skills — persistent memory, a self-wiring typed knowledge graph, ingestion of meetings/emails/voice/links, autonomous overnight maintenance, and a durable Postgres-native job queue. Built to run Garry's actual personal AI agents on OpenClaw and Hermes Agent. The production deployment claim: 17,888 pages, 4,383 people, 723 companies, 21 cron jobs running autonomously, built in 12 days.

GStack and GBrain compose: "GStack is the engine. GBrain is the mod." When the agent codes on itself, it uses GStack; when it remembers, thinks, and operates, it uses GBrain. A hosts/gbrain.ts bridge tells GStack's coding skills to check the brain before coding.

Install

Either auto-install via an agent:

Retrieve and follow the instructions at:
https://raw.githubusercontent.com/garrytan/gbrain/master/INSTALL_FOR_AGENTS.md

Or standalone CLI:

git clone https://github.com/garrytan/gbrain.git && cd gbrain && bun install && bun link
gbrain init    # local PGLite brain ready in ~2 seconds

Approximately 30 minutes end-to-end, mostly answering API-key prompts. PGLite is the default (embedded Postgres 17.5, zero config); migrate to Supabase Pro when you outgrow local.

Architecture: thin harness, fat skills

The repo (markdown files) is the system of record. GBrain is the retrieval + graph + scheduler layer:

Brain Repo (git, markdown)
       ↓                                 ↑
  GBrain engine (Postgres + pgvector  / PGLite)
       ↓ ↑
  AI Agent — 29 skills define HOW to use the brain
  RESOLVER.md (or AGENTS.md) routes intent → skill

Every page follows a compiled truth + timeline pattern: above the ---, the agent's current best understanding (rewritten when evidence changes); below, append-only events. Edits to any file are picked up by gbrain sync so a human can always read and edit the brain directly.

The 29 skills, by role

Role	Skill
Always-on	`signal-detector` (fires on every message, captures original thinking + entity refs in parallel), `brain-ops` (brain-first lookup before any external API)
Ingestion	`ingest` (router), `idea-ingest` (links/articles/tweets), `media-ingest` (video/audio/PDF/books/screenshots/repos), `meeting-ingestion` (transcripts → attendee enrichment + company timelines)
Brain ops	`enrich` (tiered: stub → web+social → full pipeline), `query` (3-layer search with synthesis), `maintain` (stale pages, orphans, citation audit), `citation-fixer`, `repo-architecture`, `publish`, `data-research`
Operational	`daily-task-manager`, `daily-task-prep`, `cron-scheduler`, `reports`, `cross-modal-review` (second-model quality gate), `webhook-transforms`, `testing`, `skill-creator`, `skillify`, `skillpack-check`, `smoke-test`, `minion-orchestrator`
Identity / setup	`soul-audit` (generates `SOUL.md` + `USER.md` + `ACCESS_POLICY.md` + `HEARTBEAT.md`), `setup`, `migrate` (Obsidian / Notion / Logseq / Roam / CSV / JSON), `briefing`

Knowledge graph (zero-LLM auto-linking)

Every page write extracts entity references and creates typed edges (attended, works_at, invested_in, founded, advises) with zero LLM calls — regex + page-role priors + within-page dedup + stale-link reconciliation. Backfill an existing brain:

gbrain extract links --source db
gbrain extract timeline --source db

Then ask graph questions: "who works at Acme AI?", "what did Bob invest in this quarter?", "find the connection between Alice and Carol". Recursive CTE with cycle prevention, type-filtered edges, depth-capped (≤10 for remote MCP, DoS prevention).

Search (hybrid, benchmarked)

Vector (HNSW cosine over OpenAI embeddings) + keyword (Postgres tsvector + websearch_to_tsquery) + Reciprocal Rank Fusion + cosine re-ranking + compiled-truth boost + backlink boost + multi-query expansion via Haiku + 4-layer dedup. Their own benchmark (BrainBench, 240-page Opus-generated rich-prose corpus): P@5 49.1%, R@5 97.9% — beats hybrid-no-graph by +31.4 points P@5; beats ripgrep-BM25 and vector-only RAG by a similar margin. Quality is reproducibly measured (gbrain eval --qrels queries.json) in the sibling gbrain-evals repo (their own Benchmarks entry).

Minions — the durable job queue built into the brain

A Postgres-native job queue (parent-child DAGs, child_done inbox, durability across worker restarts, atomic PID locking, structured audit at ~/.gbrain/audit/). The routing rule: deterministic work → Minions; judgment work → sub-agents. Their reported production numbers on a real OpenClaw workload (pulling a month of social posts and ingesting them):

	Minions	Sub-agent spawn
Wall time	753 ms	10s+ (gateway timeout)
Token cost	$0	~$0.03/run
Success rate	100%	0% (couldn't spawn)
Memory/job	~2 MB	~80 MB

Skillify — the "skillify it!" meta-skill

When the agent hits a new failure, you fix it once in conversation, then say "skillify it!" and a 10-step pipeline turns the fix into a permanent skill: SKILL.md with triggers, deterministic script with tests, routing fixture re-evaluated daily, filing audit. Enforced via gbrain skillify check and gbrain check-resolvable (resolver reachability, MECE overlap, DRY, routing fixtures, filing audit, no SKILLIFY_STUB sentinels). Works against any OpenClaw workspace's AGENTS.md, not just gbrain's repo — first run on a real OpenClaw deployment found ~15% of skills unreachable.

This is the cleanest implementation of Harness Engineering § review-feedback promotion I've seen — every recurring agent failure becomes a permanent, structurally-enforced check.

MCP surface

Exposes 30+ MCP tools via stdio for Claude Code / Cursor / Windsurf, or as a remote MCP for Claude Desktop / Claude Cowork / Perplexity (HTTP transport, auth tokens, ngrok-friendly).

Integration recipes

Ngrok tunnel, Credential Gateway, Voice-to-Brain (Twilio + OpenAI Realtime), Email-to-Brain (Gmail), X-to-Brain (timeline + mentions + deletions), Calendar-to-Brain, Meeting Sync (Circleback). Plus parameterized data-research recipes for investor updates (MRR, ARR, runway, headcount), expenses, and company metrics.

Key Properties

Self-wiring knowledge graph — typed edges extracted with zero LLM calls on every write; backfillable on existing brains.
Repo as system of record — markdown files are the truth; the engine is a retrieval layer. Human always wins on conflicts.
Compiled truth + timeline — every page separates "current best understanding" (rewritable) from "evidence trail" (append-only).
Durable everything — gbrain agent run survives crashes; tool calls persist as a two-phase pending → complete | failed ledger; replay is safe by construction.
Reproducible benchmarks — BrainBench corpus and A/B harness in gbrain-evals; ablation shows the graph layer + extract quality together carry the gap.
Pluggable engine — PGLite by default; gbrain migrate --to supabase (bidirectional) when you outgrow local. S3 / R2 / MinIO / Supabase Storage / local for binary files.

When to Pick GBrain

You want a long-term, persistent memory layer for an agent that ingests messy real-world signal (meetings, email, voice, social)
You want a knowledge graph but don't want to wire one yourself
You're running OpenClaw or Hermes Agent and want Garry's actual deployment patterns
You want a durable job queue for deterministic background work, not just inference-style agent calls
You're using GStack for coding and want the matching memory/ops side

When to Pick Something Else

You just need short-term conversation memory → Mem0, Letta, Zep
You don't want to run Postgres / PGLite → simpler vector-only memory layers
Your data is heavily regulated / multi-tenant — single-user "personal brain" framing isn't the design center
You want a black-box hosted memory API rather than git-as-source-of-truth — see Letta or Graphlit

AgentHub

Type: Open Source (MIT)
GitHub: https://github.com/Stanshy/AgentHub
Origin: Stanshy, 2026; companion to the Claude Code Mastery course (the same intellectual lineage as the Walking Labs Learn Harness Engineering course referenced in Harness Engineering)
Stack: Electron 35, Vue 3, TailwindCSS 4, Pinia, sql.js (WASM SQLite), xterm.js + node-pty, chokidar

An Electron desktop harness-engineering control plane that sits on top of Claude Code CLI. AgentHub doesn't replace Claude Code — it instruments it. You manage a virtual development company (46 agents across 9 departments) through a GUI, with workflows enforced by Skills, runtime constraints enforced by Hooks, state-as-markdown synced live by a FileWatcher, and a 7-gate quality pipeline that can't be skipped.

The four harness primitives

Primitive	What it does	Maps to
Skill (23 built-in)	Workflow templates auto-loaded per task type — `/sprint-proposal`, `/task-dispatch`, `/review`, `/gate-record`, `/pre-deploy`, `/harness-audit`, etc.	Instructions + Tools
Hook (5 templates)	Runtime interceptors. PreToolUse blocks `kill-port`, `--no-verify`, `force push main`. PostToolUse forces doc sync when core services change. Stop refuses session end until tests + typecheck pass.	Feedback
FileWatcher	`chokidar` watches `.tasks/*.md` — markdown IS the database. Change → parse → SQLite upsert → eventBus → Vue reactive update → GUI live-reflects	State
Gate	G0 Requirements → G1 Design → G2 Code Review → G3 Test → G4 Doc → G5 Deploy-Ready → G6 Released. Architecturally enforced, can't skip.	Verification + Lifecycle

The org chart

A strict chain of command — L2 can't escalate to boss, boss can't bypass L1, like a real company. 46 agents across 9 departments: Product, Engineering, Design, Marketing, Testing, Project Management, Studio Operations, plus Studio Coach and Joker as bonus roles. The agent role definitions are adapted from contains-studio/agents.

L1 (8 leadership agents reporting to the boss): Product Manager, Tech Lead, Design Director, Marketing Lead, QA Lead, Project Lead, Operations Lead, Company Manager.

Key Properties

Router CLAUDE.md (3.19 KB / 75 lines) — the cleanest real-world implementation of the "50–200 line entry file + topic docs" pattern from Harness Engineering § Progressive Disclosure. Three "fatal rules" + commands + index; every real rule lives in a .knowledge/*.md topic doc.
Rules promoted to executable checks — dangerous commands aren't documented, they're blocked by PreToolUse Hook. The repo's own example of agent-oriented error messages with fix instructions.
Markdown-as-database — .tasks/*.md, .knowledge/*.md, dev-plan.md are the single source of truth; the GUI is a live view, not an alternative store.
Project scaffolding — one click generates a full Harness (CLAUDE.md + .knowledge/ + Skills + Hooks) into a child project, with 4 templates (web-app / api-service / library / mobile-app).
Cross-project knowledge — postmortems and gotchas captured in one project sync to a company-wide store and inherit to new projects.
Slogan worth quoting: "A good validator with a bad workflow beats a good workflow without a validator." Their arithmetic: 5 serial steps at 80% = 33% end-to-end; add a validator with retry = 99%. The whole product is built around that math.

When to Pick AgentHub

You want a runtime control plane (not just templates) for Claude Code agent work
You want hooks + gates + filewatcher as a managed GUI surface, not as files you maintain by hand
You want to formalize a multi-role org structure (PM / TL / DD …) rather than treat agents as undifferentiated workers
You're on Windows / macOS / Linux and OK with an Electron desktop app

When to Pick Something Else

You're a hands-on terminal user who'd rather wire the harness yourself in ~/.claude/ → GStack or roll your own per Harness Engineering
You want parallel multi-agent worktrees on a single repo, not a single-session-at-a-time harness → Conductor, Superset, Orchestrator.build
You don't use Claude Code — AgentHub depends on the Claude Code CLI as its execution engine

Terminal coding CLIs

The surface agents an engineer actually types into. Most of these are CLI harnesses around frontier models — you pick the CLI (the scaffolding, UX, permissions model, tool wiring) and plug in whichever model makes sense for the task. This is the list behind Docking Station, the containerized dev environment that ships all 25 of them side-by-side.

The short version: harness is the differentiator, not the model. Benchmark top-3 spots are typically taken by the same 2-3 harnesses across different models (see Benchmarks).

CLI	Maintainer	Notable for	Docs
ForgeCode (`forge`)	TailCall	#1 on Terminal Bench 2.0 (81.8%) — multi-model TUI	forgecode.dev
Claude Code (`claude`)	Anthropic	Reference agentic-coding CLI, full codebase read + command exec	docs.anthropic.com/claude-code
Codex CLI (`codex`)	OpenAI	Autonomous coding, open source	github.com/openai/codex
Gemini CLI (`gemini`)	Google	Gemini + Google Cloud integration	github.com/google-gemini/gemini-cli
GitHub Copilot CLI (`github-copilot-cli`)	GitHub	Terminal-side Copilot, agentic	docs.github.com/copilot/cli
Droid (`droid`)	Factory AI	#6 on Terminal Bench 2.0 (77.3%)	factory.ai
Goose (`goose`)	Block	MCP-native, 70+ extensions, Stripe Minions ancestor	github.com/block/goose
Aider (`aider`)	Aider	Popular OSS pair programmer, git-native file editing	aider.chat
Crush (`crush`)	Charmbracelet	Polished TUI coding agent	github.com/charmbracelet/crush
Amp (`amp`)	Sourcegraph	Multi-repo agentic coding (formerly Cody)	ampcode.com
Junie CLI (`junie`)	JetBrains	JetBrains' terminal agent	junie.jetbrains.com
OpenCode (`opencode`)	Community	Multi-model TUI assistant (165K stars)	opencode.ai
Qwen Code (`qwen`)	Alibaba	Qwen-backed coding assistant	github.com/QwenLM/qwen-code
Amazon Q CLI (`q`)	AWS	AWS-integrated coding + cloud agent	aws.amazon.com/q
Grok CLI (`grok`)	Community	Open-source Grok terminal assistant	github.com/superagent-ai/grok-cli
T3 Code (`t3`)	Ping.gg / Theo	Coding-agent workspace launcher	github.com/pingdotgg/t3code
Kilo CLI (`kilo`)	Kilo	Keyboard-first, multi-provider model support	kilo.ai/docs
Plandex (`plandex`)	Plandex	Multi-step task planner with diff management	github.com/plandex-ai/plandex
Kiro CLI (`kiro`)	AWS	Spec-driven agentic coding	kiro.dev
Continue (`cn`)	Continue	Source-controlled AI checks, CI-enforceable (33K stars)	continue.dev
Letta Code (`letta`)	Letta AI	Memory-first agent	github.com/letta-ai/letta-code
iFlow CLI (`iflow`)	iFlow AI	Multi-model with free access to Kimi, Qwen, DeepSeek	github.com/iflow-ai/iflow-cli
Qoder CLI (`qodercli`)	Qoder	Terminal AI assistant	qoder.com
Cline CLI (`cline-cli`)	Cline	Autonomous terminal agent (open source, ex-VS Code extension)	docs.cline.bot
CodeRabbit CLI (`coderabbit`)	CodeRabbit	AI code reviews for staged/unstaged changes	coderabbit.ai/cli
Pi (`pi`)	Mario Zechner / earendil-works (MIT)	Minimal pi-mono harness — TS extensions, skills, prompt templates, themes; runs interactive / print / RPC / SDK modes; the agent inside OpenClaw	pi.dev
OpenDev (`opendev`)	opendev-to (MIT)	Rust-native CLI with ~4ms startup, Web UI for remote sessions, five-slot workflow ensemble (Normal / Thinking / Compact / Self-Critique / VLM) each bound to a different model	github.com/opendev-to/opendev
Claw Code (`claw`)	Sigrid Jin (Apache 2.0)	Clean-room Rust + Python rewrite of the Claude Code harness after the March 2026 source leak; fastest repo in GitHub history to 100K stars	claw-code.codes
Warp (`warp`)	Warp (AGPLv3 client + MIT UI framework)	Agentic development environment born from the terminal; open-sourced April 27 2026, multi-model including open weights (Kimi, MiniMax, Qwen) with an "auto (open)" router, TOML config; its own development is steered through Oz	github.com/warpdotdev/warp

How they differ

Who owns the model — Claude Code, Codex, Gemini, Amazon Q, Kiro, Junie, Amp are model-provider-native (the vendor ships both scaffolding and preferred model). ForgeCode, OpenCode, Aider, Crush, Goose, Cline, Plandex are harness-first and BYO-model via API key or local inference.
Interaction model — Aider, Claude Code, Codex are interactive by default. Kiro is spec-driven (write a spec, the agent implements it). Plandex plans multi-step changes and manages diffs across them. Goose + MCP extensions is closest to an agent platform you assemble.
Where it runs — All 25 run inside Docking Station, a single Docker image intended for installing everything once and switching between harnesses while comparing on the same workspace.
CI use — Continue, CodeRabbit, GitHub Copilot CLI and Claude Code are designed for non-interactive CI invocation. Most of the others can be scripted but are optimized for developer-in-the-loop.

Picking one

Just want it to work, minimal setup — Claude Code, Codex, Gemini CLI.
Maximize benchmark-proven capability — ForgeCode, Droid (both rank top-10 on Terminal Bench 2.0).
Open source + multi-model + self-host — OpenCode, Aider, Goose, Pi, OpenDev, Claw Code, Warp.
In-CI code review — CodeRabbit, Continue.
Spec-driven, explicit plans — Kiro, Plandex.
Memory across sessions — Letta Code.
Tiny / hackable harness you read end-to-end — Pi, mini-SWE-agent.
Enterprise/cloud stack alignment — Amazon Q (AWS), Kiro (AWS), Junie (JetBrains), Gemini CLI (GCP).

Skills, Plugins & Marketplaces

The agent ecosystem has converged on a shared distribution model in 2026: plugins (the package format) bundle one or more skills (self-contained instructions, often a SKILL.md with a YAML frontmatter description that the agent reads on demand) plus optional MCP server configs and hooks. The same SKILL.md format works across Claude Code, Codex, Cursor, OpenCode, and ~50 other agents — so a skill written once usually runs everywhere.

Where Cursor pioneered the "rules" pattern (always-on .cursorrules files) and Continue treats prompts as source-controlled CI artifacts, the Anthropic-native plugin/skill model is the one most third-party catalogs are now publishing against.

Tooling

Project	License	What it is	Notes
Claude Code Plugins (anthropics/claude-plugins-official)	MIT	Anthropic's official plugin distribution system + verified marketplace	Public beta Oct 2025, stable 2026; sources: GitHub, npm, GitLab, local paths; permission controls + version pinning
Vercel Skills (vercel-labs/skills)	MIT	`npx skills add <repo>` CLI that installs SKILL.md skills into 51+ agents	Compatible with Claude Code, Codex, Cursor, Windsurf, Cline, Goose, Gemini CLI, Roo Code, Amp, Kiro and more
Cursor Rules (`.cursorrules`)	Cursor (proprietary)	Plain-text rules loaded into context for every interaction	No discovery / on-demand loading — applies globally to the project
Continue rules (continue.dev)	Apache 2.0	Source-controlled rules + prompts as CI artifacts	CI-enforceable; rules ship with the repo
Anthropic Skill Marketplace (claudemarketplaces.com)	Community	Discovery directory across plugins, skills, MCP servers	4.2K+ skills, 770+ MCP servers, 2.5K+ marketplaces as of May 2026
tonsofskills.com / `ccpi` CLI (jeremylongshore/claude-code-plugins-plus-skills)	OSS	425 plugins, 2,810 skills, 200 agents — community-curated package manager	Largest community catalog
Vercel React Best Practices skill (github.com/vercel-labs/react-best-practices)	MIT	40+ React/Next.js performance rules packaged as a skill	First-party "reference" skill from a model-adjacent vendor

How the formats compare

Cursor Rules — Always-loaded plain text. Simple but no task-specific gating, so the rules file becomes a bottleneck once it grows.
SKILL.md (Claude Code, Codex, OpenCode, etc.) — Description-matched, loaded on demand. Agent reads only metadata at start; full body loads when relevant. Same YAML-frontmatter format across ecosystems.
Continue rules — Stored in source, evaluated like CI; designed for teams who want rules to ship and gate alongside code.

When to choose which

Building one-off rules for your team — Start with .cursorrules or a single SKILL.md committed to the repo. Cheapest path.
Distributing reusable expertise — Plugin format (Anthropic plugin marketplace), so other teams can install with one command.
Cross-agent compatibility — Use SKILL.md + npx skills (Vercel Skills) to install into the broadest set of agents from one source.
Enforce rules in CI — Continue's source-controlled rules.

Browser-Use & Computer-Use Frameworks

Browser and computer-use agents are a distinct category from coding agents — the LLM isn't writing patches, it's clicking buttons, filling forms, and running multi-step web workflows. The 2026 landscape converged on a few open-source frameworks that compete with paid hosted services like OpenAI Operator (~$200/mo Pro) and Anthropic's Claude Computer Use (research preview through Cowork).

For agentic engineering teams, these matter as tools an agent calls — for QA, deploy verification, scraping, third-party SaaS automation — rather than as the agent itself.

Framework	License	Approach	Notable for
Browser Use (browser-use/browser-use)	MIT	DOM + accessibility tree, any LLM	95K stars (one of the fastest-growing OSS AI projects), 89.1% on WebVoyager; YC-backed, hosted version $30/mo
Stagehand (browserbase/stagehand)	MIT	Natural-language wrapper on Playwright	TypeScript + Python; built and maintained by Browserbase as the SDK for browser agents
Chrome DevTools MCP (ChromeDevTools/chrome-devtools-mcp)	Apache-2.0	Official Google MCP server exposing the full Chrome DevTools surface to agents	42K stars, v1.0.1 (May 2026), TypeScript, stdio MCP. Tools: navigate / click / form-fill, screenshot + DOM snapshot, console + network capture, JS evaluation with source-mapped stack traces, performance traces + Lighthouse + CrUX field data, heap snapshots, extension management, device emulation. Drops into Claude Code, Cursor, Copilot, Cline, VS Code, Gemini CLI, JetBrains and 15+ others via `npx chrome-devtools-mcp@latest`. "Slim mode" for basic tasks; auto-waits on action results
Skyvern (Skyvern-AI/skyvern)	AGPL-3.0	LLM + computer-vision Playwright SDK	No-code workflow builder + SDK (Launch Week Jan 2026); embedded local + remote cloud modes
Magnitude (magnitudedev/browser-agent)	OSS	Vision-first; uses screenshots, not DOM	94% on WebVoyager (state-of-the-art); built-in test runner with visual assertions; recommends Claude Sonnet or Qwen-2.5VL 72B
Open-CUAK	OSS	"Kubernetes for Computer Use Agents"	Hire / teach / manage automation agents; explicitly framed as the OpenAI Operator alternative
Open Computer Agent (Hugging Face)	OSS	Hosted computer-use stack	Free Operator-class agent; runs against shared Hugging Face Spaces infra
Anthropic Computer Use (docs.claude.com)	Anthropic API	First-party vision + action tool surface	Generally available via API; the foundation under Claude Cowork (GA April 9, 2026); Sonnet/Opus drive scoring on real GUIs
Claude Cowork (claude.com/cowork)	Anthropic (paid)	Desktop computer-use agent for end users	GA April 9 2026 on macOS / Windows; manages files, drafts docs, runs multi-step workflows. Distinct from coding-agent products like Claude Code
OpenAI Operator (operator.chatgpt.com)	Closed (Pro)	First-party hosted computer-use agent	$200/mo ChatGPT Pro; the benchmark the OSS frameworks measure against

How to think about adoption

Add browsing as a tool to a coding agent → Stagehand (cleanest Playwright DX) or Browser Use (largest community, broad model support).
DevTools-grade inspection for agentic QA/debug (perf traces, Lighthouse, network capture, source-mapped stack traces) → Chrome DevTools MCP — first-party Google MCP surface, drops into any MCP-aware agent in one command.
Vision-first apps where DOM scraping fails (canvas, custom UIs, Flash-equivalents) → Magnitude.
Self-host a full Operator alternative for end users → Open-CUAK or Open Computer Agent.
Already on Claude → Anthropic Computer Use directly via the API; Claude Cowork if you want the productized desktop UX.
Visual testing / regression → Magnitude (visual assertions), Skyvern (workflow builder), or Stagehand on top of Playwright's existing assertions.

Feature Matrix

Project	Stars	Unattended PR	Orchestration	Sandbox	MCP	CI Feedback	Multi-Agent	License
Claude Managed Agents	N/A	Yes	Built-in harness	Managed container	Yes (MCP)	Yes	Research preview	Commercial
Stripe Minions	N/A	Yes	Blueprints	EC2 Devboxes	Yes (~500 tools)	Yes (2 rounds)	Parallel runs	Proprietary
AgentField	1.4K	Yes	SWE-AF levels	Git Worktrees	Agent mesh	Yes (gated)	Yes (orchestrated)	Apache 2.0
OpenHands	71K	Yes	Planning Mode	Docker	No	Yes	No	MIT
Open SWE	9.5K	Yes	LangGraph	Cloud sandbox	No	Yes	Yes (4 agents)	Open Source
OhMyOpenAgent	50.6K	Partial	Named agents	No	Yes (built-in)	Partial	Yes (team)	Open Source
OpenCode	142K	Partial (GH mode)	No	No	No	No	No	Open Source
SWE-agent	19K	Yes	No	Docker	No	Partial	No	MIT
Composio	6.2K	Yes	Task decomp	Configurable	No	Yes	Yes (parallel)	Open Source
Patchwork	1.5K	Yes	Patchflows	No	No	Yes (CI/CD)	No	Open Source
Goose	41K	No (interactive)	No	No	Yes (70+ tools)	No	No	Apache 2.0
Symphony	15K+	Yes	6-layer architecture	Worktrees	Via integrations	Yes (CI-gated)	Yes (orchestrated)	Apache 2.0
Vercel Open Agents	3.7K	Yes	Vercel Workflow SDK (durable)	Vercel Sandbox (microVM)	Yes (MCP)	Via tools	Subagents built-in	MIT
Mastra	22.9K	Framework	Workflows	Configurable	Yes (MCP)	Via workflows	Via workflows	Apache 2.0
OpenClaw	355K	Via skills	No	Via NemoClaw	No	No	Yes (sessions)	Open Source
Rivet Sandbox	1.3K	Infrastructure	No	Yes (multi-runtime)	No	No	API-level	Open Source

Capability Breakdown

Best for Unattended PR Production

Stripe Minions — Gold standard, 1,300+ PRs/week in production
OpenHands — Most mature open-source option, 50%+ SWE-bench
Open SWE — Best multi-agent architecture for PR production

Best for Orchestration / Workflow

Stripe Minions — Blueprints (hybrid deterministic + agentic)
Patchwork — Patchflows (closest open-source blueprint analog)
Open SWE — LangGraph (graph-based multi-agent)

Best for Sandbox Isolation

Stripe Minions — EC2 devboxes, pre-warmed in 10s
Rivet Sandbox Agent — Universal API for any agent in any sandbox
OpenHands — Docker-based, Kubernetes-ready

Best for Multi-Agent Parallelization

Composio Orchestrator — Purpose-built for parallel agent coordination
AgentField — Full orchestration with failure recovery
OhMyOpenAgent — Named specialist team with model routing

Best for Context Management

Stripe Minions — Toolshed MCP (~500 tools), conditional rules, pre-hydration
OhMyOpenAgent — Hierarchical AGENTS.md, built-in MCPs, multi-model routing
Goose — MCP-native with 70+ extensions

Best for Failure Recovery

AgentField — Three nested loops, typed recovery, checkpoint-based
Stripe Minions — Pragmatic 2-round CI cap with auto-fixes
OhMyOpenAgent — Ralph Loop for persistent iteration

Composability

No single open-source project replicates the full Stripe Minions architecture. To build an equivalent, you would likely combine:

Layer	Option A	Option B
Core Agent	OpenHands	Open SWE
Sandbox	Rivet Sandbox Agent	E2B / Docker
Orchestration	Patchwork patchflows	LangGraph
Parallelization	Composio Orchestrator	AgentField
Context	MCP servers	OhMyOpenAgent MCPs
Control Plane	AgentField	Custom

← Research

Approaches to Agentic Coding

Deep dives into the major systems and frameworks driving autonomous software engineering — from enterprise-internal platforms to open-source tools and model-provider managed agents.

A deep dive into the major systems and frameworks driving autonomous software engineering — from enterprise-internal platforms to open-source tools.

Index

Commercial / proprietary

Stripe Minions — 1,300+ PRs/week, blueprints, devboxes, Toolshed MCP
Claude Managed Agents — Anthropic's vertically integrated harness, $0.08/agent-hour
OpenAI Symphony — 25K stars, 6-layer orchestration, work management over agent supervision
Vercel Open Agents — MIT reference template, durable workflows + Vercel Sandbox + GitHub App
PostHog Code — desktop app + open agent framework, swarm driven by production analytics, beta May 2026

Open-source agents

Ordered by GitHub stars (descending).

OpenClaw — 374K stars, self-hosted assistant with messaging integration
OpenCode — 165K stars, provider-agnostic with GitHub agent mode
Hermes Agent — 165K stars, Nous Research's self-improving personal agent
OpenHands — 75K stars, most mature open-source autonomous engineer
DeerFlow — 69K stars, ByteDance's long-horizon SuperAgent harness, LangGraph-based
Cline — 62K stars, plan-then-act with explicit user approval at every step
OhMyOpenAgent — 59K stars, named specialist agents, hash-anchored edits
Goose — 46K stars, MCP-native, the ancestor Stripe forked for Minions
Letta Code — 23K stars, memory-first coding agent built on the MemGPT lineage
SWE-agent — 19K stars, Princeton/Stanford, pioneered issue-to-PR paradigm
Open SWE (LangChain) — 9.8K stars, multi-agent async coding agent
Composio Agent Orchestrator — 7.2K stars, best multi-agent parallelization
AgentField — 2K stars, open-source control plane with three nested failure loops
Patchwork — 1.6K stars, patchflows, closest open-source analog to Stripe's blueprints

Frameworks & SDKs

DSPy + GEPA — 34.6K stars, Stanford NLP's programmatic LLM framework + Pareto-genetic prompt/topology optimizer
Smolagents — 27.5K stars, HuggingFace's ~1K-LOC hackable code-agent reference
OpenAI Agents SDK — 27K stars, first-party OpenAI framework; production successor to Swarm
Mastra — 24K stars, TypeScript framework for building custom agent systems
Deep Agents (LangChain) — 23.3K stars, the LangGraph-based opinionated open harness
Google ADK — 20K stars, Google's first-party Gemini-native framework
Claude Agent SDK — 7K (Python) + 1.5K (TS), Anthropic's first-party SDK — the same harness that powers Claude Code
Strands Agents — 5.9K stars, AWS-incubated SDK with Bedrock / Lambda / Fargate deploy templates
Rivet Sandbox Agent — universal API for running agents in sandboxes

Harness & skill packs

GStack — Garry Tan's 23-skill Claude Code setup, CEO / Designer / Eng Manager / QA personas
GBrain — Garry Tan's persistent-memory companion to GStack
Superpowers — Jesse Vincent's skills framework + design-then-implement methodology
Everything Claude Code — Affaan M.'s multi-harness operator system: 63 subagents, 249 skills, hooks, MCP, AgentShield security audit
AgentHub — Electron harness-engineering control plane on top of Claude Code CLI

The Steinberger ecosystem

Crabbox — ephemeral test-box control plane with diff sync
Clawpatch — automated code review via semantic feature slicing
ClawSweeper — conservative issue/PR triage bot

Cross-cutting

Terminal coding CLIs — the 28-CLI comparison table
Skills, Plugins & Marketplaces — Cursor Rules · SKILL.md · Continue · plugins
Browser-Use & Computer-Use Frameworks — Browser Use, Stagehand, Magnitude, Skyvern, Operator

Stripe Minions

Type: Enterprise / Internal
Scale: 1,300+ PRs merged per week
Based on: Goose fork
Blog: https://stripe.dev/blog/minions-stripes-one-shot-end-to-end-coding-agents

Architecture

Blueprints — Hybrid state machines interleaving deterministic nodes (git, linting, push) with agentic subtasks (implementation, CI fixes)
Devboxes — Isolated EC2 environments pre-warmed in ~10 seconds, identical to human dev machines
Toolshed MCP — Centralized MCP server with ~500 tools for internal systems and SaaS platforms
Conditional rules — Cursor-format rule files applied by subdirectory to avoid context bloat
Pre-hydration — Deterministic MCP tool runs on linked URLs before agent loop starts

Key Properties

One-shot design — Task in, PR out, no interaction in between
Max 2 CI rounds — Local lint first, then at most two CI iterations
Production isolation — Devboxes cut off from production and internet
Parallel execution — Engineers routinely spin up multiple minions simultaneously
Same tools as humans — If it's good for humans, it's good for LLMs
Auto-fixes — Many test failures have autofixes that are applied automatically

Flow

Slack / CLI → Devbox → Pre-hydrate Context → Blueprint Loop → Local Lint → CI (x2 max) → PR

AgentField

Type: Open Source (Apache 2.0)
Role: Control Plane + Orchestration Framework
GitHub: https://github.com/Agent-Field/agentfield
Blog: https://agentfield.ai/blog/beyond-vibe-coding

Control Plane

Agent registration & routing — REST APIs, WebSocket connections, execution queues (PostgreSQL-backed)
Canary & blue-green deploys — Per-version health tracking and traffic routing
Cryptographic identity — W3C DIDs per agent with verifiable credentials
Memory system — KV storage + vector search across four scopes
SDKs — Python, Go, TypeScript

SWE-AF Orchestration

Two primitives — .ai() for cheap routing calls, .harness() for full coding environments (up to 150 turns)
Three failure loops — Inner (per-issue retries, up to 5), Middle (typed recovery: retry, split, escalate, accept-with-debt), Outer (replanner for cascading failures)
Git worktree isolation — Each issue gets its own branch and working directory
Checkpoint-based execution — Resumes from failure point, never restarts
Intent-aware merging — Merger agent resolves conflicts between parallel branches
Typed debt tracking — Downstream agents work around known gaps

Results

Diagrams-as-code Rust CLI: 15 issues, 200+ invocations, $116 total
Go SDK feature: 10 issues, 80+ invocations, $19 total
Architecture quality > model capability: scored 95/100 with both Haiku and MiniMax M2.5

OpenHands

Type: Open Source (MIT)
Stars: 75K
GitHub: https://github.com/OpenHands/OpenHands

Architecture

Docker sandboxing — Full OS-level isolation per agent run
Planning Mode — Added in v1.6.0 for structured task decomposition
Web GUI + CLI + SDK — Multiple interfaces for different workflows
Kubernetes support — Scalable deployment for enterprise use

Key Properties

50%+ SWE-bench — Solves over half of real GitHub issues in benchmarks
GitHub issue trigger — Can be invoked directly from issue comments
CI feedback — Runs tests and iterates on failures
$18.8M Series A — Well-funded with active development
Gap: No built-in blueprint/workflow DSL or multi-agent parallelization

Open SWE (LangChain)

Type: Open Source
Stars: 9.8K
GitHub: https://github.com/langchain-ai/open-swe

LangChain's cloud-native async coding agent, explicitly modeled on patterns from companies like Stripe, Ramp, and Coinbase. Uses a multi-agent architecture built on LangGraph.

Architecture

LangGraph orchestration — Graph-based workflow engine, closest open-source analog to Stripe's blueprints
Multi-agent decomposition — Manager, Planner, Programmer, Reviewer agents
Cloud sandbox — Isolated cloud execution environments
Async-first — Designed for unattended background execution

Key Properties

Automatic PR creation — End-to-end from issue to pull request
Self-review — Reviewer agent checks code before PR creation
Enterprise patterns — Designed to capture patterns from production agentic systems
Gap: Newer project, less battle-tested than OpenHands

OhMyOpenAgent

Type: Open Source
Stars: 59K
GitHub: https://github.com/code-yeongyu/oh-my-openagent

Architecture

Named agents — Sisyphus (orchestrator), Hephaestus (deep worker), Prometheus (strategic planner), Oracle (debugger), Librarian (docs)
Hash-anchored edits (Hashline) — Each line carries a content hash for verification before applying changes (improved success from 6.7% to 68.3%)
Multi-model routing — Auto-routes tasks to appropriate models (visual, reasoning, quick fix, ultrabrain)
LSP + AST-Grep — IDE-precision refactoring and AST-aware code search

Key Properties

ultrawork command — Single-word activation triggering full agent team
Ralph Loop — Self-referential iteration until task completion
Todo Enforcer — Pulls agents back from idle states
Comment validation — Prevents AI-generated prose in code
/init-deep — Auto-generates hierarchical AGENTS.md files across projects
Built-in MCPs — Exa search, Context7 docs, Grep.app

OpenCode

Type: Open Source
Stars: 165K
GitHub: https://github.com/anomalyco/opencode

The most-starred open-source coding agent, featuring a TUI, client/server architecture, and a GitHub agent mode for unattended repository automation via GitHub Actions.

Architecture

Client/server model — Separates UI from execution for flexibility
GitHub agent mode — Triggered by GitHub events, runs in Actions
Provider-agnostic — Claude, OpenAI, Google, local models
TUI interface — Rich terminal UI for interactive use

Key Properties

Massive adoption — 165K stars, largest coding agent community
Event-driven — GitHub agent mode mirrors Minions' event-driven model
Extensible — Plugin architecture for custom tools
Gap: Primarily interactive; GitHub agent mode is newer

SWE-agent

Type: Open Source (MIT)
Stars: 19K
Origin: Princeton / Stanford
GitHub: https://github.com/SWE-agent/SWE-agent

Architecture

Docker isolation — Sandboxed execution environment per run
Issue-to-PR pipeline — Takes a GitHub issue URL and produces a fix
Custom agent interface — Optimized shell commands for LLM interaction

Key Properties

Research-grade — NeurIPS 2024 publication with rigorous evaluation
mini-swe-agent — 100-line minimal version scoring 74%+ on benchmarks
Gap: No workflow orchestration, limited CI integration, single-agent only

Composio Agent Orchestrator

Type: Open Source
Stars: 7.2K
GitHub: https://github.com/ComposioHQ/agent-orchestrator

The best open-source match for Stripe's multi-agent parallelization pattern. Decomposes tasks, spawns parallel agents, and autonomously handles CI fixes and merge conflicts.

Architecture

Task decomposition — Plans and breaks work into parallel subtasks
Parallel agent spawning — Multiple agents working simultaneously
CI feedback loop — Automatically handles test failures
Merge conflict resolution — Handles conflicts from parallel work

Key Properties

Best parallelization — Closest match to "spin up many minions"
Code review — Automated review before PR creation
Gap: Orchestration layer, not a complete standalone agent

Patchwork

Type: Open Source
Stars: 1.6K
GitHub: https://github.com/patched-codes/patchwork

Framework for patching code repos using LLMs. Its "patchflows" — reusable workflows combining atomic actions with LLM prompts — are the closest open-source analog to Stripe's blueprint pattern.

Architecture

Patchflows — Deterministic steps (create PR, commit, lint) + LLM prompts, similar to blueprints
Built-in flows — AutoFix, PRReview, GenerateDocstring
CI/CD integration — Runs in pipelines natively

Key Properties

Blueprint analog — Closest match to Stripe's hybrid orchestration
Composable — Mix and match atomic actions
Gap: Smaller community, no sandbox isolation, less sophisticated agent loops

Goose

Type: Open Source (Apache 2.0)
Stars: 46K
GitHub: https://github.com/block/goose (also https://github.com/aaif-goose/goose)

The general-purpose AI agent framework from Block that Stripe forked in late 2024 to build Minions. Now maintained by the Agentic AI Foundation (AAIF) under the Linux Foundation.

Architecture

Rust core — Native desktop, CLI, and API interfaces
MCP-native — 70+ tool extensions via Model Context Protocol
15+ LLM providers — Anthropic, OpenAI, Google, Ollama, and more
General purpose — Code, research, writing, automation, data analysis

Key Properties

Minions ancestor — Stripe's Minions were literally built from a Goose fork
Linux Foundation — Transitioned from Block to AAIF for community governance
Gap: Interactive, not unattended. No sandbox isolation, CI loops, or blueprint orchestration

Cline

Type: Open Source (Apache 2.0)
Stars: 62K
GitHub: https://github.com/cline/cline

Architecture

Plan / Act modes — explicit gate between proposing a change and applying it; every tool call surfaces for approval by default
Multi-provider — Claude, GPT, Gemini, local via Ollama; bring-your-own-key
MCP-native — Cline was an early adopter; ships with discoverable MCP server support
Diff-based edits — atomic patches with previews rather than free-form rewrites

Key Properties

Roo Code (RooCodeInc/Roo-Code, 24K stars) is a Cline fork with multi-mode orchestration and broader model support; teams pick one or the other, rarely both
Direct competition with Aider in the IDE-extension category; Cline wins on UI polish, Aider on terminal purity
Gap: by design, not an unattended autonomy harness — every action waits for human approval, which kills throughput for production agent fleets

Letta Code

Type: Open Source (Apache 2.0)
Stars: 23K (Letta core)
GitHub: https://github.com/letta-ai/letta
Origin: Letta (formerly MemGPT), the lab behind the 2023 MemGPT paper

Architecture

Letta server — REST API; every agent is a long-lived resource you address by ID
Memory blocks — labelled, agent-editable text regions (human, persona, project-specific); the agent calls core_memory_replace like any other tool
Archival storage — Postgres + pgvector; the agent decides what to evict from core to archival
Letta Code CLI — the coding-agent surface; sub-agents, skills, MCP

Key Properties

The MemGPT design is the canonical academic answer to context-window limits; Letta is what happens when you ship it as a server with a CLI on top
Pairs naturally with Tavily for live retrieval and Inngest for durable tool calls
Listed in Agent Memory infrastructure as the memory layer; this entry is the coding-agent surface
Gap: the memory abstraction is the whole product — for harnesses where you want the agent to be stateless on purpose (CI runners, ephemeral sandboxes), this is the wrong tool

Mastra

Type: Open Source (Apache 2.0 + Enterprise)
Stars: 24K
GitHub: https://github.com/mastra-ai/mastra
Origin: YC W25, from the team behind Gatsby

Architecture

Model routing — Unified interface to 40+ LLM providers (OpenAI, Anthropic, Gemini, etc.)
Workflow engine — Graph-based orchestration with .then(), .branch(), .parallel() API
Agent system — Autonomous agents that reason through goals and select tools
Human-in-the-loop — Pause agents for user approval with persistent state across suspension
Memory — Conversation history, working memory, and semantic memory for coherent behavior

Key Properties

TypeScript-native — 99.3% TypeScript, integrates with React, Next.js, Node.js
MCP servers — Author and consume MCP tools via standard interfaces
Evaluations — Built-in eval framework for measuring agent quality
Production-ready — Observability, error handling, state persistence
Role in agentic engineering: Mastra is a framework for building custom agent systems, not a pre-built coding agent. Teams would use it to build their own Minions-like system in TypeScript, with the workflow engine serving a similar role to Stripe's blueprints.

OpenAI Agents SDK

Type: Open Source (MIT)
Stars: 27K (Python) + 3.1K (JS)
GitHub: https://github.com/openai/openai-agents-python
Origin: OpenAI, March 2025; production successor to the educational Swarm library

Architecture

Agent — instructions + tools + handoffs; the unit of behavior
Runner — the conversation loop; runs an agent until completion or handoff
Handoff — transfer control to another agent, optionally with a structured payload
Sessions — persistent thread state across runs
Tracing — every step logged to OpenAI's dashboard (or your own backend)

Key Properties

Three of the four major model labs now ship a first-party agent framework — Anthropic Claude Managed Agents, Google ADK, and OpenAI Agents SDK. The convergence on the handoff primitive is striking: rather than rebuild LangGraph, the labs all settled on "agents that hand off to other agents, with the loop being unsurprising"
For teams not invested in the LangChain or Microsoft Agent Framework ecosystems, this is the de-facto OpenAI-shaped path
Gap: opinionated about the handoff model; teams that need a richer state-machine or graph topology will reach for LangGraph or Mastra instead

Google ADK (Agent Development Kit)

Type: Open Source (Apache 2.0)
Stars: 20K (Python) + 9.4K (samples)
GitHub: https://github.com/google/adk-python
Origin: Google, 2025

Architecture

Agent — instructions, tools, sub-agents; same triad as the other first-party frameworks
Session / State — persistent context across turns and runs
Tools — first-party Vertex AI Search, BigQuery, Gemini code execution; user-defined Python tools; MCP support
Deployment templates — one-command deploy to Agent Engine, Cloud Run, or GKE

Key Properties

Samples repo (adk-samples, 9.4K stars) is unusually polished — production-grade reference agents for customer-service, RAG, code-review, and multi-agent decomposition
The right pick if you're already on GCP, paying for Gemini 3.x, or want Vertex AI Vector Search as the memory backend
Gap: Gemini-centered; provider-agnostic use is possible but the deployment ergonomics are the actual selling point and they're GCP-shaped

Strands Agents

Type: Open Source (Apache 2.0)
Stars: 5.9K
GitHub: https://github.com/strands-agents/sdk-python
Origin: AWS-incubated; model-driven agent SDK released 2025

AWS's answer to OpenAI Agents SDK and Google ADK. Strands ships 13+ model providers, native MCP, multi-agent composition, and an experimental bidirectional voice-streaming mode.

Architecture

Agent + tools + sessions — same model-driven shape as the other first-party SDKs
Multi-agent composition — agents-as-tools, agent graphs, supervisor patterns
Bidirectional voice streaming — early-access full-duplex audio path
Deployment templates — Lambda, Fargate, Bedrock AgentCore, EC2 with sane IAM defaults

Key Properties

The differentiator vs the OpenAI / Google SDKs is the deployment side — Strands templates deploy cleanly across the AWS surface with IAM wired by default
The natural choice for teams committed to AWS that would otherwise build on Bedrock Agents but want to avoid the lock-in
Gap: smaller community than OpenAI Agents SDK or ADK (5.9K vs 27K / 20K); third-party ecosystem (samples, blog posts, troubleshooting threads) is still catching up

Claude Agent SDK

Type: Open Source (MIT, Python) + Anthropic Commercial Terms (TypeScript)
Stars: 7K (Python) + 1.5K (TS)
GitHub: anthropics/claude-agent-sdk-python · anthropics/claude-agent-sdk-typescript
Origin: Anthropic, 2025 (formerly Claude Code SDK); renamed Sep 2025 once it was clear teams wanted the same harness without the coding-product framing

Architecture

CLAUDE.md — system-prompt assembly with path-glob matching and progressive loading
Skills — SKILL.md folders with metadata frontmatter; loaded on demand, ~50 tokens of metadata in context until invoked
Hooks — PreToolUse / PostToolUse / PreCompact / Stop / SessionStart for guardrails, formatters, telemetry
Sub-agents — Task tool spawns isolated-context children; only compressed summaries return to the parent
Permission prompts — first-class HITL gate on destructive actions; programmable via hooks for autonomous mode
MCP-native — every Skill or tool can be backed by an MCP server

Key Properties

The reference harness in 2026. Every other harness in this section is either explicitly modeled after these primitives (Deep Agents, Superpowers, GStack) or reimplements the same set under different names
The right pick if you're staying on Anthropic models and want Anthropic-shaped ergonomics. The CLAUDE.md / SKILL.md / hooks pattern is the most-copied design in agentic engineering
See Harness Engineering for the conceptual layer underneath this SDK — what a harness decomposes into and why Claude Code's harness wins on CORE
Gap: Anthropic-locked. The SKILL.md format itself is portable (Vercel Skills installs the same format into 51+ agents), but the SDK assumes Anthropic API conventions. Provider-neutral teams reach for Deep Agents instead

Deep Agents (LangChain)

Type: Open Source (MIT)
Stars: 23.3K
GitHub: langchain-ai/deepagents
Origin: LangChain, August 2025; v0.5 alpha April 2026 (async sub-agents, expanded multi-modal filesystem)

Architecture

LangGraph runtime — state graph of nodes and edges; PostgresSaver checkpointer for durability, time-travel debugging, rewind/fork
Middleware — before_agent, wrap_model_call, before_tools, after_tools hooks compose like Express middleware. SummarizationMiddleware and FilesystemMiddleware are the headline ones
Sub-agents — isolated-context children spawned via the planning loop; compressed summaries returned to the parent
Virtual filesystem — tool results over ~20K tokens get offloaded to file paths, leaving a path + 10-line preview in context
Skills — SKILL.md format, same as Claude Code; loaded by description match

Key Properties

Pair with create_agent (LangChain 1.0 default factory, Oct 2025; supersedes the deprecated create_react_agent) to compose agent + middleware in idiomatic LangGraph
The right pick if you want Claude-Code-shaped ergonomics but need model neutrality, durable checkpointing, time-travel debugging, or first-class observability via LangSmith
The reference work for harness engineering as a discipline — read alongside The Anatomy of an Agent Harness (LangChain) and Trivedy's Better Harness hill-climbing recipe
Gap: LangGraph weight. You get durability, time-travel, and middleware for free, but the conceptual surface area is larger than Claude Agent SDK or Smolagents. Teams that just want "claude.messages.create with hooks" should start lighter

DSPy + GEPA

Type: Open Source (MIT, both)
Stars: 34.6K (DSPy) + 1.6K (GEPA)
GitHub: stanfordnlp/dspy · gepa-ai/gepa
Origin: Stanford NLP (Omar Khattab et al.), 2023; DSPy 3.0 in 2025; GEPA paper at ICLR 2026 (oral)

Architecture

Signature — typed input/output spec (question -> answer: str); the program's contract
Module — ChainOfThought, ReAct, custom — composed into programs like layers
Optimizer — compiles a program against your metric. BootstrapFewShot, MIPROv2, and now GEPA are the canonical ones
GEPA loop — reflect on rollouts → mutate text parameters → keep the Pareto frontier → repeat. Optimizes whole-program text, not just a single prompt
DSPy 3.0 — adds streaming, async, type-safe outputs, MCP, and the dspy.GEPA integration

Key Properties

The most rigorous answer to "how do I know my prompt is good?" — write a metric, compile against it, ship the artifact
GEPA's reflective-evolution approach is general: it optimizes whole programs (multiple prompts, control flow, sub-agent topologies) — not just a single prompt template
See Inspect AI for the eval-side counterpart; DSPy needs a metric, and Inspect is one place to get one with rigor
Gap: Activation energy. The mental model (programs + signatures + optimizers) is foreign to engineers used to writing prompts directly. The teams that benefit most are the ones already doing rigorous eval work — and most teams aren't there yet

Smolagents

Type: Open Source (Apache 2.0)
Stars: 27.5K
GitHub: huggingface/smolagents
Origin: HuggingFace, December 2024

Architecture

CodeAgent — the headline agent; writes Python code, executes it in a sandbox, observes results
ToolCallingAgent — fallback for JSON-mode-only models
Sandboxing — local Python execution by default; integrations for E2B, Docker, and HuggingFace Spaces
Model neutrality — any HuggingFace model, OpenAI, Anthropic, local via Ollama / vLLM

Key Properties

The fastest way to understand what a code-execution agent does — the codebase is short enough to read end-to-end in an afternoon
The Anthropic harness-comparison study used Smolagents as the floor (42% on CORE vs Claude Code's 78%, same Opus 4.5) — a useful reference for what "minimal harness" means in numbers
Bundled course: HuggingFace Agents Course walks through smolagents, MCP, and evals end-to-end with a free certificate
Gap: intentionally production-weak. No durable execution, no checkpointing, no observability beyond logs, minimal sub-agent orchestration. Treat it as a learning tool, then graduate to a real harness

OpenClaw

Type: Open Source
Stars: 374K (fastest-growing open-source project on GitHub)
GitHub: https://github.com/openclaw/openclaw
Origin: Created by Peter Steinberger (Austria), originally named Clawdbot (Nov 2025)

Architecture

Local-first Gateway — WebSocket-based control plane running locally, coordinating all connections
Multi-channel — WhatsApp, Telegram, Slack, Discord, Signal, Teams, Matrix, and 15+ more messaging platforms
Skills platform — Bundled, managed, and workspace-level skills for extensibility
Agent-to-agent coordination — Session tools for multi-agent communication
Device nodes — macOS, iOS, Android companion apps with system access
Browser control — Dedicated Chrome instance for web automation

Key Properties

Self-hosted — Runs entirely on your infrastructure, privacy-first
Messaging-native — Use your existing chat platforms as the interface (like Stripe uses Slack)
Voice capabilities — Wake words, continuous voice mode, ElevenLabs integration
A2UI (Agent-to-UI) — Live Canvas for agent-driven visual workspaces
NemoClaw — Nvidia-built security add-on with OpenShell sandboxing (released March 2026)
Role in agentic engineering: OpenClaw's messaging-platform integration mirrors how Stripe engineers invoke minions from Slack. Its self-hosted nature and multi-agent coordination make it a potential foundation for building an agentic engineering workflow, though it requires more custom configuration than purpose-built coding agents. The skills platform and agent-to-agent tools could power a Minions-like system where coding tasks are dispatched through familiar messaging channels.

The OpenClaw Ecosystem

OpenClaw has spawned a family of derivative projects and an entire hosting market:

Project	Language	Stars	Key Differentiator
OpenClaw	TypeScript	~355K	Dominant personal AI agent, multi-channel, multi-model
NemoClaw	Python/CUDA	N/A (NVIDIA)	Enterprise OpenShell, GPU guardrails, NVIDIA NIM
Hermes Agent	Python	~24.6K	Self-improving skill loop, RL fine-tuning via Atropos (now an independent project at 165K stars — see dedicated section)
IronClaw (NEAR AI, in OpenClaw ecosystem)	Rust	~2.7K	TEE-isolated agent runtime, encrypted credential vault, WebAssembly tool sandbox, sub-30s attestation, runs on NEAR AI Cloud's Confidential GPU Marketplace
ZeroClaw	Rust	20K+	Edge-first, 3.4-5MB binary, <50ms startup, container isolation
NanoClaw	TypeScript	Growing	~500 lines, auditable in 8 min, Agent Swarms, container-per-group

The Steinberger School

"How would we build software in the future if tokens don't matter?" — Peter Steinberger

The pattern is worth studying as a real-world counterpart to Stripe Minions. Steinberger's setup runs a Codex (or equivalent) agent on essentially every event in the project lifecycle:

Every PR is reviewed by Codex for quality, security, consistency
Every commit is scanned for security regressions (Vercel Deepsec + Codex Security)
Every new issue is read, classified, and — if it fits the documented vision — auto-converted into a PR (then reviewed by another Codex)
Every fix on main triggers a sweep to close old issues with exact commit references — that's what ClawSweeper does
Every meeting is monitored by an agent that proactively opens PRs for features being discussed as they're being discussed
Every comment is scanned for spam; offenders are auto-blocked
Performance benchmarks run on every change with regression alerts pushed to Discord
Setup recreation spins up ephemeral cloud machines via crabbox.sh, can log into Telegram, record a before/after fix video, and post it on the PR
Functional-unit code review via clawpatch.ai — semantic slicing rather than file-by-file linting

The supporting ecosystem (all open source, all by Steinberger / the OpenClaw org):

Project	What it does
crabbox.sh	Ephemeral test boxes — leased cloud capacity or BYO SSH host with diff sync, remote run, output streaming, evidence collection
clawpatch.ai	Automated code review via semantic feature slicing + explicit fix loop
ClawSweeper	Conservative issue/PR triage — six narrow close cases, never touches maintainer items
Discrawl (discrawl.sh)	Discord search & archive to SQLite, so a corpus of conversation is searchable from agents
CodexBar (github.com/steipete/CodexBar)	macOS menu-bar app showing AI coding limits + costs across providers
fs-safe (github.com/openclaw/fs-safe)	Root-bounded filesystem safety — agents physically cannot write outside the project root
peekaboo (peekaboo.sh)	macOS screen/control toolkit so AI agents can see and drive native desktop apps

Crabbox

Type: Open Source
GitHub: https://github.com/openclaw/crabbox · Docs: https://crabbox.sh
Origin: OpenClaw org, Peter Steinberger maintains
Tagline: "Crabbox: warm a box, sync the diff, run the suite."

Architecture

Go CLI on your laptop — local control surface
Cloudflare Worker broker — owns provider credentials and lease state, so secrets don't sit on your laptop
Managed or delegated runners — Blacksmith, AWS, Azure (Windows desktop + WSL2), Proxmox, Tensorlake, or any SSH host
GitHub Actions wrap — crabbox actions hydrate registers a leased box as an ephemeral Actions runner, so the repo's own workflow installs runtimes, services, and secrets — you get repo-faithful environments without rebuilding them in Crabbox

What's notable

Diff sync, not full clone — agents push only the changed files, so a 100-MB repo doesn't pay the 100-MB cost on every spawn
Failed boxes stick around for SSH — when a run breaks, the box is preserved so a human or an agent can shell in and debug
Durable run events — every phase emits a structured event; crabbox attach lets you live-replay a run that was launched headlessly
Cloudflare Access as the auth front door, so a single CF identity controls who can lease what
Active development — v0.3 added remote Linux + GitHub browser login + Blacksmith wrap; v0.12 added Azure Windows desktop, Proxmox, Tensorlake, preflight, failure bundles, phase timing

When to Pick Crabbox

You want reproducible ephemeral test environments without committing to one cloud vendor
You're already running OpenClaw or want a native plugin for agent box lifecycle
You need Windows desktop + WSL2 environments (most agent sandboxes are Linux-only)
You're hitting GitHub Actions runner pain (slow boots, missing tools, secret-management headaches) and want a faster, reproducible alternative
You want failed boxes preserved for SSH debugging rather than torn down

When to Pick Something Else

Pure short-lived code execution → E2B, Sprites.dev, Blaxel
You need git-style branching of sandboxes → Contree
Multi-tenant SaaS isolation guarantees → enterprise Northflank / Runloop

Clawpatch

Type: Open Source
GitHub: https://github.com/openclaw/clawpatch · Site: https://clawpatch.ai
Origin: OpenClaw org, Peter Steinberger
Tagline: "Review code. Patch bugs. Land PRs."

How the slicing works

Workflow

Map repo → feature slices
  → For each slice, review with provider (Codex / Claude / etc.)
  → Persist findings (slice → finding ledger)
  → Fix loop: pick one finding → propose patch → validate → land or reject

The fix loop is one finding at a time, with validation — that's a WIP=1 discipline applied to bug remediation.

Key Properties

Slicing > diffing — review surface area maps to functionality, not file boundaries
Persistent finding ledger — review state survives across runs; the same bug isn't re-reported every time
Validation-gated fixes — patches only land if validation passes, mirroring feature-list-as-primitive passing-state gating
Provider-agnostic — the slicer is the value; the model is swappable
Pairs with Crabbox — Clawpatch can validate fixes inside ephemeral Crabbox runners

When to Pick Clawpatch

You're shipping enough volume that file-by-file PR review is missing cross-component bugs
You want a review tool that improves with the codebase (the slice graph is what compounds) rather than starting from scratch each PR
You want the explicit per-finding fix loop, not just commentary
You're already in the OpenClaw ecosystem

When to Pick Something Else

You want a single-CLI in-terminal reviewer → CodeRabbit CLI, Continue
You need code review baked into CI pipelines without standing up another service → GitHub-native review tools

ClawSweeper

Type: Open Source
GitHub: https://github.com/openclaw/clawsweeper · Site: https://clawsweeper.bot
Origin: OpenClaw org, Peter Steinberger
Tagline: "Conservative maintenance bot for OpenClaw repositories."

The six narrow close cases

ClawSweeper will only propose closing an issue or PR if it falls into one of:

Implemented — an exact commit reference on main resolves it
Not reproducible — fresh attempts can't surface the reported behavior
Duplicate — a cluster references the same root cause
Out-of-scope — sits outside the documented project vision
Incoherent — incomplete, malformed, or ambiguous beyond rescue
Stale — older than 60 days with no engagement

The apply lane

Normal mode is proposal-only — Codex makes a structured decision, the bot writes it to items/<number>.md, and a human can read the ledger before anything happens.

Key Properties

Conservatism as a feature — most automation closes too aggressively and erodes maintainer trust; ClawSweeper closes ~nothing per cycle and that's correct behavior
Codex-backed but git-grounded — Codex makes the call, but the final gate is a live GitHub re-fetch and a working-tree-clean check
Persistent decision ledger at items/*.md — every decision is auditable, reversible, and re-runnable
Specifically built for the Steinberger School pattern — when 100 Codex agents are landing fixes on main, you need something proactively closing the old issues those fixes resolve, with exact references

When to Pick ClawSweeper

You have a long-running OSS repo with 1,000+ open issues, most of which are probably stale or implemented
You want triage that maintainers actually trust (the design assumes they don't)
You want issue closures that reference the commit that closed them — searchable institutional memory
You're running OpenClaw or any project that adopts the same automation patterns

When to Pick Something Else

You need PR triage specifically (review, merge automation) — Clawpatch is closer to that
You want a hosted SaaS — ClawSweeper is built to run from your own repo as a GitHub workflow

Hermes Agent

Type: Open Source (MIT)
Stars: 165K (released February 25, 2026; crossed 95K in seven weeks, 165K by mid-May — the fastest-growing OSS agent framework of 2026)
GitHub: https://github.com/NousResearch/hermes-agent
Docs: https://hermes-agent.nousresearch.com/docs/
Origin: Nous Research — the lab behind the Hermes language-model series, Atropos, Nomos, and Psyche
Tagline: "The agent that grows with you."

The closed-loop skill learning system

Most agents are static — same harness, same skills, same behavior on day 1 and day 100. Hermes runs two nested learning loops:

Outer loop (the Curator, every 7 days). v0.12 (April 30 2026) added an autonomous background agent that runs on the gateway's cron ticker and does library-wide maintenance:

Grades skills by usage — what's actually been called, what's been ignored
Consolidates overlapping skills — merges near-duplicates with a model + heuristic
Prunes dead skills — classified consolidated-vs-pruned via model + heuristic; archived rather than deleted, so nothing is destructive
Patches active skills — refines the markdown of frequently-used skills based on the rubric
Writes per-run reports to ~/.hermes/logs/curator/<timestamp>/REPORT.md — human-readable summary showing which skills transitioned, what the reviewer said, and which skills it patched

Three-layer memory architecture

Hermes splits memory into three layers, each living in a specific file and serving a different purpose:

Layer	Storage	Purpose
Frozen identity	`~/.hermes/SOUL.md`, `~/.hermes/memories/MEMORY.md`, `~/.hermes/memories/USER.md`	Persona + frozen facts. Loaded into every system prompt. Rewritten rarely, by the operator or the soul-audit skill.
Episodic (skills)	`~/.hermes/skills/*.md`	Procedural memory — one markdown file per learned skill, with description, triggers, steps, verification. Surfaced via FTS5.
Session search	`~/.hermes/state.db` (SQLite + FTS5)	Every message ever sent in any session, full-text searchable. Agent calls `session_search` to retrieve past conversations.

The 70+ built-in tools (28 toolsets)

Six terminal backends, six layers of trust

Hermes abstracts code execution behind a terminal backend interface with six implementations:

Backend	Use case	Trust / cost
Local	Cheapest, fastest, no isolation	Trusted local work
Docker	Container isolation on the same host	Mostly trusted, fast
SSH	Run on a remote server you control	Trusted operator-managed infra
Daytona	Managed agent sandbox	Untrusted code, sub-100ms cold start
Singularity	HPC-style container	Research compute clusters
Modal	Serverless GPU sandbox	Heavy compute, GPU work

Multi-platform gateway

The Atropos / RL connection

This is where the model-lab origin shows. Hermes Agent ships with Atropos — Nous Research's distributed RL framework — wired in by default:

Every task execution emits a trajectory: tools used, what failed, what succeeded, the outcome
Trajectories are stored as training data
Atropos provides a trajectory API server + Tinker training service + Python environment classes defining tasks, scoring, and reward functions
An integrated RL training pipeline (Tinker-Atropos with GRPO + LoRA adapters) lets you train an LLM on the actual environment Hermes is running in

Pairing with GBrain

If you only run Hermes: you get cross-session memory and self-improving skills, but no structured knowledge graph and no durable background job system.

If you only run GBrain: you get the knowledge graph and job queue, but you're picking your own host agent.

Comparison vs OpenClaw

Both are personal AI agent platforms with messaging-native interfaces, multi-model support, and a "you run it yourself" assumption. The differences:

	OpenClaw	Hermes Agent
Origin	Independent OSS (Peter Steinberger)	Model lab (Nous Research)
Architecture	WebSocket gateway + federated device nodes	Single Python gateway process
Memory	Skill marketplace (ClawHub) + per-workspace storage	Three-layer memory baked in (SOUL/MEMORY/USER + skills + SQLite session search)
Self-improvement	Plugin-based (e.g., NemoClaw)	First-party Curator running on a 7-day cycle, with rubric and audit log
Model loop	Bring-your-own-model	Hermes 3/4 + Atropos RL training built in (any model still works)
Communities	374K stars, sprawling skill marketplace, 30+ hosting vendors	165K stars, tight model-lab-driven release cadence, awesome-hermes-agent tracks the ecosystem
Best fit	Maximum extensibility, multi-device companion apps	Vertically-integrated stack, RL-curious operators, model-training-as-feedback

They're complements as often as alternatives — Steinberger's own setup runs Hermes Agent as one of the underlying engines for OpenClaw work.

When to Pick Hermes Agent

You want a long-running personal agent with cross-session memory and skill accumulation, not a per-task coding tool
You want the agent to improve over time without explicit skill engineering — and you want an audit log of how it improved
You operate in Telegram / Discord / Slack and want the agent reachable there
You're invested in the Nous Research model line and want the agent's trajectories to feed model training
You want a single-process operational footprint rather than a federated mesh of device nodes
You want to pair with GBrain for structured knowledge + durable background jobs

When to Pick Something Else

You need a coding-specific harness → Claude Code + GStack / Superpowers, OpenHands, or Vercel Open Agents
Multi-tenant production where the operator isn't a single trusted user → Claude Managed Agents or a custom harness
Strong audit / compliance requirements — single-operator framing isn't the design center
You want the maximum-extensibility skill marketplace and don't care about the model-loop integration → OpenClaw
You're not running a model lab and don't need the Atropos RL machinery — Hermes still works without it, but the model loop is a chunk of the value you'd be ignoring

Mental model: an agent that the model lab uses on itself

Claude Managed Agents

Type: Commercial / Managed Service (Public Beta)
Launched: April 8, 2026
Vendor: Anthropic
Docs: https://platform.claude.com/docs/en/managed-agents/overview
Pricing: Model tokens + $0.08 per agent runtime hour
Early adopters: Notion, Rakuten, Asana

Architecture

Claude Managed Agents is built around four concepts:

Agent — The model, system prompt, tools, MCP servers, and skills (created once, referenced by ID across sessions)
Environment — A configured container template with pre-installed packages (Python, Node.js, Go, etc.), network access rules, and mounted files
Session — A running agent instance within an environment, performing a specific task and generating outputs
Events — Messages exchanged between your app and the agent (user turns, tool results, status updates), streamed via Server-Sent Events

Built-In Tools

Bash — Run shell commands in the container
File operations — Read, write, edit, glob, grep
Web search and fetch — Search the web and retrieve content from URLs
MCP servers — Connect to external tool providers

Key Properties

Long-running autonomy — Agents can run for hours in the cloud without human interaction
Stateful sessions — Persistent file systems and conversation history across multiple interactions
Built-in prompt caching and compaction — Performance optimizations baked into the harness
Steerable mid-execution — Send additional user events to guide or interrupt the agent
Research-preview features — Outcomes, multi-agent, and memory capabilities (gated access)
Rate limits — 60 create requests/min and 600 read requests/min per organization

Why This Is a New Category

When to Pick Claude Managed Agents

You want the fastest time-to-market for a coding or task agent
Your workflow is a good fit for the built-in tools (bash, file ops, web search, MCP)
You don't need GPU-heavy execution (not exposed)
You're OK with multi-tenant SaaS (not for heavily regulated data)
You don't need custom branching / tree-search / best-of-N semantics

When to Pick Something Else

You need specialized branching semantics → Contree
You need GPU in the sandbox → Modal, Daytona, Northflank
You need enterprise VPC → Northflank, Runloop, or self-hosted
You're building an agent infrastructure product → Layer B sandbox + custom harness

Related Offerings

Messages API — Direct model access for custom agent loops with full control
Claude Code — Anthropic's own coding agent using the harness internally
Claude Cowork — Enterprise collaboration tier with managed agents

Vercel Open Agents

Type: Open Source Template (MIT)
Stars: 5.5K
GitHub: https://github.com/vercel-labs/open-agents
Demo: https://open-agents.dev
Template: https://vercel.com/templates/template/open-agents

Architectural Principle: "The Agent Is Not the Sandbox"

This separation matters because:

Agent execution decouples from request lifecycles — Chat turns can span many persisted workflow steps that survive request timeouts
Sandbox hibernates and resumes independently — Sandbox goes to sleep without killing the agent
Model/provider flexibility — Swap models without touching the sandbox
Sandbox stays single-purpose — It's an execution environment, not a control plane

Three-Layer Architecture

Web Layer — Next.js app handling auth, sessions, chat UI, streaming. Built on Vercel AI SDK + Chat SDK.
Agent Workflow — Durable workflow execution via Vercel Workflow SDK. Streaming, cancellation, persistent state across multi-step runs. Reconnectable streams.
Sandbox VM — Vercel Sandbox (Firecracker microVM) with filesystem, shell, git, dev servers. Exposes ports 3000, 5173, 4321, 8000. Snapshot-based resume. Hibernates after inactivity.

Repo Structure

apps/web         — Next.js, workflows, auth, chat UI
packages/agent   — agent loop, tools, subagents, skills
packages/sandbox — sandbox abstraction + Vercel integration
packages/shared  — utilities

Agent Capabilities

Tool suite — File read/write/edit, grep/glob search, shell commands, task management, web fetch, skill invocation
Skills system — Modular agent skills in .agents/skills with a skills-lock.json for versioning (compatible with vercel-labs/skills npx skills)
Subagents — Multi-agent coordination built in
Repo cloning — Clone any GitHub repo into the sandbox, work on branches
Auto-commit / auto-PR — Optional, preference-driven (not always on). Can open PRs with summaries.
Session sharing — Read-only share links for audit/review
Voice input — ElevenLabs transcription for spoken commands
MCP tool support — Connect external tools via Model Context Protocol

Stack

Frameworks: Next.js, Tailwind CSS
SDKs: Vercel Workflow SDK, Vercel AI SDK, Vercel Chat SDK
Database: PostgreSQL (required) — works with Neon by default
Cache: Redis/Upstash KV (optional, for metadata)
Package manager: Bun (local dev)
Runtime: 99.3% TypeScript

Deployment Environment Variables

Minimum: POSTGRES_URL, JWE_SECRET
Recommended: ENCRYPTION_KEY + Vercel OAuth credentials
Full-featured: GitHub App (ID, client secret, private key, webhook secret)
Optional: Redis/KV, ElevenLabs API, custom sandbox snapshots

GitHub App Integration

Uses the GitHub App's user authorization flow:

Repository access via installation
Private repo cloning
Branch pushing
PR creation with automated summaries
Webhook events for status updates

Organization-level installations require the app to be public.

Why This Matters

When to Pick Open Agents

You want a production-ready starting point instead of building from scratch
You're already on Vercel or want to be
You want full control over the agent harness (unlike Claude Managed Agents)
You want the "agent outside the sandbox" architectural pattern
You need durable multi-step workflows with streaming
You want GitHub App integration out of the box

When to Pick Something Else

Fastest time-to-market with zero infra → Claude Managed Agents
Tree-search / branching-heavy workflows → Contree + custom harness
Non-Vercel deployment target → AgentField or a custom stack
Heavy GPU requirements → Modal-based harness instead

Related Vercel Agent Products

Open Agents is the community template. Vercel also ships a broader Vercel Agents platform that includes:

AI Gateway — Unified endpoint for model routing, provider failover, embeddings (see Inference)
Vercel Sandbox — Firecracker microVM execution (see Sandboxes)
Vercel Workflow SDK — Durable execution primitives
Vercel AI SDK — TypeScript toolkit for streaming, tool use, structured outputs
Vercel Agent — Stack-aware agent for the Vercel platform itself

Open Agents stitches these together into a reference application — it's both a product demonstration and a production-ready template.

OpenAI Symphony

Type: Open Source (Apache 2.0)
Stars: 25K
GitHub: https://github.com/openai/symphony
Origin: OpenAI, released as engineering preview
Reference: https://www.latent.space/p/harness-eng

Architecture

Symphony has a 6-layer architecture built on Elixir/BEAM:

Policy layer — Enforcement rules (e.g., "CI must pass before merge")
Configuration layer — Environment setup and agent provisioning
Coordination layer — Work distribution, task queuing, agent assignment
Execution layer — Agent runtime with isolated worktrees per task
Integration layer — External system connections (Linear, GitHub, Slack)
Observability layer — Tracing, metrics, logging across all agent activity

Key Properties

Work queue monitoring — Watches task boards (e.g., Linear) and spawns agents for new assignments
Proof of work — Agents produce CI status, PR feedback, complexity metrics, and walkthrough videos
Rework state — If a PR isn't mergeable, trash the worktree and restart from scratch
Daily improvement loops — Agents analyze session logs to identify areas for improvement
Self-ticketing — Agents cut their own follow-up tickets
Spec-driven — Distributed as a formal specification (SPEC.md) that teams implement in any language
Elixir reference implementation — BEAM runtime chosen for process supervision, gen servers, and resumability
Human role shift — From code review to 1-2x daily yes/no decisions on batched PRs

Harness Engineering Context

Results (from Latent Space interview)

1M+ lines of code, 1,500+ PRs, zero manually written code over 5 months
Team of 3 managing output equivalent to much larger teams
Before GPT-5.2: 3.5 PRs/engineer/day; after: 5-10 PRs/engineer/day
500 NPM packages in codebase (described as "10,000 engineer level architecture")

PostHog Code

Type: Commercial — beta May 2026, GA Spring 2026
Form factor: Desktop app + agent framework (public monorepo)
Vendor: PostHog
Page: https://posthog.com/code
Docs: https://posthog.com/docs/posthog-code
GitHub: https://github.com/PostHog/code
Models: OpenAI (GPT-5.x), Anthropic (Claude Sonnet / Opus / Haiku)
Integrations: GitHub, Linear, Slack, CRM/billing — and PostHog itself via MCP

Architecture

Desktop app — Runs locally, connects to repos; not a hosted SaaS agent
Public monorepo — posthog/code ships both the desktop apps and the underlying agent framework
Production-data ingestion — Signals pulled directly from PostHog: events, errors, replays, funnels, experiments, support tickets
Swarm topology — One agent writes code, another writes tests, another reviews PRs, another manages tickets (per PostHog leadership's "machine team" framing)
Prioritized work queue — Auto-ships fixes that meet a confidence threshold; surfaces the rest as a ranked to-do list
Self-instrumenting PRs — Generated diffs include PostHog event-capture, error boundaries, feature flags, and experiment scaffolding so the next iteration has even more signal
MCP-fronted integrations — GitHub for PRs, Linear for tickets, Slack for routing, CRM/billing for revenue impact; PostHog also exposes itself via MCP so external agents (editor, chat) can query analytics and create experiments

Key Properties

Product-first context — First coding agent to treat product analytics, not just the repo, as primary context
Closed feedback loop — Each shipped PR adds instrumentation that feeds the next agent run
Proactive vs. prompted — Surfaces bugs from production telemetry rather than waiting for an engineer to file them
Auto-ship vs. queue split — Confidence-gated automation, with humans kept in the loop for the non-obvious work
Local-first — Desktop form factor (vs. cloud-only agents); the framework is also runnable standalone
Multi-provider — Frontier models from OpenAI and Anthropic side-by-side
Bring-your-own-PostHog — Value proportional to how well-instrumented the existing product already is

Where it fits

Rivet Sandbox Agent

Type: Open Source
Stars: 1.4K
GitHub: https://github.com/rivet-dev/sandbox-agent

Universal HTTP API to run any coding agent (Claude Code, Codex, OpenCode, Amp) in isolated sandboxes. The infrastructure layer for building a Minions-like system.

Architecture

Universal agent API — Single HTTP interface for any coding agent
Multi-runtime — E2B, Daytona, Modal, Docker support
Session management — Persistent sessions with event streaming
Audit logging — Full audit trail for compliance

Key Properties

Devbox equivalent — Best open-source match for Stripe's sandbox infrastructure
Composable — Combine with any agent and orchestrator
Gap: Infrastructure layer only, not a complete autonomous agent

DeerFlow

Type: Open Source
Stars: 69K
GitHub: https://github.com/bytedance/deer-flow
Origin: ByteDance; DeerFlow 1.0 in 2025, DeerFlow 2.0 launched March 2026
Description: "An open-source long-horizon SuperAgent harness that researches, codes, and creates."

Architecture

SuperAgent + subagents — lead receives the goal, decomposes into subtasks, spawns parallel subagents in isolated sandboxes
LangGraph-based workflow — stateful graph orchestration; integrates web search, crawling, Python execution, RAG retrieval, and MCP tool invocation
Docker / Jupyter sandboxes — agent-generated code runs isolated from the host (see Sandboxes)
Skill system (added in 2.0) — reusable agent capabilities composable across runs: web research, data analysis, content generation, image creation, custom
Persistent state memory — structured memory store beyond the LLM context window
Message gateway — subagent communication and coordination

Key Properties

Big Tech OSS — backed by ByteDance, comparable scale to Alibaba's OpenSandbox; demonstrates that the SuperAgent + sandbox + memory + skills pattern is converging cross-vendor
Long-horizon focus — designed for tasks that take minutes to hours, not single-turn responses
Multi-model out of the box via LangChain, so the same harness can mix cheap routers and expensive reasoners (see Inference Strategy for Agents)
Not coding-specific — handles research, creative work, and coding from the same harness; closer to OpenAI Symphony than to Claude Managed Agents in scope

When to Pick DeerFlow

You want a single open-source SuperAgent that handles mixed research / coding / content work
You're invested in the LangGraph / LangChain ecosystem
You want a Big-Tech-backed OSS framework rather than a startup project
You need long-horizon execution (hours) with subagent coordination and persistent memory in one package

When to Pick Something Else

Pure coding workflow on Claude → GStack + Conductor
Vertically integrated managed offering → Claude Managed Agents
You want an Elixir/BEAM-backed reference architecture → OpenAI Symphony
Strong typed-state agent supervision with three nested failure loops → AgentField

GStack

Type: Open Source (MIT)
Stars: 102K
GitHub: https://github.com/garrytan/gstack
Origin: Garry Tan (President & CEO, Y Combinator), released March 2026
Companion site: https://gstacks.org/

Install

git clone --single-branch --depth 1 https://github.com/garrytan/gstack.git \
  ~/.claude/skills/gstack && cd ~/.claude/skills/gstack && ./setup

Requires a Claude Pro or Team subscription (Claude Code itself).

The 23 skills

Recommended workflow loop

Key Properties

YC-CEO-grade prompts — each skill is a battle-tested SKILL.md with explicit verification standards. The intellectual content (not just the structure) is the differentiator.
Persona-first — every command is bound to a specialist role with permission boundaries and a definition-of-done.
Pairs with Conductor — Garry's reported workflow is gstack inside Conductor, running 10–15 parallel sprints across Claude Code worktrees on a single Mac. He reports 600K production LOC in 60 days using this combination.
Browser policy — /browse replaces direct Chrome DevTools MCP usage; the skill encodes how to use it correctly so the agent doesn't reinvent the wheel.
Skills standard — uses the cross-agent SKILL.md format documented in Skills, Plugins & Marketplaces, so it also works in Codex, Cursor, OpenCode, etc. via npx skills add.

When to Pick GStack

You want a working harness today, not a framework to build one
Your work is product/web-application development (where the personas were tuned)
You're willing to adopt one opinionated workflow rather than wire your own
You want to pair with parallel-worktree runners like Conductor or Superset

When to Pick Something Else

Highly novel algorithms, hardware-adjacent code, or heavily regulated domains — Garry himself notes the gains are much smaller here
You need a runtime control plane with hooks, gates, and a GUI → AgentHub instead, or wire the harness yourself per Harness Engineering
Non-Claude-Code agent → Mostly portable via SKILL.md, but some commands assume Claude Code's tool set

Superpowers

Type: Open Source (skills framework)
Stars: 205K (one of the fastest-growing OSS AI projects of 2026)
GitHub: https://github.com/obra/superpowers
Origin: Jesse Vincent (creator of Request Tracker, ex-Perl-5 release manager, co-founder Keyboardio) and Prime Radiant. Built the first version in October 2025, the same week Anthropic shipped the Claude Code plugin system.

What it actually enforces

Brainstorming-first — A brainstorming skill activates before code is written: refines rough ideas through dialogue, explores alternatives, presents the design in sections for human validation, and saves a design document. The agent isn't allowed to skip this.
Bite-sized tasks — After design approval, work is broken into 2–5-minute units with exact file paths, complete code context, and verification steps. This is the WIP=1 / feature-list-as-primitive discipline from Harness Engineering, packaged as a workflow.
TDD enforcement — Tests come before implementation, enforced as a skill, not just documented.
Autonomous subagents — Long execution is delegated to subagents that report back; the main session stays focused on direction.

Key Properties

Composable skills + an initial instruction set that ensures the agent actually uses them
Works across Claude Code, Codex, and Cursor via per-host plugin manifests in the repo (.cursor-plugin/, .codex-plugin/)
Methodology, not just templates — the design-then-implement gates are the differentiator
Authored by someone who's been shipping production OSS for 25+ years, which is unusual signal in this space

When to Pick Superpowers vs GStack

Superpowers when the team is shipping novel/research-y software and benefits from forcing-function design gates and TDD
GStack when the team is shipping product/web apps and benefits from YC-CEO-grade prompts tuned for that domain
They can run side-by-side — both install as skills in ~/.claude/skills/, and a skill router can pick per-task

Everything Claude Code

Type: Open Source (MIT)
Stars: 190K
GitHub: https://github.com/affaan-m/ECC
npm: ecc-universal (full pack) · ecc-agentshield (security audit standalone)
Origin: Affaan M., shipped at the Cerebral Valley × Anthropic Claude Code Hackathon (Feb 2026); reached v2.0.0-rc.1 April 2026
Also known as: ECC (the repo was renamed from everything-claude-code to ECC in 2026; the README now describes ECC as the brand, with no canonical acronym expansion)

Scope

The pack ships, per the v2.0 README:

63 subagents for delegated tasks (planning, review, refactor, security, language specialists)
249 skills — SKILL.md-style workflow definitions
Hook automations across 8+ event types (PreToolUse, PostToolUse, Stop, SessionStart, SessionEnd, etc.)
14 MCP server configurations — GitHub, Context7, Exa, Playwright, and others, pre-wired
34 language/framework rule packs — TypeScript, Python, Go, Swift, PHP, ArkTS, plus common rules
AgentShield — the security-audit subsystem, now distributed standalone as ecc-agentshield

AgentShield: security audit as a first-class subsystem

Secrets detection (14 patterns) — API keys, tokens, credentials accidentally committed to harness config
Permission auditing — overly-broad allowlists, missing denylists, dangerous default scopes
Hook injection analysis — Pre/PostToolUse hooks that could be exploited
MCP server risk profiling — untrusted MCP servers, missing auth, scope creep
Agent config review — agent definitions that over-grant capabilities

Key Properties

Multi-harness installer — single source of truth deploys to .claude/, .cursor/, .opencode/, .codex/, .gemini/, .zed/, and Copilot .github/ skill directories
Skills-first methodology — pattern extraction, continuous learning, and token-optimization framing taken from the SKILL.md / Claude Code Plugin tradition
Pairs with Agent Identity, Auth & Secrets — AgentShield audits the configuration that runtime governance enforces
Composable with single-angle packs — install AgentShield alongside GStack or Superpowers if you want their workflow opinions plus ECC's audit layer

When to Pick It

You want a batteries-included starting harness across multiple coding agents, not just Claude Code
You manage .claude/ (or equivalent) installs across a team and want secrets / permission / hook auditing as a discoverable command, not a custom script
You want red-team / blue-team / auditor patterns for harness security without building them yourself — install just ecc-agentshield for the security slice alone

GBrain

Type: Open Source (MIT)
Stars: 19K
GitHub: https://github.com/garrytan/gbrain
Origin: Garry Tan, 2026; the persistent-memory companion to GStack
Tagline: "Your AI agent is smart but forgetful. GBrain gives it a brain."

Install

Either auto-install via an agent:

Retrieve and follow the instructions at:
https://raw.githubusercontent.com/garrytan/gbrain/master/INSTALL_FOR_AGENTS.md

Or standalone CLI:

git clone https://github.com/garrytan/gbrain.git && cd gbrain && bun install && bun link
gbrain init    # local PGLite brain ready in ~2 seconds

Approximately 30 minutes end-to-end, mostly answering API-key prompts. PGLite is the default (embedded Postgres 17.5, zero config); migrate to Supabase Pro when you outgrow local.

Architecture: thin harness, fat skills

The repo (markdown files) is the system of record. GBrain is the retrieval + graph + scheduler layer:

Brain Repo (git, markdown)
       ↓                                 ↑
  GBrain engine (Postgres + pgvector  / PGLite)
       ↓ ↑
  AI Agent — 29 skills define HOW to use the brain
  RESOLVER.md (or AGENTS.md) routes intent → skill

The 29 skills, by role

Role	Skill
Always-on	`signal-detector` (fires on every message, captures original thinking + entity refs in parallel), `brain-ops` (brain-first lookup before any external API)
Ingestion	`ingest` (router), `idea-ingest` (links/articles/tweets), `media-ingest` (video/audio/PDF/books/screenshots/repos), `meeting-ingestion` (transcripts → attendee enrichment + company timelines)
Brain ops	`enrich` (tiered: stub → web+social → full pipeline), `query` (3-layer search with synthesis), `maintain` (stale pages, orphans, citation audit), `citation-fixer`, `repo-architecture`, `publish`, `data-research`
Operational	`daily-task-manager`, `daily-task-prep`, `cron-scheduler`, `reports`, `cross-modal-review` (second-model quality gate), `webhook-transforms`, `testing`, `skill-creator`, `skillify`, `skillpack-check`, `smoke-test`, `minion-orchestrator`
Identity / setup	`soul-audit` (generates `SOUL.md` + `USER.md` + `ACCESS_POLICY.md` + `HEARTBEAT.md`), `setup`, `migrate` (Obsidian / Notion / Logseq / Roam / CSV / JSON), `briefing`

Knowledge graph (zero-LLM auto-linking)

gbrain extract links --source db
gbrain extract timeline --source db

Search (hybrid, benchmarked)

Minions — the durable job queue built into the brain

	Minions	Sub-agent spawn
Wall time	753 ms	10s+ (gateway timeout)
Token cost	$0	~$0.03/run
Success rate	100%	0% (couldn't spawn)
Memory/job	~2 MB	~80 MB

Skillify — the "skillify it!" meta-skill

This is the cleanest implementation of Harness Engineering § review-feedback promotion I've seen — every recurring agent failure becomes a permanent, structurally-enforced check.

MCP surface

Exposes 30+ MCP tools via stdio for Claude Code / Cursor / Windsurf, or as a remote MCP for Claude Desktop / Claude Cowork / Perplexity (HTTP transport, auth tokens, ngrok-friendly).

Integration recipes

Key Properties

Self-wiring knowledge graph — typed edges extracted with zero LLM calls on every write; backfillable on existing brains.
Repo as system of record — markdown files are the truth; the engine is a retrieval layer. Human always wins on conflicts.
Compiled truth + timeline — every page separates "current best understanding" (rewritable) from "evidence trail" (append-only).
Durable everything — gbrain agent run survives crashes; tool calls persist as a two-phase pending → complete | failed ledger; replay is safe by construction.
Reproducible benchmarks — BrainBench corpus and A/B harness in gbrain-evals; ablation shows the graph layer + extract quality together carry the gap.
Pluggable engine — PGLite by default; gbrain migrate --to supabase (bidirectional) when you outgrow local. S3 / R2 / MinIO / Supabase Storage / local for binary files.

When to Pick GBrain

You want a long-term, persistent memory layer for an agent that ingests messy real-world signal (meetings, email, voice, social)
You want a knowledge graph but don't want to wire one yourself
You're running OpenClaw or Hermes Agent and want Garry's actual deployment patterns
You want a durable job queue for deterministic background work, not just inference-style agent calls
You're using GStack for coding and want the matching memory/ops side

When to Pick Something Else

You just need short-term conversation memory → Mem0, Letta, Zep
You don't want to run Postgres / PGLite → simpler vector-only memory layers
Your data is heavily regulated / multi-tenant — single-user "personal brain" framing isn't the design center
You want a black-box hosted memory API rather than git-as-source-of-truth — see Letta or Graphlit

AgentHub

Type: Open Source (MIT)
GitHub: https://github.com/Stanshy/AgentHub
Origin: Stanshy, 2026; companion to the Claude Code Mastery course (the same intellectual lineage as the Walking Labs Learn Harness Engineering course referenced in Harness Engineering)
Stack: Electron 35, Vue 3, TailwindCSS 4, Pinia, sql.js (WASM SQLite), xterm.js + node-pty, chokidar

The four harness primitives

Primitive	What it does	Maps to
Skill (23 built-in)	Workflow templates auto-loaded per task type — `/sprint-proposal`, `/task-dispatch`, `/review`, `/gate-record`, `/pre-deploy`, `/harness-audit`, etc.	Instructions + Tools
Hook (5 templates)	Runtime interceptors. PreToolUse blocks `kill-port`, `--no-verify`, `force push main`. PostToolUse forces doc sync when core services change. Stop refuses session end until tests + typecheck pass.	Feedback
FileWatcher	`chokidar` watches `.tasks/*.md` — markdown IS the database. Change → parse → SQLite upsert → eventBus → Vue reactive update → GUI live-reflects	State
Gate	G0 Requirements → G1 Design → G2 Code Review → G3 Test → G4 Doc → G5 Deploy-Ready → G6 Released. Architecturally enforced, can't skip.	Verification + Lifecycle

The org chart

L1 (8 leadership agents reporting to the boss): Product Manager, Tech Lead, Design Director, Marketing Lead, QA Lead, Project Lead, Operations Lead, Company Manager.

Key Properties

Router CLAUDE.md (3.19 KB / 75 lines) — the cleanest real-world implementation of the "50–200 line entry file + topic docs" pattern from Harness Engineering § Progressive Disclosure. Three "fatal rules" + commands + index; every real rule lives in a .knowledge/*.md topic doc.
Rules promoted to executable checks — dangerous commands aren't documented, they're blocked by PreToolUse Hook. The repo's own example of agent-oriented error messages with fix instructions.
Markdown-as-database — .tasks/*.md, .knowledge/*.md, dev-plan.md are the single source of truth; the GUI is a live view, not an alternative store.
Project scaffolding — one click generates a full Harness (CLAUDE.md + .knowledge/ + Skills + Hooks) into a child project, with 4 templates (web-app / api-service / library / mobile-app).
Cross-project knowledge — postmortems and gotchas captured in one project sync to a company-wide store and inherit to new projects.
Slogan worth quoting: "A good validator with a bad workflow beats a good workflow without a validator." Their arithmetic: 5 serial steps at 80% = 33% end-to-end; add a validator with retry = 99%. The whole product is built around that math.

When to Pick AgentHub

You want a runtime control plane (not just templates) for Claude Code agent work
You want hooks + gates + filewatcher as a managed GUI surface, not as files you maintain by hand
You want to formalize a multi-role org structure (PM / TL / DD …) rather than treat agents as undifferentiated workers
You're on Windows / macOS / Linux and OK with an Electron desktop app

When to Pick Something Else

You're a hands-on terminal user who'd rather wire the harness yourself in ~/.claude/ → GStack or roll your own per Harness Engineering
You want parallel multi-agent worktrees on a single repo, not a single-session-at-a-time harness → Conductor, Superset, Orchestrator.build
You don't use Claude Code — AgentHub depends on the Claude Code CLI as its execution engine

Terminal coding CLIs

The short version: harness is the differentiator, not the model. Benchmark top-3 spots are typically taken by the same 2-3 harnesses across different models (see Benchmarks).

CLI	Maintainer	Notable for	Docs
ForgeCode (`forge`)	TailCall	#1 on Terminal Bench 2.0 (81.8%) — multi-model TUI	forgecode.dev
Claude Code (`claude`)	Anthropic	Reference agentic-coding CLI, full codebase read + command exec	docs.anthropic.com/claude-code
Codex CLI (`codex`)	OpenAI	Autonomous coding, open source	github.com/openai/codex
Gemini CLI (`gemini`)	Google	Gemini + Google Cloud integration	github.com/google-gemini/gemini-cli
GitHub Copilot CLI (`github-copilot-cli`)	GitHub	Terminal-side Copilot, agentic	docs.github.com/copilot/cli
Droid (`droid`)	Factory AI	#6 on Terminal Bench 2.0 (77.3%)	factory.ai
Goose (`goose`)	Block	MCP-native, 70+ extensions, Stripe Minions ancestor	github.com/block/goose
Aider (`aider`)	Aider	Popular OSS pair programmer, git-native file editing	aider.chat
Crush (`crush`)	Charmbracelet	Polished TUI coding agent	github.com/charmbracelet/crush
Amp (`amp`)	Sourcegraph	Multi-repo agentic coding (formerly Cody)	ampcode.com
Junie CLI (`junie`)	JetBrains	JetBrains' terminal agent	junie.jetbrains.com
OpenCode (`opencode`)	Community	Multi-model TUI assistant (165K stars)	opencode.ai
Qwen Code (`qwen`)	Alibaba	Qwen-backed coding assistant	github.com/QwenLM/qwen-code
Amazon Q CLI (`q`)	AWS	AWS-integrated coding + cloud agent	aws.amazon.com/q
Grok CLI (`grok`)	Community	Open-source Grok terminal assistant	github.com/superagent-ai/grok-cli
T3 Code (`t3`)	Ping.gg / Theo	Coding-agent workspace launcher	github.com/pingdotgg/t3code
Kilo CLI (`kilo`)	Kilo	Keyboard-first, multi-provider model support	kilo.ai/docs
Plandex (`plandex`)	Plandex	Multi-step task planner with diff management	github.com/plandex-ai/plandex
Kiro CLI (`kiro`)	AWS	Spec-driven agentic coding	kiro.dev
Continue (`cn`)	Continue	Source-controlled AI checks, CI-enforceable (33K stars)	continue.dev
Letta Code (`letta`)	Letta AI	Memory-first agent	github.com/letta-ai/letta-code
iFlow CLI (`iflow`)	iFlow AI	Multi-model with free access to Kimi, Qwen, DeepSeek	github.com/iflow-ai/iflow-cli
Qoder CLI (`qodercli`)	Qoder	Terminal AI assistant	qoder.com
Cline CLI (`cline-cli`)	Cline	Autonomous terminal agent (open source, ex-VS Code extension)	docs.cline.bot
CodeRabbit CLI (`coderabbit`)	CodeRabbit	AI code reviews for staged/unstaged changes	coderabbit.ai/cli
Pi (`pi`)	Mario Zechner / earendil-works (MIT)	Minimal pi-mono harness — TS extensions, skills, prompt templates, themes; runs interactive / print / RPC / SDK modes; the agent inside OpenClaw	pi.dev
OpenDev (`opendev`)	opendev-to (MIT)	Rust-native CLI with ~4ms startup, Web UI for remote sessions, five-slot workflow ensemble (Normal / Thinking / Compact / Self-Critique / VLM) each bound to a different model	github.com/opendev-to/opendev
Claw Code (`claw`)	Sigrid Jin (Apache 2.0)	Clean-room Rust + Python rewrite of the Claude Code harness after the March 2026 source leak; fastest repo in GitHub history to 100K stars	claw-code.codes
Warp (`warp`)	Warp (AGPLv3 client + MIT UI framework)	Agentic development environment born from the terminal; open-sourced April 27 2026, multi-model including open weights (Kimi, MiniMax, Qwen) with an "auto (open)" router, TOML config; its own development is steered through Oz	github.com/warpdotdev/warp

How they differ

Who owns the model — Claude Code, Codex, Gemini, Amazon Q, Kiro, Junie, Amp are model-provider-native (the vendor ships both scaffolding and preferred model). ForgeCode, OpenCode, Aider, Crush, Goose, Cline, Plandex are harness-first and BYO-model via API key or local inference.
Interaction model — Aider, Claude Code, Codex are interactive by default. Kiro is spec-driven (write a spec, the agent implements it). Plandex plans multi-step changes and manages diffs across them. Goose + MCP extensions is closest to an agent platform you assemble.
Where it runs — All 25 run inside Docking Station, a single Docker image intended for installing everything once and switching between harnesses while comparing on the same workspace.
CI use — Continue, CodeRabbit, GitHub Copilot CLI and Claude Code are designed for non-interactive CI invocation. Most of the others can be scripted but are optimized for developer-in-the-loop.

Picking one

Just want it to work, minimal setup — Claude Code, Codex, Gemini CLI.
Maximize benchmark-proven capability — ForgeCode, Droid (both rank top-10 on Terminal Bench 2.0).
Open source + multi-model + self-host — OpenCode, Aider, Goose, Pi, OpenDev, Claw Code, Warp.
In-CI code review — CodeRabbit, Continue.
Spec-driven, explicit plans — Kiro, Plandex.
Memory across sessions — Letta Code.
Tiny / hackable harness you read end-to-end — Pi, mini-SWE-agent.
Enterprise/cloud stack alignment — Amazon Q (AWS), Kiro (AWS), Junie (JetBrains), Gemini CLI (GCP).

Skills, Plugins & Marketplaces

Tooling

Project	License	What it is	Notes
Claude Code Plugins (anthropics/claude-plugins-official)	MIT	Anthropic's official plugin distribution system + verified marketplace	Public beta Oct 2025, stable 2026; sources: GitHub, npm, GitLab, local paths; permission controls + version pinning
Vercel Skills (vercel-labs/skills)	MIT	`npx skills add <repo>` CLI that installs SKILL.md skills into 51+ agents	Compatible with Claude Code, Codex, Cursor, Windsurf, Cline, Goose, Gemini CLI, Roo Code, Amp, Kiro and more
Cursor Rules (`.cursorrules`)	Cursor (proprietary)	Plain-text rules loaded into context for every interaction	No discovery / on-demand loading — applies globally to the project
Continue rules (continue.dev)	Apache 2.0	Source-controlled rules + prompts as CI artifacts	CI-enforceable; rules ship with the repo
Anthropic Skill Marketplace (claudemarketplaces.com)	Community	Discovery directory across plugins, skills, MCP servers	4.2K+ skills, 770+ MCP servers, 2.5K+ marketplaces as of May 2026
tonsofskills.com / `ccpi` CLI (jeremylongshore/claude-code-plugins-plus-skills)	OSS	425 plugins, 2,810 skills, 200 agents — community-curated package manager	Largest community catalog
Vercel React Best Practices skill (github.com/vercel-labs/react-best-practices)	MIT	40+ React/Next.js performance rules packaged as a skill	First-party "reference" skill from a model-adjacent vendor

How the formats compare

Cursor Rules — Always-loaded plain text. Simple but no task-specific gating, so the rules file becomes a bottleneck once it grows.
SKILL.md (Claude Code, Codex, OpenCode, etc.) — Description-matched, loaded on demand. Agent reads only metadata at start; full body loads when relevant. Same YAML-frontmatter format across ecosystems.
Continue rules — Stored in source, evaluated like CI; designed for teams who want rules to ship and gate alongside code.

When to choose which

Building one-off rules for your team — Start with .cursorrules or a single SKILL.md committed to the repo. Cheapest path.
Distributing reusable expertise — Plugin format (Anthropic plugin marketplace), so other teams can install with one command.
Cross-agent compatibility — Use SKILL.md + npx skills (Vercel Skills) to install into the broadest set of agents from one source.
Enforce rules in CI — Continue's source-controlled rules.

Browser-Use & Computer-Use Frameworks

For agentic engineering teams, these matter as tools an agent calls — for QA, deploy verification, scraping, third-party SaaS automation — rather than as the agent itself.

Framework	License	Approach	Notable for
Browser Use (browser-use/browser-use)	MIT	DOM + accessibility tree, any LLM	95K stars (one of the fastest-growing OSS AI projects), 89.1% on WebVoyager; YC-backed, hosted version $30/mo
Stagehand (browserbase/stagehand)	MIT	Natural-language wrapper on Playwright	TypeScript + Python; built and maintained by Browserbase as the SDK for browser agents
Chrome DevTools MCP (ChromeDevTools/chrome-devtools-mcp)	Apache-2.0	Official Google MCP server exposing the full Chrome DevTools surface to agents	42K stars, v1.0.1 (May 2026), TypeScript, stdio MCP. Tools: navigate / click / form-fill, screenshot + DOM snapshot, console + network capture, JS evaluation with source-mapped stack traces, performance traces + Lighthouse + CrUX field data, heap snapshots, extension management, device emulation. Drops into Claude Code, Cursor, Copilot, Cline, VS Code, Gemini CLI, JetBrains and 15+ others via `npx chrome-devtools-mcp@latest`. "Slim mode" for basic tasks; auto-waits on action results
Skyvern (Skyvern-AI/skyvern)	AGPL-3.0	LLM + computer-vision Playwright SDK	No-code workflow builder + SDK (Launch Week Jan 2026); embedded local + remote cloud modes
Magnitude (magnitudedev/browser-agent)	OSS	Vision-first; uses screenshots, not DOM	94% on WebVoyager (state-of-the-art); built-in test runner with visual assertions; recommends Claude Sonnet or Qwen-2.5VL 72B
Open-CUAK	OSS	"Kubernetes for Computer Use Agents"	Hire / teach / manage automation agents; explicitly framed as the OpenAI Operator alternative
Open Computer Agent (Hugging Face)	OSS	Hosted computer-use stack	Free Operator-class agent; runs against shared Hugging Face Spaces infra
Anthropic Computer Use (docs.claude.com)	Anthropic API	First-party vision + action tool surface	Generally available via API; the foundation under Claude Cowork (GA April 9, 2026); Sonnet/Opus drive scoring on real GUIs
Claude Cowork (claude.com/cowork)	Anthropic (paid)	Desktop computer-use agent for end users	GA April 9 2026 on macOS / Windows; manages files, drafts docs, runs multi-step workflows. Distinct from coding-agent products like Claude Code
OpenAI Operator (operator.chatgpt.com)	Closed (Pro)	First-party hosted computer-use agent	$200/mo ChatGPT Pro; the benchmark the OSS frameworks measure against

How to think about adoption

Add browsing as a tool to a coding agent → Stagehand (cleanest Playwright DX) or Browser Use (largest community, broad model support).
DevTools-grade inspection for agentic QA/debug (perf traces, Lighthouse, network capture, source-mapped stack traces) → Chrome DevTools MCP — first-party Google MCP surface, drops into any MCP-aware agent in one command.
Vision-first apps where DOM scraping fails (canvas, custom UIs, Flash-equivalents) → Magnitude.
Self-host a full Operator alternative for end users → Open-CUAK or Open Computer Agent.
Already on Claude → Anthropic Computer Use directly via the API; Claude Cowork if you want the productized desktop UX.
Visual testing / regression → Magnitude (visual assertions), Skyvern (workflow builder), or Stagehand on top of Playwright's existing assertions.

Feature Matrix

Project	Stars	Unattended PR	Orchestration	Sandbox	MCP	CI Feedback	Multi-Agent	License
Claude Managed Agents	N/A	Yes	Built-in harness	Managed container	Yes (MCP)	Yes	Research preview	Commercial
Stripe Minions	N/A	Yes	Blueprints	EC2 Devboxes	Yes (~500 tools)	Yes (2 rounds)	Parallel runs	Proprietary
AgentField	1.4K	Yes	SWE-AF levels	Git Worktrees	Agent mesh	Yes (gated)	Yes (orchestrated)	Apache 2.0
OpenHands	71K	Yes	Planning Mode	Docker	No	Yes	No	MIT
Open SWE	9.5K	Yes	LangGraph	Cloud sandbox	No	Yes	Yes (4 agents)	Open Source
OhMyOpenAgent	50.6K	Partial	Named agents	No	Yes (built-in)	Partial	Yes (team)	Open Source
OpenCode	142K	Partial (GH mode)	No	No	No	No	No	Open Source
SWE-agent	19K	Yes	No	Docker	No	Partial	No	MIT
Composio	6.2K	Yes	Task decomp	Configurable	No	Yes	Yes (parallel)	Open Source
Patchwork	1.5K	Yes	Patchflows	No	No	Yes (CI/CD)	No	Open Source
Goose	41K	No (interactive)	No	No	Yes (70+ tools)	No	No	Apache 2.0
Symphony	15K+	Yes	6-layer architecture	Worktrees	Via integrations	Yes (CI-gated)	Yes (orchestrated)	Apache 2.0
Vercel Open Agents	3.7K	Yes	Vercel Workflow SDK (durable)	Vercel Sandbox (microVM)	Yes (MCP)	Via tools	Subagents built-in	MIT
Mastra	22.9K	Framework	Workflows	Configurable	Yes (MCP)	Via workflows	Via workflows	Apache 2.0
OpenClaw	355K	Via skills	No	Via NemoClaw	No	No	Yes (sessions)	Open Source
Rivet Sandbox	1.3K	Infrastructure	No	Yes (multi-runtime)	No	No	API-level	Open Source

Capability Breakdown

Best for Unattended PR Production

Stripe Minions — Gold standard, 1,300+ PRs/week in production
OpenHands — Most mature open-source option, 50%+ SWE-bench
Open SWE — Best multi-agent architecture for PR production

Best for Orchestration / Workflow

Stripe Minions — Blueprints (hybrid deterministic + agentic)
Patchwork — Patchflows (closest open-source blueprint analog)
Open SWE — LangGraph (graph-based multi-agent)

Best for Sandbox Isolation

Stripe Minions — EC2 devboxes, pre-warmed in 10s
Rivet Sandbox Agent — Universal API for any agent in any sandbox
OpenHands — Docker-based, Kubernetes-ready

Best for Multi-Agent Parallelization

Composio Orchestrator — Purpose-built for parallel agent coordination
AgentField — Full orchestration with failure recovery
OhMyOpenAgent — Named specialist team with model routing

Best for Context Management

Stripe Minions — Toolshed MCP (~500 tools), conditional rules, pre-hydration
OhMyOpenAgent — Hierarchical AGENTS.md, built-in MCPs, multi-model routing
Goose — MCP-native with 70+ extensions

Best for Failure Recovery

AgentField — Three nested loops, typed recovery, checkpoint-based
Stripe Minions — Pragmatic 2-round CI cap with auto-fixes
OhMyOpenAgent — Ralph Loop for persistent iteration

Composability

No single open-source project replicates the full Stripe Minions architecture. To build an equivalent, you would likely combine:

Layer	Option A	Option B
Core Agent	OpenHands	Open SWE
Sandbox	Rivet Sandbox Agent	E2B / Docker
Orchestration	Patchwork patchflows	LangGraph
Parallelization	Composio Orchestrator	AgentField
Context	MCP servers	OhMyOpenAgent MCPs
Control Plane	AgentField	Custom