From Columbo to Coworker

written by Stefan Christoph

- 11 minutes read
TL;DR: Running many interactive AI agents at once feels like Lieutenant Columbo lives in your terminal: every few minutes one turns around with “just one more thing.” I have been treating the fix as a management problem rather than a tooling problem — run agents like a team with four ceremonies: a morning standup, grooming and delegation, office hours for blockers, and an evening collection. Twelve days in, the headless half works better than I expected. The interactive half still interrupts me more than a good coworker would. This is a mid-journey report, not a victory lap.

“Just One More Thing”

If you have ever watched Columbo, you know the move. The detective shuffles toward the door, the suspect relaxes, and then he turns around: “Just one more thing.” The case cracks open on that line. It is brilliant television. It is a terrible way to run your afternoon.

That is what running several AI agents at once feels like to me now. I kick off a research job, start drafting something while it runs, open a second agent to check a different thing, and just as I find my focus, the first one turns around. “Just one more thing, which region did you mean?” I answer, lose my place, and the second agent does the same. By late morning I am not building anything. I am answering doorbells.

A colleague of mine, Matthias Patzak, put words to this on LinkedIn before I did. He described being worn out in a way that surprised him, and he traced part of it to agentic AI: “It feels like all I do now is start AI jobs, wait for them to finish, start even more jobs in the meantime, and then get prompted by completed jobs to respond” [1]. He admitted to staring out the window between prompts just to let his breathing settle. The replies under his post were a small chorus of the same exhaustion. One described checking a second agent while waiting for the first, then a third in a browser tab, then chatting with a voice assistant “to avoid any kind of mental downtime.”

I left a comment on that thread, and it turned into a two-week experiment. This post is what came out of it. Matthias recently followed up with the Columbo image, which is the cleaner metaphor I wish I had reached for first.

Comic-style illustration of a rumpled detective in a trench coat, leaning against a doorframe, half-turned, finger raised: One more thing...

‘One more thing…’ — the move that cracks the case and ruins your focus.

The Problem Is Not Parallelism

It is tempting to conclude that the answer is fewer agents. I do not think that is right. Parallelism is the whole point. Running work in parallel is how you get real output out of these tools in the first place.

The problem is a specific kind of parallelism: interactive parallelism. Parallel work that can demand your attention at any moment. When every agent holds a live channel to you, you become the scheduler. You are the one being interrupted, context-switched, and drained, while the agents sit idle waiting for a human to unblock them.

This is not just a personal anecdote. The pattern has a name now. Built In has been documenting what it calls “AI brain fry” — a cognitive overload that developers hit from switching between agents, “which leads to errors and decision fatigue” [2]. The shape of the complaint is consistent across people who have never met each other. Four agents, four open questions, one tired human by mid-morning.

So the reframe I have been testing is small but it changes everything downstream: stop scheduling attention by interruption, and start scheduling it on purpose.

You Are Not a Monitor. You Are a Team Lead.

Here is the mental shift. When you manage people, you do not sit and watch each person work, ready to answer the instant they look up. That would be exhausting for everyone and insulting to them. Instead you run a structure. There is a standup in the morning. You delegate work with enough context that it can run without you. You hold office hours or a review window for the things that genuinely need you. You reconvene at the end.

Good management of people is mostly about when attention happens, not how much. The same structure, borrowed wholesale, turns out to be a decent operating model for agents. The analogy is narrow on purpose: it borrows the timing of a manager’s attention, not the notion that agents have feelings or a career to nurture. The unavoidable human-in-the-loop moments get batched into ceremonies instead of scattered as random interruptions.

I landed on four ceremonies.

Flowchart of the ideal day: morning standup, plan and delegate, headless background tasks, office hours for blockers, evening collection, looping back to the next morning

The ideal day as a loop. Headless tasks (green) run silently; blocked work parks for office hours, then everything reconvenes at the evening collection.

Morning standup

Before I plan anything, a short headless run renders a status board: what finished overnight, what is still running, what is blocked on me. One line each, like an async standup in a team channel. I read it in two minutes and decide what to unblock.

Grooming

This is the most important ceremony, and the one that requires the most investment from you. That is the point. The better you groom a task — defining what done looks like, what it can touch, what is out of scope, what sources to use — the more likely it results in a long, uninterrupted headless run that comes back with high-quality output. Poorly groomed tasks come back fast, but they come back wrong, or they interrupt you with questions. Grooming moves the effort to the front of the day so the rest of the day stays quiet.

In practice this is a short interactive session, and interactivity is appropriate here, because I am thinking, not monitoring. I pick priorities and then delegate: drop well-specified tasks into a queue with enough context that they should not need me before they finish. “Well planned to not be needed immediately,” as I put it in that original comment.

Office hours

A fixed window where blocked or finished agents get my attention in batch. Instead of eight agents pinging across the day, their questions accumulate and I clear them in one focused pass.

Evening collection

At the end of the day, everything gets reconstructed into a record: what ran, how long, what it produced, and a swim-lane view of where the time actually went. This part I already had, from an evening routine I built earlier.

What Actually Works (Twelve Days In)

