Designing for Who Holds the Loop

Brent Fitzgerald recently described a scene that anyone working with agents will recognize. Eleven tabs open, each with an agent halfway through something: one researching, one writing code, one waiting for an answer he hadn't given yet. None of those tabs had been a bad idea. Each delegation, taken on its own, made sense. And yet the whole left a strange feeling, hard to name: a lot of motion, very little certainty about who was steering. His conclusion was that the human isn't in the loop, as we usually say. The human is the loop. If he doesn't return to each tab, nothing closes.

That sentence interests me because it corrects a way of thinking about agency we take for granted. We tend to talk about it as something you either have or don't, a property of the person: I have agency over my work, I give it up, I take it back. But the scene with the eleven tabs suggests something else. Agency wasn't lost at any identifiable moment. Nobody decided to hand it over. It thinned out through a series of small concessions, each so cheap it didn't feel like a concession. And that changes the design question: if ceding control costs almost nothing, the problem isn't that people cede it badly, but that they don't notice they're ceding it.

The governor

Cybernetics has a useful image for thinking about this, and it's older than computers. The centrifugal governor on steam engines: two metal balls spinning on a shaft. When the engine speeds up, the balls spin faster, swing outward and, as they rise, close the steam valve slightly. The engine slows, the balls drop, the valve opens again. Nobody operates it. It's a loop: measure, compare with what was wanted, correct. The word itself, cybernetics, comes from the Greek for helmsman, the one who corrects the course.

Stafford Beer used that logic to think about whole organizations, and his reading works at the scale of a single person. Read this way, agency isn't a property but a role within a loop: the place from which someone compares what happened with what they wanted to happen, and corrects. Having agency over a task means occupying that place. Losing it doesn't require anyone to take it from you. It's enough for the loop to start closing somewhere else.

That's exactly what can happen with an agent. If I delegate the execution of a task but keep comparing the result against what I was after, I'm still holding the loop: the machine moves, I regulate. But the line between comparing and approving is thin. Takuma Kakehi put it with a precise image: Toyoda's automatic loom left the worker with understanding and took away inspection; AI tends to do the reverse, taking away understanding and leaving us with inspection. Looking at a result and saying it's fine is not the same as having compared it against an intention of your own. In the first case I'm the governor. In the second, I'm the valve.

Ceding without noticing

In an earlier essay I wrote about invisible effort: how we judge the machine's work by signals, because we can't see it. Here the other side shows up. What's invisible isn't the machine's effort but our own withdrawal. Every time an agent does something we used to do, the cost of no longer doing it is close to zero, and what costs nothing doesn't get registered. There's no moment when you feel you've lost something, because you didn't lose anything all at once.

This makes the usual discussion about what to delegate misleading. It tends to be framed task by task: does the AI do this, or do I? But agency isn't played out in each task; it's played out in the sum. No individual delegation takes the helm from me. A hundred reasonable ones do. And because each one is evaluated on its own, the sum never is.

That silent ceding has, I think, two costs worth separating, because one is emotional and the other cognitive, and they're easy to confuse.

The first cost: the refuge

The psychoanalyst Donald Winnicott described something we've all seen: the stuffed animal, the blanket, the object a child won't let go of. He called it a transitional object. It isn't a whim: it lets the child tolerate the mother's absence, a bridge between the inner world and the outer one. In its time it's healthy. And it's meant to be left behind.

Fitzgerald reaches for a similar word to describe his relationship with agents, and it makes sense. An agent can work as a transitional object in front of a task that's frightening or hard to start. Launching it feels like having started. The task is in motion, seemingly on its way, and you never had to touch the part that made it difficult. The agent doesn't help us do the thing we fear: it protects us from having to do it. And that's very different from delegating. Delegating is handing someone something you've already understood. Taking refuge is handing it over so you don't have to understand it.

I'm not saying it's wrong. We all need refuges. I'm saying that if these tools are designed so that launching an agent feels the same as facing a problem, it will be very hard to tell when we're moving forward and when we're procrastinating with a clear conscience.

The second cost: open loops

In the 1920s, Bluma Zeigarnik observed that people remembered interrupted tasks better than finished ones. The original finding has replicated unevenly, so it's wise not to lean on it too hard. But later research supports a sturdier version: unfinished goals keep occupying our thoughts, slipping in when we try to focus on something else. And the interesting part is that you don't need to finish them for them to go quiet. Making a concrete plan for when and how you'll return to them is enough.

Eleven tabs with agents halfway through are eleven open goals. Even when I'm not looking at them, they're there, consuming part of the attention that delegation promised to free up. The paradox is subtle: we delegate to think less about something and end up thinking about more things at once, all of them half-done. Wira Indra Kusuma proposes, in another context, what he calls microboundaries: small, deliberate closures that give the day back its edges. With agents, a microboundary could be as simple as not launching a new task without first deciding when you'll review the previous one.

The organizational scale

All of this is amplified when delegation stops being a personal choice and becomes a policy. Goodhart's law says it in one line: when a measure becomes a target, it ceases to be a good measure. If an organization starts measuring AI adoption—how many agents get launched, how many tasks get delegated, how many sessions per person—people will optimize exactly that. The result is a kind of snake eating its own tail: using the tools to maximize use of the tools.

The loop that mattered—did the work come out better? did anyone understand what was done?—gets replaced by a loop that measures the loop's activity. And in that replacement, once again, nobody decided anything. We simply measured what was easy to measure.

Designing the loop

If agency is a role and not a property, then it can be designed. Not as a permission granted, but as a place the system either makes visible or erases.

Some concrete questions change when you look at it this way. Where does this loop close, and does it pass through a person or around them? Does the system ask whoever uses it to compare the result against what they were after, or only to approve it? Does it show what's still pending, or hide it in one more tab? Some examples already point in that direction. Richa Sehgal designed an audit tool that, when it isn't confident in its evaluation, hands the screen back to a human instead of resolving it alone: the system knows when the loop has to pass through someone. Amelia Wattenberger argues for interfaces that show the state of the work and let you manipulate it, instead of hiding it inside a conversation.

And here the idea of dose that keeps following me returns. Not every loop needs a person. Many close perfectly well on their own, and holding them by hand would be useless friction. The design question isn't how to keep the human in every loop, but how to make visible which ones pass through them, so that ceding stops being silent.

Maybe that's the simplest test of agency right now. Not whether we delegate a lot or a little, but whether at the end of the day we could say which loops still pass through us. And if the answer is that we don't know, is it because we gave up the helm, or because nobody ever designed a way to know where it was?