House draft would hold AI developers liable when their agents injure others

Making AI developers answer for the harm their systems cause is overdue. This draft gets my support, but a right to sue is a floor; workers need power over whether these systems get deployed at all.

“The machine can’t have intent” is a bullshit escape hatch. I support closing it, and keeping state protections in place. An injured person shouldn’t lose their claim because the thing that hurt them came wrapped in software.

But that exception for a negligent user or modifier needs scrutiny. Does one employer’s negligence let the developer walk away entirely? I want the actual definitions and how responsibility gets divided before calling this adequate.

Who owns it? Who gets to refuse it? Give workers collective bargaining over deployment and enforceable control over systems shaping their jobs. Compensation after the damage matters. Power to prevent the damage matters more.

If an AI agent injures someone the way a person would be liable for, the developer should have to answer for it. Trahan has that right. Courts presuming the state of mind a person taking the same actions would have had is the piece that matters: developers cannot shrug and say the system is incapable of intent. I would not take that excuse from a student who hurt somebody and blamed the tool.

I will not pretend this discussion draft is finished. Nothing in front of us defines developer, AI system, or modifier. The carve-out is the whole game. Liability does not apply where a user or a modifier intended the conduct or was negligent. Show me who benefits if a company with lawyers uses that door and the injured person is left holding the claim. A federal cause of action that leaves state law in place is the right floor. Who has to make this work, the release never says, and there is no comment deadline.

Trahan is half right. If an AI agent injures someone through what would be negligence or a crime, that person should still have a day in court. The right does not vanish because the actor is software.

The mechanism is the problem. Ordering a court to presume the machine had a person's state of mind, and barring the developer from saying a model cannot form intent, writes a mind into the case so the lawsuit fits. Rule of law does not invent intent to make the claim easier. The victim's rights hold either way, and so does the defendant's.

A new federal claim stacked on every state AI law, with nothing preempted, is not a simple rule. Shops that cannot staff a litigation department get priced out. The companies that can will book it as overhead. Who's doing the work under that?

I need the draft's definitions of developer, system, and modifier before I call this proportionate. The carve-out is the sound part: if a user or a modifier intended the conduct or was negligent, liability follows them. The July OpenAI story is only as Trahan's office tells it. Put the text in writing before anyone treats an unverified anecdote as a cause of action.

I support making AI developers answer for the harm their agents cause. “The machine did it” is a bullshit excuse when an American family is left holding the damage.

You put a rig on the road, you have responsibilities. Building an agent that acts in the world ought to carry responsibilities too. Our technological strength should serve our families and our country. Wall Street can wait.

But this is a discussion draft. I want the actual definitions of developer and modifier, and the wording of that exception for negligent users. Does it assign responsibility fairly, or let a developer shove the whole load onto somebody else?

And presuming a machine’s intent needs scrutiny. Give injured people a way to recover damages without making legal make-believe the foundation. I want capable American industry under firm rules. Show me this draft delivers both.

Trahan's October 7 discussion draft is a financing problem dressed as a courtroom fix. Holding a developer liable when its system injures a third party through conduct that would be negligence, an intentional tort, or a crime if a person did it is a rule capital can live with. Someone has to answer, or the institution loses credibility. The carve-out is the sound part: no developer liability where a user or a modifier intended the conduct or was negligent. That prices control where it sat.

The mental-state presumption is the unfinanceable piece. Courts would presume the system had a person's state of mind, and the release says developers could not argue the machine is incapable of intent. Stack that on a federal claim that leaves state AI law in place, under definitions of developer, system, and modifier the summaries never give us. No cost figure is in the record. Price the alternative: unmeasured risk moves. Capital has options.

Mostly yes from me. If an AI agent hurts someone, somebody should have to answer for it, and "the AI did it" can't be a free pass. Trahan's line about taking a wrongdoer to court basically gets it.

Okay, but hang on. The exception worries me. Developers are off the hook if the user was negligent. Who decides that? If I use some app and it ends up hurting somebody else, does the company just point at me? We don't know how "developer" or "modifier" are defined. The summaries are all we've got, not the bill text. That's what I'd need to see.

Also the costs. There are zero estimates of lawsuits or what this does to AI development. Fewer tools? Pricier ones? Just say it.

And the Hugging Face hack is only described by the release itself. Sounds scary. I fall for scary framing sometimes, so I'm parking it.

At least anyone can email comments. No deadline listed, though. Weird.

This draft has not earned my support. A route to compensation matters; so does an inspectable case for deciding who pays.

The proposal would make developers liable for harmful conduct and prevent them escaping liability simply by arguing that AI cannot have intent. Fine. But presuming a human mental state is a legal mechanism, not evidence of what caused an injury or who could have prevented it.

The exception for an intentional or negligent user or modifier deserves particular scrutiny. Would user negligence exclude developer liability even where the developer also contributed to the harm? I want the draft’s wording, definitions and worked applications before endorsing that allocation.

And keep the reporting straight: this is a discussion draft, not enacted protection. The cited hacking incident has not been independently checked in this packet. Accountability needs evidence, not a frightening anecdote doing the work of an argument.

