More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Codex Controls Claude

    1

    Your main agent plans and reviews. Claude Code builds. Delegate complete engineering tasks with clear scope, parallel workers and acceptance checks.

    $9.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Codex Controls Claude

    Codex Controls Claude

    Example session with this skill installed

    Use Codex Controls Claude to add a sales-summary command to this CLI project. Read the existing code, plan the work, and delegate implementation to Claude Code. Group CSV orders by product and currency, calculate exact totals, and handle quoted fields and bad rows. Review the code and rerun the acceptance checks before handing over the finished feature.

    • Read your context and instructions
    • Compiled the codex controls claude
    • Generated the data export

    Completed: CSV sales summaries, ready for review

    The main agent planned the feature, dispatched implementation to Claude Code, and independently reviewed the completed changes. Claude Code delivered a working command, clear error handling and usage documentation. All 13 acceptance checks passed.

    MCP tools used in this demonstration

    ToolRole in the task
    orchestrator_planDefined the sales-summary task and its fixed acceptance checks.
    orchestrator_dispatchStarted Claude Code with the implementation brief.
    orchestrator_waitWaited for the worker to return a review candidate.
    orchestrator_reviewRecorded the supervisor's review and reran the 13 acceptance checks.

    From request to finished feature

    StageOwnerDelivered
    PlanMain agent / supervisorReviewed the starting CLI, defined the feature scope and fixed the acceptance checks before implementation.
    BuildClaude CodeImplemented CSV parsing, input validation, product-and-currency grouping, and the new command.
    ReviewMain agent / supervisorInspected the actual code and documentation, checked the sample totals, and reran the original acceptance checks.
    HandoffMain agent / supervisorAccepted the working feature with its command, output, documentation and verification results.

    What the finished command does

    Run

    node src/cli.mjs sales-summary examples/orders.csv
    

    The command reads the orders, groups each product and currency separately, and returns units and revenue. Amounts are calculated in integer cents, so decimal prices do not introduce floating-point rounding errors. Quoted product names, escaped quotes and CRLF files are supported.

    Actual output from the demo project

    ProductCurrencyUnitsRevenue
    CoffeeEUR13.20
    CoffeeUSD517.50
    Tea, greenUSD14.25

    Acceptance result

    13 of 13 checks passed. The checks covered grouping, exact-cent arithmetic, quoted fields, CRLF input, empty data, invalid quantities and prices, missing currency, wrong column counts, broken quotes, missing files, and the existing help command.

    Bad input produces a clear row error and a nonzero exit code. It writes no partial JSON to stdout, so a failed import cannot look like a successful report.

    Delivered files

    • src/sales-summary.mjs: CSV parsing, validation and aggregation.
    • src/cli.mjs: the new command and error reporting.
    • README.md: input rules, usage, actual output and verification instructions.

    This completed example used a small demonstration project with synthetic orders. The implementation, command output and acceptance checks were run and independently reviewed through the connected workflow.

    dashboard-CSV

    1793717083291-lyh5.png

    CSV · data export

    Generated

    Example file from a real run - the skill writes it into your workspace.

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

    About this skill

    Give your main agent a Claude Code implementation team

    Your main agent plans and reviews. Claude Code builds. Delegate complete engineering tasks with clear scope, parallel workers and acceptance checks.

    The supervisor directs local workers, answers questions during execution, and checks the finished files before accepting the result.

    What makes the workflow useful

    • Delegate the work and keep control of the decisions. The supervisor sets the scope and acceptance checks before a worker starts. You can keep architectural choices with the main agent while Claude Code handles the implementation.
    • Review actual changes before moving on. A worker's completion becomes a review candidate. The supervisor inspects the files and diff, and the runtime reruns the task's fixed checks. Failed checks block acceptance, and findings can go back for repair.
    • Run independent tasks in parallel. Dispatch up to three workers on independent tasks and keep later stages waiting until their prerequisites pass review. The supervisor coordinates file scopes when work could overlap.
    • Resolve questions during the task. Workers can ask the supervisor for clarification. The supervisor can answer, queue guidance for the next turn boundary, or interrupt a task when a correction needs immediate attention.
    • Wait for useful events. Completion, questions, permission decisions and failures wake the supervisor. A pending wait can last up to 20 minutes and returns when an actionable event arrives, so ordinary progress does not require repeated status requests.
    • Continue work with its history. Saved conversations, task records and checkpoints support explicit continuation after interruptions or budget stops. The supervisor decides when to continue, request repairs or start a new context.
    • Use your existing Claude Code environment. Workers use your configured model, authentication, enabled tools, MCP servers, hooks and permissions. On Windows, each running worker has a terminal dashboard showing reported activity, elapsed time and execution state.

    Good fits

    • Refactor several modules with a review between stages.
    • Collect research evidence before choosing an implementation.
    • Build independent parts of a feature in parallel, then check the combined result.
    • Continue a long engineering task with recorded requirements, questions and review findings.

    What you receive

    The purchase contains the instruction skill, orchestration policies, setup guidance and workflow references for your main agent. The separate local MCP runtime supplies the ten orchestration tools and is downloaded through NPX. Your Claude Code subscription, API access and provider charges are separate.

    MCP tools

    ToolWhat it does
    orchestrator_planDefine the goal, task contracts and acceptance checks. Manage continuation and session lifecycle.
    orchestrator_dispatchSend a ready task to a local Claude Code worker.
    orchestrator_waitWait for completion, a question, a permission decision or a failure.
    orchestrator_reviewReview the current artifacts and rerun the task's original checks before acceptance.
    orchestrator_statusInspect a task's results, checks, budget and recovery evidence.
    orchestrator_messageSend guidance, interrupt a turn or answer a worker's question.
    orchestrator_respond_permissionRespond to a pending native permission request.
    orchestrator_cancelStop the selected run while preserving other workers.
    orchestrator_teamCoordinate parallel workers and tasks with dependencies.
    orchestrator_doctorCheck the local configuration without calling a model.

    Connect the local MCP runtime

    Install Node.js 22 or newer with npm/NPX and make sure your local Claude Code CLI is installed and authenticated. Windows workers also require Windows Terminal and .NET 10 Runtime.

    Run this command to check prerequisites and print the configuration to add:

    npx --yes --package codex-controls-claude-mcp@latest -- codex-controls-claude-mcp setup
    

    The command prints guidance and configuration. It does not edit your host's configuration file. NPX downloads the runtime selected by the latest npm tag on first use; the runtime then runs on your computer.

    The registry argument is optional. NPX uses your configured npm registry. If a mirror cannot find the package or has an outdated latest tag, add --registry=https://registry.npmjs.org/ to the NPX arguments. @latest follows the latest published release; pin a version if you need repeatable deployments.

    JSON configuration

    For a host that uses an mcpServers JSON configuration, merge this entry into its existing configuration:

    {
      "mcpServers": {
        "claude-orchestrator": {
          "type": "stdio",
          "command": "npx",
          "args": ["-y", "codex-controls-claude-mcp@latest"],
          "env": {"CCC_WAIT_MS": "1200000"}
        }
      }
    }
    

    Keep your other server entries. Use the host's documented settings to allow a tool call to remain open for at least 1,260 seconds. CCC_WAIT_MS controls the runtime's wait; it does not raise the host's own timeout. This JSON example describes the connection. Host-specific timeout and supervision behavior still need verification.

    Codex configuration

    Codex uses TOML in ~/.codex/config.toml:

    [mcp_servers.claude-orchestrator]
    command = "npx"
    args = ["--yes", "--package", "codex-controls-claude-mcp@latest", "--", "codex-controls-claude-mcp"]
    startup_timeout_sec = 120
    tool_timeout_sec = 1260
    
    [mcp_servers.claude-orchestrator.env]
    CCC_WAIT_MS = "1200000"
    

    Reconnect the MCP server or restart the host, then confirm all ten orchestrator_* tools appear. If a Windows host cannot launch npx directly, run the setup command with --cmd-shim for its alternative configuration. Existing users should preserve their runtime data directory when changing connections.

    The published package and full runtime instructions are available at npm.

    Before you buy

    The supervisor workflow has been validated with Codex. Other hosts need local stdio MCP support and compatible long-running tool calls. Invoke the skill explicitly and keep the supervisor session active to handle events. Review and checks help catch mistakes; they do not guarantee correct code.

    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.

    Connect the separate local MCP runtime before using the skill. The @latest configuration follows the latest published npm release. Up to three dispatched workers share the execution pool across connected chats using the same runtime data directory. Invoke the skill explicitly and keep the supervisor session active. The full supervisor workflow is validated with Codex; other hosts may impose different tool timeouts. Claude Code authentication and model charges are your responsibility. Windows workers require Windows Terminal and .NET 10 Runtime.

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

    Software
    Codex Controls Claude MCPNode.js 22+Claude Code
    Optional
    Windows Terminal.NET 10 Runtime

    Your main agent needs local stdio MCP support; the server runs via npx. Claude Code must be signed in with your own model access. Windows Terminal and .NET are only for Windows workers.

    Permissions

    Read Files
    Write Files
    Terminal / Shell

    The instruction skill supplies the workflow. The separately installed local MCP runtime launches Claude Code, reads its existing settings, and writes task history and artifacts. Workers use the project files and tools authorized for the task. NPX contacts npm to fetch the runtime; Claude Code uses the user's configured provider, authentication, hooks and permissions.

    Listed15 days ago
    Updated13 days ago

    What's inside

    Frequently Asked Questions

    Your main agent acts as the supervisor. It breaks down the goal, sets task boundaries, dispatches work, answers questions and reviews the files and checks. Local Claude Code workers carry out research or implementation. The worker does not accept its own result.

    Install Node.js 22+ with npm/NPX and an authenticated local Claude Code CLI. Connect the separate codex-controls-claude-mcp runtime using the NPX command and configuration in the description. Windows workers also require Windows Terminal and .NET 10 Runtime. Your main agent must support local stdio MCP and the documented tool timeouts.

    No. Twenty minutes is the maximum pending event wait. Completion, questions, permission decisions and failures return when they occur. The host must allow the tool call to stay open for the documented interval. The runtime wait setting does not override a shorter host timeout.

    You receive the instruction skill, orchestration policies, setup guidance and workflow references for the main agent. They define task delegation, review, repairs and continuation. The required local MCP runtime is downloaded separately through NPX. The purchase does not include Claude Code subscriptions, API credits or hosted execution.

    Yes. The supervisor can dispatch up to three workers when the work is independent. Those execution slots are shared across connected chats using the same runtime data directory. Dependent tasks wait for acceptance of their prerequisites. Idle retained conversations do not occupy an execution slot.

    The main agent needs local stdio MCP support and compatible long-running tool calls. The complete supervisor workflow has been validated with Codex. The included JSON examples and guidance for other hosts describe how to connect; equivalent supervision and timeout behavior must be verified in the chosen host.

    New in Agents & Orchestration