Who Is Liable When Your AI Agent Gets It Wrong

When an AI agent makes a mistake that costs someone money, the question of who is liable is settled less by law than by evidence. Whoever can prove what happened controls the outcome. If you can show exactly what the agent did, why, within what limits, and where a human signed off, you can allocate responsibility precisely. If you cannot, the liability defaults to you, the operator, because you deployed a system whose behavior you cannot account for. Governance is not a compliance nicety here. It is the mechanism that decides where the blame lands, and it decides it before the mistake ever happens.

I deploy AI agents across a portfolio, some in fields where a wrong action has real consequences. I think about liability constantly, and it always comes back to one thing: what can I prove.

Liability follows the evidence, not the intent

You cannot argue your way out of a bad outcome with good intentions. In any serious dispute, the side with the clearer record wins, because the record is the only thing that survives contact with a regulator or a court. If your agent made an error and your defense is a description of how the system was supposed to work, you have already lost, because the other side has whatever your logs actually show, and if your logs show nothing, the gap gets filled with the worst interpretation.

This is why I treat the audit trail as the load-bearing part of any autonomous system. The trail is not there to satisfy an auditor in the abstract. It is there so that when responsibility is being assigned, you are the party holding the evidence rather than the party hoping nobody looks too closely.

What "provable" means in a liability context

To be on the right side of a liability question, you need to be able to answer, from records alone:

• What input did the agent act on, and was it correct?
• Which version of the system produced the action?
• Was the action inside the authorized scope, or did the system exceed it?
• Did a human review or override it, and on what basis?

Answer those and you can show precisely where a failure originated. Maybe the input was bad data from a third party, which moves responsibility. Maybe a human overrode a correct refusal, which moves it again. Without the records, none of these distinctions exist, and undifferentiated liability lands on the operator by default.

Scope enforcement changes the liability story

An agent that can only act within enforced limits has a fundamentally better liability position than one that can do anything. If the system is built to refuse out-of-scope actions and log the attempt, then a whole category of catastrophic mistakes simply cannot occur, and the ones that do occur happened inside a boundary you defined and can defend.

This is why I push teams to build guardrails into the AI product rather than trust the agent to behave. Guardrails are not only a safety feature, they are a liability feature. They convert "the agent did something insane and we have no idea how" into "the agent operated within its defined limits, here is the record," which is a defensible position instead of a catastrophic one.

The human override is a liability hinge

Where a human sits in the loop, and whether that human's decision is recorded, often determines who owns a mistake. If a person approved the action, that changes the allocation, but only if the approval was captured with a reason and an identity. A human in the loop whose decisions vanish gives you the friction of oversight with none of the liability protection, which is the worst possible trade.

Record every override as carefully as every automated action. When the question of responsibility arrives, the difference between "a human approved this, here is who and why" and "we think someone approved it" is the difference between a shared responsibility and a sole one.

Decide the liability before the mistake

Here is the whole point. You do not wait for the error and then figure out who is liable. You build the system so that when the error comes, and it will, the evidence already exists to allocate responsibility fairly and to keep it off you where it does not belong. That work happens at design time, in the logs and the limits, long before anyone is arguing.

I build every agent at Girard AI so that the liability question has a clean answer waiting in the record. An agent you cannot account for is not just a product risk. It is an open-ended liability wearing the costume of an efficiency gain, and the bill arrives when you can least afford it.