Zero Skills

Zero-shot vulnerability detectors from Zero Cool.

Skills that aim to inject information outside the model’s training distribution. The vulnerabilities that win contests and matter in production tend to live outside what frontier models already know. A skill is useful when it extends the model’s effective knowledge boundary.

Why these skills exist

Most public security skills restate well-documented patterns. Reentrancy, access control, integer overflow. Frontier models already encode this knowledge from years of public audits, educational material, and vulnerability databases.

Zero Skills target what the model doesn’t know:

• Domain-specific context learned through experience finding real bugs
• Protocol-specific invariants that must hold but aren’t in any training set
• Nuanced implementation details around storage semantics, upgrade patterns, and state persistence
• Post-training information from incidents and patterns discovered after the model’s cutoff
• Edge cases the model won’t infer because they don’t appear often enough in public data

Skills

Slot Sleuth (slot-sleuth/SKILL.md)

EVM storage-safety vulnerability detector. Targets bugs that cause persistent state updates to be lost, overwritten, misdirected, or collide across proxy and upgrade boundaries.

What it finds:

• Memory vs storage confusion
• Lost writes (state mutated in memory, never persisted)
• Attacker-influenced storage slot writes
• Storage collisions across proxy/upgrade layouts
• Upgrade layout hazards

The skill runs five detection phases with explicit applicability gates. If the contract doesn’t have the relevant storage patterns, it doesn’t force findings. It encodes heuristics from human experience finding these bugs in production code.

Vyper Vanguard (vyper-vanguard/SKILL.md)

Vyper-specific language-semantics and protocol-accounting bug detector. Goes beyond compiler-CVE archaeology to cover the patterns that actually produce exploits in modern Vyper codebases.

What it finds:

• raw_call/@raw_return forwarding bugs (wrong target, wrong return bytes, wrong success state)
• Factory and blueprint traps in create_from_blueprint, raw_create, create_copy_of, create_minimal_proxy_to
• Reentrancy observation windows including read-only paths consumed by oracles/keepers
• Module-system drift (uses:/initializes:/exports: mismatches and lock-policy gaps)
• Interface/ABI drift (.vyi, JSON ABIs, default_return_value, skip_contract_check, mutability mismatches)
• Bytes/convert/side-effect semantics (slice, concat, extract32, Bytes[N] equality, signed/unsigned boundaries)
• Iterative-solver invariant drift, asymmetric rounding, dust/share inflation, zero-amount state mutation, and multicall sequencing
• unsafe_* and pow_mod256 arithmetic in value-impacting paths

The skill explicitly demotes compiler-CVE matching as a side branch — it records the version for sharpening evidence but requires a concrete exploit path before reporting any version-dependent bug.

Symmetry Sniper (symmetry-sniper/SKILL.md)

Paired-operation asymmetry detector. Finds places where two functions that should mirror each other do not — the round-trip that nets a profit, the guard that protects one side but not its counterpart, the ledger that updates going in but not coming out.

What it finds:

• Invariant breaks where a pair fails to conserve or invert the relevant quantity (shares, totalAssets, balances, debt)
• Authorization mismatches where a sensitive check exists on one side of a pair but is missing on the other
• Fee/rounding asymmetry that can be round-tripped to extract value or bypass fees
• Batch bypasses where a doMany/multicall path skips a check the single path enforces

It gates on whether an expected symmetry can actually be established from naming, events, interfaces, or tests, and requires a concrete exploit or invariant-failure sequence before reporting. Running inside Zero Cool’s own engine since January 2026, it has surfaced 240 confirmed findings (20 critical, 105 high, 115 medium), including the issue published as H-01 in the Code4rena Panoptic: Next Core report.

UniV4 Hook Harbinger (univ4-hook-harbinger/SKILL.md)

Uniswap v4 hook and integration detector. The PoolManager sequences callbacks, runs pool math, and forces transient currency deltas to settle before an unlock ends. It guarantees nothing above that line. A hook can settle to zero deltas while its own ledger is insolvent, the wrong user holds the output, or one pool has spent another’s assets. Cork and Bunni cost more than $20 million between them without a flaw in v4 core.

What it finds:

• Permission bits encoded in the deployed hook address that disagree with callbacks, upgrades, or privileged configuration
• Missing PoolManager authentication, and authenticated callbacks that still trust sender, hookData, or an arbitrary PoolKey
• Pool isolation breaks where state is keyed by less than its full economic domain, so one pool can spend another’s assets
• Custom accounting and delta errors across all four exact-input and exact-output quadrants, including int128 truncation and return-delta permission gaps
• Settlement paths (settle, settleFor, take, clear, native currency, ERC-6909 claims) that a direct transfer or another pool’s funds can satisfy
• Dynamic-fee and JIT-penalty sequences that reset age, evade penalties, or freeze a manipulated spot price as a trusted checkpoint
• Oracle and external-dependency failures involving stale or manipulable prices, unit mismatches, sequencer or cross-chain state, and blocked exits
• Custom-curve and shared-custody math bugs across fixed-point scales, boundary conditions, rounding cycles, and recursive receipt-token pools
• Callback liveness bugs caused by reentrancy, malformed returns, state growth, or gas exhaustion

The skill treats the hook as one component of a protocol and traces routers, pools, vaults, and protocol-issued tokens alongside it. If beforeSwap offsets the native swap into a no-op, the hook is the entire AMM and gets reviewed as one. It reports only when it can show a reachable attacker path, the exact callback and settlement sequence, the false assumption, the broken invariant, and who gains and loses.

Test Terminator (test-terminator/SKILL.md)

Test-suite analysis skill. Treats existing tests and missing coverage as security intelligence, then traces each clue into production and reports only reachable vulnerabilities with concrete security impact.

What it finds:

• Production paths that violate invariants encoded by assertions, expected reverts, and postconditions
• Security assumptions created by fixtures, mocks, seeded state, and trusted dependencies
• Missing and one-sided coverage around value-bearing functions and terminal state transitions
• Reachable failures hidden by fuzz filters, skipped cases, TODOs, and test workarounds
• Gaps between what test names and comments promise and what their assertions prove
• Conflicting assumptions across unit, integration, invariant, and end-to-end suites

Running for six months, Test Terminator has contributed to 84 verified critical, high, and medium findings (10 critical, 36 high, 38 medium).

Contributing

Build a skill that finds real vulnerabilities, the kind that live outside the training distribution, and we’ll pay you for it. [Details coming soon.]

Contact

Website: zerocool.ai Twitter: @ZeroCool_AI

Built by security researchers. For teams building onchain.