Earlier this month, we won a $2.5M bug bounty–the largest bounty ever received by an AI agent. This was a bug in a major blockchain, and it put >$100M of funds at risk. We found the bug fully autonomously using V12, our AI security agent, and worked collaboratively with the team to remediate the issue.
V12 isn’t a generic agentic security tool. It regularly finds critical bugs like this, among countless 0days (including Linux LPEs, QEMU escape, Firefox UXSS, Postgres and Redis bidirectional RCE). That’s because, while we are building a product, our main mission is to research and build dangerously powerful offensive security tools. To make this possible, we've raised a $10 million seed round led by Electric Capital, with participation from ZachXBT, samczsun, Walden Yan, and more.
We encourage you to try V12 yourself. It’s self-serve, and you’ll get $200 of free usage upon signup for the next seven days.
Part 1: What We’re Doing
Our goal is to build a cyber nuke. That means building something that can find all of the bugs in a system. This is particularly interesting because such a capability would allow you to exploit software that’s previously considered secure. This hasn’t been possible until now, but frontier AI changes this.
We are not doing pentesting. Black-box pentesting that simulates an outside attacker isn’t interesting to us. It’s a saturated market, and we don’t want to make another product that throws XSS payloads. An agentic pentest is great for finding some bugs, but what we want is something that finds all of the bugs. That isn’t possible without reading and understanding code. We need to focus on white box code auditing, which looks more like vulnerability research.
meme credit: LiveOverflow
More concretely, that looks like a system that can reason about code and all of the underlying abstractions, even creating new ones (e.g. weird machines). We want a system that doesn’t just find bugs, but can invent entirely new bug classes. That being said, this has also been the area of security that has most resisted automation. A lot of vulnerability research looks like carefully reasoning about code and proving to yourself “no, this can’t be buggy” or alternatively, wondering “wait, what if…?” All of this requires human-level intelligence, which hasn’t been possible to scale until now.
So in short, what we want is an AI system that takes in an arbitrarily large and complex codebase, reasons about how it actually works, and then uses that understanding to invent–not just discover–bugs and exploits.
Of course, a system that can truly find all bugs is not really possible; that’s the halting problem in disguise. It's equivalent to proving that something has no bugs, where exploits are counterexamples. You can make programs that are arbitrarily hard to exploit. For example, a program that's vulnerable if the Collatz conjecture is false. But we intend to push the limits and build the closest approximation that's practically possible.
And none to guide us
Let’s say we actually build the cyber nuke. Now what?
Given an explosion of offensive capabilities, the world will drastically change. However, it’s unrealistic to expect developers–especially enterprises–to suddenly adapt on their own. Mature organizations lack the vision or expertise to properly make the shift. They also need solutions–functioning, well-designed products–not just "bags of tools".
Regarding organizations’ ability to adapt: it's easy to point at new, state-of-the-art models and claim that cyber is solved. It's another thing for developers to meaningfully leverage models to secure their code. The average developer is still asking Claude or Codex to "review my PR for bugs" followed by "OK fix these". This is nowhere close to sufficient! Attackers already employ complex, aggressive bug-finding harnesses and pipelines. There’s asymmetry here. Defenders neither have the resources to create these pipelines, nor can they amortize the cost across many bug-hunting targets. They need someone to leverage, harness, and deploy these models to unlock their full capability.
Meanwhile, people are busy. They are overwhelmed trying to meet deadlines and ship features on the roadmap. They don't have time to think about security; they want someone–or something– to come in and fix it for them. It should embed directly into their organization (i.e. in their Slack), understand their workflow (do you use Github? how do bugs get assigned? what do you use for issue tracking? what agents do you use?), and feel tailored to their context.
For the same reason, defenders lose unless they have a product that’s useful out of the box. It needs to be either fully self-serve or come with white glove implementation. It should have the correct form factor (a CLI? an MCP? a Slack agent? a Github bot? all of the above?); it should feel good (not laggy, works on mobile, buttons are where you expect, …); it should make sense (inoffensive billing model, access control works appropriately, logical audit scope selection, …). There are a million things here to get right for such a product to actually be adoptable.
So in short: build something that takes in arbitrarily complex programs, fully reasons about them, and finds novel bugs. Then package that capability into a useful product, and handhold developers so they can actually use and benefit from it.
Part 2: Things We Believe In
OK, so how do we actually make this happen? Any concrete game plan is useless (this is a seed stage company). It makes more sense to lay out our guiding principles and how we predict the world will evolve.
Against "Safetyism"
First, we believe the most efficient way to secure the world's software is to give everyone bug-finding capabilities. We don't believe in "contact us" or "apply for access". The logical end state is a world where all bugs are found and patched. Gatekeeping access just slows down this process. For maintainers, adapting to a new threat landscape is uncomfortable but unavoidable, and we think the best approach is to just find all the bugs now. In practice, that means arming defenders with offensive capabilities so they can harden their own code.
To be clear, we want software to be safe and trusted. It's irresponsible to unleash offensive capabilities that the world is unprepared for. But a lot of the “controlled access” or “cyber verification” we see lately is posturing and marketing. People use safety concerns as a pretext for not actually giving anyone access–and in the process, not protecting people at scale. This year alone, V12 has protected users with over 6,000 security reviews. We're not against safety, we're against safety LARP.
Open Disclosure
We believe in open disclosure. Responsible disclosure will be seen as an outdated way of reporting and fixing bugs. Embargoes and coordinated disclosure don't make sense in a world where anyone with the right tools can find and weaponize a vulnerability with minimal human intervention or expertise. We saw this when we found and reported Fragnesia, Pintheft, and DirtyDecrypt–Linux LPE 0days that ended up being leaked before patches landed in mainline kernels. Anyone can monitor public commits and trivially recreate a weaponized exploit. The only real solution is eliminating the patch gap entirely. In practice, this looks like more frequent (and automatic) updates and vendors shipping patches the same day (hour!) a bug is found. Particularly, that means defenders need extraordinary PoC and fix generation capabilities.
Bug bounties are dead
Bug bounties in their current form will be dead, beside vulnerability acquisition programs for exceptionally valuable bugs. All other bugs will be mined out by offensive cyber tools like V12 before the code is shipped i.e. before attackers get a chance to start looking.
Maintainers are buckling under the weight of AI bug bounty submissions. Many have announced they are ending bug bounties entirely. Now that bugs have become cheaper than ever, the only solutions are to either (1) stop caring about most bugs or (2) stop shipping them. In the past, both were untenable because while virtually all code is flawed, reasoning through all the possible bugs was time and cost prohibitive. But now, we believe it's not only possible but inevitable.
Crypto security is interesting
Crypto projects are interesting targets and an important wedge for our company. We are obsessed with finding all the bugs, and crypto is currently the place where this matters most. More than $500M has been stolen in hacks just this year. If V12 can succeed in crypto–if we can win on “hard mode”–then we can win anywhere.
With limited exceptions (iOS full chain?), there are no bugs outside of crypto that claim seven or eight figure bounties. Outside of crypto, $50k is still considered a huge bounty. In crypto, a critical fund loss vulnerability is worth hundreds of millions of dollars if exploited. In general, no one wants to take security seriously, but crypto companies are forced to. That means when choosing security products, they select for bug-finding ability over dashboards–what V12 is optimized for. Meanwhile, outside crypto, security still revolves around a culture of compliance, not substance.
All software is vulnerable, but the world operates as if this weren’t the case. This only worked so far because attackers were rare–technical skill was the bottleneck. AI removes that constraint. Now, if software isn’t secure, it WILL get exploited.
The impact is magnified by the fact the world is increasingly online, and most of the world meaningfully exists “in a computer” now. Everything will have to become much more secure very quickly, and that looks like many more teams treating security as seriously as crypto companies do.
By the way, to dispel a common misconception: crypto codebases are non-trivial in size, complexity, and diversity. Firedancer is 722k LoC of highly optimized C, Geth + Prysm is 1.1M LoC of Go, Zcash is 304k LoC of C++ and Python (Orchard alone is 44k LoC of circuits and cryptography in Rust). These all contain virtual machines, low-level systems code, and distributed databases. For context, Postgres and CPython both hover around ~1M LoC.
Time for real security
The world’s software has always been vulnerable, but now it’s impossible to ignore. The modern web depends on secure cryptography and browsers, frontier models rely on TEEs to protect weights, and innovations in robotics and biology will only make security more important. Basically, all code eventually becomes high assurance code.
Don’t forget about the growing complexity of software supply chains. A lot of code we don't think about will be (or already is) high assurance. OpenSSH certainly comes to mind, but what about all of the packages we forgot about? The internet depends on software that nobody is looking at.
The way security is currently done will not work. It is an afterthought and performed on a best-efforts basis. Teams focus on developing features and make security someone else’s responsibility. Most security products look like band-aids that manage the symptoms of bugs, not real solutions. But in a world with powerful AI, if there is even a single bug, someone is going to find and exploit it.
Instead, security needs to be continuous and comprehensive–every merged PR needs to be vulnerability-free. The road to get there will not be easy, and we don't have everything figured out. No one does. But the fundamental problem this boils down to–finding bugs–is what we’ve been obsessed with for the last 10 years. Before V12, we founded Zellic, one of the world’s leading security firms, with 1500+ security reviews for 500+ highly attacked clients (e.g. crypto exchanges, bridges, L1s, wallets, open-source operating systems). And before that, we founded perfect blue, the world’s #1 CTF team for 3 years.
Every person on the V12 team hails from either CTFs or vulnerability research. Look at what we've reported so far: multiple Linux LPEs, a QEMU escape, wormable RCEs in Redis and Postgresql (bidirectional!), MariaDB, and Anydesk. And what’s even more promising is that whatever new software we throw V12 at, bugs keep pouring out: Dolphin emulator, an employee’s NAS, Signal messenger.
Closing Thoughts
A good seed round gives you the best thing in the world: the chance to build something you love with your friends.
We've dreamed about this problem–automatically finding all bugs–since we were teenagers. Now AI is finally powerful enough for us to take a real stab at it. We’re excited. If we’re right, what we’re building will be dangerously capable, and the world will adapt around it.
We want to be the ones who make it happen. If V12 sounds like something you’d want to be part of: join us, we’re hiring!
