Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Jules Orchestrator

    1

    Transform Google Jules into an autonomous engineering team. A battle-tested Lead Architect skill for contract-first task decomposition, non-interfering parallel session dispatch, and strict 5-gate plan governance.

    $1

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Jules Orchestrator

    Jules Orchestrator

    Example session with this skill installed

    We need to add a resilient webhook delivery engine with exponential backoff retries and an admin Dead-Letter Queue (DLQ) dashboard. Please orchestrate this with Jules.

    • Read your context and instructions
    • Compiled the jules orchestrator

    Lead Architect Assessment:
    This feature spans two independent subsystems: the backend delivery queue (src/engine/webhookQueue.ts) and the frontend DLQ inspector component (src/components/DLQInspector.tsx).

    Phase 1: Contract Locking
    I am defining and committing the shared webhook event interfaces and status types to src/types/webhooks.ts on main.

    Phase 2: Parallel Dispatch
    Dispatching 2 concurrent, non-interfering Jules sessions:

    • Session 1 (Queue Engine): Implementing retry backoff logic and unit tests in tests/webhookQueue.test.ts.
    • Session 2 (UI Dashboard): Implementing the DLQ table and retry controls in tests/DLQInspector.test.tsx.

    [Dispatched Session 1 (#1042) and Session 2 (#1043) in 1 turn]

    Coding Assistant (Gatekeeper Plan Review):
    🔍 Reviewing Plan for Session 1 (Queue Engine):

    • Touch boundaries: Confined to src/engine/webhookQueue.ts ✅
    • Tests: Explicitly includes tests/webhookQueue.test.ts with exponential backoff edge cases ✅
    • Plan passes all 5 gates. Plan Approved.

    ⚠️ Reviewing Plan for Session 2 (UI Dashboard):

    • Touch boundaries: Confined to src/components/ ✅
    • Tests: ❌ Plan omits component test execution!

    [Steering Session 2 via send_message]:
    "Plan Revision Required: Add a step to create tests/DLQInspector.test.tsx and run 'npm test tests/DLQInspector.test.tsx' verifying retry button dispatches before completing."

    Session 2 updated its plan with test coverage. Plan Approved.

    Coding Assistant (Verification & Delivery):
    Both sessions have completed their pull requests concurrently in 8 minutes:

    • PR #41: feat/webhook-retry-queue (All 8 Vitest unit tests passed)
    • PR #42: feat/dlq-inspector-ui (All 5 RTL component tests passed)

    Merging branches in topological order and running the full project build...
    npm test ➔ 13/13 passing. npm run build ➔ Success.
    The webhook dispatch engine and DLQ monitor are live and fully verified!

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

    About this skill

    Supercharge Your Coding Agent with Multi-Agent Jules Orchestration

    Delegating coding tasks to autonomous agents usually fails for predictable reasons:

    • The Kitchen-Sink Prompt: Developers ask an agent to build an entire feature all at once. Overwhelmed, the agent cuts corners, outputs fake stubs, hallucinated coordinates, and broken mock data.
    • Rubber-Stamp Plan Approvals: The agent blindly approves coarse plans that lack unit test steps.
    • The Serial Waiting Bottleneck: Users wait 20 minutes on a single sequential session while independent modules sit idle.
    • The Rework Penalty: You spend hours manually cleaning up and debugging code you thought was automated.

    Jules Orchestrator fundamentally changes how AI assistants delegate work to Google Jules. It trains your agent (Claude Code, Cursor, Antigravity, Devin, Kimi Code) to behave as a Lead Architect: locking down shared interfaces first, splitting features into bite-sized tasks, launching non-interfering parallel worker sessions in 1 turn, strictly enforcing plan quality, and verifying pull requests before closing tasks.


    ⚡ Core Capabilities

    • 1. Contract-First Task Decomposition:
      Enforces a 3-tier pipeline: locks down shared types and coordinate conventions on main before delegating, ensuring workers never conflict or hallucinate interfaces.
    • 2. Multi-Session Parallelism:
      Identifies disjoint file domains (e.g. Engine/Math vs Benchmark Scenarios vs UI Shell) and dispatches concurrent Jules sessions in a single turn. Cuts feature delivery time by $60\text{–}75%$.
    • 3. The 5-Gate Plan Review Rubric:
      Acts as an unyielding gatekeeper when Jules generates a plan. Automatically inspects:
      1. Touch Boundaries (stays within assigned files)
      2. Verification Steps (explicit test file & bash execution command)
      3. Anti-Stubbing Check (real mathematical algorithms, no // TODO placeholders)
      4. Domain & Coordinate Invariants (coordinate conventions, realistic physical units)
      5. Dependency Creep (prevents unapproved third-party packages)
    • 4. Step Budget & Turn Protection:
      Prevents agents from burning reasoning loops on repetitive polling by utilizing milestoned, non-blocking wait_for_session cycles.
    • 5. "Rulings, Not Stalls":
      Empowers the orchestrator to resolve minor implementation ambiguities autonomously without halting your workflow.
    • 6. Verification Before Completion:
      Guarantees that a pull request is never merged until tests pass locally with exit code 0.

    📦 What’s Included in This Bundle

    • SKILL.md: The Master Lead Architect & Orchestration Playbook.
    • 5 Modular Reference Guides:
      • task-decomposition.md: Right-sizing tasks ($< 4$ files, $< 10$ min runtime).
      • parallel-dispatch.md: Concurrency rules, branch naming, and merge ordering.
      • plan-review-checklist.md: The 5-Gate Review Rubric and steering prompt patterns.
      • prompt-templates.md: Battle-tested prompt templates for algorithms, fixtures, UI, and bugfixes.
      • patterns.md: Autonomous error recovery loops capped at 3 rounds and scheduled background supervisors.
    • Multi-Platform Plugins: Pre-configured manifests for Claude Code, Cursor, Antigravity, Codex, Devin, Kimi, Muse, Hermes, and OpenCode.
    • Auto-Configuring .mcp.json: Instant detection for MCP-compatible editors.

    1. Requires an active Google Jules account and API key (available from jules.google.com/settings#api).
    2. The target GitHub repository must be connected in your Google Jules web console so that it appears in list_sources.
    3. Dependent tasks cannot be run in parallel (e.g. shared database schemas or contract types must be committed before worker sessions launch).

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

    Requires

    Google Account
    GitHub
    Git
    Jules MCP
    localtunnel
    Node.js
    cloudflared

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Network Access

    Allowed Hosts

    accounts.google.com
    api.github.com
    Listed16 days ago

    What's inside

    Frequently Asked Questions

    This skill acts as a Lead Architect for Google Jules, breaking down large features into smaller tasks and running them in parallel sessions to prevent context bloat and low-quality code stubs.

    The 'Strict Plan Gating' feature enforces five quality checkpoints that a worker's plan must pass—evaluating file touchsets and test plans—before any code implementation is allowed to start.

    Unlike manual prompting, this skill uses a long-polling monitoring system rather than rapid loops, ensuring the orchestrator stays active without prematurely exhausting your agent turn limits.

    Yes. Google Jules executes code in cloud sandbox environments. You provide your own Jules API key from jules.google.com/settings#api, which uses your personal Google quota. This skill ensures your quota is spent efficiently without waste.

    New in Agents & Orchestration