Agentic Coding and the Smart Contract Liability Crisis: What the 33% Internal Build Failure Rate Means for Web3

Hook

MIT NANDA published a number that should terrify every CTO in Web3: 33%. That is the internal build success rate for agentic coding systems. Two-thirds of the teams that tried to build their own AI-powered development pipelines failed. I read that statistic and I thought of the last three smart contract audits I performed. Two of them were written with AI assistance. Both had reentrancy vectors that an experienced Solidity developer would have caught in a standard review. The AI did not catch them. The developer did not catch them. The auditor caught them. That is the difference between a 33% success rate and a production deployment.

The code does not lie, only the whitepaper does.

Context

The enterprise software market is shifting from buying finished products to buying the ability to build custom software. McKinsey, Gartner, Forrester, and Deloitte all published data in 2026 documenting this shift, and the numbers are consistent across every major research house. Thirty-two percent of organizations have decided not to purchase off-the-shelf software, choosing instead to construct internal systems with agentic coding tools. Among high performers — defined as organizations deriving at least 5% of EBIT from AI — nearly half skip software purchases entirely. Forty percent of large enterprises are expanding their agent deployments, up from 27% the previous year.

The technology itself is a combinatorial innovation. A large language model is wrapped in a loop: plan, call tools, generate code, execute tests, self-correct. The architecture is not a new model paradigm. It is an orchestration layer on top of existing models. That distinction matters. Orchestration layers fail differently than models do. They fail in integration, in context management, in error recovery, and in the silent corruption of state that no single test catches.

I have spent eleven years analyzing blockchain projects. I have read hundreds of whitepapers and thousands of smart contracts. The pattern in this AI data is identical to the pattern I saw in the ICO boom of 2017 and the DeFi summer of 2020. The adoption curve is real. The production readiness is not. Deloitte reports that only 11% of agentic systems are production-ready. Gartner's CIO survey shows that only 17% of organizations have actually deployed agents. Forrester claims 75% of organizations are adopting. The gap between 75% adopting and 17% deployed is the same gap between a token sale and a working mainnet. It is the gap between narrative and reality.

The blockchain sector is adopting agentic coding tools faster than enterprise, with less governance, and with higher stakes. Web3 teams are younger, more distributed, more dependent on scarce Solidity talent, and under more pressure to ship before their tokenomics become irrelevant. They are the perfect market for AI coding agents. They are also the worst possible environment for unverified code.

Core: The Systematic Teardown

The Architecture Problem

Let me break down what agentic coding tools actually do, because the failure modes are structural, not incidental. The loop is: the model receives a task, it plans a sequence of actions, it calls tools — file reads, code searches, test runners, linters — it generates code, it executes tests, it observes the results, and it iterates. Each iteration consumes tokens. A single coding task can generate dozens or hundreds of LLM calls. The token consumption of an agentic coding task is an order of magnitude higher than a standard chat-based interaction. For complex, multi-file tasks, the consumption can be one to two orders of magnitude higher.

McKinsey reports that 20% of organizations already feel AI operational cost pressure. That number will rise. For smart contract development, the cost problem is also a security problem. Expensive agentic loops incentivize developers to skip verification steps. I have seen this in practice. A development team using an AI coding agent to write a DeFi protocol will let the agent iterate on the test suite until the tests pass. The tests pass because the agent wrote them to pass. The agent does not understand economic invariants. It does not understand that a flash loan can manipulate a price oracle. It does not understand that a reentrancy guard can be bypassed with a cross-function reentrancy attack. The agent writes tests that validate the code it generated. That is circular verification. It is the same as auditing a contract against its own whitepaper instead of against the actual threat model.

The architecture of the Ethereum Virtual Machine amplifies every weakness of agentic coding. Gas semantics, call stack depth, delegatecall pitfalls, storage collision in upgradeable proxies, the distinction between transfer and send, the behavior of fallback functions — these are not patterns that a general-purpose code model learns reliably. They are footguns specific to the EVM. An agent trained on a corpus of GitHub repositories has seen Solidity code. It has seen a lot of Solidity code, including a lot of vulnerable Solidity code. The training data includes the exploits. The agent does not know which parts of its training data are examples to emulate and which are examples to avoid. It emulates all of it.

Circular Verification

