Who owns the work when the agent does it?

An agent renewed a vendor contract last night. It read the upcoming expiry, pulled the prior terms, drafted the renewal at the same price, and clicked send, all before anyone was awake. The contract is signed. The work is real. And there is exactly one question nobody at the company can answer cleanly this morning: who did that?

Not “which model.” Who. Whose name goes on it when someone asks why the price didn’t get renegotiated.

That gap, between the work being done and a person who owns it, is the whole problem. Autonomy without accountability is a liability; here’s the org design that fixes it. The rest of this post is the mechanism: how you let an agent act and still always have a name attached to the act.

The question nobody asked about software, until now

For sixty years you never had to ask who owned a piece of software’s output, because software didn’t have output you could be blamed for. A spreadsheet recalculated a column. A CRM saved a field. The tool did the arithmetic; a person did the deciding. If the number was wrong, the person who typed the formula owned it. Accountability never moved, because the tool never decided anything.

An agent decides. It reads a situation, weighs options, and commits to one, send or don’t, this price or that one, escalate or wait. The moment software crosses from computing to deciding, a new question lands that we have ducked for our entire careers: when this thing acts on the company’s behalf, whose behalf, exactly?

The instant a tool starts deciding, “who owns the result” stops being obvious, and starts being a design choice.

You can feel enterprises circling this. They want the leverage of agents that act. They are terrified of the liability of agents that act unaccountably. Both feelings are correct. The mistake is thinking you have to choose between them.

The naive answer: the agent owns it

The first instinct, and the one most of the early hype encourages, is the clean one: let the agent own its work. It did the task, so it’s responsible for the task. Give it a name, a dashboard, a little avatar, and treat it like a digital employee with its own column in the org chart.

It feels modern. It is a trap.

An agent cannot own anything, because ownership is not about who did the work, it’s about who answers for it. Ownership is the thing you can call into a room when a customer is angry, the thing a regulator subpoenas, the thing that loses sleep and changes its behavior because it felt the consequence. An agent feels nothing. It cannot be fired, cannot be sued, cannot be promoted, cannot care. Pointing the blame at the agent is just a more sophisticated way of pointing it nowhere.

Here is where the naive answer fails in practice. Suppose the renewal that went out last night was a mistake, the vendor’s service had degraded, and any human would have used the expiry to renegotiate, not rubber-stamp. You go looking for the owner. The agent? It’s a process; you can pause it, but you can’t hold it to account. Its outputs are real and its consequences are real, but the line of responsibility dead-ends at a thing that cannot be responsible. You have manufactured a new category of orphaned work: actions with consequences and no one who owns them.

Autonomy without accountability is a liability. An agent that owns its own work is autonomy with the accountability deleted.

So if the agent can’t own the work, and you still want the agent to do the work, the ownership has to live somewhere else. The question is where, and the answer is the org design.

The real answer: ownership stays human, the work moves

The fix is older than software, and every functioning company already runs on it. We just stopped noticing because we only ever applied it to people.

When a manager delegates a task to a junior analyst, the analyst does the work, but the manager still owns the outcome. That’s what delegation is. The work moves down; the accountability does not. If the analysis is wrong, “my analyst did it” is not a defense the manager gets to use. They chose to delegate, they chose to trust, and they own the result of that choice. Delegation moves the labor without moving the answerability.

This is the design that fixes agents, and it’s almost embarrassingly simple: an agent doesn’t own work. It is delegated work by a human who still does.

Every agent action traces, unbroken, back to a person who stands behind it. Not the person who built the agent, the person who deployed it onto this task, with this authority, on this company’s behalf. They are the owner the same way the manager is the owner of the analyst’s work. The agent is the labor. The human is the name on it.

Delegation never transferred ownership. It moved the work and kept the name. That’s the rule we already trust, agents just need to inherit it.

Notice what this quietly solves. The “digital employee” framing wanted the agent to be a new kind of person. This framing says the opposite: the agent is a new kind of tool, the most capable tool a person has ever delegated to, but a tool, and tools are always owned by the human wielding them. A surgeon owns the operation even though the scalpel did the cutting. The agent is a very fast scalpel. Someone is still holding it.

What that demands from the operating system

A principle is only as good as the machinery that enforces it. “Ownership stays human” is a nice sentence; on its own it’s a poster on a wall. For it to be real, the system the agents run on has to make accountability structural, not optional. Three things have to be true at the substrate level.

