critique gate

    1

    Enforce quality gates using single-critic, multi-lens, adversarial, or ensemble review patterns via loop-ledger.

    Free

    2 usesSecurity scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    critique gate

    Example session with this skill installed

    /critique-gate:critique-multi review this python auth logic for security, style, and performance independently. don't ship until they all clear a 0.9 score.

    • Read your context and instructions
    • Compiled the critique gate

    I have initiated a multi-critic gate for the authentication logic. I will act as three independent reviewers and rewrite the code until the weakest score clears 0.9.

    Multi-Critic Gate: Auth Logic

    Round 1 Results:

    • Security: 0.6 (Missing bcrypt salt, potential timing attack on comparison)
    • Style: 0.9 (Clear naming, follows PEP8)
    • Performance: 0.8 (Redundant DB lookup in loop)
    • Current Progress (Min Score): 0.6
    • Status: should_continue: true

    Rewriting to address Security and Performance gaps...

    Round 2 Results:

    • Security: 0.95 (Implemented constant-time comparison and salted hashing)
    • Style: 0.9 (Maintained)
    • Performance: 0.92 (Cached DB lookup results)
    • Current Progress (Min Score): 0.9
    • Status: target_reached
    import bcrypt
    import hmac
    
    def verify_user(username, provided_password, user_db):
        # Optimized: Single lookup
        user_record = user_db.get(username)
        if not user_record:
            return False
        
        # Security: Constant-time comparison to prevent timing attacks
        return bcrypt.checkpw(
            provided_password.encode('utf-8'), 
            user_record['password_hash']
        )
    

    Next steps

    1. Review the implemented constant-time comparison.
    2. Verify the user_db.get integration with your specific database driver.
    3. Close the loop ledger entry to finalize the session.

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

    About this skill

    LLMs often call a draft "done" even when sections are vague or unsupported. This skill separates the generator from the critic, ensuring outputs clear a specific quality bar before they ship. It implements four distinct review patterns to prevent the model from grading its own homework.

    What it does

    • Score-retry gates outputs behind a single critic scoring against a rubric.
    • Multi-critic reviews the same draft through independent lenses like security, style, and correctness, gating on the weakest score.
    • Adversarial subjects the draft to active red-teaming, requiring all objections to be rebutted or patched.
    • Judge-ensemble aggregates opinions from multiple independent judges to surface disagreement and variance.
    • Enforced Retries blocks the session from closing until the quality target is met or the budget is exhausted.

    How it works

    1. The user invokes a specific mode like /critique-gate:critique-score or /critique-gate:critique-adversarial.
    2. The skill initiates a loop via loop-ledger, setting a target_value (default 0.8) and max_iterations.
    3. A critic role analyzes the draft, reporting scores as progress and specific issues as state.
    4. If the gate isn't cleared, the generator rewrites the draft based on the critic's feedback and ticks the loop again.

    Frameworks & tools

    This skill requires the loop-ledger MCP plugin. It uses loop_start, loop_tick, and loop_end tools to manage state and enforcement.

    Why this beats prompting it yourself

    Prompting a model to "check its work" usually results in sycophancy where the model confirms its own brilliance. This skill enforces a structural separation of concerns, uses scalar progress tracking to detect stalls, and allows for multi-modal critiques that a single prompt cannot reliably coordinate.

    Use cases

    • Security Audits: Run adversarial red-teaming on design docs to catch exploits before implementation.
    • PR Reviews: Validate code against independent correctness, style, and safety lenses.
    • Policy Proposals: Use a judge ensemble to ensure consensus across multiple independent viewpoints.
    • Content Quality: Gate technical summaries behind a strict 0.8 rubric score to ensure metrics aren't missing.

    Known limitations

    This skill has no internal logic or server; it is a prose-driven orchestration of the loop-ledger plugin. It cannot gate on variance in ensemble mode as a native exit condition.

    Requires loop-ledger MCP plugin to function. Cannot natively gate on score variance in ensemble mode. Defaults to 3 retries and 0.8 threshold unless specified.

    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

    2 uses

    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

    Permissions

    Environment Variables
    Listed28 days ago

    What's inside

    Frequently Asked Questions

    Critique Gate prevents 'sycophancy'—the tendency for LLMs to ignore their own errors—by enforcing a structural separation between the generator and the critic through four distinct review architectures.

    This skill requires the loop-ledger MCP plugin to function, as it relies on that plugin's toolset to manage state, track progress scores, and enforce iteration limits.

    Yes, you can define your own rubrics and target scores (e.g., 0.9 for high-stakes security audits) and set max_iteration limits to manage your token budget.

    You receive the orchestration logic and prompt patterns required to execute the four review modes (Score-retry, Multi-critic, Adversarial, and Judge-ensemble) via the loop-ledger framework.

    The skill is designed to work with any advanced LLM (like GPT-4o or Claude 3.5 Sonnet) that supports tool-calling and the Model Context Protocol (MCP).

    Critique Gate uses scalar progress tracking via the loop-ledger; if the critic's score fails to improve across iterations, the system can trigger a stall alert to prevent infinite loops.

    New in Agents & Orchestration