This is the deepest problem and the one that the McKinsey and Gartner data does not capture. Agentic coding tools do not just generate code. They generate the tests that validate the code. In a mature software organization, tests are written by a different person than the one who wrote the implementation. The separation of concerns is a security control. When the same agent writes both the implementation and the tests, the verification loop is closed. The agent will not discover its own errors because the tests encode the agent's own assumptions about correct behavior.

In my audit practice, I see the consequences of this every month. I recently audited a lending protocol where the team had used an AI coding agent for the initial implementation. The agent had written a comprehensive test suite. The tests covered the happy paths, the edge cases, the interest accrual math. What the tests did not cover was the interaction between the protocol's liquidation mechanism and a malicious borrower who could manipulate the price feed. The agent did not think of that attack because the agent does not think. It predicts. Its prediction was based on the patterns in its training data. The pattern of price oracle manipulation is in the training data, but it is a small fraction of the data. The agent's probability distribution favored the common patterns. The uncommon patterns were the ones that mattered.

The 33% internal build success rate is partly a measurement of this failure. Teams that build their own agentic systems underestimate the complexity of the codebase they are targeting. They underestimate the cost of context management across multiple files. They underestimate the difficulty of integrating with the existing toolchain. In blockchain, the existing toolchain is the EVM itself, with its own semantics, its own security model, and its own attack surface. An agent that has not been fine-tuned on Solidity specifically, with a curated dataset of known vulnerabilities, will produce code that passes its own tests and fails in production.

The Cost Curve

The economics of agentic coding have not been priced correctly. A single agentic coding task on a complex smart contract — one with multiple modules, upgradeable proxies, and cross-contract calls — can consume more compute than the entire deployment and audit combined. The McKinsey partner quoted in the report says the most successful organizations treat operational costs as a design constraint. This is correct. It is also the principle that blockchain teams ignore.

I have seen the budget breakdowns. Teams allocate funds for the audit, for the deployment, for the marketing. They do not allocate funds for the cost of the agent's iterations. When the agent burns through the token budget, the team faces a choice: spend more on the agent or ship the code as is. They ship the code as is. The agent's last iteration is the code that gets deployed. The errors in that final iteration are the ones that matter.

McKinsey's 20% cost pressure figure is a lagging indicator. The leading indicator is the number of teams that start with agentic tools and abandon them mid-project because the compute bill is untenable. The Gartner prediction that 40% of agentic AI projects will be cancelled by the end of 2027 cites cost as one of the three main reasons, alongside unclear business value and insufficient risk control. For blockchain projects, the cost pressure is more acute because the projects are smaller, the funding is more constrained, and the runway is shorter. A protocol that burns its treasury on agent compute has less to spend on the audit. The audit is the last line of defense. Cutting it is the worst possible cost optimization.

Data Sovereignty

The data leakage problem is underappreciated. Enterprise agentic coding tools process requests on the vendor's servers. That means proprietary code leaves the organization's boundary. For a blockchain project, this is catastrophic. Smart contract code contains the economic mechanics of the protocol. It encodes the game theory, the incentive structures, the arbitrage opportunities, the failure modes. Sending that code to a third-party LLM is like sending your vault combination to a locksmith who keeps a copy.

High-performing organizations build internally partly for this reason. They want to keep code in their own infrastructure. But the 33% success rate for internal builds means most of them will fail, and the code they generated during the failed attempt has already been exposed. The exposure is not theoretical. Model providers log prompts. They use them for training. They share them with subcontractors. The code that a blockchain team feeds into an AI coding agent becomes part of the model's training data. It will come back out in responses to other users. The economic secrets of a protocol are not secret once they enter the model.

This is also a regulatory issue. The EU MiCA framework, which I have worked with extensively, requires that financial infrastructure have clear audit trails and accountability. If the code generation process is opaque — if the agent's decision-making cannot be traced — then the audit trail is broken. The MiCA compliance framework I helped design for a Frankfurt-based fintech startup included a requirement that all code changes be traceable to a human author. That requirement is incompatible with unconstrained agentic coding. The agent generates code. The human approves it. But the human did not write it. The human may not understand it. The human is signing off on code they cannot fully verify. That is not accountability. That is a signature on a liability.

Trust is a variable, verification is a constant.

The Liability Vacuum

Gartner predicts that over 40% of agentic AI projects will be cancelled by the end of 2027, citing cost, unclear business value, and insufficient risk control. The risk control gap is the one that matters in blockchain. When an AI agent generates code that introduces a vulnerability, who is liable? The developer who reviewed it? The vendor who sold the tool? The model provider? This is an unresolved legal question. In the blockchain space, where code is money and exploits are irreversible, the liability question is existential.

