When Not to Use an Agent

There's a specific kind of waste that comes from putting an agent on a task that didn't need one. It isn't dramatic — the agent mostly works, the outputs are mostly fine, and the whole thing quietly costs more attention than the manual version did.

Three options exist for any recurring task: a person does it, a rule does it, or an agent does it. Agents get chosen by default at the moment because they're the interesting one, and for a meaningful share of tasks they're the worst of the three.

When a rule is better

If the task is deterministic — same input shape, same steps, same correct answer every time — a rule beats an agent on every dimension that matters. It's faster, free, auditable, and it fails loudly.

An agent doing deterministic work introduces variance into something that had none. Occasionally it will do it slightly differently, and you'll never know which time, because nothing flags a run that was a bit unusual.

The test: could you write down the steps precisely enough that a new starter would get an identical result? Then it's a rule. Filters, templates, and scheduled exports are unglamorous and they don't drift.

When a person is better

When the judgement is the task. If the work is deciding rather than producing, an agent produces a well-formatted version of a decision it wasn't equipped to make. Prioritisation, whether a concern has substance, what a stakeholder actually meant.

When the relationship is part of the output. Some messages are worse for having been produced efficiently, and the recipient can tell. Condolences, difficult feedback, an apology to a client who's already annoyed.

When you can't hand over the context. If the necessary background is confidential, or about a specific person, or lives in conversations that were never written down, the agent is working from a materially incomplete picture. That's a reason to keep the task, not a problem to route around.

When the supervision costs more than the task

The one people miss. An agent that takes three minutes to run and eight minutes to verify has not saved anyone anything, and it's added a review job to someone's day.

Run the arithmetic honestly on a task you've automated: agent time plus your verification time plus the occasional rerun, against what doing it yourself takes. Anything requiring near-full review of every output is a candidate for going back to manual — not because the agent is bad, but because the verification is the expensive part and you haven't removed it.

When you'd never find out it was wrong

Silent failure is the strongest single reason not to use an agent. If the task produces output nobody checks against reality — an internal metric, a categorisation feeding a dashboard, a summary read by people with no way to notice omissions — then errors accumulate invisibly, and confidence grows precisely because nothing has visibly gone wrong.

Either add a check that would catch it, or don't hand the task over. "It's been fine for months" is not evidence when the failure mode is undetectable.

When it's a one-off

Setting up an agent well — brief, permissions, checkpoints, a couple of validation runs — is an hour or two. That pays back on the tenth run and never on the first.

For a one-off, use AI directly and keep your hands on it. The agent framing adds ceremony to something you were going to supervise closely anyway.

Chidi — the task that went back to manual

Chidi manages a small legal ops team. He'd set up an agent to categorise incoming contracts by type and risk level — a plausible task with clear categories.

Six weeks in he ran the numbers. Roughly two minutes per contract of agent time, and six to eight minutes of checking, because the risk categorisation was consequential enough that nobody was willing to sample rather than review. Doing it manually had taken five minutes.

He kept the agent for extracting dates and parties, where checking is a glance, and gave the risk call back to a person. His summary: the agent was doing the easy half and creating work in the hard half.

Elin — the dashboard nobody could check

Elin is a customer insight lead at a subscription business. An agent tagged support conversations by theme, feeding a dashboard the leadership team used to prioritise.

Nothing ever looked wrong, which was the problem — there was no ground truth anywhere. If the tagging drifted, the dashboard would still look like a dashboard.

She added a monthly check: fifty conversations tagged by hand and compared. The first month showed a real drift on one theme that had been quietly shrinking for a quarter. Her rule now is that no agent output feeds a decision unless something, somewhere, would notice it being wrong.

The one thing

Agents are one of three options and get picked by default. Use a rule when the task is deterministic, a person when the judgement is the work or the context can't be handed over.

And don't use an agent when the verification costs more than the task, or when nothing anywhere would tell you it had gone wrong.