More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Swarm Workspace: Multi-Agent Git Worktrees

    1

    Run parallel coding agents on one repo without collisions: a worktree per agent branched from one coordination hub, lifecycle setup, and coordinator-only merges.

    $5

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Swarm Workspace: Multi-Agent Git Worktrees

    Swarm Workspace: Multi-Agent Git Worktrees

    Example session with this skill installed

    Set up parallel work for three agents on my app: one on payments, one on the settings page, and one on a database migration that the payments work depends on.

    • Read your context and instructions
    • Compiled the swarm workspace

    WORKSPACE PLAN, built by applying the skill's protocols:

    Layout: hub created at ~/app-hub (plain repo, no remote, nobody edits or builds here). Three branches from the base: payments, settings-ui, migration. Worktree paths derived from branch names, so uniqueness is automatic: ~/app-payments, ~/app-settings-ui, ~/app-migration.

    Dependency test before fan-out: payments consumes the migration's schema, so it fails the independence test. Route chosen from the decision table: freeze the contract, then fan out. The frozen contract is the migration's table and column definitions (names, types, nullability) — the migration agent may change internals, but that file is fixed before the payments agent starts. settings-ui shares no interface with either and fans out immediately.

    Branch assignment records (one per agent, abbreviated): Workstream payments — branch payments, worktree ~/app-payments, depends on migration (schema contract, frozen), env files: app .env + payments sandbox keys, dependencies: prebuilt copy, merge order 3. Migration: depends on none, env: app .env only, merge order 1. Settings-ui: depends on none, env: app .env only, merge order 2.

    Lifecycle: setup script handles fresh setup for all three today; each agent runs the same script tomorrow for re-entry (seconds, reinstall skipped); if the migration agent's session dies, its worktree is detected as stale and recreated cleanly, branch untouched.

    Merge protocol: agents commit on their own branches with a mid-task status commit so divergence shows early. Coordinator merges migration → settings-ui → payments into integration, resolving the one expected conflict (a shared types file) with both sides visible. No agent merges anything; no pushes anywhere.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Two agents editing one checkout corrupt each other — build artifacts interleave, dependency trees get rewritten mid-install, and one agent's git stash eats the other's uncommitted work. This skill fixes it structurally instead of asking agents to be careful. Every agent gets its own git worktree at a path derived from its branch name, all branched from a single coordination hub that nobody edits or builds in. A setup script handles the three lifecycle states — fresh, re-entry, stale — so agents never hand-debug git state. Dependencies are copied per worktree from a prebuilt tree, never shared; environment files follow a per-workstream contract. Integration is a protocol, not an accident: agents commit on their own branches, and only the coordinator merges, in dependency order, with full context of both sides. Includes a fan-out-or-sequence decision table, a branch assignment record template, the four classic failure modes of parallel work (phantom dependency, contract drift, merge surprise, environment snowflake), and a pre-delivery quality gate.

    • It isolates checkouts, not intent: two workstreams that must edit the same files still need sequencing, which the decision table will tell you.
    • Worktrees register absolute paths to the hub; moving the hub means recreating worktrees from their branches (branches are durable, worktrees disposable).
    • It does not split the work for you. Task decomposition — who builds what, against which contract — happens before this skill's setup runs.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 8 days ago

    Requires

    Git

    Permissions

    Terminal / Shell
    Listed8 days ago
    Updated6 days ago

    What's inside

    Frequently Asked Questions

    Clones work but cost you the shared object store: every clone re-fetches, branches aren't instantly visible to the coordinator, and merging becomes a push/pull exercise. Worktrees on one hub make a commit on any branch immediately visible and merging a purely local operation.

    No — that recreates the exact corruption this skill exists to prevent: one agent's install rewriting the tree while another builds against it. The skill copies a prebuilt dependency tree per worktree and lets the package manager reconcile; on one filesystem, hardlinked copies keep the disk cost modest.

    Its branch survives in the hub and its worktree registration goes stale. The coordinator inspects the branch, merges or cherry-picks what's salvageable, and the next setup run tears the stale worktree down and recreates it cleanly. Nothing about a dead agent blocks the hub or the other agents.