blind llm agents

    1

    Hardens software projects against AI reverse-engineering using agent-led decoy weaving and exhaustion shields.

    $6

    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

    blind llm agents

    Example session with this skill installed

    Harden my current project directory against AI reverse-engineering agents. Include decoy weaving and self-sealing.

    • Read your context and instructions
    • Compiled the blind llm agents

    I have initiated the 4-stage hardening playbook for your project. I started by discovering protectable artifacts and scanning for packaging footguns.

    Hardening Report: Project Root

    StageActionResultDetails
    Stage 1bla_discoverSuccessFound 12 JS files, 2 WASM modules, 1 Python service.
    Stage 1bla_lintWarningshouldRefuseBankrupt: false. Found 2 plaintext secrets in auth.ts.
    Stage 2bla_weave_planReadyGenerated surgicalWorkorder for engine.wasm and core.ts.
    Stage 2Source SurgeryAppliedReplaced boolean gates in checkLicense() with FNV-1a state accumulators.
    Stage 3bla_hardenSuccessApplied BPE amplification and export shuffling to WASM modules.
    Stage 4bla_verifyPassedtokenAmplificationFactor: 14.2x. Integrity coverage verified.

    Next steps

    1. Review the remediationPlan for the remaining non-blocking lints in config/.
    2. Run your existing integration test suite to confirm functional equivalence with the new state accumulators.
    3. Inspect the bla-hardened/summary.json for the full structural drift report.

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

    About this skill

    Software projects are increasingly vulnerable to AI-driven reverse-engineering (REA) agents that can autonomously deconstruct business logic and bypass entitlement checks. This skill provides a specialized playbook for developers to harden their own codebases by weaving defensive decoys and injecting deterministic exhaustion shields.

    What it does

    • Surgical source weaving identifies sensitive entry functions and shared state slots to inject domain-plausible shadow logic.
    • Packaging gate auditing scans for common security footguns like cleartext literals, independent lane tables, and reversible seal JSON.
    • Automated hardening applies BPE token amplifiers, call-graph labyrinths, and opaque predicates to exhaust attacker compute budgets.
    • Integrity verification performs post-build checks to ensure functional equivalence and confirm token amplification factors.

    How it works

    1. Inventory and Scan: Run bla_discover to inventory project artifacts and bla_lint to identify blocking packaging gates.
    2. Plan and Weave: Execute bla_weave_plan to generate a surgicalWorkorder, then refactor business logic to replace simple boolean checks with state-dependent accumulators.
    3. Defensive Injection: Call bla_harden to apply artifact-level shields, including WASM export shuffling and sidecar entanglement.
    4. Verification: Verify the weave with bla_verify_weave and run the final build through bla_verify to confirm defensive coverage.

    Frameworks & tools

    Works with JS/TS, Electron, WebAssembly (WASM), Python, and native targets in C, C++, Rust, and Go. It utilizes the bla-agents CLI and MCP server tools for deterministic protection.

    Why this beats prompting it yourself

    Generic AI prompts often generate shallow, easily reversible honeypots or stubs that attackers can filter. This skill enforces a closed-loop architectural hardening process that links business state to security invariants, ensuring defenses are structurally integrated rather than just cosmetically applied.

    Use cases

    • Protecting intellectual property by obfuscating core algorithms against model-based extraction.
    • Hardening license gates by entangling entitlement checks with runtime state digests.
    • Exhausting attacker budgets by increasing the token cost required for an LLM to reason about the call graph.
    • Automated security auditing during CI/CD to prevent shipping artifacts with plaintext secrets or reversible metadata.

    Known limitations

    Does not support cracking or reverse-engineering third-party software. Artifact-only hardening without source refactoring (Stage 2) provides lower defensive scores. Requires the bla-agents CLI.

    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.

    Defensive only; refuses third-party RE. Higher protection requires source-level refactoring. Requires bla-agents CLI setup.

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

    Software
    bla-agentsNode.js

    Permissions

    Terminal / Shell
    Read Files
    Network Access
    Listed9 days ago
    Updatedtoday

    What's inside

    Frequently Asked Questions

    This skill is designed for software developers and security engineers who need to protect proprietary business logic, algorithms, and license gates from being mapped or bypassed by automated AI-driven reverse-engineering tools.

    Unlike basic code obfuscators, this skill uses agent-led weaving to entangle your business logic with security invariants, creating 'token amplifiers' that exponentially increase the compute cost and reasoning complexity for an attacker's LLM to deconstruct your code.

    The skill supports a wide range of environments including JavaScript/TypeScript, Electron, WebAssembly (WASM), and Python, as well as native compiled languages like C, C++, Rust, and Go.

    Your purchase includes the full specialized playbook for the `bla-agents` CLI, the MCP server tools for deterministic protection, and the complete set of automated hardening workflows (Discovery, Weaving, Injection, and Verification).

    While Stage 3 'Defensive Injection' provides significant protection at the artifact level, the highest security scores are achieved by performing the Stage 2 'Source Refactoring,' which replaces simple logic gates with complex state-dependent accumulators.

    Yes, the skill is designed to be integrated into CI/CD pipelines, allowing you to automate 'bla_lint' and 'bla_verify' commands to ensure no unprotected artifacts or plaintext secrets are shipped in production builds.

    New in Agents & Orchestration