More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Cross Family Gatekeeper

    1

    Enforce adversarial, cross-model-family review cycles to verify code changes and technical claims.

    $7

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Cross Family Gatekeeper

    Cross Family Gatekeeper

    Example session with this skill installed

    Use Cross-Family Gating Orchestrator to coordinate a focused fix to our record-deduplication function.

    Each record has a string identifier. Keep the first record for each exact identifier, preserve first-appearance order, ignore empty or whitespace-only identifiers, and leave the input unchanged.

    Assign the builder, independent reviewer and verification responsibilities using our project policy and available authorized agents. The approval reviewer must use a known different model lineage from the builder. Reuse our existing project handoff and review-record locations.

    Freeze the candidate and requirements before review. Have the reviewer inspect the actual proposal independently, verify substantive findings with focused checks, and re-review any correction against the updated candidate.

    Return the role assignments, proposed function, review findings, verification results and next action. Keep review approval, executed checks and action authorization separate. If independent review or evidence is unavailable, report the incomplete gate.

    Do not add unrelated changes, merge or deploy..

    • Read your context and instructions
    • Compiled the cross family gatekeeper

    Focused Task and Gating Report

    The revised deduplication proposal preserves the first qualifying record for each identifier and maintains input order. An independent challenge exposed a last-record-wins defect in the initial proposal; the correction stayed within the requested function.

    Illustrative completed scenario, not an actual execution log or review receipt. Family A/B and candidates R1/R2 are explanatory labels. A live run records observed model identities, exact candidate hashes and original evidence.

    Task assignments

    ResponsibilityAssignment and boundary
    CoordinatorMaintains scope, requirements and the gate record. Follows the project’s approval and authority rules.
    Builder — Family APrepares the proposed function and makes the bounded correction. Does not approve its own work.
    Independent reviewer — Family BInspects the frozen candidate read-only against the same requirements, without other reviewers’ verdicts.
    Verification responsibilityChecks the revised behavior and records actual results against the tested candidate.
    Action-ownerRetains permission to apply, merge or deploy. Review approval grants none of those permissions.

    Independent finding and correction

    Candidate R1 stored records in a dictionary keyed by identifier. A later duplicate replaced the earlier record, violating the keep-first requirement.

    The reviewer demonstrated the issue with two records sharing identifier A but containing different values. Candidate R2 replaces that behavior with a seen-identifier set and appends only the first qualifying record.

    Proposed function

    def dedupe_records(records):
        seen = set()
        result = []
    
        for record in records:
            record_id = record["id"]
            if not record_id.strip() or record_id in seen:
                continue
            seen.add(record_id)
            result.append(record)
    
        return result
    

    Verification results in this worked scenario

    CheckResult
    Two records with identifier AFirst record retained.
    Identifiers A, B, AFirst A, then B, preserving order.
    Empty or whitespace-only identifierRecord skipped.
    Empty inputEmpty result returned.
    Input list and original recordsUnchanged.

    A real run attaches the executed command, its output and the exact tested candidate. This illustrative table is not a substitute for that evidence.

    Gate and action state

    • Review: The revised review covers R2 and the unchanged requirements. R1’s receipt remains historical.
    • Verification: Focused checks pass in this illustrative scenario; a live run retains the execution evidence.
    • Authorization: No merge or deployment is authorized by this report.
    • Scope: No unrelated refactor, new framework or additional feature was introduced.

    Next action

    Present R2 and its supporting gate record to the authorized owner. If the candidate or relevant requirements change, refresh the affected checks and independent review before reporting a new pass.

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

    About this skill

    Consequential code changes often bypass rigorous review when handled by solo agents. This skill enforces a structured cross-family adversarial review cycle to ensure technical claims and diffs are verified by independent model lineages before proceeding.

    What it does

    • Coordinate cycles by managing the propose, independently review, verify, and decide workflow for code milestones.
    • Freeze candidates by pinning content hashes and snapshots to ensure reviewers evaluate the exact code intended for change.
    • Verify independence by identifying model families from runtime metadata to prevent "self-review" by the same model lineage.
    • Audit evidence by classifying findings as confirmed, unresolved, or disputed based on reproducible counterexamples and source spans.
    • Manage handoffs by tracking gate status, execution signatures, and remaining conditions across different agent sessions.

    How it works

    1. Establish task by reading project instructions to identify authorized decision-makers and the required gating policy.
    2. Snapshot candidate to capture the diff, baseline, and test output, ensuring the reviewer sees the raw artifacts rather than summaries.
    3. Dispatch review to a different model family with specific instructions to find requirement violations or material risks.
    4. Reconcile findings by verifying reviewer claims against the code and reporting the final gate status to the project lead.

    Frameworks & tools

    This skill is designed for multi-agent environments using diverse LLM providers (e.g., Anthropic, OpenAI, Google). It works alongside Git for diff tracking and standard test runners for evidence collection.

    Why this beats prompting it yourself

    Standard prompts often let agents "rubber stamp" their own work or accept vague summaries. This skill enforces strict identity checks between model families and requires raw evidence for every claim, preventing silent failures in the review chain.

    Use cases

    • Gating pull requests by requiring a PASS from a different model family before merging.
    • Validating architecture plans to find logic flaws before implementation starts.
    • Recovering review context after a session handoff by verifying candidate hashes.
    • Auditing high-risk changes where a single agent's bias might overlook edge cases.

    Known limitations

    Does not provide a sandbox or model service. Cannot verify independence if model metadata is hidden or falsified by the provider. Requires an existing project policy to define decision-makers.

    Requires access to model metadata to verify family independence. Does not automate model deployment or cost management. Scope is limited to technical review, not legal or financial approval.

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

    Permissions

    Read Files
    Write Files
    Listed14 days ago

    What's inside

    Frequently Asked Questions

    It acts as a decentralized quality control layer, preventing 'echo chambers' by forcing agents from different lineages (e.g., GPT-4 vs. Claude 3) to rigorously audit each other's code before it is merged.

    This skill is framework-agnostic and compatible with any multi-agent environment that supports major LLM providers like Anthropic, OpenAI, and Google, provided the runtime metadata is accessible.

    The skill uses content hashing and snapshotting to ensure the reviewer evaluates the exact raw diff and test outputs, preventing agents from passing off misleading summaries or altered code.

    You will receive the structured workflow logic, metadata verification protocols, and integration templates for your agent environment, along with documentation for setting up gating policies.

    The skill requires an environment where you can provide access to at least two distinct model families and a file system or Git repository to track snapshots and diffs.

    While the skill manages the review cycle and identifies model lineages, it relies on your project's predefined policy to authorize the final decision-makers and set the pass/fail thresholds.

    New in Agents & Orchestration