Every vulnerability claim must survive physical execution against real EVM state before it is evidence. Everything else is conjecture.
Vibe Audit Engine is a hybrid neuro-symbolic Automated Exploit Generation platform. It does not scan. It does not alert. It synthesizes and detonates adversarial hypotheses against live EVM execution environments and returns binary, stake-weighted verdicts.
A finding is confirmed only when the execution substrate measures a quantifiable economic or invariant violation. Execution truth is the only currency.
The smart contract security industry operates on a structurally flawed feedback loop. Static analyzers produce thousands of unverified alerts rooted in pattern-matching heuristics with no ground-truth verification mechanism.
Manual auditors apply high-skill reasoning across dangerously narrow time windows, generating findings whose completeness is bounded by human fatigue and calendar constraints.
Conventional fuzzers mutate calldata stochastically without understanding economic intent, protocol invariants, or the adversarial context in which vulnerabilities become exploitable.
None of these systems can answer the only question that matters in production: can an autonomous adversary, operating with realistic capital and timing constraints, produce a measurable economic or invariant violation from this codebase?
Vibe Audit Engine is built around the empirical answer to that question.
Vibe Audit Engine partitions security intelligence into two irreconcilable domains connected only by a strictly typed, versioned, schema-validated IR serialization layer.
Extracts a rigorous machine-readable representation of the target protocol's economic topology — its assets, access-control surfaces, guarded state-mutation paths, and invariant structure — entirely from source artifacts, without executing a single instruction.
Receives compiled adversarial programs derived from semantic representations and measures their effect against real forked or synthesized EVM state using a high-performance multi-threaded execution substrate written entirely in systems-level Rust.
These two domains share no data structures, no LLM outputs, and no execution context.
No degree of semantic confidence, no LLM agreement, no static implication graph elevates a hypothesis to a vulnerability. Execution truth is the only currency.
Fourteen integrated capabilities that define VibeSec's adversarial infrastructure. Each module below explains what it delivers — not how it is wired internally.
Builds a precise economic map of your protocol directly from its own source and build artifacts — not from generic vulnerability templates.
Automatically derives what your protocol claims must never break, then turns those claims into falsifiable security targets.
Tests your protocol the way an unprivileged external attacker would — not as an omnipotent admin.
Confirms vulnerabilities through two independent lenses: measurable economic harm and broken protocol invariants.
Audits contest codebases and pre-mainnet protocols even when no live chain history exists.
Keeps deployment bootstrap logic cleanly separated from actual attack attempts.
Stress-tests protocols under fully funded attacker conditions, not just empty-wallet scenarios.
Learns from the contract's own rejection signals to push through guarded entry points.
Explores unknown calldata and numeric inputs without requiring manual harness authoring.
Discovers multi-step attack chains rather than relying on fixed, linear call scripts.
Turns opaque EVM failures into actionable attack intelligence.
Escapes stalled exploration paths without losing validated progress.
Binds attacks to values that only exist once the protocol is actually running.
Scales deep adversarial analysis across large protocol surfaces in parallel.
Builds a precise economic map of your protocol directly from its own source and build artifacts — not from generic vulnerability templates.
Every downstream hypothesis is anchored to what your code actually exposes: guarded functions, asset flows, and reachable attack surfaces. You get audit intelligence that is traceable to your protocol, not borrowed from a pattern library.
Automatically derives what your protocol claims must never break, then turns those claims into falsifiable security targets.
Instead of hunting random bug classes, the engine focuses on violations of your protocol's own economic and access-control promises — reducing noise and aligning findings with real security intent.
Tests your protocol the way an unprivileged external attacker would — not as an omnipotent admin.
Setup, initialization, and governance actions are separated from exploitation. The result: fewer out-of-scope false positives and findings that reflect realistic adversarial conditions.
Confirms vulnerabilities through two independent lenses: measurable economic harm and broken protocol invariants.
Theft, accounting breakage, unauthorized state changes, and sabotage can all be confirmed — even when an attack does not produce obvious extractable profit.
Audits contest codebases and pre-mainnet protocols even when no live chain history exists.
The engine reconstructs a realistic operational protocol state from the project's own test environment, so verification quality does not depend on mainnet deployment.
Keeps deployment bootstrap logic cleanly separated from actual attack attempts.
Findings represent exploitable adversarial paths — not artifacts of how the test harness initialized the system.
Stress-tests protocols under fully funded attacker conditions, not just empty-wallet scenarios.
Surfaces vulnerabilities that only appear when an adversary has meaningful capital, timing, and execution depth — the cases manual review often misses.
Learns from the contract's own rejection signals to push through guarded entry points.
Instead of brute-forcing random inputs forever, the engine converges on values that matter at the protocol's decision boundaries.
Explores unknown calldata and numeric inputs without requiring manual harness authoring.
Enables broad, meaningful coverage of complex function parameters — especially where the correct attack input is not obvious from static inspection alone.
Discovers multi-step attack chains rather than relying on fixed, linear call scripts.
Reentrancy sequences, ordering-dependent exploits, and compound state manipulations become searchable attack paths instead of one-off manual hypotheses.
Turns opaque EVM failures into actionable attack intelligence.
When a path fails, the system explains what guard blocked progress — accelerating convergence toward viable exploit routes.
Escapes stalled exploration paths without losing validated progress.
The engine abandons poisoned branches, preserves successful prefixes, and continues searching from the last stable execution state.
Binds attacks to values that only exist once the protocol is actually running.
Exchange rates, share prices, collateral parameters, and other runtime-derived values can drive realistic economic exploit attempts without manual setup.
Scales deep adversarial analysis across large protocol surfaces in parallel.
Multiple specialized agents attack different regions of the system simultaneously — increasing coverage without redundant collision on the same paths.
The engine's competitive differentiation is not any single technique. It is the precise, enforced integration of all techniques across a coherent pipeline architecture where each layer's outputs are the exclusive inputs to the next, every data contract is machine-validated at the boundary, and no component can produce results that bypass the physical execution truth gate.
Every hypothesis traces to a verifiable artifact in the target codebase — not a pattern database, not a vulnerability template, not a framework assumption.
Governance operations are contextualized correctly — setup is separated from exploitation, legitimate administrative actions are distinguished from attack vectors, and the engine never produces out-of-scope findings that require admin cooperation.
The full landscape of protocol violations is confirmable — theft, sabotage, invariant destruction, state corruption, DoS — without requiring each vulnerability class to produce measurable extractable profit.
The reasoning substrate can explore the non-linear attack surface without accumulating contradictory context that induces hallucinated tool usage.
The LLM cannot produce code. The IR compiler cannot emit semantically invalid programs. The execution substrate cannot confirm findings that do not pass the OR-gate verdict.
The tautology eliminators cannot be bypassed at either stage. The causality decoupling cannot be violated at any layer. The actor identity constraints cannot be circumvented by any topology the schema layer accepts.
The SAGE partition cannot place governance operations in adversarial execution lanes. Security infrastructure at production scale requires this kind of compositional correctness. Individual techniques can be approximated. The systematic, enforced integration cannot.
The engine accepts a structured YAML audit manifest specifying the target repository, scope constraints, trusted role definitions, known issues, and protocol-authoritative invariants. These invariants are merged with machine-generated invariant targets from the AIG pipeline to form the complete auditor task table. No manual configuration beyond the manifest is required for standard engagements.
The engine operates against any EVM-compatible target — deployed mainnet contracts via live state forking, pre-deployment contest codebases via zero-state synthesis, and local Foundry workspaces via direct AST extraction. The execution mode is determined automatically from target characteristics.
Static analysis workers and dynamic verification workers run concurrently. Static worker count scales with invariant surface area up to the API concurrency limit. Dynamic worker count is determined by the invariant dispatch table. Both pools are independent and non-blocking.
All expensive intermediate artifacts — synthesized protocol states, compiled build-info ASTs, completed auditor findings — are preserved across session boundaries. An interrupted or partially completed engagement resumes from the most recent stable artifact checkpoint without repeating any completed computation.
Every finding produced by the dynamic verification phase is accompanied by the specific IR sequence that produced it, the measured economic or invariant violation, the execution trace at the point of confirmation, and the relevant SDMS constraint that was broken or the profit delta that was measured. No finding is produced without this evidence package.
It is not a linter. It is not a pattern-matcher. It is not a test generator. It is not an alert system that requires a human to triage its output before determining whether the finding is real.
It is an autonomous adversarial verification system. The findings it produces are not suggestions. They are measured violations of formally specified security properties, confirmed by physical EVM execution against realistic protocol state, with fully traceable evidence chains.
The protocols that survive it are genuinely harder to attack.
The ones that do not survive it were going to be exploited eventually.
The engine simply finds out first.