The End of “As-Is”: Could AI Undermine Software’s U.S. Legal Shield?

Every August, the cybersecurity industry descends on Las Vegas for hacker summer camp. Walk the expo floor and you will hear bold pitches about AI: autonomous agents that find previously undiscovered vulnerabilities en masse and models that patch zero-days before attackers can weaponize them. AI-assisted security capabilities have become a marquee selling point.

But purchase the product, and the story flips in the fine print. Buried in nearly every End User License Agreement (EULA) is a familiar disclaimer: The software is provided “as-is,” with all defects, errors, and vulnerabilities disclaimed to the fullest extent permitted by law.

The software industry cannot have it both ways. Either AI can reliably identify major classes of vulnerabilities before products ship, or software defects remain an inherently unforeseeable reality that justifies broad legal immunity. Technology companies increasingly market the former to investors and customers. Yet much of U.S. software liability law still assumes the latter.

The tension extends beyond corporate marketing and into public policy. The 2023 National Cybersecurity Strategy proposed shifting liability onto software vendors on the theory that they, not their customers, are best positioned to prevent defects. In March 2026, the new Cyber Strategy dropped that proposal entirely in favor of deregulation and voluntary private sector action instead. Ironically, that reversal came just as AI made the case for software liability more compelling. Vendors began publicly demonstrating that AI could find defects more reliably, and cheaply enough, to make those precautions reasonable to expect.

The Myth of Digital Exceptionalism

Software occupies a privileged legal space that no other consumer product enjoys. A lamp that catches fire, a car with a defective airbag, or a harness that snaps under normal use all fall under strict product liability, a body of tort law that holds manufacturers responsible for defects regardless of fault. Software largely escaped that fate. Courts and legislators treat software as a licensed service rather than a product, letting it hide behind contract law instead. That exceptional treatment was a deliberate policy choice, and it is built on three core justifications that AI now undermines entirely:

1. Fear of Chilling Innovation: The software licensing regime that took shape in the 1990s assumed a fragile, nascent tech sector that could not survive the litigation costs strict liability would impose. Bugs became the acceptable price of a fast-moving industry that regulators did not want to strangle. But whatever validity that argument held in the 1990s is gone: An information technology sector that commands more than 36 percent of the S&P 500’s total market weight is no longer a fragile infant in need of a legal shield.
2. Infinite Complexity: While a car has roughly 30,000 physical parts, software contains tens of millions of lines of code with trillions of execution paths. Because mapping every possible configuration of user clicks and background processes was a mathematical impossibility for human teams, courts accepted that exhaustive testing was infeasible. That is why courts have long held software to a lower bar than physical goods. Frontier AI shatters that defense: Automated tools can now stress test millions of these complex, branching paths simultaneously and at superhuman speed.
3. The Ubiquitous Nature of the EULA: Boilerplate “as-is” language repeated in nearly every license shifted almost all operational risk onto the end user, whether that user was a hospital network or an individual consumer. Courts deferred to these contractual liability shields largely because others did, and because the first two justifications gave them cover to do so.

All three justifications rest on one assumption: that finding defects before shipment costs too much to demand it. Frontier AI breaks that assumption, which means the policy logic built on it should be revisited as well.

Revisiting the Economics of Negligence

The law has a relevant formula. Judge Learned Hand laid it out in United States v. Carroll Towing Co.: A party is negligent when the burden of precautions (B) is less than the probability of harm (P) multiplied by the gravity of that harm (L). In other words, negligence occurs when B < P x L.

For 70 years, software vendors won this equation by default. The cost of hiring armies of elite software engineers to manually audit tens of millions of lines of code before every release sat far above the expected harm (P x L) from almost any individual bug.

That reality shifted almost overnight as autonomous security agents proved they could outpace human security teams. In late 2024, Google’s Project Zero and DeepMind unveiled “Big Sleep,” an AI agent that uncovered a zero-day flaw in SQLite, a database engine embedded in billions of devices and renowned for being one of the most obsessively audited codebases. By mid-2025, Big Sleep escalated from catching unreleased bugs to thwarting an active zero-day exploit in the wild moments before threat actors could weaponize it.

What makes these capabilities so game-changing is not just their sophistication, but also their radically lower cost. University of Illinois researchers evaluating AI security agents showed that running automated exploit attempts against real-world vulnerabilities costs as little as $8.80 per run using off-the-shelf models such as GPT-4, a fraction of what human security researchers would cost. A security startup called Depthfirst used a commercially available model to surface 21 previously unknown vulnerabilities in FFmpeg, a piece of software embedded in an enormous share of the internet’s video infrastructure, for roughly $1,000 in total compute. None of this required a multi-billion-dollar custom research lab.

