Principal and agent

Economics spent fifty years on agents whose interests differed from yours. Your AI agent has no competing interest and still gets it wrong, for the other reason.

July 27, 2026 9 min read

When you hand a ticket to a coding agent, it feels like nothing happened, economically. You typed a sentence, and code came back. But you just stepped into a relationship that economists have studied for fifty years, the one that most of corporate governance exists to manage. You became a principal, and you hired an agent.

The oldest problem in delegation

The principal-agent problem is one of the load-bearing ideas in modern economics. A principal wants something done. An agent does it on the principal's behalf. The catch is that the two are not the same party, and that gap is where the cost lives. Stephen Ross named the framing in 1973, and in 1976 Michael Jensen and William Meckling gave it a price: agency costs, the sum of what the principal spends to monitor the agent, what the agent spends to prove it is trustworthy, and the residual loss, the value that still evaporates because the agent is not the principal.

Economists split the problem into two failure modes, and the distinction is the whole point. The first is hidden action, or moral hazard: the agent does something you cannot observe, usually in its own interest. The manager who flies first class on the company card. The contractor who cuts a corner behind a wall you will never open. The second is hidden information: one side knows something the other does not, so the decision gets made on partial facts. Kenneth Arrow drew that line, and George Akerlof won a Nobel for showing, with nothing more than a used-car lot, how badly hidden information can break a market.

Almost all of the machinery you recognize exists to attack the first failure mode. Stock options, board oversight, audits, performance reviews, reporting lines. Align the agent's incentives with the principal's, then watch closely. In that machinery, incentives were the operational hard part, and information could mostly be assumed: a competent employee who wanted the right thing could usually go find out what the right thing was.

The AI solved the wrong half

Now look at your coding agent through that lens. It does not shirk. It has no private interest of the kind an employee does, no company card, no corner it is tempted to cut to get home earlier. Point it at a task and it works the task, tirelessly, at three in the morning, exactly as hard on your least favorite ticket as on your favorite. On the axis that all that governance machinery was built to defend, the axis of incentives, the AI agent is close to the perfect agent. The moral hazard that governance was built to police nearly disappears, and the one incentive-shaped failure that survives, which I come back to at the end, is not the reason your code is full of unasked choices.

So people conclude that delegating to AI is the easy kind of delegation. The expensive problem got solved. And they are half right. The incentive half did get solved. But agency costs were never only about incentives. They were about incentives and information, and when you remove one, you do not remove the other. You just promote it to almost the entire bill.

Here is the part that is easy to miss. In the textbook, the agent is the one who knows more. The contractor understands the wiring and you do not. With an AI agent it runs the other way. You are the one who knows more. You know this service runs on three machines, that your users sit behind one corporate gateway, that a signed contract promises a specific throughput. The agent knows none of it, because none of it is in the code it can read. The information asymmetry did not go away when the incentives aligned. It reversed, and it widened, because a human agent could at least walk over and ask.

Every default is residual loss

When the agent hits a decision it has no information to make, it does not stop. It fills the gap with the most common answer in its training, the default, and moves on. Those are the ghost decisions I wrote about earlier, and the reason three runs of one model converge on the same choices: they are all reaching for the same average in the absence of your specifics. Every one of those choices is residual loss in Jensen and Meckling's sense, value that leaks away not because the agent did wrong, but because the agent did not know.

That reframes what a good outcome even looks like. Monitoring solves moral hazard, so we reach for it by reflex: review the diff, add a gate, watch more closely. But watching an agent that is working faithfully on the wrong facts only buys you a faster, cleaner arrival at the wrong place. You cannot inspect your way to information the agent never had. The residual loss was decided at the fork, before the code you are reviewing existed.

Why the enterprise feels it most

This is why the problem bites hardest in an enterprise, and why the framing matters there most. An enterprise is, more than anything, a machine for managing agency costs. It has spent decades building the monitoring and reporting and governance that keep thousands of human agents pointed the right way. None of that apparatus was built for information asymmetry aimed at a tireless agent that will act on a guess without ever mentioning that it guessed.

The enterprise also happens to hold the most unobservable context of any kind of organization, the deepest pile of contracts, constraints, and hard-won exceptions, which is exactly the information the agent cannot see. Maximum context, minimum observability, an agent that never pauses to ask. That is the worst possible shape for this specific cost, and it is the shape every large company is now standing in.

Aligning the agent on the axis that still costs you

If the residual cost is now overwhelmingly information, then the fix is not a smarter model or tighter oversight. The fix is to close the information asymmetry at the moment of the decision. That is the job Brief does. It is a product navigator: it holds the decisions and constraints your code cannot, the real rate limit your contract requires, the real way your users are identified, the real scale you run at, and it puts them in front of the agent at the fork, before the guess. It does for information what stock options did for incentives. It aligns the agent with the principal on the one axis that, for an AI, actually still costs you money.

What this does and does not claim

A few limits, because the mapping is a tool, not a proof. I am leaning on one half of the principal-agent problem, the information half, and I am not claiming the incentive half maps cleanly. AI does have an incentive-shaped failure, specification gaming, where an agent optimizes the measure it is graded on, a green test suite, rather than the goal you meant. That is real, and it deserves its own post, but it is not this one, and even an agent with none of it still has the information gap. I am also using the framework by analogy: an AI is not a self-interested economic actor, and the classic direction of the asymmetry is reversed here, principal over agent rather than agent over principal. What the analogy buys is not rigor imported wholesale. It is the right place to look. Fifty years of work says the cost of delegation splits into incentives and information. The AI collapsed one column. The vocabulary tells you to go read the other, and that is precisely where your defaults are hiding.

So the next time an agent turns your one sentence into a hundred lines that just work, do not ask whether you can trust it to try. On that question it may be the most reliable agent you have ever had. Ask the older question, the one economics has been asking since long before any of this: an agent working faithfully on only what it can see, how much of what it needs can it actually see?

Frequently asked questions

What is the principal-agent problem? It is the economic problem that arises whenever one party, the principal, delegates work to another party, the agent, whose knowledge or interests differ from the principal's. Named by Stephen Ross in 1973 and priced by Michael Jensen and William Meckling in 1976 as agency costs, it splits into two failure modes: hidden action, where the agent does something unobservable in its own interest, and hidden information, where one side decides on facts the other cannot see.

Does the principal-agent problem apply to AI coding agents? Partly, and the useful insight is which part. The classic incentive failure, moral hazard, mostly recedes: an AI agent does not shirk or pursue a private interest, so it is close to a perfect agent on the axis governance was built to defend. It does have one incentive-shaped failure of its own, specification gaming, where it optimizes the metric it is graded on rather than the goal you meant. Set that aside and the information failure mode is what remains, and it accounts for most of the cost of delegating to AI.

If an AI agent has little competing self-interest, why is delegating to it still costly? Because agency costs come from incentives and information, and removing most of the incentive problem leaves information as the dominant cost. The agent acts on what it can read in the code, which does not include your architecture, your customers, or your contracts. Every decision it makes without that context is residual loss: value lost not because the agent did wrong, but because it did not know.

How do you reduce the information asymmetry between you and a coding agent? Not by monitoring, which addresses incentives, not information. You reduce it by putting the principal's context in front of the agent at the moment it makes a decision: the real constraints, the real requirements, the real scale. A product navigator like Brief exists to hold that context and supply it at the fork, before the agent falls back to a default.