You delegate something. Whoever you delegated to knows more about the work than you do, makes choices you never see, and hands you a result you can't check. That is the principal-agent problem, and economists were arguing about it long before anything called an agent ran on a computer.
It is worth borrowing, because when the agent is software one half of the problem vanishes and the other half gets considerably worse.
The classic version
A principal delegates to an agent who acts on their behalf: shareholders and the executives running the company, a client and the professional they retained, a homeowner and the contractor rebuilding their kitchen.
The problem needs two ingredients. Information asymmetry — the agent knows things the principal cannot cheaply check: how much effort went in, which corners were cut, whether the recommendation was the best option or the most convenient one. And divergent interests — the agent has a payoff of their own, and it is not the principal's. Not villainy, arithmetic: an agent paid by the hour and one paid by the outcome make different calls at the margin, and both believe they are being reasonable.
Nearly every standard remedy targets the second ingredient: equity, contingency fees, and milestone payments each bolt the agent's payoff onto the principal's so self-interest and duty point the same way. Monitoring exists too, as the expensive fallback. Incentive alignment is the workhorse.
Software agents break the standard remedy
An AI assistant is an agent in exactly that sense. You delegate, it acts, it exercises discretion you do not observe. If it can call tools and act on what comes back, it is an agent in the technical sense as well as the economic one.
But it has no payoff. It does not earn more by recommending the expensive option, does not build a career, does not get tired at four o'clock and take the shortcut. The second ingredient is largely absent — and with it every remedy that assumed there was something to align. Nothing to bolt on.
One real qualification: the model has no payoff, but the system around it has an owner whose interests can be built into how it behaves. That is a genuine principal-agent problem — it just runs between user and vendor, answered with contracts and defaults rather than anything AI-specific.
The asymmetry gets worse in three ways
Goals get inferred, silently. Instructions are always underspecified. Ask for "a short reply to this" and a hundred choices follow that you never made: tone, what to concede, what to leave out, whether to commit to a date. A human agent who hits a consequential ambiguity tends to ask; a software agent resolves it and continues — acting competently on a goal you never issued, and leaving no trace of the choice unless the system was built to record one.
Fluency erases the usual tell. When a person misunderstands the brief, the work reads as confused, and that confusion starts the follow-up conversation. A model that misunderstood produces work exactly as polished as work that understood. The rough correlation between confidence and correctness, which every principal quietly relies on, is gone.
Speed removes the mid-course glance. Ordinary delegation takes days, so you notice drift in the middle. An agent may finish before you look at anything.
The classic worry is that the agent may not want what you want. The software version is that the agent will act on a goal it invented on your behalf, and sound completely right doing it.
The mitigations that apply instead
With no incentive to align, incentive tools are irrelevant. What remains attacks the asymmetry.
Observability — make the inference visible before it is acted on. The agent should show what it concluded your goal was, and mark which facts came from you rather than from its own reading. That is provenance: a per-part record of origin, so a reader can tell a stated fact from an inferred one. What is labelled stated is yours; what is labelled inferred is the gap, offered for inspection rather than smuggled in.
Confirmation — put a human decision before anything irreversible. You cannot review everything; attempting it defeats delegation. So review goes where a wrong inference stops being cheap. Reading, computing, drafting: unsupervised, because a bad inference there costs a redo. Sending, publishing, spending, deleting: a person, because afterwards nobody can correct it. Which actions deserve a gate, and how gates decay when they fire too often, is human-in-the-loop AI.
Capping what the agent may do at all is the backstop under both — what a connection grants is usually broader than people assume.
Correspondence is the sharpest case
Delegating a message concentrates all of it: the inference goes out under your name, to someone who reads it as your position, and no goodwill afterwards makes it reversible.
RelayLink is built around that instance. Your assistant composes the briefing privately with you, and every assumption in it is labelled stated by sender or inferred by sender's AI. The send is split in two: one call creates a draft, the human reviews the rendered package exactly as it will arrive, a second call from the same account releases it. There is no unsend — which is why review is a step of its own, not a confirmation dialog.
What neither mitigation fixes
Observability requires the principal to look. A labelled inference nobody reads is no better than an unlabelled one, and the failure is quiet: the record exists, the oversight does not. Confirmation degrades into reflex when it fires too often; the twentieth approval of the hour is latency, not judgment.
There is also a limit in principle: you cannot verify every inference without redoing the work, which is what delegation was for. Some gap survives any arrangement where one party acts for another. Eliminating it was never the goal — moving it somewhere visible is, and putting the human decision where being wrong is still cheap.
To see labelled inferences in a message you are about to send, connect your assistant.