Vendors are not hiding this new capability. They lead with it in earnings calls and product announcements, and they pitch it to customers and shareholders as a competitive advantage. That is precisely why the Hand formula should flip the policy conversation, even where it has not yet flipped it in a courtroom. Courts have enforced “as-is” disclaimers for decades because the assumption beneath them made that deference reasonable. Slapping an “as-is” disclaimer on software after running—or opting not to run—a low-cost precautionary scan that a company actively markets as effective should no longer be a valid legal shield. Contractual disclaimers cannot erase basic duty of care. When code is headed into hospital networks or power utilities, attempting to disclaim liability away from preventable defects becomes a deliberate choice to offload catastrophic risk onto the public. Under the formula’s own terms, that is negligence in substance, even if not yet in doctrine.

The Economics of Software Development

The total economics of building software have shifted as much as the economics of finding the bugs in it. AI does not just lower the cost of security auditing; it slashes the overall cost of routine software engineering by 30–50 percent. Historically, vendors starved security budgets, which typically represent under 11 percent of enterprise cyber spending, to protect core engineering margins. That trade-off no longer holds. Capital freed up by automated development easily covers continuous AI verification, allowing vendors to ship more secure software while still expanding profit margins.

But freed-up capital does not spend itself on defense. A corporation’s obligation, as Milton Friedman once famously argued, is to maximize value for its shareholders. In a competitive market, the vendor that pockets the savings wins; the vendor that spends the savings on security nobody requires does not. That creates a closing window. The same automation that makes bug hunting cheap for defenders will make exploit development cheap for attackers. Whoever automates first keeps the advantage. Left alone, the market pushes that race toward the attacker. The Hand formula says the legal shield should fall. The economics of agentic development say it must fall now while the cost advantage still belongs to the people finding bugs, rather than to the people exploiting them.

None of this happens on its own. Courts have little appetite to unwind decades of enforced boilerplate text case by case. And doing so unevenly, jurisdiction by jurisdiction, would produce years of unpredictable litigation before any vendor changed its behavior. That is the argument for legislative action: Congress can update the assumption on purpose, and on a deliberate timeline, instead of leaving it to a slow accumulation of individual lawsuits to do it by accident.

Reevaluating the Policy Toolbox: Reasonable Process over Perfect Code

The harder conceptual work has already been done. Government experts and legal scholars have developed a substantial body of work on software liability and secure development. The Office of the National Cyber Director’s 2024 symposia helped map the policy architecture. The Secure Software Development Framework (SSDF), developed by the National Institute of Standards and Technology (NIST), already provides a practical baseline. Legal scholars have spent years developing theories of software liability and proposing ways to implement it. Internationally, the European Union has made the same conceptual leap: Its revised Product Liability Directive, adopted in 2024, formally classifies software as a product, though enforcement will not begin until member states transpose it by the end of 2026.

Together, that work points toward a framework centered on reasonable process, not perfect code:

• Revisit secure-development safe harbors. Congress should codify protections for software producers that follow recognized secure-development practices. Vendors that follow frameworks such as NIST’s SSDF, document AI-assisted security testing, and maintain a risk-based remediation process for serious flaws should receive meaningful protection from punitive damages and overbroad tort claims. The goal should be to reward diligence, not punish every residual bug.
• Target liability at gross inaction. Legal exposure should focus on willful blindness, not ordinary imperfection. Companies that decline to use standard automated scanning tools, ignore high-confidence findings, or repeatedly ship code with known or easily discoverable failure modes into critical infrastructure and other high-consequence environments. The strongest cases will not involve close calls. They will involve precautions that were cheap, available, and widely understood, but still ignored.
• Protect open-source maintainers while holding commercial integrators responsible. Any serious framework should distinguish between volunteers maintaining open-source code and commercial vendors monetizing enterprise products. Liability should rest primarily with the firms that package, deploy, and profit from software without conducting basic automated due diligence. That is usually where the capacity to test, remediate, and internalize the cost of failure sits.

Policymakers do not need to invent a new theory of software liability, nor should they demand flawless code. They only need to revisit the outdated economic assumptions that justified software’s exceptional treatment and build from the body of work already on the shelf. When the cost of precaution drops toward zero, the justification and legal case for disclaimed liability collapses. The economics and the technology have changed. Our legal expectations should change with them.

Sezaneh Seymour is an adjunct fellow (non-resident) in the Strategic Technologies Program at the Center for Strategic and International Studies in Washington, D.C.