There's a thought experiment that legal scholars have been using for decades to probe our intuitions about delegation and responsibility. You ask your assistant to handle your correspondence. Your assistant, in handling your correspondence, makes a promise you didn't authorize. Who is responsible for the promise?

The answer in most legal systems involves a doctrine called apparent authority: if you created the conditions under which a reasonable person would believe the assistant had authority to make that promise, you may be bound by it even though you never explicitly authorized it. The key insight is that responsibility follows from enabling capacity, not just from explicit instruction.

We're going to need to think about this much more carefully in the context of AI agents. And we're currently not thinking about it nearly carefully enough.

The delegation gradient

Human delegation of decisions and tasks to other agents - employees, contractors, advisors - has a long history and a fairly well-developed legal and ethical framework. We have concepts of scope of authority, fiduciary duty, negligent supervision, vicarious liability. These frameworks are imperfect, but they've been stress-tested by centuries of real disputes and refined accordingly.

AI delegation is different in several important respects. The first is scale: a single person can deploy agents that act across thousands of simultaneous interactions. A human manager supervises, at most, dozens of employees. An AI deployer might effectively supervise millions of agents, each interacting with a different person. The oversight ratio that our frameworks assume - close enough that responsible supervision is possible - doesn't hold.

The second difference is opacity. When a human employee does something wrong, we can ask them why. We can examine their reasoning, identify where a judgment call went wrong, understand the process that produced the outcome. AI systems - even capable, articulate ones - produce explanations of their outputs that may bear little relation to the actual computational process that generated them. The apparent reasoning is a post-hoc rationalization, not a transparent window into the process. This complicates both oversight and accountability.

The third difference is the gradient of autonomy. Human employees exist on a fairly narrow band: they take instruction, they exercise judgment, but they're clearly agents acting on behalf of a principal. AI systems can exist anywhere on a spectrum from "calculator that executes instructions literally" to "autonomous agent that pursues a goal with minimal human involvement." This spectrum is not well-mapped onto existing accountability frameworks.

The accountability gap

Current practice has produced what I think of as an accountability gap. When an AI system causes harm - makes a discriminatory decision, provides incorrect medical information, executes an unauthorized transaction - the question of who is responsible is genuinely unclear, and the answer varies across jurisdictions and contexts in ways that are inconsistent and arguably incoherent.

The developer of the model? The operator who deployed it in a specific context? The user who gave it particular instructions? All three have arguments for why responsibility lies elsewhere. The developer didn't know how it would be deployed. The operator didn't anticipate this specific failure mode. The user thought they were getting a reliable tool.

"We've built systems capable of consequential action without building the accountability structures that should accompany that capability. That's not a technical gap. It's a governance gap."

In the absence of clear frameworks, what tends to happen is: nobody is clearly responsible, which means nobody has strong incentives to prevent harms that are probabilistic, distributed, and hard to trace. This is a well-understood failure mode in other domains - it's part of why we have product liability law, why we have professional licensing, why we have mandatory insurance in some sectors. The solution isn't to punish innovation; it's to ensure that the costs of failure are borne by those with the most capacity to prevent it.

The autonomy question

There's a deeper issue beneath the accountability question, which is the question of what it means to delegate a decision versus to delegate the execution of a decision you've already made.

When you ask a navigation app to route you to your destination, you haven't delegated a decision - you've decided where to go, and you're delegating the calculation of how to get there. The app can be wrong in ways that cause inconvenience, but the domain of its authority is bounded and clear.

When you ask an AI agent to "handle my inbox," the delegation is much more ambiguous. You've delegated not just execution but judgment: what counts as important, what warrants a response, what tone to take, what promises to make. The agent is making decisions on your behalf that you haven't made - and may not even review.

As AI agents become more capable and more integrated into how we work and live, this second kind of delegation becomes more common and more consequential. We're not just outsourcing calculation; we're outsourcing judgment. And the ethical and governance questions that raises are ones we haven't fully reckoned with.

Some distinctions that actually matter

Not all AI delegation is the same, and being more precise about the distinctions is useful for thinking about governance.

There's a meaningful difference between reversible and irreversible actions. An AI agent that drafts an email for human review before sending is doing something fundamentally different from an AI agent that sends emails autonomously. The governance question for reversible-action agents is primarily about quality and trust calibration; the governance question for irreversible-action agents involves accountability for outcomes that can't be undone.

There's a difference between high-stakes and low-stakes decisions. An AI making micro-decisions about which ads to show you is exercising a kind of autonomy, but the consequences of any individual decision are small. An AI making a decision about whether to extend you credit, or how to triage your medical symptoms, is in a categorically different risk space. The same capability deployed in different contexts carries very different governance implications.

And there's a difference between transparent and opaque delegation. If you know that an AI is handling your customer service interaction, you can calibrate your expectations, escalate if needed, and consent to the delegation. If you don't know - if an AI is impersonating a human or making decisions in systems you interact with without disclosure - the ethical picture changes considerably.

Where this leaves us

I don't have a tidy policy prescription. The people working on AI governance - in academia, in regulatory bodies, in civil society - are grappling with hard problems that don't have clean solutions. I'm skeptical of both the "regulate hard now before it's too late" camp and the "innovation will be killed by premature regulation" camp; both tend to use their preferred conclusion as a premise.

What I think we can say with some confidence:

The accountability gap is real and getting larger as AI systems are deployed in more consequential contexts. Doing nothing is a policy choice, and it has predictable consequences - harms that are hard to trace will be undercompensated, and the costs will fall disproportionately on people with less power to demand accountability.

The technical community has a responsibility to think about governance, not just capability. Building an agent that can take consequential action without also thinking about oversight, auditability, and reversibility is incomplete engineering. Not ethically neutral - incomplete.

And the concepts matter. "Who's responsible?" sounds like a legal question, but it's also a design question. Systems can be designed to make accountability traceable or to make it diffuse. That choice is made by people who build and deploy them, long before any harm occurs. The moral weight of that choice deserves more recognition than it currently gets.

For the practical dimension - how to work with AI agents without losing the accountability thread - the AI at Work path covers the delegation patterns worth knowing. And MCP changed how I think about software examines how one technical standard tries to encode a principled answer to the bounded-agent question.