Trump Administration Bets on Lawsuits: Who Pays When AI Fails

The Trump administration has chosen legal liability as its main lever for AI safety, Bloomberg reports. The approach looks economical: there is no need to create a licensing body or negotiate lists of banned architectures. It is enough to make clear that someone will have to pay for harm. But the scheme has a weak spot, and it is already visible: the law does not yet say who exactly should pay when a model "goes haywire." Those who built it, or those who embedded it in their product?

Bloomberg's report cites no specific statutes, amounts, or deadlines, so the details of the mechanism remain unclear. The underlying logic, however, is plain, and it can be examined through disputes that have already happened.

Two chains of liability

Any AI system in production involves at least two parties. The first trains the model and defines its base behavior. The second connects it to its own data, writes the system prompt, gives it tools, and decides where it can be used. Damage most often occurs at the seam between them: the model made a mistake, and the company gave it access to something it should not have had access to.

The European AI Act wrote this division into its terminology: there is a "provider" and a "deployer," and their obligations differ. The US has no single framework. What remains is product liability, negligence law, and contract law. Courts apply these to AI by analogy, and the results are unpredictable.

A telling example from 2024: a tribunal in British Columbia ruled that Air Canada was responsible for incorrect information about discounts given by its chatbot. The airline tried to argue that the bot was a separate entity. It failed. The party that deployed the system in front of the customer was held liable, not the party that trained it.

Where it will hit developers

Before this, California considered bill SB 1047 in 2024, which contained liability rules for developers of large models. Governor Newsom vetoed it, largely because of industry objections. Now the idea of liability is returning, this time from the federal level and in the logic of supporting the market rather than restraining it.

Developers' typical defense is user agreements that shift risk onto the customer. The exception is protection against copyright claims: Microsoft, Google, and OpenAI have offered enterprise customers such guarantees. No comparable guarantees exist for harm caused by model behavior. If liability becomes real, these terms will have to be rewritten.

The main points of tension:

• The line between a model defect and improper deployment: who has to prove what exactly broke.
• Agentic systems: the more autonomy and tool access, the harder it is to allocate fault along the chain.
• Contract disclaimers: whether developers will still be able to disclaim liability in their licenses.
• Insurance: the market for AI risk coverage is still thin, and rates will depend on the first high-profile rulings.
• Open models: it is unclear who is responsible for harm if third parties download and fine-tune the weights.

What companies should do now

There is no need to wait for the final rules: the logic is clear, and preparation is cheap. Companies that deploy AI should audit their contracts with model vendors and establish which risks the vendor takes on and which stay with them. It helps to keep logs of agent actions and to save versions of prompts and configurations: in a dispute over where an error originated, this data will show whose zone it falls into.

Model developers should document their testing and known limitations. That will be their main argument that the product had no defect. For everyone else, the practical takeaway is simple: limit agents' permissions to the bare minimum and keep a human in the loop at points where the cost of an error is high. When liability becomes the subject of lawsuits, it is exactly these decisions that a court will examine.