Multi-Agent Systems

team-builder is an interactive agent picker for composing and dispatching parallel teams from markdown persona files. The team-builder skill helps you browse available agents, group specialists by domain, and build ad-hoc teams for Workflow Automation. Best for repos with flat or subdirectory agent libraries and clear persona structure.

santa-method is a multi-agent verification workflow for outputs that need to be right before they ship. It uses independent review to catch blind spots in content, code-adjacent deliverables, compliance-sensitive copy, and workflow automation tasks. Install the santa-method skill when you need a repeatable generate, verify, converge loop.

ralphinho-rfc-pipeline is an RFC-driven multi-agent workflow skill for splitting large features into verifiable units, validating each step, and merging with integration checks. It is ideal for ralphinho-rfc-pipeline for Multi-Agent Systems, refactors, schema changes, auth, perf, and security work.

iterative-retrieval is a workflow pattern for progressively refining context retrieval in agentic work. It helps subagents avoid too much or too little context, making it useful for iterative-retrieval usage, install decisions, and iterative-retrieval for Workflow Automation.

dmux-workflows is a guide for orchestrating parallel AI agent sessions with dmux in tmux panes. It helps split research, implementation, testing, and docs across Claude Code, Codex, OpenCode, and similar harnesses so you can manage multi-agent development with less context bottlenecking.

continuous-agent-loop helps agents run repeatable autonomous loops with quality gates, evals, recovery steps, and clear stop rules for reliable task completion.

claude-devfleet is a multi-agent orchestration skill for Claude DevFleet. It helps you plan projects, dispatch parallel agents in isolated worktrees, monitor progress, and read structured reports. Best for larger coding tasks that benefit from dependency-aware missions, not quick single-file edits.

autonomous-loops is a skill for designing autonomous Claude Code workflows, from simple sequential pipelines to multi-agent DAG orchestration with quality gates and handoffs.

autonomous-agent-harness turns Claude Code into a persistent, self-directing agent system with memory, scheduled runs, task dispatch, and computer use. It fits agent orchestration, recurring checks, and long-lived workflows when you need more than a one-time prompt.

Learn the agentic-engineering skill for eval-first execution, task decomposition, model routing, and safer workflow automation with regression checks.

agent-payment-x402 helps AI agents handle x402 payments with MCP tools, spending caps, recipient allowlists, and non-custodial wallets for paid APIs and agent orchestration.

dispatching-parallel-agents is an Agent Orchestration skill for splitting truly independent tasks across separate agents with isolated context and coordinated results.

langchain-architecture is a design guide for building LangChain 1.x and LangGraph applications. Use it to choose between chains, agents, retrieval, memory, and stateful orchestration patterns before implementation.

The multi-agent-patterns skill helps you design and implement agent systems with Agent Orchestration, context isolation, parallel work, and structured handoffs. Use it when choosing between a single agent and a multi-agent setup, or when you need supervisor routing, peer handoffs, consensus, or fault handling. It is best for orchestration-heavy tasks where clear coordination matters more than adding agents.

agents-sdk helps you build Cloudflare Workers agents with stateful conversations, durable execution, WebSocket or streaming chat, MCP integration, scheduled tasks, and browser automation. This agents-sdk skill focuses on install decisions, configuration, and practical usage for existing or new Workers apps, with guidance for multi-agent systems only when they fit Cloudflare runtime constraints.

subagent-driven-development helps you break implementation plans into independent tasks, dispatch a fresh subagent for each one, and review results between steps. It is built for agent orchestration when you need faster delivery with quality gates, especially for 3+ independent issues, bug fixes, feature slices, or repo cleanup.

tree-of-thoughts is a reasoning workflow skill that helps agents explore multiple approaches, prune weak branches, and synthesize a better answer. It is useful for hard debugging, planning, architecture tradeoffs, and tree-of-thoughts for Agent Orchestration.

launch-sub-agent helps you dispatch a focused sub-agent for bounded tasks in multi-agent systems. It analyzes task complexity, selects an appropriate model tier, supports specialized agent matching, and adds self-critique verification for more reliable results.

multi-agent-patterns is a practical guide for designing Multi-Agent Systems in Claude Code when one agent is not enough. Use it to split work, coordinate sub-agents, and compare orchestration patterns without adding unnecessary overhead.

judge-with-debate evaluates solutions through structured multi-agent debate, using a shared specification, evidence-based counterarguments, and up to 3 rounds to reach consensus. It is well suited for code review, rubric-based assessment, and judge-with-debate for Multi-Agent Systems workflows.

do-in-steps helps an agent tackle complex tasks by splitting work into ordered subtasks, orchestrating sub-agents, and verifying each step before moving on. It is a strong fit for repository changes, multi-step refactors, migrations, and do-in-steps for Agent Orchestration when you need controlled handoff and fewer silent failures.

do-in-parallel is a workflow skill for Agent Orchestration that launches multiple sub-agents in parallel across files or targets, groups repeatable work intelligently, and verifies results with meta-judges and LLM-as-a-judge review. Use the do-in-parallel skill when you need batch execution with less guesswork than a generic prompt.

do-competitively helps you solve important tasks with parallel candidate generation, rubric-based judging, and evidence-based synthesis. It is best for Workflow Automation and other high-stakes requests where quality, robustness, and tradeoff handling matter more than speed.

implement-task is a workflow automation skill for turning a task spec into implemented changes with automated LLM-as-Judge verification on critical steps. It helps agents read a task file, execute work in sequence, verify quality, and continue from partial progress with less guesswork.