Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Agent Branch Coordinator for Parallel Coding Agents

    1

    **The problem.** Running three agents at once is easy.

    $12

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Agent Branch Coordinator for Parallel Coding Agents

    Agent Branch Coordinator for Parallel Coding Agents

    Example session with this skill installed

    I have three agents working on our TypeScript/Python repo on branches agent/claude-code/rename-fmt, agent/cursor/report-export and agent/cline/user-schema. Can you check whether they're safe to merge and tell me in what order?

    • Read your context and instructions
    • Compiled the agent branch coordinator

    Example session (illustrative).

    1. Preconditions checked

    • harness 0.1.0 is on PATH, harness.toml is committed on main with [conflicts] branches = ["agent/*"].
    • Ran git fetch and compared against origin/main so a stale local main can't shift merge bases.

    2. Detector run (harness conflicts --base origin/main --json, from the main checkout)

    harness conflicts · agent/claude-code/rename-fmt · agent/cline/user-schema · agent/cursor/report-export
      L1 renamed-symbol `fmt` [agent/claude-code/rename-fmt -> agent/cursor/report-export]
         `agent/claude-code/rename-fmt` renames `fmt` to `format_value`, and `agent/cursor/report-export` adds references to the old name (app/report.py)
         fix: rename references `fmt` -> `format_value` in app/report.py (harness conflicts --fix)
      L2 removed-member `User.email` [agent/cline/user-schema -> agent/cursor/report-export]
         `agent/cline/user-schema` removes `email` from `User`, and `agent/cursor/report-export` adds code reading `email` (web/export.ts): schema drift that no textual merge conflict will reveal
    BLOCKED: 1 conflict(s) need a human
    

    Exit code 1. git merge would report no textual conflicts for any of these pairs.

    3. Level 1 fix applied in the report-export worktree (the branch referencing the old name):

    • harness conflicts --fix agent/claude-code/rename-fmt agent/cursor/report-export printed fixed app/report.py: `fmt` -> `format_value` .
    • git diff showed rename-only edits; git grep -nw fmt found only the old definition in app/lib.py, which rename-fmt replaces. Committed as a rename-only commit on that branch, with your approval. The full harness run gate for this branch waits until rename-fmt is merged, because report-export now imports format_value, which only exists after that merge.

    4. Level 2 conflict: needs your decision
    user-schema renames User.email to User.emailAddress; report-export adds a CSV column that reads u.email. Proposal: merge report-export first, then user-schema rebases and migrates the new u.email read in web/export.ts, because whoever makes the breaking change owns the migration.

    5. Proposed merge order

    1. agent/claude-code/rename-fmt: the rename; its consumer is already fixed.
    2. agent/cursor/report-export: rebase on main, rerun harness run, merge.
    3. agent/cline/user-schema: rebase, update web/export.ts, harness run, merge.
      After each merge I rerun harness conflicts. Nothing has been merged yet; say go and I'll start with step 1.

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

    About this skill

    The problem. Running three agents at once is easy. Merging their work is where it goes wrong. Agent A renames a function or drops a field, agent B adds new code that uses the old name, git merges both without complaint, and main stops building. Textual merge conflicts never show this kind of semantic conflict.

    What the agent does with this skill.

    • Sets up the parallel layout: a committed harness.toml with [conflicts] branches = ["agent/*"], one agent/<agent-id>/<task> branch and one git worktree per agent, all branched from the same up-to-date base.
    • Runs harness conflicts at the right points (mid-task checkpoints, before merging, after every merge) and knows what it compares: local branches matching the glob, the checked-out branch from its working tree, every other branch from its last commit.
    • Reads each finding (renamed-symbol, lockfile, removed-symbol, removed-member, signature-change, concurrent-edit) and knows which ones are Level 1 (auto-fixable) and which are Level 2 (need a human).
    • Applies harness conflicts --fix from the right worktree, then checks what the codemod left alone (TypeScript/JavaScript property accesses and shorthand properties, files that declare the old name themselves) and reviews Python edits, where attribute accesses and keyword arguments with the old name are renamed too.
    • Produces an ordered merge plan with a reason for each step. The rules: whoever makes a breaking change owns the migration, renames merge after the fix is applied, and every merge is followed by a rebase and a fresh check.
    • States the tool's blind spots honestly: structural rules cover TypeScript, JavaScript and Python only, only newly added references are detected, and stale squash-merged branches cause false positives.

    Who it's for. Developers and teams running Claude Code, Cursor, Codex CLI, Cline or similar agents in parallel on the same repository who want a repeatable way to merge their branches.

    Requirements. A git repository; the AgentHarness harness binary (free, open source: prebuilt releases or cargo install --locked --git https://github.com/KadonWills/agent-harness harness-cli. The harness-cli crate on crates.io is a different tool); Docker if you also run the full harness run gate. Structural conflict detection covers TypeScript/TSX, JavaScript/JSX and Python.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Agents & Orchestration.

    Structural rules apply only to TypeScript, JavaScript, and Python. Rust and Go support is limited to lockfiles. Agents must commit work for sibling detection to see their changes.

    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 buying a skill.

    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 17 days ago

    Software
    Githarness (AgentHarness CLI)Docker (for the full `harness run` gate)

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Listed17 days ago

    What's inside

    Frequently Asked Questions

    Yes. The skill drives the open-source `harness` CLI from github.com/KadonWills/agent-harness. Install it from the GitHub releases or with `cargo install --locked --git https://github.com/KadonWills/agent-harness harness-cli`. Don't install `harness-cli` from crates.io: it is an unrelated tool with the same name.

    TypeScript/TSX, JavaScript/JSX and Python get the structural rules (renames, removed symbols and members, signature changes, concurrent edits). Every repo, including Rust and Go, gets the lockfile rule for files such as Cargo.lock, go.sum, package-lock.json and poetry.lock. The skill tells you when only the lockfile rule could run.

    No. It produces a plan and applies Level 1 fixes only on the branch you are working in. It asks before merging, rebasing, deleting branches or touching another agent's worktree.

    It rewrites identifier references from an old function name to the new one, in the checked-out branch only. Strings, comments and any file that declares the old name itself are never touched. In TypeScript/JavaScript, property accesses (`obj.fmt`) and shorthand properties (`{ fmt }`) are left alone too; in Python, attribute accesses and keyword arguments with the old name are renamed as well, so the skill reviews the diff before committing. Lockfile conflicts are never auto-applied; you get the command to run after merging instead.

    They're recommended so each agent has its own working directory, dependencies and `.harness/` output. The detector itself works on any local branches matching your `[conflicts].branches` glob, worktrees or not. Other agents' changes are only visible to it once they're committed.

    New in Agents & Orchestration