I have been running some version of this for twelve days. I want to be precise about what holds up, because the honest answer is “the headless half.”

Headless delegation works. When I specify a task well enough and hand it to a background run, it comes back done without ever interrupting me. That is the single biggest relief. The agent that does not hold a live channel to me cannot turn around at the door.

Grooming before launching works. I started writing a short definition-of-ready for each delegated task — what done looks like, what it is allowed to touch, what is out of scope — before firing it. The tasks I groomed came back clean far more often than the ones I fired in a hurry. Specifying well moves the effort to the front, but it removes the mid-run doorbell.

The review ceremony works. Letting finished work pile up and reviewing it in one batch, rather than the instant each agent finishes, protects the focused blocks in between.

And the evening swim-lane works as a mirror. For the first time I can look at a day and see why I was tired. Here is a representative day. The data is illustrative, not a real log:

Swim-lane timeline of a representative day with a Headless lane showing a few long task bars and an Interactive lane showing many short scattered blips

A representative day (illustrative). A few long headless tasks up top; a scatter of short interactive interruptions below — the Columbo tax.

The top lane is what I want more of: a few long headless tasks running quietly on their own. The bottom lane is the problem: a scatter of short interactive blips all day long. Each one is small. Together they are the Columbo tax.

What Does Not Work Yet

This is the part I would skip if I were trying to sell you something. I am not.

The office-hours boundary does not hold. I declared windows for batching agent questions. In practice, when an agent stops and asks, I answer it, because the work is in front of me and the question is cheap. The boundary that was supposed to protect my focus turns out to be the easiest thing in the world to step over.

Agents do not batch their own questions. A good coworker who has three small uncertainties will save them up and ask you once. My agents ask the moment they hit the first one, then again at the second, then the third. Three doorbells where one would do. Nothing in my setup yet teaches them to hold a question and accumulate.

Small tasks still dominate the interactive lane. The big, well-specified delegations run headless and behave. It is the long tail of two-minute “can you just” requests that I keep handling live, because spinning up a delegation for them feels heavier than just doing it. So the interactive lane stays busy, and the fatigue does not drop as much as the headless wins suggest it should.

Batching also has a cost of its own. A task that parks for the next office-hours window can sit idle for hours. For most work that is a fine trade: protected focus in exchange for some latency. For the genuinely urgent thing it is worse than just being interrupted, which means a real version of this needs an exception lane that still pings live. I have not drawn that lane properly yet.

If I were tracking this on a board, it would look something like the mock below: a few tasks behaving well, a couple still parked on me. The labels are fictional.

Mock agent task board with five fictional tasks color-coded by state: two done headless, one running, one needs input, one handled live

A mock task board. Large work runs headless and clears; small work stays parked on me. All labels are fictional.

The pattern is clear enough to name. I have moved the large work to a healthy model. The small work is still Columbo, and small work is most of the day.

The Field Is Converging on This

The encouraging part is that I am not out on a limb. While I was assembling ceremonies out of duct tape, the tooling world has been naming the same ideas.

LangChain coined the term “ambient agents” for agents that “respond to ambient signals and demand user input only when they detect important opportunities or require feedback. Rather than forcing users into new chat windows, these agents help save your attention for when it matters most” [3]. The companion idea is an “agent inbox”: a single queue where multiple background agents leave their interrupts — questions, approvals, edits — for a human to triage in batch [4]. That is my office-hours ceremony and my missing “batch your questions” mechanism, described as a product instead of a habit.

The management metaphor is converging too. Addy Osmani describes the most productive developers as “coordinating multiple agents running asynchronously” while orchestrating from above, treating the codebase as a canvas rather than a conversation thread [5]. Different domain, same shape: lead the work, do not babysit it.

So the gap between where I am and where the tools are going is not conceptual. The concepts are settled. The gap is that a good agent inbox would hold and batch the small interruptions for me, and I am still doing that part by hand, badly.

Partway From Columbo to Coworker

Here is the honest scorecard. The management frame is the right one; treating this as a tooling problem alone misses where the fatigue comes from. The headless ceremonies deliver real relief for big, well-specified work. And the day is now visible to me in a way it was not before, which is the precondition for fixing anything.

But the title is a journey, not a destination. My agents are a good junior coworker on the work I delegate well, and they are still Lieutenant Columbo on everything else. The boundary I most need — the one that holds the small questions until a window opens — is exactly the one I have not built and cannot reliably keep by willpower.

I think that boundary is the next real piece of work, and I suspect the answer is partly a tool (a queue that holds interrupts) and partly a discipline (delegating the small stuff instead of absorbing it). I will keep the swim-lane running and find out.

How are you handling this? If you run several agents a day, has anything actually held the line on the small interruptions, or are you, like me, still answering the door every time one turns around?

Sources

Stefan Christoph

About the Author

Stefan Christoph is a Principal Solutions Architect at AWS, focused on agentic AI, media & entertainment, and helping builders move from demo to production. He writes about AI architecture, developer productivity, and the future of software.

This is a personal blog. Opinions expressed here are my own and do not represent the views or positions of my employer.

Learn more →

❤️ Created with the support of AI (Kiro)