Decision guides

One LLM call, or an agent?

Four questions about your task, and a clear answer about how much machinery it actually needs.

"Agent" is the exciting word, so people build one for problems that a single prompt would solve. The honest default is to reach for the simplest thing that works: a single call, then a fixed chain, and only then an agent that drives itself. An agent is powerful but costs you speed, money, and predictability — don't pay for autonomy the task doesn't need.

Are the steps the same every time, or do they depend on the input?

The same every time (e.g. read → summarize → answer)They depend on what each input turns out to need

Does it need to take actions, or just produce an answer?

Just produce text or structured output from what it's givenIt needs to call tools or take actions (search, code, APIs)

Is one pass enough, or does it need to check its work and keep going?

One pass is enoughIt needs to try, check the result, and keep going until it's done

How much do speed, cost, and predictability matter here?

Less — background or low-volume work; some unpredictability is fineA lot — user-facing or high-volume; it must be fast and predictable

Answer every question to see your recommendation.

All options at a glance

A single LLM call

One well-structured prompt in, one answer out. No orchestration, no tools, no loop. It's the fastest, cheapest, and most predictable option — and it covers far more cases than people expect.

Choose this when

The job is to turn input into text or structured output
One pass is enough and it doesn't need to act in the world
You want it fast, cheap, and easy to evaluate

Trade-offs

Can't fetch fresh information or take actions on its own
Very long or multi-part jobs may need to be broken into steps

A fixed chain or workflow

A sequence you lay out yourself: a few calls and tool steps wired together in a fixed order. The model does the sub-tasks; you stay in control of the flow. You get tool use and multiple steps without handing the wheel to the model.

Choose this when

The steps are the same every time, but there's more than one
It needs a tool or two, in an order you can plan in advance
You want predictable cost and an easy path to test each step

Trade-offs

You design and maintain the flow yourself
If the steps really do vary per input, a fixed chain will fight you

An agent (let the model drive)

The model decides its own next step, calls tools, checks results, and keeps going until it's done. This is the right tool when the path genuinely can't be scripted ahead of time — but keep it on a short leash.

Choose this when

The steps depend on the input and can't be planned in advance
It needs to use tools and iterate until the result is right
The task is worth the extra cost and unpredictability

Trade-offs

Slower, pricier, and harder to predict than a fixed flow
Needs guardrails: a step limit, typed tools, and evals before it ships
Hardest to debug — isolate and test the tools before blaming the loop