Agent Toolkit Landscape

A growing catalog of AI agent toolkits, organized by what they actually do. Not a ranking — a map for choosing the right tool for the right job.

Categories

Skill Marketplaces

Discover, install, and share agent skills. The npm/crates.io of agent capabilities.

skills.sh — open ecosystem for reusable agent skills. npx skills add installs to any of 20+ agents. Leaderboard tracks installs (top skill: 731K installs). Categories: dev (React, Next.js, Postgres), cloud (Azure, Firebase), marketing (SEO, copywriting), productivity (browser automation, docs).

SkillsMP — community directory indexing 700K+ skills from GitHub. Uses the open SKILL.md standard (Anthropic, Dec 2025; adopted by OpenAI for Codex CLI). Filters low-quality repos (min 2 stars), scans for quality. Independent project, not official.

SKILL.md standard: model-invoked (agent decides when to use) vs slash commands (user-invoked). Personal: ~/.claude/skills/. Project: .claude/skills/. Works across Claude Code and Codex CLI. See skills-standard for the full spec, marketplace breakdown, and authoring tips.

When to use: before building a custom skill, search these marketplaces. Someone probably already built it.

Prompt Libraries

Collections of agent personalities/prompts. Zero setup, no state, no orchestration.

Agency Agents — 130+ specialists organized by division (engineering, design, marketing, sales, product, testing, PM). Each = markdown file with identity, workflows, deliverables, success metrics. Convert to any platform with one script.

When to use: you need a domain expert you don’t have a skill for (Solidity audit, Chinese market localization, threat detection). Copy a file, go.

Limitation: prompts only. No state, no memory, no pipeline, no quality gates.

Executable Skill Systems

Pipeline-oriented tools that chain multi-step workflows. Skills read previous outputs, write artifacts, enforce quality.

Superpowers (143K stars) — enforced 7-phase development workflow: brainstorming → git worktrees → writing plans → subagent-driven execution → TDD → code review → finish branch. Key innovations:

• Mandatory, not optional — agent checks for relevant skills before any task
• Subagent-driven development — fresh agent instance per task prevents context drift, two-stage review (spec compliance → code quality)
• Plans for a “junior engineer” — 2-5 min tasks with exact file paths, complete code, no ambiguity
• TDD enforced — deletes code written before tests
• Cross-platform — Claude Code, Cursor, Copilot CLI, Codex, Gemini CLI, OpenCode

vs solo-factory: Superpowers focuses on the development workflow (plan → code → test → review). solo-factory covers the full product lifecycle (research → validate → scaffold → build → deploy → launch → promote). Superpowers has better cross-platform support; solo-factory has business/marketing skills. Complementary — use Superpowers for code quality, solo-factory for product strategy.

solo-factory — 30 executable skills in 4 phases:

• Analysis (5): /research, /swarm, /validate, /stream, /you2idea-extract
• Development (6): /scaffold, /setup, /plan, /build, /deploy, /review
• Promotion (11): /launch, /landing-gen, /content-gen, /video-promo, /reddit, /seo-audit…
• Utility (8): /init, /factory, /pipeline, /retro, /audit, /memory-audit…

Pipeline: output of one skill is input to next. /pipeline chains automatically. Harness-aware — respects CLAUDE.md, runs tests, follows TDD.

When to use: you’re building a product solo and want the full cycle from idea to launch.

Limitation: Claude Code only. Opinionated methodology (STREAM, S.E.E.D., harness engineering).

Compound Engineering (Every Inc, MIT) — 36 skills + 51 agents built on one belief: each unit of engineering work should make the next unit easier. Their ratio claim: “80% of engineering is in planning and review, 20% is in execution” — enforced by making planning and review actual commands (/ce-ideate, /ce-brainstorm, /ce-plan, /ce-work, /ce-code-review, /ce-commit-push-pr, /ce-compound) instead of steps you skip when tired.

Why it matters even if you write your own skills: /ce-compound is the harness loop promoted to an explicit, invocable step in the cycle — not a habit you hope to remember. That’s the transferable idea: the ratchet needs its own command, not just a principle in CLAUDE.md.

Project Managers

Autonomous long-running execution systems. State machines, crash recovery, git isolation.

Symphony (15K stars, OpenAI) — turns project work into isolated, autonomous implementation runs. Teams manage work instead of supervising agents. Elixir-based. Each run is isolated — no context leaking between tasks. OpenAI’s answer to “how to let agents work on real projects.”

Conductor (Melty Labs, $22M Series A) — Mac GUI for running many Claude Code + Codex agents in parallel, each in an isolated git worktree. Customers: Linear, Vercel, Notion, Ramp, Spotify. GUI-first variant of the “teams manage work, agents type” pattern.

Orca (Stably, trending Jul 2026) — self-described ADE, Agent Development Environment: a fleet of parallel agents run with your own subscriptions (Claude Code, Codex, Grok, Cursor, Copilot, Devin, Goose, …). What Conductor doesn’t have:

• Mobile + VPS surfaces — kick off and review runs from a phone, or park the fleet on a server instead of your laptop
• Account switcher with usage tracking — see Claude/Codex rate-limit resets and hot-swap accounts without re-login (the practical bottleneck when running many agents on one Max plan)
• Diff-line comments shipped back to the agent — review, edit, commit without leaving Orca
• Computer Use — agents drive desktop apps when a workflow needs real UI interaction

brew install --cask stablyai/orca/orca. Also Windows, Linux AppImage, AUR.

GSD-2 (Get Shit Done 2) — autonomous coding agent with hierarchical project management:

• Milestone → shippable version (4-10 slices)
• Slice → demoable vertical capability (1-7 tasks)
• Task → single context-window unit of work

Key capabilities:

• Fresh 200K-token context per task (no context pollution)
• SQLite-backed state machine with TOCTOU hardening
• Git worktree isolation per milestone
• Crash recovery via lock files + session forensics
• Stuck detection (sliding-window pattern analysis)
• Parallel multi-worker execution with file-based IPC
• 3 modes: step (/gsd), auto (/gsd auto), headless (CI/cron)
• .gsd/ artifacts: PROJECT.md, DECISIONS.md, KNOWLEDGE.md, RUNTIME.md, STATE.md

vs solo-factory: GSD-2 is a project manager that runs autonomously for hours. solo-factory is a toolkit you invoke per task. GSD-2 manages the execution loop; solo-factory manages the methodology. They could complement each other — solo-factory for what to build, GSD-2 for how to execute.

When to use: you have a clear spec and want autonomous multi-session execution with crash recovery.

Agent Org Orchestration

The layer above the runtime. Not “run many agents” (that’s Project Managers) but “give them roles, reporting lines, budgets, and approval gates” — the company around the employees. This category didn’t exist in the April version of this map; it formed in Q1-Q2 2026.

Paperclip is the one to study — MIT, self-hosted, and it wraps the runtime you already have rather than replacing it (“if it can receive a heartbeat, it’s hired”). Five mechanics worth stealing even standalone: atomic task checkout in the same transaction as the budget check, per-agent monthly budgets that hard-stop, goal ancestry carried on every task, a DB-backed heartbeat queue with coalescing, and portable org templates with secret scrubbing.

The honest caveat for the whole category: the org chart solves coordination, not quality. “Zero-human company” is branding — a human stays at the top as the board. Independent tests of Paperclip produced hallucinated market statistics and broken sites, which is why the serious entrants now bolt on evals and agent performance reviews.

vs Project Managers: GSD-2 and Symphony manage one project’s execution loop. This category manages the organization — many goals, many agents, cost and permission boundaries between them. vs solo-factory: our unit is a skill in a pipeline; theirs is a role in a hierarchy. Roles beat skills when work is continuous and concurrent; skills beat roles when work is a staged pipeline with artifacts.

Integration & Tool Platforms

Connect agents to external services — 1000+ APIs, auth, sandboxing. The “plumbing” layer.

Composio — powers 1000+ toolkits for AI agents: GitHub, Slack, Gmail, Notion, Jira, Salesforce, etc. Handles the hard parts: OAuth/API key authentication, tool search (find right tool from 1000+), context management, sandboxed execution.

Key features:

• Tool search — agent describes what it needs, Composio finds the right tool from 1000+
• Authentication — manages OAuth flows, API keys, token refresh for all integrations
• Sandboxed workbench — safe execution environment for agent actions
• MCP + SSE support — works as MCP server or standalone
• Python + TypeScript — works with LangGraph, CrewAI, AutoGen, Claude, OpenAI

When to use: your agent needs to interact with external services (send emails, create PRs, update CRM, post to Slack). Instead of building each integration, use Composio as the tool layer.

Agent Frameworks

Infrastructure for building custom agents. Maximum flexibility, maximum setup cost.

When to use: you’re building a product that IS an agent system (not using agents to build a product).

Key difference: frameworks = building blocks. Everything else = finished tools.

Memory Systems

Persistent memory that survives between sessions. See agent-memory-architecture for deep dive.

When to use: your agent needs to remember across sessions — decisions, preferences, code patterns, user context.

Code Knowledge Graphs (the deterministic branch)

Graphify (Apache-2.0 OR MIT) — the retrieval-without-embeddings bet: “Not a vector index. No embeddings, no vector store: a real graph you traverse.” Code is parsed locally by tree-sitter (36 grammars, 0 LLM credits), docs/PDFs go through your assistant’s model, audio/video transcribe locally via faster-whisper. Leiden community detection splits the graph into subsystems. Outputs graph.json + GRAPH_REPORT.md + interactive graph.html. No telemetry.

Two mechanics worth stealing regardless of which tool you keep — see graphify-vs-solograph:

• Git merge driver for the graph file — two devs committing in parallel get their graphs union-merged instead of conflicting
• PreToolUse hook that intercepts file reads and nudges the agent toward a graph query; strict mode blocks the first raw read outright

OpenViking (Volcengine, AGPLv3 — study, don’t embed) — mounts memory, RAG, and skills as one virtual filesystem the agent browses with ls / tree / find instead of querying an opaque vector store:

