swarm

Coordinate multiple AI agents on shared subtasks using SQLite atomic claiming.

Updated Feb 20, 2026
One-click install
npx skills add https://github.com/ssccio/cc-on-web-base --skill swarm-ssccio
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: swarm
Source: https://github.com/ssccio/cc-on-web-base/tree/main/skills/swarm
Command: npx skills add https://github.com/ssccio/cc-on-web-base --skill swarm-ssccio

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

It eliminates slow, error-prone single-agent work by coordinating multiple agents to process many subtasks in parallel while safely dividing ownership of work items.

Core Features & Use Cases

  • SQLite atomic task claiming: Multiple agents draw from the same pool with race-condition-free, transactional claiming.
  • Fault-tolerant execution: Lease-based ownership with heartbeat monitoring and automatic recovery of stale claims.
  • Progress visibility: Tracks pending/claimed/done/failed counts and which agent owns which task, producing a clear final summary.

Use Case Examples:

  • Fixing many files concurrently (e.g., TypeScript type errors) with executor agents.
  • Implementing UI work across components in parallel with designers.
  • Reviewing multiple API endpoints simultaneously with specialist reviewers.

Quick Start

Provide the command /swarm 5:executor "fix all TypeScript errors" to spawn five coordinated executors that claim and work through the decomposed file-level subtasks.

Frequently Asked Questions about swarm

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I coordinate multiple AI agents to fix codebase issues in parallel without collisions?

Multi-agent coordination for parallel codebase automation uses SQLite-based atomic task claiming to let multiple agents draw from a shared subtask pool without race conditions. Agents claim, process, and complete decomposed file-level tasks concurrently with transactional state transitions.

How does fault tolerance work when running parallel agents for batch code reviews?

Fault tolerance in parallel agent execution uses lease-based ownership with heartbeat monitoring. If an agent stalls, stale-claim cleanup automatically recovers the task, ensuring batch security or design reviews complete reliably without manual intervention.

What is the maximum number of agents I can spawn for parallel task claiming?

Parallel task claiming enforces an orchestration limit of 1 to 5 agents. This constraint ensures safe multi-agent coordination while processing decomposed subtasks like fixing TypeScript type errors across multiple files concurrently.

How do I start a parallel documentation sprint using multi-agent coordination?

Start a parallel documentation sprint by running a command like `/swarm 5:executor` with your task description. This spawns five coordinated agents that automatically decompose the work, claim file-level subtasks, and track pending, claimed, done, and failed states.

Can I track real-time progress when multiple agents process subtasks concurrently?

Yes, concurrent multi-agent execution provides progress visibility by tracking pending, claimed, done, and failed task counts. It monitors which agent owns which task and produces a clear final summary upon deterministic completion signaling.

Do I need to install SQLite separately to use atomic task claiming for codebase automation?

The metadata does not specify external SQLite setup requirements. SQLite-based atomic claiming and transactional state transitions are integrated directly into the multi-agent coordination process to manage concurrent subtask ownership safely.