Who's Accountable When an AI Agent Makes a Mistake?

When an AI agent makes a mistake, exactly one human is accountable: the named human owner whose seat the agent reports to on the org chart. That answer should be in the agent's job description, on its org chart box, and known to every person who interacts with the agent's output. If the answer is fuzzy, the agent is not ready to be running in production.

This is not a complicated principle. It is the same rule companies have used for decades to manage human teams. The reason it deserves an entire post is that AI-augmented orgs keep inventing reasons to soften it. The agent was built by engineering, so isn't engineering accountable? The agent is used by everyone, so isn't accountability shared? The agent is a tool, so isn't accountability really on whoever pushed the button? Each of these arguments has a kernel of truth, and each of them, taken seriously, destroys the structure that makes AI agents actually work.

The single-throat-to-choke rule

Every AI agent in your company should have one human who can be pointed at when something goes wrong. Not a team. Not a committee. One human. That person's name is on the org chart box. That person is reviewed at performance time on the agent's KPIs. That person is the one who fixes the prompt, updates the failure modes document, and answers the question "why did this happen?" at the post-mortem.

This is called the single-throat-to-choke rule. It is not a polite phrase, and that's intentional. The point of the phrase is to make the principle impossible to misread. When something breaks, somebody owns the fix. Not in the abstract, in the specific. That person is identifiable before the failure occurs, not assigned after the fact.

The rule applies whether the agent is doing trivial work or critical work. A drafting agent that produces internal summaries has the same accountability structure as an agent that auto-sends client emails. The stakes are different. The rule is the same.

What this prevents

The single-throat-to-choke rule prevents four specific failure patterns, all of which we've watched companies fall into.

The first is shared blame. When an agent fails and ownership is shared across three or four people, the post-mortem becomes a negotiation about who messed up. No one owns the fix because no one fully owns the problem. The agent stays broken. The exact same failure recurs in two months.

The second is deflection. Without a clear owner, the failure gets routed away from anyone who could fix it. Engineering says it's a prompt issue, the prompt owner says it's a data issue, the data owner says it's a scope issue, the scope owner says it's an engineering issue. The loop closes and nothing improves.

The third is the absence of performance review. If no human owns the agent, no human gets reviewed on the agent's performance. There's no quarterly check on whether the agent is improving. There's no incentive for anyone to invest in making the agent better. The agent drifts and the company shrugs.

The fourth is the slow erosion of trust. When humans on the team see an agent fail and no consequence land, they learn that AI failures don't matter. They start ignoring agent output, or worse, they start using it but distrusting it, which is the most expensive possible mode (the work gets done twice, with no time savings, and a hallucination still occasionally gets through).

The single-throat-to-choke rule blocks all four. The named owner has skin in the game. The performance review attaches consequence to outcomes. The fix has a clear path to implementation. The team sees that agent quality is being managed and starts trusting the output that's been reviewed.

What this enables

The flip side of the failure patterns is a set of things that only happen when ownership is clear.

Clear escalation. When the agent flags something it can't handle, the routing is obvious. The owner gets pinged. The owner decides what to do. There's no debate about which Slack channel to use or whose turn it is to look at the alert.

Real performance reviews. The owner sits in their own performance review and answers questions about the agent's KPIs. Did the agent's correction rate improve this quarter? Did the override rate come down? Did the cost per output trend in the right direction? These questions can only be answered if there's an owner who has been watching the numbers.

Real improvement. The owner has the standing and the incentive to push for prompt updates, scope changes, and tool integrations. They have the context, because they've been reviewing the agent weekly. They have the authority, because the agent reports to them. They have the motivation, because their own performance is partly tied to the agent's.

Defensible decisions. When leadership asks "should we keep this agent running, retire it, or expand it?" the owner can answer with data and a recommendation. Without an owner, that question becomes a committee discussion that goes nowhere.

The objections people raise

Three objections come up almost every time the single-throat-to-choke rule gets proposed. All three have the same answer.

"But the agent does work for multiple teams." Fine. The agent's owner reports its KPIs to multiple teams. Accountability stays singular. The owner is the conduit, not a bottleneck. This is exactly how a head of finance owns the financial reporting that goes to every department, without diluting their accountability.

"But the agent was built by engineering, not by the function that uses it." The user owns the agent. Engineering builds the infrastructure, in the same way IT builds the laptops and HR builds the org structure, but the seat is owned by the function that depends on the output. If sales depends on a prospecting agent, the head of sales owns it. If finance depends on a reconciliation agent, the head of finance owns it. The fact that an engineer wrote the prompt does not transfer accountability to engineering, any more than the fact that HR wrote a job description transfers accountability for a hire's performance to HR.

"But what if the owner isn't actually at fault for the failure?" They're still accountable. Accountability is not the same as blame. A human manager whose report makes a serious mistake is still accountable for the fix, the post-mortem, and the prevention plan, even if they didn't personally cause the error. Same standard. The owner doesn't have to have caused the failure to be the right person to handle it. They just have to be the one whose job it is to make sure it doesn't happen again.

How to assign ownership

The assignment is usually obvious once you ask the question correctly. The question is not "who built this?" or "who codes the prompts?" The question is "whose work depends on this agent's output, and who is the most senior person in that chain who can fix things?"

For Sneeze It, Pepper (executive assistant) belongs to David because David's email is the work being augmented. Crystal (project manager) belongs to David because project delivery is what would break if Crystal failed. Dash (ad analyst) belongs to David because client ad performance is the function. Dirk (sales) belongs to David because revenue is the outcome. In a larger company, these agents would belong to different functional heads (head of customer service for Pepper, head of operations for Crystal, head of growth for Dash, head of sales for Dirk).

The pattern is that the agent goes to the seat that would be hiring a junior human for this work if the agent didn't exist. That seat is the right owner.

The one exception that isn't really an exception

Sometimes leadership wants to argue that a particularly cross-functional agent should be owned by the CEO or COO directly. This is usually a sign that the agent's scope hasn't been resolved. The fix is to narrow the scope, not to broaden the ownership.

If an agent genuinely needs CEO-level ownership, that's allowed, but the rule still applies: exactly one human, named, with KPIs, with a performance review attached. CEO-owned agents are rare and should be rarer than they tend to be in practice. Most agents that drift up to the CEO do so because the actual function head doesn't want them. Solve that, don't pretend the CEO is going to run a weekly performance review on twelve agents.

What to do this quarter

Three steps to install the accountability discipline.

First, list every AI agent doing recurring work in your company. Next to each name, write down the single human accountable. If the answer is "the team" or "shared" or "we're still figuring it out," that's the first agent to fix.

Second, write the owner's name on the agent's org chart box and in the JD. The visibility matters. People who interact with the agent should be able to see whose desk to walk to when something is wrong.

Third, build the owner-review into your existing leadership cadence. Owners report on their agents' KPIs in the same forum where they report on their human team's performance. Same meeting, same level of seriousness, same consequence for trends.

The single-throat-to-choke rule sounds harsh. It is. It is also the only rule that produces agents that get better instead of agents that quietly rot. Pick a name. Put it on the box. Watch the agent improve.