The Use Cases Agents Genuinely Solve Today

Separating what works now from what demos well is easier with a criterion than with a list. The criterion: complete inputs, a mechanical check, and bounded blast radius. Applications with all three are working in production; applications missing one are the ones that stall after the pilot.

Here's what currently clears the bar.

Working reliably now

Code implementation from a clear specification, with tests. Inputs complete, oracle strong, blast radius bounded by review. The flagship case, and it works.

Mechanical code migration at scale. Framework upgrades, API renames, logging swaps. Verifiable per file, parallelizable, and the alternative is weeks of tedium.

Structured extraction from documents. Invoices, forms, contracts into schemas. Constrained output, mechanically validatable, quoted-span verifiable against the source.

Classification and routing into a closed set. High volume, cheap, checkable against outcomes.

First-line support for documented questions. Bounded, escalatable, and the failure mode is a handoff rather than a harm — provided the handoff carries the conversation.

Research briefing with sourced claims. Gathering and synthesizing with every claim tied to a quoted span. The quote requirement is what makes it trustworthy; without it, it's the confidently-wrong-citation problem.

Test generation from a contract, validated by mutation.

Log and trace investigation. Correlating across sources, forming hypotheses, narrowing. Read-only, fast, and it compresses the tedious opening of every incident.

Internal tooling that was never worth an engineer's week. ✅ Quietly one of the largest sources of realized value, and the least discussed — the long tail of scripts and dashboards that now cost an hour.

Working with a human gate

Genuinely useful, not autonomous:

• Code review as a first pass, with humans deciding
• Drafting communications for review
• Data cleaning proposals with a quarantine list
• Incident investigation, with remediation left to a person
• Prioritization input — options and trade-offs enumerated, choice made by someone

⚠️ Not working reliably yet

• Autonomous multi-step work in unfamiliar systems, where each step's error compounds.
• Anything requiring unwritten organizational context as the deciding input.
• Open-ended investigation with no reproduction. Produces plausible causes that aren't the cause.
• Judgment calls with no oracle — what to build, what's worth fixing.
• Anything where a wrong action is expensive and undetectable.
• Long autonomous runs without checkpoints, where the reliability arithmetic works against you.

💡 The pattern in what works

Every reliable application shares the same shape: the agent does the doing, a mechanical check catches the mistakes, and a human decides what should be done.

That's not a temporary arrangement pending better models — it's a division that follows from where oracles exist and where context lives. Applications that respect it work now; applications that skip a part are the ones stuck in pilot.

🔍 Evaluating your own candidate

Four questions:

1. Are the inputs complete in artifacts a machine can read?
2. Is there a check — or can you build one?
3. What's the blast radius of a wrong action, and is it bounded?
4. Can you tell whether the output is right, cheaply, at volume?

Four yes answers means it probably works today. A no on question two is often fixable — building the oracle is engineering. A no on question one is a context-capture problem. A no on three is a permissions problem. A no on four means you can't operate it regardless of how well it works.

The takeaway

What works today is code from specifications, mechanical migration, structured extraction, classification, first-line support, sourced research, contract-based test generation, log investigation, and the long tail of internal tooling. All of them have complete inputs, a mechanical check, and bounded blast radius. Score your candidate on those three plus whether you can measure it — and where the answer is no, note that two of the four gaps are things you can build rather than wait for.