Should You Even Build an Agent? A Feasibility Framework

Gartner expects more than 40% of agentic AI projects to be canceled by the end of 2027. When you read the post-mortems, the cause is rarely the model and rarely the framework. It's that the problem was never agent-shaped to begin with. Someone had a hammer that could reason, and everything started looking like a nail.

So before any architecture diagram, the highest-leverage skill in this entire field is triage — looking at a problem and knowing whether it wants an agent, a workflow, a single model call, or just some boring deterministic code. This post is a framework for that decision. By the end you should be able to say 'no, use a workflow' with the same confidence as 'yes, build the agent' — and to defend either with numbers.

First, resist the jump to agents

There's a spectrum of automation, and agents sit at the far, expensive end. Most problems are solved better — cheaper, faster, more reliably — somewhere to the left. The instinct to reach straight for a multi-agent system is the source of most wasted budgets.

Anthropic's guidance on building effective agents makes the same point bluntly: find the simplest solution possible, and only increase complexity when it demonstrably improves outcomes. A single well-prompted LLM call with retrieval solves a startling fraction of 'we need an agent' requests. The agent is the answer only when the path itself is unpredictable.

The core trade: determinism for flexibility

Here's the one sentence to anchor on: an agent trades determinism for flexibility. A workflow does the same thing every time — predictable, debuggable, cheap. An agent decides what to do at runtime — flexible enough to handle messy, open-ended tasks, but harder to predict, test, and bound. You take that trade only when the flexibility is worth more than the determinism you're giving up.

That single trade explains the whole feasibility question. If a problem has a knowable, fixed path, paying for an agent's flexibility is pure waste — you bought unpredictability you didn't need. If the path genuinely varies per input and can't be enumerated in advance, a rigid workflow will keep falling off the edges, and the agent's flexibility earns its cost. Two dimensions decide it.

The candidate scorecard

The 2×2 gives you intuition; this gives you a checklist. A problem is a genuine agent candidate when most of these are true at once. Toggle them and watch the verdict move — and notice how quickly 'it would be cool' collapses into 'use a workflow' when the signals aren't there.

Two of these signals deserve special weight. 'There's a way to verify the output' is close to a hard requirement — an agent you can't check is an agent you can't trust at scale, because you'll never know when it quietly went wrong. And 'wrong answers are recoverable' is what keeps you out of the danger zone: an agent acting irreversibly with no review is a risk, not a feature, no matter how capable it is.

When the answer is just 'no'

Saying no here isn't pessimism — it's what makes the yeses credible. A team that has a clear list of things agents are bad at is a team you can trust when they say a particular problem is a fit.

The ROI math nobody runs until it's too late

A use case can be perfectly agent-shaped and still lose money at scale. Feasibility isn't just 'can an agent do this?' — it's 'does it pay?' once you multiply by volume. The economics are simple enough to put in a calculator, and sobering enough that most teams should run it before the build, not after the invoice.

Notice what the calculator teaches: at low volume almost anything pencils out, which is why pilots look great. At high volume, two things dominate — your cost per task (driven by model choice, steps, and retries) and your success rate (because failures are tasks you paid for and have to redo or escalate). A pilot that looked profitable at 500 tasks a month can invert at 200,000.

The accuracy trap that ambushes you at scale

Here's the one that ambushes good teams. A single step that's 95% accurate sounds excellent. But agents chain steps, and accuracy compounds — multiplies — down the chain. Ten steps at 95% each isn't 95%; it's 0.95 to the tenth power, about 60%. The model didn't get worse. The chain did.

Where agents actually win at scale

None of this is an argument against agents — it's an argument for aiming them well. When the math works, agents win in three recognizable ways: they augment expensive human experts (drafting, research, triage that a person then approves), they deliver consistency at a volume humans can't sustain, and they unlock tasks that were simply uneconomical to do by hand at all. The common thread is that the value per task is high enough, and the work variable enough, that flexibility beats a script.

And the smart way to get there is not to bet the company on full autonomy on day one. It's to climb a ladder.

The whole framework in one decision

Put it together and the feasibility question collapses into a short walk: Is the path fixed? Can you verify the output? Is the task worth the cost? Answer those honestly and the recommendation falls out — often it's 'use a workflow', sometimes it's 'not yet', and exactly when it should be, it's 'build the agent'.

Agentic AI is genuinely transformative for the problems it fits — and a money pit for the ones it doesn't. The framework above won't pick the problem for you, but it will stop you from building the agent you'll regret. In a field where 40% of projects get canceled, knowing which 60% to start is most of the battle.