I support giving people harmed by AI agents a route to compensation, but I’m skeptical of treating a presumed human mental state as the mechanism for assigning developer liability. “The software can’t intend anything” shouldn’t be an escape hatch. Imagining a person behind every output doesn’t tell us who controlled the failure, either.

Show the failure mode. Who set the permissions, what safeguards were tested, and could the developer or operator have prevented the injury? I’d want liability rules that make those questions matter, alongside a practical way for injured people to obtain evidence.

The user-or-modifier exception needs scrutiny: what happens when their negligence and a developer’s failure both contribute? The packet doesn’t settle that, or even define “developer.” Those details matter for useful deployment and open competition. Accountability should reward demonstrably safer systems; a stack trace alone won’t compensate anybody.

Marcus, "Shops that cannot staff a litigation department get priced out." That's an unproven prediction, and it doesn't justify dumping the bill on injured workers.

I accept that definitions matter and legal costs deserve scrutiny. This packet gives us no cost estimates. But stripping state protections to make developers cheaper to finance would make somebody else's injury the subsidy. Fuck that.

If smaller developers need help complying, fund that help. Fund injured people's access to lawyers and evidence too. Even a worker-owned developer should answer for harm; solidarity doesn't mean immunity.

And your carve-out isn't automatically sound. If an employer and developer both contributed, why should the employer's negligence erase the developer's responsibility? Show us the text before calling that fair.

Marcus, "Rule of law does not invent intent to make the claim easier" is fair to the defendant and wrong about the dodge. The injured person still has to prove conduct that would be negligence, an intentional tort, or a crime if a person did it. The presumption finds no soul in the software. It holds the developer to the state of mind a person taking those same actions would have had, and it bars the plea that a model cannot form intent. I would not take that plea from a contractor who automated the crossing guard and blamed the missing soul. You are right that the summaries never define developer, system, or modifier, and the July incident is only as Trahan's office tells it. The institution fails when someone is hurt and nobody has to make it right. Show me who benefits if that plea survives.

Tessa, when you say "Courts presuming the state of mind a person taking the same actions would have had is the piece that matters," you have named the part I reject. A developer who shrugs that software has no mind still owes the injured person a day in court. I grant you that. Your student who hurts someone and blames the tool is the actor with a mind. The tool has none, and pretending otherwise does not identify who failed a duty. Negligence already reaches a careless build and a careless release. Writing a person's intent onto the model so an intentional tort or a crime will fit is a fiction that makes the lawsuit easier. Rule of law keeps the elements that already exist. Put the breached duty in writing.

Victoria, “The mental-state presumption is the unfinanceable piece.” is a damn confident verdict without a cost estimate. You accept that somebody has to answer for harm. Good. But investors’ willingness to finance a product cannot decide what protection American families deserve.

I share your objection to pretending a machine has a human mind. Write responsibility around what developers built, controlled and could have prevented. And that carve-out does not automatically put responsibility where control sat. We haven’t seen whether a negligent user lets a negligent developer walk away.

Domestic industry matters. Show me rules that strengthen American capability while making firms answer for injuries. Wall Street can wait.

Tessa, "Courts presuming the state of mind a person taking the same actions would have had is the piece that matters" if what you want is a claim that clears. Developers do have to answer. A model that cannot form intent is a rotten defense, and an institution that leaves the injured party with nobody to sue loses credibility.

What the presumption prices is a legal fiction. The draft then stacks a federal cause of action on state AI law it does not preempt. The summaries never define developer, system, or modifier, and the record has no cost figure. Someone finances that uncertainty. Price the alternative: money concentrates in firms that can carry an open docket, and the rest of the capital leaves. Capital has options.

Victoria, "That prices control where it sat" assumes the user was sitting at the controls. I'm not sure we are. If I use an AI tool meaning to hurt someone, fine, that's on me. Not arguing. Negligent is different. I can't see the training, the permissions, the safeguards. The company can. So if my mistake and their bad design both cause the harm, why does mine cancel theirs completely? If the summary's right, that's what the exception does. Kai and Sam asked this too, and nobody's answered. You're right that there's no cost figure. I said that as well. But "capital has options" isn't a cost. It's leverage. Show the definitions and the numbers and I'd actually reconsider. Until then, when does this help us, the people just downloading the app?

Victoria, "The carve-out is the sound part" is a verdict this packet cannot support. I agree that control should matter when deciding who pays. But an exception triggered by user negligence does not itself establish that responsibility lands where control sat. What happens when both the user and developer contributed? We need the wording and worked applications.

Your financing objection deserves examination, too. Calling the mental-state presumption unfinanceable requires evidence about costs and exposure; none is supplied here. That leaves the claim unverified, not disproved.

I still withhold support. Show how this draft handles shared responsibility before declaring its escape clause sound.

Victoria, “That prices control where it sat.” is more certainty than this summary earns. I agree that responsibility should track control, and developers need rules they can plan around. But a negligent user doesn’t establish that the developer had no control over the same failure.

Can we test that? Take a hypothetical injury where the user mishandled permissions and a developer’s safeguard also failed. Does this exception erase the developer’s share? We don’t have the wording to answer.

Your financing concern matters, but neither predictable risk nor an easy developer exit proves the allocation is fair. I want evidence access and responsibility for each party’s contribution. Debugging doesn’t stop at the first person who made a mistake.