Agent Use Cases

The question is whether the loop earns its cost

What are AI agents covers what an agent is. This page is narrower and more useful: which jobs are worth building one for, given that an agent costs roughly 4× the tokens of a chat interaction and a multi-agent system around 15×.

That multiple is the whole test. An agent is a model in a loop with tools, deciding its own next step. You are paying for the deciding. If the steps were knowable in advance, you bought something you did not need.

Four properties that make a task suitable

Run a candidate past these before building anything.

The path is not knowable up front. If you can draw the flowchart, write the flowchart. A task where step three depends on what step two found is the case an agent exists for; a task with three fixed steps is a script that costs less and whose failures are easier to read.

Success is checkable. The tests pass, the file parses, the invoice reconciles, the endpoint returns 200. An agent can iterate toward a target it can evaluate. Without one it cannot tell progress from motion, and it will stop when it runs out of budget rather than when it is done.

The action space is bounded. Every tool you expose is something the agent can do at three in the morning with no one watching. A read-only agent and an agent that can issue refunds are different risk propositions wearing the same architecture.

A wrong answer is survivable or catchable. Either the cost of an error is low, or something checks before it lands. An agent that drafts is safer than an agent that sends.

Tasks that have all four are worth the multiple. Tasks missing the second are where most disappointment comes from.

Where it works

Software tasks. The canonical fit, because it has all four properties naturally. Code either compiles or does not, tests either pass or do not, and the path through a bug is unknown until you look. Migrations, test writing, dependency upgrades and reproducing a reported failure are all shaped right.

Research and synthesis across many sources. Nobody knows in advance which sources will matter. This is also where parallel agents pay, since each can read in its own window and report back a condensed finding rather than the whole page. Multi-agent context sharing covers that shape and its price.

Triage over messy input. A support ticket, a log spike, an alert. The work is gathering enough to classify, and how much gathering is needed varies per case. Pair it with a human decision at the end and the error cost stays bounded.

Operations against an API surface. Reconciling records between two systems, chasing a discrepancy, filling gaps. Repetitive, tedious, checkable one at a time,, and irregular enough that nobody has automated it.

Where it does not

Anything with a fixed procedure. Extraction, classification, formatting, summarizing one document. One call, no loop. Reaching for an agent here buys latency and a new failure mode.

Work whose correctness only a person can judge. If nothing but taste settles whether the output is right, the loop has no signal and iteration adds nothing but cost. Better to produce one draft and put it in front of the person.

Anything where being wrong is expensive and nothing checks. Payments, irreversible writes, outbound communication to customers. An agent can do it. The problem is that the shape leaves you nowhere to catch the case it gets wrong.

High-volume, latency-sensitive paths. A loop has unpredictable duration by construction. Something in a request path with a budget of a few hundred milliseconds is the wrong home for it.

Start with the smallest version

The failure pattern in adoption is scope, not capability. A first agent with twelve tools and an open-ended objective fails in a way nobody can diagnose, because too many things are varying.

Start with one that has two or three tools, a task you can check, and a hard cap on iterations. Read the traces. Most of what you learn will be that the task description was vaguer than you thought, which is the cheapest possible lesson at that scale.

Further reading

• What are AI agents: the definition, and the loop.
• Multi-agent context sharing: the token multiples, and when several windows beat one.
• Multi-agent systems: the shapes available once a task qualifies.
• Context failure modes: how a long-running loop degrades.