The code executes, not the promise. On August 9, a voluntary security team deployed a multi-model AI arsenal—Kimi K3, OpenAI GPT Sol, Anthropic Claude Fable, Opus, and Z.ai's GLM 5.2—to scan approximately 150 Bitcoin core project repositories. The result: over a dozen vulnerabilities across wallets, cryptographic libraries, and infrastructure. The team claims an average of one critical vulnerability per researcher per hour. Over 12 hours, they submitted reports to multiple undisclosed projects. This is not a drill. This is the new baseline for security research.
Context: The State of Bitcoin Core Security
Bitcoin's core codebase is battle-tested, but not invulnerable. The ecosystem spans thousands of repositories: Bitcoin Core client, libsecp256k1, various wallet implementations (Electrum, Sparrow, Bitcoin Core itself), sidechains, and infrastructure like block explorers and mining pools. Historically, vulnerabilities are found through manual code review, static analysis tools, and bug bounty programs. The process is slow. A single critical vulnerability—like the CVE-2018-17144 inflation bug—can take months to discover and patch. Enter AI. The Coldcard and Boltz incidents earlier this year demonstrated that attackers are already using AI to automate exploit discovery. Now, defenders are catching up.
But the team's methodology raises critical questions. They used five distinct AI models, each with different strengths. Kimi K3 excels at long-context reasoning. GPT Sol is optimized for code generation and analysis. Claude Fable and Opus provide deep semantic understanding. GLM 5.2 offers multilingual support. The combination allowed them to cover different attack surfaces: logic errors, cryptographic misuse, race conditions, and integer overflows. The reported rate of one critical vulnerability per hour per researcher is extraordinary—if true. During my 2017 ICO audits, I averaged one critical finding per two days across similar-sized codebases. Something is different.
Core: Technical Analysis of the AI-Assisted Audit Pipeline
Let me disassemble the pipeline. The team likely followed a three-stage process: ingestion, analysis, and validation. First, they fed the repositories into the AI models as raw code. Not all models handle entire repositories at once. Kimi K3 can process up to 200K tokens per context window, which is roughly 150,000 lines of Python or C code. Bitcoin Core alone is over 300,000 lines. So they must have chunked the code by module: wallet, consensus, P2P, crypto, etc. Each chunk then went through multiple models for cross-validation.
The vulnerabilities reported span wallets, cryptographic libraries, and infrastructure. Wallet vulnerabilities typically involve improper key derivation, insufficient entropy, or flawed transaction signing. Cryptographic libraries like libsecp256k1 are finicky—a single curve point validation failure can lead to signature malleability. Infrastructure includes block explorers and API servers, where SQL injection or incorrect TLS handling can leak sensitive data. The AI models likely flagged patterns like unchecked return values, misuse of EC_MUL, or missing access control in HTTP endpoints.
But here is the critical insight: the models are not finding zero-day exploits. They are finding known patterns that humans miss due to fatigue. Static analysis tools like Slither or Mythril have been doing this for years. The difference is the rate. AI can scan 150 repos in hours, not weeks. The team's claim of one critical per hour aligns with the efficiency of a well-tuned neural network. However, I have seen AI-generated false positives—code that looks vulnerable but is actually safe due to external constraints. The team must have a manual validation step. Without public disclosure, we cannot verify the severity or reproducibility.
From my audit experience with ZK-rollup circuits, I have tested similar AI-assisted pipelines. The bottleneck is not discovery—it is context. A model can find a missing require statement, but it cannot always determine if that statement is in a depth-3 call chain that is never invoked. The Bitcoin core codebase is heavily optimized with macros, assembly, and inline functions. AI models trained on generic code may miss Bitcoin-specific idioms. The team's use of five models mitigates this, but it does not eliminate it.
Let me quantify the efficiency gain. Traditional manual review of 150 repos would require a team of 10 senior auditors working for 3 months—roughly 5,000 hours. The AI team claims 12 hours with an undisclosed number of researchers. If they had 10 researchers, that is 120 human-hours, plus AI compute time. That is a 40x improvement. But is the quality the same? My experience says no. AI is excellent at catching compliance violations—like variable naming conventions or missing error handling—but poor at understanding economic incentives or protocol-level invariants. The vulnerability in the Coldcard hardware wallet was a logic error in the PIN verification loop. An AI model could catch that if trained on hardware security patterns. But the Boltz exploit involved a race condition in a Lightning swap—requires understanding of the payment channel lifecycle. That is harder.
Contrarian Angle: The Blind Spots in AI-Assisted Audits
Here is the counter-intuitive argument: the AI team's rapid discovery may actually increase risk. Why? Because the speed of vulnerability discovery outpaces the speed of patching. The Bitcoin ecosystem is decentralized—no single party can push a fix. Each project maintainer must review the report, assess impact, develop a patch, and coordinate a release. If the team submitted reports to multiple projects in 12 hours, the maintainers are now overloaded. One of my rules: "Audit first, invest later." But here, the audit is happening faster than the investment (of time) to fix.
Furthermore, the AI models themselves are black boxes. The team used proprietary models from OpenAI, Anthropic, and Z.ai. These models are trained on vast internet data, which may include outdated or malicious code. If a model produces a hallucinated vulnerability—a false positive that looks real—the team might waste hours validating it. Worse, the model could miss a real vulnerability because it was trained to ignore certain patterns. We have no transparency into the training data. "Zero knowledge, infinite accountability" applies here—the team should publish their methodology and results for community verification. Without it, the report is a promise, not a fact.
Another blind spot: the team's anonymity. They call themselves a "voluntary security team." There is no reputation at stake. If they submit a flawed report, the project maintainers might disregard future legitimate reports. The Bitcoin security community relies on trust—researchers like Sergio Demian Lerner or Pieter Wuille have years of proven track records. An anonymous AI team undermines that trust. The Coldcard and Boltz incidents were handled by known entities with public disclosure. The AI team's lack of transparency is a liability.
The Real Threat: AI-Augmented Attackers
The same tools are available to black hats. The team used five models; an attacker can use the same five. Or they can fine-tune a model on Bitcoin core code to find zero-day exploits. The barrier to entry for vulnerability research has dropped dramatically. Previously, a would-be attacker needed years of C++ and cryptography experience. Now, they need a subscription to an AI API and a GPU. The speed of attack will increase. Defenses must evolve too.
My take: the AI audit is a double-edged sword. It accelerates discovery, but it also accelerates disclosure without coordination. The Bitcoin ecosystem needs a standardized vulnerability disclosure protocol that includes AI-generated reports. The maintainers should establish a shared database of AI findings, cross-referenced with manual review. "Immutability is a feature, not a flaw"—but the code is not immutable until it is deployed. The vulnerability must be fixed before the next release.
Takeaway: The Vulnerability Forecast
Over the next 12 months, I predict a 10x increase in reported vulnerabilities across Bitcoin-adjacent projects. AI-assisted audits will become mandatory for any protocol that handles significant value. The team's report is a proof of concept. The real question is not whether AI can find bugs—it clearly can. The question is whether the ecosystem can handle the volume. Without a coordinated response, the speed of discovery will outpace the speed of fixing. That is a recipe for a crisis.
"The code executes, not the promise." The team's promise is that they found vulnerabilities. The code will execute regardless. The only way to ensure safety is to audit, fix, and verify. The AI is a tool, not a replacement for human judgment. I will be watching the disclosed repositories for patches. If they are not applied within 30 days, the risk is real. The clock is ticking.
Immutability is a feature, not a flaw. But flawed code is still a liability. The Bitcoin ecosystem must adapt to this new reality. AI is here. It is not going away. The question is: are we ready to manage the speed?