Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    agent coordinator

    1

    Deterministic multi-agent orchestration for parallel coding tasks, GPU resource gating, and isolated worktree management.

    $9

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    agent coordinator

    agent coordinator

    Example session with this skill installed

    Run a model evaluation benchmark using agy on gemini-2.5-pro. Wait for at least 4GB free GPU VRAM before starting.

    • Read your context and instructions
    • Compiled the agent coordinator

    I have dispatched the evaluation benchmark to the Antigravity worker harness. It is currently waiting for the specified GPU resources to become available in an isolated Git worktree.

    Multi-Agent Dispatch Status

    Task IDHarnessModelStatusWorktree
    agy-7721Antigravitygemini-2.5-proWAITING_FOR_GPU.coordinator/worktrees/agy-7721
    worker-1Claudeclaude-3-7-sonnetIDLEN/A

    Execution Details:

    • Target Branch: agent/agy/agy-7721
    • GPU Constraint: 4000MB minimum free VRAM
    • Current VRAM: 1240MB free (Waiting for release...)

    The worker will automatically begin the benchmark once the resource gate clears. It will modify evals/benchmark.py and produce a TASK_REPORT.json upon completion.

    Next steps

    1. Run coord status in 5 minutes to check if the GPU resource gate has opened.
    2. Use coord logs agy-7721 --tail 20 to view the benchmark output once it starts.
    3. Review the final diff via git diff main..agent/agy/agy-7721 after the task completes.

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

    About this skill

    Stop waiting for long-running builds or deep test suites to finish. When you're managing complex features, your agent shouldn't be locked into a single process or context. This skill implements a deterministic multi-agent architecture that offloads implementation, testing, and heavy compute tasks to autonomous worker agents.

    What it does

    • Parallel Task Execution runs multiple independent coding tasks concurrently using isolated Git worktrees to prevent race conditions.
    • Heterogeneous Orchestration coordinates between Claude Code, Google Antigravity, OpenCode, and OpenAI Codex harnesses.
    • GPU Resource Gating monitors and reserves VRAM for compute-heavy tasks like model training or 3D rendering before dispatching workers.
    • Zero-Token Monitoring tracks background agent progress via structured TASK_REPORT.json files instead of ingesting massive conversation transcripts.
    • Automated Worktree Management handles the lifecycle of dedicated branches and isolated workspaces for every task.

    How it works

    1. Initialize the workspace with coord init to establish role-based rules and token-efficient communication protocols.
    2. Dispatch a task to a specific worker agent (e.g., agy for GPU/large context, opencode for free boilerplate) with defined file scopes and success criteria.
    3. Monitor progress using coord status and coord logs to view execution state without consuming LLM context tokens.
    4. Review the structured report and git diff once the worker finishes its implementation and internal test loop.
    5. Merge the validated task branch and run coord clean to prune metadata and isolated workspaces.

    Frameworks & tools

    This skill integrates with Claude Code, Antigravity (agy), OpenCode (opencode), and OpenAI Codex (codex). It requires Python 3.9+ and Git.

    Why this beats prompting it yourself

    Manual multi-agent prompting often leads to context leakage and working-tree collisions. This skill provides a hard-coded orchestration layer that enforces Git isolation and structured reporting, ensuring agents don't overwrite each other's work.

    Use cases

    • Parallel Refactoring where one agent updates the API while another scaffolds the frontend and a third writes integration tests.
    • GPU-Bound Workflows offloading PyTorch or CUDA training jobs to an agent while you continue architectural planning.
    • Boilerplate Offloading using zero-cost models for unit test generation and documentation to save your primary model's quota.

    Known limitations

    Requires Git for full worktree isolation. Workers can only modify files explicitly scoped in the dispatch command. Supports Linux and macOS environments only. Need to mention the LLM models for the agents explicitly to reduce more token usage.

    Requires Git for full worktree isolation. Workers can only modify files explicitly scoped in the dispatch command. Supports Linux and macOS environments only. Need to mention the LLM models for the agents explicitly to reduce more token usage.

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

    Requires

    GitHub
    Python
    Git

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Network Access

    Allowed Hosts

    api.github.com
    Listed7 days ago
    Updated6 days ago

    What's inside

    Frequently Asked Questions

    The Agent Coordinator uses isolated Git worktrees for every sub-task, ensuring that different agents can work on the same repository simultaneously without overwriting files or creating merge conflicts.

    It is compatible with Claude Code, Google Antigravity, OpenCode, and OpenAI Codex, though you must have these harnesses installed on your local system to use them as workers.

    The GPU Resource Gating feature monitors your system's VRAM and only dispatches compute-heavy tasks once sufficient resources are available, preventing system crashes during model training or rendering.

    Instead of feeding massive chat logs back to the main LLM, this skill uses a 'Zero-Token Monitoring' system that reads structured JSON reports, saving you significant costs on context window usage.

    You will receive the full Python-based orchestration engine, a CLI tool for workspace management, and pre-configured integration templates for the supported agent harnesses.

    This skill requires a Linux or macOS environment and Python 3.9+, and while it supports snapshot-based workflows, it is highly recommended to use it within a Git repository for best results.

    New in Agents & Orchestration