dsg production evidence auditor

    0

    Audit AI-agent production evidence bundles for integrity and requirement coverage using an offline, hash-based verifier.

    $19

    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 CLIDeepSeekDeepSeekMuseMuse+22 more

    dsg production evidence auditor

    Example session with this skill installed

    Audit my AI-agent Production E2E evidence bundle in ./dist/release-v1.2/ using the manifest.json found there. Provide a readiness summary.

    • Read your context and instructions
    • Compiled the dsg production evidence

    I have audited the production evidence bundle located in ./dist/release-v1.2/. The integrity check processed 4 artifacts against the provided manifest.json.

    Production Evidence Audit Report

    RequirementLocal CheckIndependent Proof StateNext Fix
    Source IntegrityLOCAL_INTEGRITY_MATCHSOURCE_FOUNDNone: SHA-256 matches commit a1b2c3d
    CI Test LogsLOCAL_INTEGRITY_MATCHCI_TESTEDNone: Verified 100% pass rate in artifact
    Security ScanUNVERIFIEDPENDINGAttach trivy-report.json to bundle
    Owner ApprovalFAILUNVERIFIEDDigest mismatch for approval.sig; recapture signature

    Readiness Recommendation: NO-GO
    The audit failed due to a digest mismatch on the approval signature and missing security scan evidence. Even if these are fixed, the operator must independently verify Auth0 MFA events and AWS isolation postconditions as per references/e2e-checklist.md.

    Next steps

    1. Recapture the approval.sig from the trusted release vault and update the manifest.
    2. Include the missing trivy-report.json in the ./dist/release-v1.2/ directory.
    3. Perform manual verification of provider-side account isolation before re-running the audit.

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

    About this skill

    AI agent deployments often lack verifiable proof of testing, approval, and artifact integrity, leading to risky production releases. This skill provides a read-only, offline auditing workflow to validate local evidence bundles against expected hashes before a GO/NO-GO decision.

    What it does

    • Integrity validation checks local artifact SHA-256 digests against supplied expected hashes.
    • Requirement mapping scans manifest files to identify gaps in approvals, CI runs, and isolation checks.
    • Path sanitization enforces security boundaries by rejecting absolute paths, symlinks, and parent directory traversal.
    • Status reporting generates structured findings distinguishing between local integrity matches and unverified live conditions.
    • Readiness assessment produces remediation steps and deployment recommendations based on evidence completeness.

    How it works

    1. Scope definition requires the user to provide a directory containing local evidence files and a manifest.json.
    2. Manifest inspection uses the audit_evidence.py script to parse artifacts and verify file-level integrity.
    3. Report generation interprets exit codes and JSON outputs to categorize requirements as LOCAL_INTEGRITY_MATCH, UNVERIFIED, or FAIL.
    4. Manual verification prompts the operator to perform independent runtime and provider postcondition checks.

    Frameworks & tools

    This tool uses Python 3.9+ (Python 3.10+ recommended) and standard library modules. It relies on a specific manifest.json schema and local file system access for SHA-256 hash comparison.

    Why this beats prompting it yourself

    Writing prompts to check files often results in hallucinated hashes or missed security vulnerabilities like symlink attacks. This skill provides a hardened, executable Python script and a formal schema that ensures every artifact is accounted for without network-based hallucinations.

    Use cases

    • Pre-flight auditing of agent production E2E evidence bundles before launch.
    • CI artifact validation to ensure exported builds match the verified source.
    • Release blocking analysis to identify which specific approvals or receipts are missing.
    • Security review of evidence bundles to detect tampered files or unsafe path structures.

    Known limitations

    This is an offline utility that cannot verify live provider postconditions, signatures, or MFA events. It requires a pre-configured manifest and does not perform live network calls or 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 LLM Ops.

    Offline only. Cannot verify live signatures, MFA, or provider states. Requires Python 3.9+. No support for absolute paths or symlinks.

    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

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 22 days ago

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Network Access
    Listed22 days ago

    What's inside

    Frequently Asked Questions

    This skill provides a secure, offline Python-based workflow to verify the integrity and completeness of AI agent deployment artifacts against a manifest. It prevents risky production releases by catching tampered files, missing approvals, and security vulnerabilities like symlink attacks that manual prompting often misses.

    The skill is agent-agnostic and works with any AI agent or LLM-based application, provided the deployment evidence is organized into a directory with a standard `manifest.json` file. It focuses on the integrity of the artifacts themselves rather than the specific logic of the agent.

    You will receive the `audit_evidence.py` script, a formal `manifest.json` schema to structure your evidence, and comprehensive documentation for integrating the auditing workflow into your pre-flight checks.

    No, this is a read-only, offline utility designed for local file system access to ensure maximum security. It does not make network calls or verify live MFA events, which prevents "hallucinated" verification results often found in cloud-based prompting.

    The auditor requires Python 3.9 or higher (3.10+ recommended) and uses standard library modules for SHA-256 hashing and path sanitization. It is designed to be lightweight and easily portable across different developer environments without complex dependency management.

    New in LLM Ops