I have seen the aftermath of a $2 million exploit that originated in a single integer overflow in a royalty calculation function. That bug was written by a human. The next one will be written by an agent. The agent will not be held accountable. The protocol will. The developers will be blamed. The auditors will be blamed. The agent's vendor will not be blamed, because the vendor's terms of service disclaim liability for generated code. The model provider will not be blamed, because the model is a tool, not a colleague.

The regulatory landscape is not ready for this. The SEC's approach to crypto has been regulation-by-enforcement, deliberately withholding clear rules while prosecuting individual cases. The same pattern will apply to AI-generated code. The SEC will not issue rules about who is liable for AI-generated smart contract vulnerabilities. It will wait for an exploit, then prosecute whoever is most convenient. The developer who approved the AI-generated code is the most convenient defendant. The AI is not a defendant. The vendor is not a defendant.

Build vs. Buy as a Security Decision

The MIT NANDA finding — 33% internal build success versus 67% vendor tool success — is usually read as an argument for buying. It is also a security argument. Vendor tools have been tested at scale. They have been hardened against edge cases that internal tools have never encountered. They have dedicated security teams. They have bug bounties. An internal agentic coding pipeline built by a blockchain team of five engineers does not have any of that. It has the team's own assumptions, the team's own blind spots, and the team's own pressure to ship.

But the vendor tool success rate is also misleading. The 67% figure includes simple tasks. A standard ERC-20 implementation is a solved problem. A vendor tool can handle it. An NFT contract with a standard metadata schema is a solved problem. A vendor tool can handle it. The tasks that are not solved — the novel game mechanics, the intricate incentive designs, the complex cross-contract interactions — are the tasks where the vendor tool's success rate drops. The 67% figure is an average across task complexity. The blockchain industry lives at the high-complexity end of the distribution. The average does not apply.

For blockchain teams, the build-versus-buy decision should be made with security as the primary input, not cost, not speed, not developer preference. The question is: can the organization verify the code that the tool generates? If the answer is no — and for most teams it is no — then the tool is a liability regardless of whether it is built internally or purchased from a vendor. The verification capability is the binding constraint. The agentic coding tool is an accelerator, but an accelerator is only useful if the vehicle has brakes.

I read the implementation, not the intent.

The Organizational Risk

The report notes that 39% of employees expect layoffs, up from 32% the previous year. This anxiety is not theoretical. It has a direct security consequence. A developer who believes the AI tool will replace them has no incentive to share knowledge, to document the codebase, to train their replacement. The knowledge drain increases the failure rate of internal builds. In blockchain, where protocols depend on deep domain expertise in game theory, mechanism design, and cryptographic primitives, this knowledge drain is fatal.

I have seen protocols die not because the code was bad, but because the team's security expertise was dispersed before the code was complete. The senior auditor left. The lead developer took a job at a larger firm. The protocol was left with a codebase that the remaining team did not fully understand. The agentic coding tool did not help, because the tool did not understand the codebase either. It generated plausible code that fit the existing patterns. It did not understand the invariants that the codebase depended on. The protocol shipped with a critical vulnerability that no one on the remaining team could identify.

The layoff anxiety also affects the agent's training data. When a team knows that the agent will replace some of them, they are less likely to contribute their knowledge to the system. The agent's fine-tuning data is poorer. The agent's performance is worse. The failure rate increases. This is a negative feedback loop that the McKinsey and Gartner reports only partially capture. The internal build failure rate of 33% is not just a technology problem. It is an organizational problem. The technology fails because the organization fails first.

Infrastructure Blind Spots

The infrastructure requirements for agentic coding are not being discussed honestly. The report cites McKinsey's finding that 20% of organizations feel AI operational cost pressure. The implication is that the cost pressure is a problem to be managed. It is also a signal of where the infrastructure is failing. The token consumption of agentic coding tasks is the direct consequence of models that are not optimized for long-horizon, multi-step reasoning. The models are too large, too slow, and too expensive for the tasks they are being asked to perform.

