The smart contract security stack has gotten dramatically better in the last two years. AI-augmented scanners surface more findings, more accurately, with better severity ranking, than anything available before. But more findings isn't the same as fewer exploits. In 2024, $2.2 billion was still stolen from crypto platforms, with private key compromises alone accounting for 43.8% of that figure (Chainalysis). The detection improved. The exploits kept happening.
The reason is that detection and exploitability aren't the same thing.
That's the gap BattleMode is built to close.
Smart contract security isn't bottlenecked by a shortage of tools. It's bottlenecked by the volume of unprioritized findings those tools generate.
A 2024 benchmark of static analysis tools published in Proc. ACM Softw. Eng. (FSE) measured Slither's F1 score at 2.38% (recall 36.18%, precision 1.23%) and CSA at 6.40%, with all four static analyzers studied averaging F1 scores below 10% (Li et al.). The recall is reasonable, but precision is the killer: the tools flag a lot, and most of it isn't real.
AI-augmented analysis improves the situation but doesn't eliminate it. Modern LLM-based audit pipelines produce far more useful output than pure static analysis, but they still operate on code patterns rather than runtime behavior, and they still surface findings that look bad in isolation but aren't exploitable in context.
Traditional scanners give you a list of problems and walk away. They have no context on your specific protocol, no awareness of your team's past security decisions, and no way to know that you already accepted the risk on a particular finding three weeks ago.
When VII Finance ran an initial audit with Cygent's CARA engine, the system "automatically invalidated 99% of the invalid findings." That tells you something about the other tools those findings originally came from, and about how much developer time gets burned triaging non-issues across the industry every day.
The distance between "here's a potential vulnerability" and "here's what will actually get you exploited" is where billions are lost.
Static analysis tools, and even AI scanners that reason over code, share a structural limit: they analyze patterns, not runtime behavior. They can tell you a reentrancy pattern exists in your code; they can't tell you whether your specific contract's token set makes that pattern exploitable.
Here's a concrete example from CARA, our audit engine. During analysis of a lending protocol, CARA found a classic Checks-Effects-Interactions violation in withdrawCollateral: the external call happened before the state update, which would normally be flagged as a reentrancy issue. A standard static analyzer would mark it critical and move on.
CARA categorized it as "Invalid." The protocol only supported WETH and USDC as collateral, and neither token has arbitrary callback functions, so the pattern wasn't exploitable in this context. The code violated best practices and was flagged for future-proofing, but the developer didn't need to drop everything. A team relying solely on a static analyzer would have spent hours fixing a non-issue and possibly introduced new bugs in the process.
Code-level analysis also misses protocol-specific edge cases that need domain knowledge. WBTC uses 8 decimals, unlike most ERC-20s, which use 18. If your collateral math doesn't account for that, you have a critical vulnerability that no pattern-matching scanner will catch because the code itself looks syntactically correct.
A 2025 systematic literature review on smart contract security frames the difference well: "unlike static code auditing, which assesses code at a single point in time, dynamic information analysis reflects the actual behavior of smart contracts in live environments" (Cao et al.).
Spiral Stake saw this when they ran Cygent against their codebase: "It caught some interesting composite chains that individual findings alone wouldn't surface." Multi-step vulnerability chains don't emerge from scanning individual code patterns; they emerge from understanding how contract components interact at runtime.
Finding the bug is only 10% of the battle. Fixing it safely, correctly, and without breaking something else is the other 90%. If the underlying problem is that you can't distinguish real vulnerabilities from theoretical ones without testing them in a live environment, the solution is a tool that does exactly that.
Red team / blue team adversarial testing isn't a new concept. In traditional cybersecurity, it's the gold standard for validating defenses: deploy one team to attack, another to defend, and learn more from the simulation than from any number of static scans. Agentic AI is now being applied to this approach, with autonomous agents that can generate novel attack vectors, run multi-stage campaigns, and adapt in real time. BattleMode applies the same methodology to smart contracts.
Here's what happens when you trigger it:
This is a live stress test. It proves whether a vulnerability is exploitable in a runtime environment, not just whether it matches a pattern in code.
Patrick Collins, our co-founder and CEO, calls BattleMode "Cygent's most advanced feature," and the framing matters: static analysis finds candidates, context-aware triage filters the noise, and BattleMode provides runtime proof.
BattleMode includes an optional Discovery Mode that goes beyond the CARA pipeline. Discovery Mode targets your deployed contract versions, probing for vulnerabilities that exist in production. That means it can surface issues introduced through upgrades, configuration changes, or interactions with other on-chain protocols that weren't present during the original audit.
Fuzzing generates random inputs and throws them at your contracts, hoping to trigger unexpected behavior. It's valuable, but it's a brute-force approach: as the Effuzz paper notes, fuzzing "can be ineffective when it fails to randomly select the right inputs."
BattleMode's Red Team agents aren't generating random inputs. They're adversarial AI agents with reasoning capabilities, actively writing exploit code and attempting to steal funds. The difference is between a tool that shakes the lock and a tool that studies the mechanism and crafts a key.
If you're deploying contracts into a sandbox and running adversarial agents against them, the security of the testing environment matters. All development keys and secrets are encrypted at rest when using BattleMode, and the sandboxed environment means no risk to production contracts. You get the intelligence of a live attack simulation without any of the exposure.
One important caveat: a failure to exploit doesn't prove a contract is secure. It proves that the known vulnerabilities identified by Cygent's analysis pipeline weren't exploitable by the Red Team agents in the tested configuration. That's still enormously valuable. It tells you where not to spend remediation time, and where to focus urgently. But it isn't a guarantee of invulnerability, and no honest tool would claim otherwise.
Anyone can build an AI tool that interacts with smart contracts. The question is what that AI knows.
We run the number one education site for smart contract developers (Updraft), build security tools like Solodit and Aderyn, and run security engagements for major protocols including MetaMask, Wormhole, Uniswap, Chainlink, and ZKsync. That's not a generic "we have experience" claim, it's a specific, verifiable data moat. We've taken the data, exploits, and methodologies we use to train human security researchers and used them to train Cygent.
This matters because generic AI has both surprising capabilities and surprising limitations in smart contract security. A 2024 study in ACM TOSEM evaluated ChatGPT against dedicated static analysis tools across seven vulnerability types. ChatGPT performed comparably or slightly better on four types but worse on three, with low precision and inconsistent results across repeated runs (only 29 of 50 contracts produced consistent answers across five trials) (Chen et al.). For production-grade DeFi protocols with complex token interactions, cross-contract composability, and chain-specific edge cases, generic AI alone falls short. Domain-specific training data is what closes the gap.
Cygent uses a combination of top-tier AI models working together rather than a single standalone model, but the models are only as good as the data and methodology behind them. The Red Team agents in BattleMode aren't improvising from general programming knowledge. They're drawing on the same exploit patterns, attack methodologies, and vulnerability databases our human auditors use.
Buck.io put the difference plainly: "It found a few interesting bugs in my recent work that none of the other AI tools picked up on." That gap between what generic AI tools find and what domain-trained AI finds is where BattleMode's adversarial agents operate.
There's also a strong proof of work: Cygent is good enough to help build itself. Every day, Cygent audits its own updates, fixes its own bugs, and opens its own pull requests against our codebase.
The security tool graveyard is full of impressive point solutions. Another dashboard, another report, another thing to check that doesn't talk to anything else.
BattleMode's value comes from sitting inside Cygent's end-to-end security lifecycle, where findings flow through a connected pipeline:
This is a closed loop. BattleMode (verification) feeds remediation, which feeds back into BattleMode (retest), which feeds into PR review (validation). All of it tracked on a central dashboard with project health, active issues, scheduled tasks, and BattleMode results.
"The audit isn't the bottleneck. Remediation is." BattleMode verifies exploitability before remediation begins, so your team isn't spending days fixing theoretical issues while exploitable vulnerabilities sit in the backlog. The retest phase ensures patches actually work, no more assuming a vulnerability is closed because someone pushed a commit.
Teams using Cygent's broader platform are already living this workflow. Remora, an RWA protocol with real investor funds at stake, reports that "Cygent adds a continuous security layer beyond one-time audits, consistently surfacing thorough and actionable findings." Buck.io runs "a serious solidity audit on smart contracts at the end of every coding day, directly from Slack." These are teams with security embedded in their daily development cycle, not bolted on.
The enterprise layer reinforces this: SOC2-standard security, fully isolated instances, role-based access, and encrypted keys across all features including BattleMode.
If your current testing workflow ends at code-level analysis, you have a verification gap. You're generating findings you can't prioritize and spending remediation cycles on issues you can't confirm are real.
BattleMode is a shift from "scan and pray" to "simulate and prove." Practically:
Cygent supports Solidity, Rust, and Go codebases, and multi-chain coverage spans Solana (Anchor), Aptos (Move), and Sui (Move). Local Anvil integration means BattleMode plays well with the Foundry toolchain and existing developer workflows rather than demanding a new one.
BattleMode doesn't replace human auditors. The strongest results in adversarial testing come from combining autonomous tools with human expertise: automated systems handle the systematic, repeatable work at a scale humans can't match, and human researchers focus on creative, context-dependent vulnerability discovery. BattleMode handles the systematic adversarial testing so our human auditors can focus on the creative work that requires human intuition.
The smart contract security industry has spent years trying to build better scanners. The breakthrough isn't a better scanner, it's a tool that takes scanner output and proves whether it matters.
The industry lost $2.2 billion in 2024 with losses still accelerating (Chainalysis), and Immunefi reports that 80% of projects find vulnerabilities missed by code audits. AI scanners are getting better, but the exploits are still happening, because finding a candidate isn't the same as proving it can drain funds.
BattleMode bridges the gap between detection and exploitability verification, built by the team that audits MetaMask, Wormhole, Uniswap, Chainlink, and ZKsync, and trained on the largest smart contract security dataset in the industry.
If your current workflow ends at static analysis, you're operating with a verification gap that costs the industry billions every year. BattleMode exists to close it.
Explore how Cygent fits into your security workflow at cygent.dev.