viking://
├── resources/          # docs, repos, web pages
└── user/{user_id}/
    ├── memories/       # preferences extracted from sessions
    ├── skills/         # SKILL.md files the agent can discover
    └── peers/          # collaborative context

The transferable idea is tiered loading: L0 abstract (~100 tokens, relevance check) → L1 overview (~2k, structure) → L2 full content on demand, plus directory-recursive retrieval that finds the best directory first and drills down, keeping surrounding context intact. Their numbers on LoCoMo + tau2-bench: accuracy 24-57% → 80-83%, input tokens −34-91%, latency −58-66%. Backed by the VikingMem paper (VLDB 2026).

Observability & Evals

Two different questions, often conflated. Observability tells you what happened — traces of prompts, tool calls, RAG stages, cost. Evals tell you whether the answer was good and fail the build if it wasn’t. Most teams need both; most tools do one well and bolt on the other.

Practitioner note from the 2026 roundups: instrument via OpenTelemetry SDKs rather than monkey-patching or mocks — it’s the only approach that reliably reconstructs streaming traces as the agent codebase changes.

When to use: the moment an LLM call is in production and a user can see a bad answer. Before that, evals in CI alone are enough.

Our position: CLI-first testing and DeepEval cover the eval side. Nothing covers tracing — so when an LLM product ships, Langfuse (self-host, MIT, privacy-compatible) or Laminar (OTel-native) is the missing layer, not another skill.

Governance & Sandboxing

The layer that assumes the agent will do the wrong thing and makes it structurally unable to.

agent-governance-toolkit — the framing is the valuable part: “prompt-level safety (‘please follow the rules’) is not a control surface.” Actions are intercepted in application code before they execute. Components: Agent OS (policy engine, lifecycle gates), Agent Mesh (discovery, routing, trust), Agent Runtime (four privilege rings, command denylist, execution-plan validation), Agent SRE (kill switches, SLO monitoring, chaos testing), Agent Compliance (policy linting, integrity checks). Claims 10/10 coverage of the OWASP Agentic Top 10.

The API is one call, which is why it’s worth knowing about even for a solo setup:

from agentmesh.governance import govern
safe_tool = govern(my_tool, policy="policy.yaml")

Cloud- and framework-agnostic (Semantic Kernel, AutoGen, LangGraph, CrewAI, …; Python, TS, .NET, Rust, Go). CLI: agt doctor, agt verify, agt lint-policy.

Important limit, stated by the project itself: it operates at the application-middleware layer, not the OS kernel — so it composes with VM/container isolation rather than replacing it. Middleware answers “which agent did this, and was it allowed?”; the VM answers “can it touch the host at all?”

When to use: multiple agents sharing API keys, agents acting on customer data, or any deployment where “which agent did this?” must have an answer. For a single laptop with a single operator, a VM is still the higher-leverage control.

Comparison Matrix

The Layered Stack

These aren’t competing — they’re layers:

1. Memory & retrieval — Solograph / Graphify / MemPalace for persistence
2. Skills — solo-factory for methodology (what to build, in what order)
3. Execution — GSD-2 for autonomous long-running tasks, Orca for a parallel fleet
4. Organization — Paperclip when the fleet needs roles, budgets and approval gates rather than more tabs
5. Specialists — Agency Agents for domain experts on demand
6. Guardrails — VM isolation + policy middleware where agents touch real systems
7. Feedback — traces (Langfuse / Laminar) + evals in CI — without this the loop below has no input
8. Harness — CLAUDE.md + linters + hooks tying it all together

The harness loop applies to all layers: agent mistake → fix the harness. Layer 7 is what makes the loop observable instead of anecdotal — you can’t ratchet on mistakes you never saw.

See Also

• project-solo-factory — our executable skill system
• graphify-vs-solograph — Graphify vs our own code graph: what to steal, what to keep, when to switch
• paperclip-agent-company — Paperclip in depth: the five mechanics to steal, and where “zero-human company” stops being true
• agent-memory-architecture — memory layer deep dive (4 types, 3 loops, 5 systems)
• harness-engineering-summary — the discipline that makes any toolkit reliable
• context-engineering — how to feed context to agents regardless of toolkit
• claude-code-anatomy — Claude Code reverse-engineered and compared with LangGraph/SWE-Agent/OpenHands/Aider — different bets on where to impose safety
• fff-agent-file-search — fff.nvim: memory pushed into the tool layer (file search) instead of the agent. Reduces tokens and roundtrips
• design-md-spec — Google Labs’ DESIGN.md: the CLAUDE.md/AGENTS.md pattern applied to design systems. Another agent-readable spec file with a linter
• vercel-agent-browser — Vercel Labs’ agent-browser: 30k★ Rust CLI with CDP. Browser-automation primitives rewritten for LLMs (a11y refs, content boundaries, daemon persistence)

Catalog is growing. Last updated: 2026-07-30.

On star counts: the numbers in this catalog are what the projects and aggregators claim, and in this ecosystem they’re unreliable — Graphify shows up as 76K, 97K, and 98K across three sources on the same day. Treat stars as a rough signal of attention, never of quality. Judge by license, what runs locally, and whether the core is actually open.