The infrastructure that agentic coding requires — low-latency model serving, long-context KV cache optimization, intelligent caching, model routing, local deployment options for open-source models — is not commodity infrastructure. It requires engineering capability that most blockchain teams do not have. The high performers who build internally have this capability. They have model deployment teams. They have inference optimization engineers. They have observability platforms. The 33% internal build success rate is not a random number. It is the percentage of organizations that already have the infrastructure to support internal AI development. Everyone else is attempting to build on top of a foundation that does not exist.

For blockchain teams, the infrastructure gap is worse because the security requirements are higher. The code being generated is financial code. The sandboxing requirements are stricter. The isolation between the agent's execution environment and the production environment has to be absolute. The monitoring has to be comprehensive. The audit trail has to be complete. Most blockchain teams do not have the resources to build this infrastructure. They buy a vendor tool, assume it is safe, and ship. The vendor tool was not designed for financial code. It was designed for enterprise software. The security models are different.

What the Sector Data Actually Shows

The industry distribution data — technology at 41%, healthcare at 39%, professional services and energy at 38% — tells a specific story. These are knowledge-work industries with highly customized workflows and strict compliance requirements. They are adopting agentic coding tools because off-the-shelf software does not meet their needs. The same logic applies to blockchain. There is no off-the-shelf software for a DeFi protocol. There is no SaaS product for a zk-rollup. Every blockchain project is a custom build. The agentic coding tool is the only option for teams that cannot afford a full engineering team.

But the compliance requirements in healthcare and energy are governed by established regulatory frameworks. The regulators have published rules. The rules are knowable. In blockchain, the regulatory framework is still being written. The MiCA regulation is a start, but it does not cover AI-generated code. The SEC has not issued guidance on AI-assisted smart contract development. The compliance vacuum means that blockchain teams adopting agentic coding tools are operating without a safety net.

The high adoption rates in healthcare and energy also reflect the cost of failure in those industries. A bug in a healthcare system is expensive but recoverable. A bug in an energy trading system is expensive but recoverable. A bug in a smart contract is permanent. The code is immutable. The exploit is irreversible. The funds are gone. The cost of failure is categorically different in blockchain. The adoption data does not capture this difference. The risk tolerance that is appropriate for enterprise software is not appropriate for financial code.

Contrarian: What the Bulls Got Right

The bulls are not entirely wrong. The vendor tool success rate of 67% is real. For well-defined tasks — a standard ERC-20, a simple NFT contract, a basic staking module — agentic coding tools are competent. They are faster than a junior developer. They do not make typos. They do not get tired. The production-ready figure of 11% from Deloitte is a lagging indicator, not a verdict. The technology is improving.

The infrastructure opportunity is genuine. Companies that provide evaluation platforms, observability tooling, security governance, and private deployment solutions will capture real value. The cloud providers and model API vendors will benefit enormously. The consulting firms will profit from the high failure rate. These are all real positions.

The direction of travel is clear. The tools will improve. The models will become more specialized. The fine-tuning on Solidity and Rust and Move will get better. The verification tools will mature. The question is not whether agentic coding will mature. It is whether the blockchain industry will survive the maturation period without a wave of AI-generated exploits that erode trust in the entire ecosystem. The 33% internal build failure rate is not a reason to abandon the technology. It is a reason to gate it. Stage reviews. Mandatory audits. Formal verification requirements. Human sign-off on every deployed contract. These are the guardrails that turn a 33% success rate into a production system.

The teams that will benefit most are the ones that treat agentic coding tools as what they are: generators of candidate code, not authorities on correctness. The tool produces a draft. The human reviews the draft. The human verifies the draft. The human signs off on the draft. That workflow is slower than letting the agent ship directly. It is also the only workflow that produces code that survives contact with the mainnet.

Silence is not agreement, it is data. The silence from the vendor community about the security limitations of agentic coding tools is data. The silence from the model providers about the liability question is data. The silence from the regulators about AI-generated financial code is data. Read the silence.

Takeaway

The ledger remembers what the founders forget. In 2026, the ledger will record which teams treated agentic coding tools as accelerators and which treated them as replacements for engineering discipline. The teams that succeed will use AI to generate candidate code and humans to verify it. The teams that fail will use AI to replace verification entirely.

Precision is the only form of respect. Respect the code. Verify the agent. The market will do the rest. The 33% failure rate is not a warning. It is an invitation. The teams that build the verification infrastructure around agentic coding will be the ones that survive the next cycle. The teams that skip verification will provide the next cycle's cautionary tales. The code does not lie. It never has. It never will.