Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    elevate

    1

    A deep-reasoning protocol for L3/L4 tasks using adversarial verification, domain cartridges, and external state.

    $12

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    elevate

    elevate

    Example session with this skill installed

    ELEVATE: We need to change our primary user ID from an auto-incrementing integer to a UUID across the entire distributed system. How should we handle the migration?

    • Read your context and instructions
    • Compiled the elevate

    The migration requires a dual-write phase followed by a background backfill to ensure zero downtime and referential integrity.

    User ID Migration Strategy: Dual-Write Shadowing

    Schema Update: Add a nullable public_id (UUID) column to the users table and all related foreign key tables. Add a unique index to users.public_id.
    2.

    Dual-Write: Update the User service to generate a UUID on creation. Write both id and public_id to the database. Updates should look up by id but maintain both.
    3. Backfill: Run a throttled background job to generate and populate UUIDs for existing rows.
    4.

    Code Transition: Update downstream services to accept public_id in API requests, while keeping internal joins on the integer id for performance.
    5.

    Cutover: Once all rows are populated and services are updated, make public_id NOT NULL and shift all external references to it.

    ── ELEVATE ──
    Level: L4 | Candidates: A/B/C (one line each)
    A: Direct migration with maintenance window. B: Shadow columns with dual-writes. C: API Gateway translation layer.
    Winner: B because it offers the lowest risk of data loss and supports zero-downtime requirements. | Borrowed from others: C (mapping layer).
    Checks failed and fixed: Initial check for foreign key constraints failed; added explicit backfill order.
    Cartridges applied: cartridge-architecture.md | Traps checked: ARCH-04 (Distributed State), ARCH-12 (Migration Lock)
    Confidence: high because the dual-write pattern is an industry standard for L4 data changes.
    Escalation: no

    Next steps

    • Audit the orders and profiles services to identify all tables requiring the new public_id column.
    • Initialize STATE.md to track the status of the backfill job across production shards.
    • Verify the performance impact of a unique index on a UUID column at our current write volume.
    cartridge-architecture.md

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

    About this skill

    AI models often suffer from early evaluation bias, collapsing onto the first plausible answer instead of exploring the best one. This is dangerous for high-stakes decisions like database migrations, security boundaries, or pricing changes where errors are hard to reverse. This skill forces a systematic deep-reasoning protocol that trades token budget for architectural depth and adversarial verification.

    What it does

    • Multi-solution generation produces three independent architectures based on orthodox, minimal, and structural assumptions before choosing one.
    • Adversarial verification acts as a hostile reviewer, running solutions against pass/fail checks and domain-specific failure modes.
    • External state management maintains a STATE.md file to track decisions, invariants, and verified module interfaces across long sessions.
    • Domain cartridges provide pre-computed judgment for architecture, security, and product decisions to catch invisible traps.
    • Escalation protocol triggers a mandatory hand-off to human experts when verification loops fail or risks exceed model limits.

    How it works

    1. Classify the task level from L1 (routine) to L4 (irreversible) to determine if the full protocol is required.
    2. Read the relevant domain cartridges and existing STATE.md to load constraints and pre-computed traps.
    3. Generate three divergent solutions without critiquing them, ensuring a broad search space.
    4. Verify all candidates using binary pass/fail checks and cartridge IDs before synthesizing the final answer.

    Frameworks & tools

    This skill is platform-agnostic and works with any agent capable of reading local project files. It utilizes a structured references/ directory containing domain-specific markdown cartridges and a root-level STATE.md for persistent memory.

    Why this beats prompting it yourself

    Standard prompts rely on the model's internal weights to "think hard," which often results in confident but shallow hallucination. This skill implements a rigorous process discipline that forces the model to spend compute on breadth, adversarial checking, and external memory.

    Use cases

    • Designing a multi-tenant data isolation strategy that must not leak records.
    • Refactoring a core payment processing flow where a mistake causes financial loss.
    • Evaluating the trade-offs of a major library migration across a large codebase.
    • Reviewing a new public API for breaking changes and security vulnerabilities.

    Known limitations

    The protocol requires significant token overhead (3-5x) and is not intended for routine L1/L2 tasks. It cannot verify failure modes that are not documented in the provided cartridges or visible in the current file context.

    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 3-5x token overhead. Not for simple edits. Cannot verify risks outside the provided domain cartridges or active file context. Max 3 repair loops before mandatory escalation.

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

    Permissions

    Read Files
    Write Files
    Network Access
    Listed26 days ago

    What's inside

    Frequently Asked Questions

    This skill is designed for L3/L4 tasks where errors are irreversible, such as security architecture or financial logic. It replaces standard "one-shot" responses with a rigorous protocol involving multi-solution generation, adversarial verification, and persistent state management to eliminate early evaluation bias.

    Elevate is platform-agnostic and works with any agent or LLM that has the ability to read and write to your local project directory. It relies on a structured file-based system (STATE.md and domain cartridges) rather than specific API integrations.

    You will receive the core deep-reasoning protocol instructions, a suite of domain cartridges (Security, Architecture, and Product), and a template for the external state management system. It also includes the classification framework to help your agent distinguish between routine and high-stakes tasks.

    Because this protocol generates three independent solutions and runs them through a hostile verification loop, it typically consumes 3-5x more tokens than a standard query. It is a premium compute strategy intended for accuracy-critical tasks where the cost of failure exceeds the cost of tokens.

    Setup is straightforward: you place the provided 'references/' directory and 'STATE.md' file into your project root. Once your agent is pointed to these files, the protocol takes over to ensure all reasoning is anchored to your specific project constraints and domain traps.

    New in Agents & Orchestration