Every action carries a named owner, by construction

The naive way to track this is a policy: tell everyone to write down who deployed each agent. That fails the first busy week, because the moment accountability is paperwork, it’s the first thing dropped under pressure.

The owner has to be a property of the action itself, not a note someone is supposed to keep. When an agent acts, the action is born already stamped with the human who delegated it, the way a well-run company knows, without anyone filing a form, that the renewal was the procurement lead’s call. You don’t ask after the fact who owns it. The ownership was attached the moment the work was handed over, and it travels with the work wherever it goes.

Authority is granted, scoped, and revocable

A second failure of the agent-owns-it model is that it treats authority as binary: the agent can either act or it can’t. Real delegation is never binary. A manager doesn’t hand a new analyst the company checkbook. They grant a slice of authority, you can draft renewals under last year’s terms; anything that changes price comes to me, and that slice is scoped, time-boxed, and can be pulled the instant trust breaks.

The operating system has to model authority the same way: as a grant from a specific human, for a specific scope, that the human can widen or revoke at any moment. The agent acts inside the boundary of someone’s delegated authority, never beyond it. And because the grant came from a person, the boundary is the person’s responsibility to set well. Autonomy lives entirely inside a fence a human chose.

The trail reconstructs the decision, not just the click

When something goes wrong, “the agent sent it at 2:14am” is not enough to learn anything. You need the decision: what the agent saw, what options it weighed, why it chose send over escalate, and which human’s standing instructions made that the default. A click log tells you what happened. A decision trail tells you whether the delegation was sound, and that’s the thing the owner is actually accountable for.

This is the part most “AI audit” theater skips. It logs the output and calls it governance. But the owner isn’t accountable for the keystroke; they’re accountable for the judgment, theirs, encoded into the agent, executed at scale. The trail has to make that judgment legible, so the human who owns it can defend it or correct it.

Put those three together and you get something an enterprise can actually live with. Not “trust the AI.” Not “ban the AI.” A structure where agents do enormous amounts of work and every bit of it has a human name on it, because the owner, the scope, and the reasoning were attached at the moment of delegation, not reconstructed in a panic after the fact.

Why “trust the agent” and “ban the agent” are the same mistake

The two reactions enterprises have to autonomous agents look like opposites. They are the same error wearing different clothes.

“Trust the agent, let it run” deletes the human from the loop and orphans the work. “Ban the agent, too risky” keeps the human as the only thing allowed to act, which means the company moves at human speed and the leverage evaporates. One throws away accountability to get autonomy. The other throws away autonomy to keep accountability. Both believe the two things can’t coexist.

They can. Delegation is the existence proof, every company on earth already runs on autonomous actors (employees) whose work is owned by someone above them. Autonomy without accountability is a liability. Autonomy inside accountability is just an organization that works. Agents don’t need a new social contract. They need to be slotted into the one we’ve trusted for a hundred years.

The turn: you become the manager, not the bottleneck

Here is what actually changes when you get this right, and it isn’t about the agents at all.

Today, in most companies, the people who could be deciding what’s worth doing are instead the ones personally doing it, because they’re the only ones accountable enough to be trusted with it. Accountability and labor are fused in the same human, and so the most answerable people are also the busiest. That’s backwards. The whole reason we built management was to separate those two: the manager owns the outcome and decides what good looks like; the team does the work. Agents finally let that separation reach all the way down.

When an agent is delegated work and you still own it, your job stops being execution and becomes the thing a good manager actually does, choosing what to delegate, setting the scope wisely, deciding what “right” means, and standing behind the result. You don’t lose accountability when the agent acts. You keep all of it. What you lose is the obligation to personally do the work in order to be the one who answers for it. That obligation was never leverage. It was just exhaustion wearing the mask of responsibility.

The agents will do more work than any team you could hire. But the judgment about which work, under what authority, toward what standard, that stays exactly where it belongs. On a person. With a name. Who answers for it.

---

That’s what we’re building at Apollo Space, an operating system where agents carry the labor and humans carry the name, because we think the future of work isn’t humans replaced by autonomous things, it’s humans finally free to manage instead of toil. Autonomy was never the scary part. Unowned autonomy was. Give the work an owner, and you can let it run.