Google Jules Orchestrator

    1

    A full-cycle development orchestrator that gates plans, reviews PR diffs, and iterates until code is merge-ready.

    Free

    1 useSecurity scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Google Jules Orchestrator

    Example session with this skill installed

    Run the Jules development loop to fix the retry logic in the sync service. The backoff counter isn't resetting on success. Follow the iteration cap of 3.

    • Read your context and instructions
    • Compiled the google jules orchestrator

    I have initialized the orchestration loop for the sync service fix. The task is scoped, and the session is active.

    Orchestration State: Task-SYNC-992

    StageStatusDetails
    ScopingCompletedDefined fix for sync.py::push() retry loop.
    SessionCreatedSession ID: sess_88291-jules
    PlanApprovedPlan ID: plan_001 - includes test case for counter reset.
    ImplementationIn-ProgressJules is currently modifying sync.py.
    ReviewPendingAwaiting PR publication.

    Plan Summary

    1. Locate push() function in sync.py.
    2. Add self.backoff_counter = 0 inside the successful request block.
    3. Verify with a mock success after three failed attempts.

    Next steps

    • Poll get_session to monitor implementation progress.
    • Once status is COMPLETED, I will call publish_pr and begin the diff review.
    • Check references/code-review-rubric.md to ensure the fix doesn't introduce side effects in the sync loop.

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

    About this skill

    Development agents often drift from the original spec or submit messy pull requests that require manual fixing. This skill implements a strict orchestration loop that separates scoping and review from raw code implementation. It prevents implementation models from marking their own homework, ensuring every line of code is verified against a defined spec before merging.

    What it does

    • Task scoping creates a closed spec with explicit acceptance criteria to prevent scope creep.
    • Session management handles the lifecycle of Jules implementation sessions via MCP tools.
    • Plan gating enforces a mandatory approval step where the orchestrator reviews implementation plans before execution.
    • Automated PR publishing triggers the native publish_pr flow once coding tasks are completed.
    • Loop-based iteration analyzes diffs against a rubric and generates structured fix-it prompts for re-implementation.
    • Automated merging handles the final GitHub merge flow via CLI or MCP once code passes all checks.

    How it works

    1. Scope the task using the provided template to define files, goals, and checkable criteria.
    2. Execute the Jules session by creating the task, approving the plan, and polling for completion.
    3. Audit the resulting pull request diff using a logic-dense code review rubric.
    4. Resolve issues by sending targeted fix-it prompts back to the session or merging the clean PR via GitHub.

    Frameworks & tools

    This skill requires the Jules MCP server for session control and the GitHub MCP server or gh CLI for repository management. It uses structured Markdown templates for state tracking and scoping.

    Why this beats prompting it yourself

    Manual prompting often leads to "hallucinated progress" where an agent claims success without verification. This skill forces a rigorous check-and-balance system that treats the implementation agent as a junior dev and the orchestrator as a senior reviewer.

    Use cases

    • Automating the end-to-end fix for reported GitHub issues or bug tickets.
    • Implementing new features across specific modules while maintaining strict architectural boundaries.
    • Refactoring legacy codebases where every change must be gated by a plan review.
    • Managing high-volume repository maintenance tasks that require PR creation and merging.

    Known limitations

    Requires an authenticated Jules MCP server and GitHub access. Merging logic defaults to squash but follows repo conventions. Handover is mandatory if iteration caps are reached.

    Requires Jules MCP and GitHub MCP/CLI. Iteration cap defaults to 4 attempts. Jules must be pre-registered with target repo sources.

    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

    1 use

    Times used to date

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 28 days ago

    • Free with an Agensi account

    Requires

    GitHub
    Google Account
    Googleapis
    Python
    Git

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Network Access
    Environment Variables

    Allowed Hosts

    jules.googleapis.com
    api.github.com
    jules.google.com
    Listed28 days ago

    What's inside

    Frequently Asked Questions

    It prevents 'hallucinated progress' by separating the coding agent from the reviewing agent. By enforcing a mandatory plan-gating step and auditing diffs against a strict rubric, it ensures code isn't merged until it actually meets your spec.

    This skill is designed specifically for environments using the Jules MCP server for session management and either the GitHub MCP server or the GitHub CLI (gh) for repository actions. It integrates seamlessly into workflows that support these Model Context Protocol standards.

    You receive the complete orchestration logic, including the task-scoping templates, the plan-gating workflow, and the automated diff-review rubric. It includes everything needed to set up the senior-reviewer-to-junior-coder loop.

    The orchestrator includes an iteration cap to prevent infinite loops; if the implementation agent cannot resolve the diff issues within the set limit, the skill will pause and prompt for manual developer handover.

    Yes, the skill is highly effective for high-volume maintenance, as it can autonomously scope, execute, and merge bug fixes or refactors while ensuring every change is verified against your architectural boundaries.

    New in Agents & Orchestration