Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Gungnir Evidence Gate

    1

    Lock the goal. Verify real artifacts and command exit codes. Repair failed work before an AI coding agent says "done.

    Free

    Security scanned
    Gungnir Evidence Gate

    Gungnir Evidence Gate

    Example session with this skill installed

    Verify that the new logging utility in src/utils/logger.ts is implemented and the existing unit tests pass.

    • Read your context and instructions
    • Compiled the gungnir evidence gate

    I have executed the Gungnir Evidence Gate to verify the requested logging utility implementation. The task has reached a

    PASS verdict based on the deterministic evidence collected from the workspace.

    Delivery Verdict

    Objective: Implement logging utility and verify via unit tests.
    Status: PASS

    IDCriterionTypeResultEvidence
    AC-1src/utils/logger.ts existsArtifactPASSFile located at /project/src/utils/logger.ts
    AC-2npm test -- src/utils/logger.test.tsCommandPASSExit code: 0
    AC-3Logger exports info, warn, errorContentPASSGrep confirmed required symbols in source

    Executed Checks

    1. Checked for artifact existence at specified path.
    2. Executed test runner for the specific module.
    3. Inspected file content for required interface exports.

    Next steps

    1. Review the generated src/utils/logger.ts for any style preference adjustments.
    2. The DispatchContract JSON has been removed from the temporary directory.
    3. You can now proceed to integrate the logger into the main application entry point.

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

    About this skill

    Coding agents often hallucinate success, claiming a task is done when tests are still failing or files are missing. This skill forces agents to verify work against real workspace evidence before declaring completion. It replaces "I think I'm done" with a deterministic gate based on exit codes and artifact checks.

    What it does

    • Lock acceptance criteria by converting user requirements into a formal, observable DispatchContract JSON.
    • Execute deterministic verification using the Gungnir CLI to validate command results and file states.
    • Categorize delivery verdicts into explicit Pass, Fail, Partial, or Unverifiable states based on ground truth.
    • Automate repair loops by identifying specific failed criteria and forcing targeted fixes until the gate clears.
    • Generate evidence reports that document exactly what was checked, which commands ran, and what artifacts exist.

    How it works

    1. Goal Locking: Define the objective and map requirements to observable command exit codes or file paths in a temporary contract.
    2. Work Execution: The agent performs the requested coding task using its standard toolset.
    3. Verification: Run npx dsh-gungnir-verify against the workspace and contract to get a model-free verdict.
    4. Failure Reconciliation: If the gate returns a Fail or Partial status, analyze the mismatch and apply targeted repairs.
    5. Final Reporting: Present the verdict, executed checks, and any unverifiable obligations to the user.

    Frameworks & tools

    This skill requires Node.js to run the dsh-gungnir-verify package via npx. It is designed for coding agents with shell and file system access like Claude Code, Cursor, and Codex.

    Why this beats prompting it yourself

    Standard prompts rely on the LLM to "double-check" its own work, which frequently leads to confirmation bias. This skill offloads verification to a deterministic CLI, ensuring that an agent cannot claim success unless the environment actually satisfies the contract.

    Use cases

    • Gate PR ready status on successful test suite execution and linting exit codes.
    • Verify the existence and content of specific generated artifacts after a refactor.
    • Prevent false positives in autonomous coding loops by requiring external evidence.
    • Document compliance with acceptance criteria for complex multi-step migrations.

    Known limitations

    Requires a Node.js environment to execute the verifier. It cannot verify requirements labeled as sandbox-external, such as external API states or live URL deployments.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Agents & Orchestration.

    Requires Node.js for CLI verification. Cannot verify 'sandbox-external' requirements. Does not replace the agent loop; requires tool access to execute commands and read files.

    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 buying a skill.

    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

    Free to use

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 15 days ago

    • Free with an Agensi account

    Software
    dsh-gungnir-verifyNode.js

    Permissions

    Terminal / Shell
    Write Files
    Network Access
    Listed15 days ago

    What's inside

    Frequently Asked Questions

    It solves 'hallucinated success' where agents claim a task is finished despite failing tests. By using a deterministic CLI gate, it ensures an agent can only signal completion if real workspace evidence, like exit codes and file states, matches the requirements.

    The skill is compatible with any agent that has shell and file system access, including Claude Code, Cursor, Windsurf, and custom frameworks. It requires a Node.js environment to run the verification package via npx.

    Setup involves providing the agent with the Gungnir skill definition and ensuring Node.js is installed; the agent then uses the included CLI to generate contracts and verify its own work against the workspace.

    You receive the specialized skill definition, the logic for generating DispatchContract JSONs, and the integration bridge to the Gungnir CLI verifier. This includes the patterns necessary for the agent to autonomously handle repair loops when a gate fails.

    Gungnir can verify anything observable via shell commands or file system checks, such as test suites, linting results, and file existence. It cannot verify external states like live cloud deployments or third-party API dashboards that are outside the agent's local sandbox.

    Unlike prompting, which relies on the agent's own biased 'thought process,' Gungnir offloads the final verdict to a model-free, deterministic system. This replaces subjective self-assessment with objective ground truth based on actual code execution.

    New in Agents & Orchestration

    Free