More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    omni maximus

    1

    Autonomous Adversarial SRE and AppSec engine for rigorous code verification and zero-false-positive vulnerability PoCs.

    $39

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    omni maximus

    omni maximus

    Example session with this skill installed

    Audit the user registration flow in /src/auth/register.ts for concurrency issues and physical limits.

    • Read your context and instructions
    • Compiled the omni maximus

    I have completed a 6-Gate Adversarial Audit of the registration flow. A critical SEV-2 concurrency vulnerability was identified regarding duplicate wallet creation during rapid request bursts.

    Adversarial Audit Report

    <supply_chain_gate>
      <manifests status="VERIFIED" lockfile_present="true" />
      <secrets_risk detected="NONE" />
      <sentinel_violations count="0" />
    </supply_chain_gate>
    
    IDTypeRoute / SymbolFile:LineAuth LevelReached Data Sinks
    EP-01POST/api/registerregister.ts:12PublicDatabase:Users, Database:Wallets
    <taint_matrix>
      <vector id="SEV-2">
    
    <source>Concurrent HTTP POST requests with identical email/identity.</source>
    
        <flow>validate() -> createUser() -> createInitialWallet()</flow>
        <sink file="src/auth/register.ts" line="42">Wallet table insert lacks row-level lock or atomic check.</sink>
      </vector>
    </taint_matrix>
    
    <falsation_audit>
    
    1. Taint / Stress Check: Confirmed. The wallet creation occurs after the user insert but before the transaction commits without a mutex.
    2. Executable PoC Vector: for i in {1..5}; do curl -X POST http://localhost:3000/api/register -d '{"email":"test@example.com"}' & done;
    3. Runtime Lifecycle: Standard Node.js cluster mode will allow race condition.
    4. Verdict: CONFIRMED.
    </falsation_audit>
    
    // Phase 1: Atomic Concurrency Fix
    async function registerUser(data: RegData) {
      return await db.transaction(async (tx) => {
        // Added SELECT FOR UPDATE to lock identity row
        const existing = await tx.select().from(users).where(eq(users.email, data.email)).for('update');
        if (existing) throw new Error("Conflict");
        
        const newUser = await tx.insert(users).values(data).returning();
        await tx.insert(wallets).values({ userId: newUser.id, balance: 0 });
        return newUser;
      });
    }
    

    Next steps

    1. Run the provided shell script to verify the fix prevents duplicate wallets.
    2. Review the LIMIT clauses on the user lookup to satisfy SEV-5 requirements.
    3. Convene the 4-Voice Council to discuss migrating to a distributed lock if scaling horizontally.

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

    About this skill

    Why Standard AI Coding Agents Fail in Production

    AI coding models suffer from conversational sycophancy and self-referential blindness: when asked to review their own code, they say "everything looks clean and well-structured" while missing critical bugs:

    • Unbounded database queries without LIMIT that exhaust connection pools under load.
    • Concurrency race conditions in balances and inventory permitting double-spending.
    • UI state machines where sequential handlers silently cancel each other out.
    • Handcrafted regexes vulnerable to Catastrophic Backtracking (ReDoS).

    OMNI-MAXIMUS transforms your AI into a ruthless, zero-sycophancy Adversarial Red-Team.


    🛡️ The 6 Hard Gates Pipeline

    1. Gate 0 (Supply Chain & Sentinel NIH Shield): Enforces committed lockfiles, scans for hardcoded secrets, and blocks handcrafted crypto or homebrew JWT parsers.
    2. Gate 1 (AST Surface Inventory): Maps all public routes, webhooks, and workers with their call paths to critical data sinks.
    3. Gate 2 (SRE Physical Limits): Enforces computational limits: heap streams (<= 8 KB), CAS atomic locks, and mandatory LIMIT clauses on all collection queries.
    4. Gate 3 (UI Forensics & Click-Path Audit): Detects silent state cancellations in React/Zustand/Redux, WCAG 2.2 AA contrast (4.5:1), and zero horizontal scroll on 360px.
    5. Gate 4 (Mandatory PoC Falsification): Zero False Positives: Every reported issue MUST synthesize an executable curl command or concurrency script proving the failure.
    6. Gate 5 (Surgical 2-Phase Remediation): Applies atomic diffs verified by dual independent reviewers (Santa Method) requiring a resilience score >= 95/100.

    ⚡ Universal Compatibility

    Fully compliant with the Open SKILL.md Standard. Works natively across Claude Code, Cursor, Windsurf, Google Antigravity, Copilot, and Amazon Q.

    Requires lockfiles for supply chain checks. PoC execution depends on the agent having terminal access. Scope is limited to code and architectural forensics, not live infrastructure monitoring.

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

    Permissions

    Read Files
    Terminal / Shell
    Write Files

    Allowed Hosts

    api.example.com
    Listed19 days ago

    What's inside

    Frequently Asked Questions

    Unlike standard assistants that prioritize helpfulness, this skill uses a "Cognitive-Executive Separation" model where an adversarial subagent actively tries to break your code before suggesting any fixes. This ensures that only verified, battle-tested patches are applied, eliminating the "conversational sycophancy" that often leads to shallow code reviews.

    Omni-maximus is designed for high-performance environments and is compatible with Claude Code, Cursor, Windsurf, and Antigravity. It supports major languages including Node.js, Python, Rust, PHP, and Go, provided it has access to project lockfiles for dependency analysis.

    The "Zero-False-Positive" feature synthesizes actual executable scripts (like curl commands or concurrency triggers) that demonstrate a vulnerability in a runtime environment. This proves a bug is real and exploitable before any remediation steps are taken, saving developers from chasing ghost issues.

    The skill requires access to your project's lockfiles (e.g., package-lock.json, Cargo.lock) to perform accurate supply chain audits. Additionally, for full PoC generation, the agent needs permission to operate within a terminal or networking-enabled environment to test for real-world failures.

    Beyond security, the skill performs SRE-focused audits for resource exhaustion (RAM/CPU), identifies concurrency deadlocks, and even conducts UI forensics to catch render waterfalls and viewport overflows. It is a comprehensive tool for both application security and system stability.

    New in Security