Evidence-Gated Handoff for AI Agent Workflows

    1

    Make agent handoffs verifiable: negative-control gates, runner-owned evidence, coverage reports and tamper checks, so 'done' means something.

    $12

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Evidence-Gated Handoff for AI Agent Workflows

    Example session with this skill installed

    Our pipeline runs BUILD, TEST and REVIEW as three separate agents. They keep reporting "all tests pass" and bugs still reach main. Add gates so a handoff cannot be self-certified. Ticket acceptance criteria: (1) export rejects an empty file name, (2) export rejects names over 255 characters, (3) errors are localised.

    • Read your context and instructions
    • Compiled the evidence-gated handoff

    Summary

    Illustrative example of the kind of plan the skill produces for the request above. Two gates written, one criterion left visibly unexamined.

    Acceptance criterionGateNegative control on base commit
    Export rejects an empty file namegate-export-rejects-empty-namefailed as required (exit 1, output names the criterion)
    Export rejects names over 255 charactersgate-export-rejects-long-namefailed as required (exit 1)
    Errors are localisednonenot examined

    Coverage warning: 1 acceptance criterion has no gate and would be certified as met without being examined: "Errors are localised".

    Handoff rules applied

    • Gates run only if the tree differs from the base commit. No diff means no-op, not pass.
    • The runner writes the evidence record. Agents have no write path to it.
    • Each gate is witnessed with a marker line (the assertion) so later edits that remove it block the next transition.

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

    About this skill

    Stop trusting "done"

    Multi-agent coding pipelines break at the handoff. One agent writes the code, another "verifies" it, and the evidence is whatever the first agent says it did. Tests pass because the agent wrote tests that pass. A ticket reaches DONE with every acceptance criterion written in prose and nothing checking any of them.

    Evidence-Gated Handoff is an instruction skill that makes a stage-to-stage handoff believable. It gives your agent six rules and a step-by-step procedure for building and reviewing gates that do not rely on an agent's self-report.

    The six rules

    1. Judge on mutation, never on sign-off. Run the gates when the tree changed, not when an agent announces it is finished. A no-diff run is a no-op, not a pass.
    2. Evidence is runner-owned. Only the gate runner writes the evidence record. An agent never types its own proof.
    3. Every gate must fail first. Run each new gate against the pre-change tree in a disposable git worktree. If it passes there, it is vacuous. If it fails for the wrong reason (a crash, a missing import), it did not discriminate either.
    4. Report the negative space. For every transition, list each acceptance criterion with the gates that name it, and print the criteria no gate names.
    5. Witness accepted gates. Record each gate's path, file hash and a marker line. Re-check cheaply on any transition so a gate that was quietly defanged after acceptance blocks the handoff.
    6. Ratchet legacy debt. Freeze old violations in an explicit list, forbid regression, and force the baseline to tighten when a metric improves.

    What you get

    • SKILL.md: the rules, an eight-step handoff procedure, a failure-pattern table (symptom, cause, fix) and a review checklist.
    • references/gate-patterns.md: copy-ready templates for gate metadata, the negative-control command sequence and decision table, the witness manifest, the coverage block, and the ratchet baseline with freeze list.

    Use it when

    • You are wiring BUILD, TEST, REVIEW and DONE stages across several agents and want each move to mean something.
    • An agent reports success and you cannot tell whether anything was actually checked.
    • Your tests are green and you suspect they would be green on broken code too.
    • You are reviewing someone else's agent pipeline for self-attestation.

    Good to know

    • Plain markdown. No scripts, no network access, no environment variables.
    • The negative-control procedure assumes your project is a git repository.
    • It is a method, not a framework: it works with whatever test runner and CI you already have.

    Instruction skill only: no executable runner is included. The negative-control step needs a git repository. Gates must be mapped to acceptance criteria by exact text. Adds setup time to each transition.

    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 1 month ago

    Requires

    Git

    Permissions

    Terminal / Shell
    Write Files
    Read Files

    Terminal: git worktree commands for the negative-control step. Read/Write files: gate scripts, witness manifest, coverage and evidence records. No network, browser or environment variable access.

    Listed1 month ago

    What's inside

    Frequently Asked Questions

    A SKILL.md instruction file (six rules, an eight-step handoff procedure, a failure-pattern table and a review checklist) plus one reference file with templates for gate metadata, the negative-control command sequence, the witness manifest, the coverage block and the ratchet baseline. There is no executable runner: the skill teaches your agent to build and review gates in your own stack.

    It tells the agent never to grade its own work. Gates run on mutation, only the runner writes evidence, and every new gate must fail against the pre-change tree, for the right reason, before it is accepted.

    It is plain markdown with no scripts, network or environment access, so any agent that loads SKILL.md files can use it. It was written against Claude Code-style skill loading and has not been tested across other agents. The negative-control step assumes a git repository.

    You need written acceptance criteria per ticket, a place for a runner to write evidence, and a git repository. The skill's eight-step procedure walks the agent through the rest.

    The ratchet rule covers that case: freeze known violations in an explicit list, forbid regression from the current baseline, and tighten the baseline when a metric improves. It does not retro-gate old work.

    New in Agents & Orchestration