When Not to Agent

An agent is the right shape when:

• The path branches on observations you cannot hard-code
• Tools are real and permissioned
• You can tell what “done” looks like
• Failure has a budget and a handoff

An agent is the wrong shape when:

• The path is a fixed checklist (invoice: validate, tax, send)
• One search box plus a template email would do
• You cannot say what “done” looks like
• The only tool is “be clever in English”

A workflow skips optional steps in code. An agent that “might skip validation” is a bug with a marketing name. If a checklist, a form, or a search box will do, ship that. Agents are for branching work — and they sit next to the multiagent track, not instead of a script.

This is the last lesson of the loop track. You now have six parts, ReAct vs plan, reflection, typed state, HITL, jobs, traces, thrash, and handoff. Use them when the work branches. Do not use them as a status symbol.

Fixed paths are workflows

Validate, then tax, then send. Always. That is a workflow. Skip-validation is a flag in code, not a thought. The live box runs a list of step names. There is no model. There is no chance the thought forgets validate unless you set the flag.

Could you wrap that list in ReAct? Yes. Would the model skip validate on a Tuesday? Yes. That is not flexibility. That is a regression. Flexibility you want belongs in if skip_validation reviewed in git.

A checklist with no tools is also not an agent. It is a script. Adding a model to name the next checklist item is a fancy for loop with extra failure modes.

Branching work

Debug prod: logs might show OOM or disk or permissions. The next tool depends on the observation. You cannot hard-code a 20-step plan that stays true. ReAct (or plan-and-replan) earns its keep. Tools exist. Done can be “root cause string plus a cited log line.” Budget and handoff exist. That may be an agent.

If there are no tools, you have a chatbot. Templates and retrieval might still beat a loop. If you cannot describe done, you cannot stop except on budget — you will ship a furnace that talks.

Forms and search boxes

A refund form with order id and amount, plus policy in code, plus HITL, does not need a loop to fill itself. A search box over docs does not need ReAct to query once. Add an agent when the user intent is messy and tools must be sequenced in ways you cannot form-design. Sequence you can form-design should be a form.

Computer use on the accounting GUI to send invoices is the wrong costume for a fixed path. A swarm of invoice agents is the next track’s temptation. Both are in the quiz as traps.

Cheapest machine that works

Order of operations:

1. Script / workflow
2. Form + policy code
3. Search + template
4. Router + specialist + verifier (still one runtime)
5. Full ReAct or plan-and-execute loop
6. Multi-agent when specialists must talk (next track)

Skip to 5 because of a blog post and you will debug six parts you did not need. Evals and production serving come later; they do not make a workflow into an agent. They make an agent measurable and shippable if it should exist.

Skip validation is a flag

The invoice function takes skip_validation=False. Review that flag. Do not let a thought set it. If a model can skip validate, you did not have a workflow. You had an agent pretending to be finance.

You still need the loop skills

When you do need an agent, you now have the pieces: assembler budget, fail-closed parser, stop, ReAct, observe-before-finish, plans as data, grounded critic, typed state, machines, HITL freeze, jobs, checkpoints, breakers, traces, thrash, handoff. Missing any of them is how a justified agent still becomes a furnace.

When you do not need an agent, those skills still help: parsers fail closed on forms, jobs wait on email, traces debug workflows. The costume is optional. The discipline is not.

Branching vs messy vs “the model will skip it”

Branching means the observation picks the next tool in a way you cannot write as a fixed list: logs show OOM vs disk vs auth, and those three paths use different tools. Messy language (“this is busted”) is not enough by itself — a form with a category dropdown might still win. Use an agent when messy language and branching tools coincide, and you can name done.

“The model will skip optional steps we forgot to code” is not a feature. Optional steps belong in the workflow as flags or branches you wrote. If validation is optional for a class of invoices, skip_validation is reviewed. If it is never optional, the list is always three long. ReAct that skips tax because the thought was in a hurry is not agility.

No tools: a template, retrieval, or a single search box. A loop that only emits English is a chatbot with a step counter. No done predicate: you will only stop on budget, and then you will be tempted to guess. That is the furnace.

God-loop vs router: even when you need an agent, start with router + small specialist + verifier, not forty tools. Multi-agent is when those specialists must talk, not when you wanted a fancier invoice script.

If you are unsure, ship the workflow and log where humans branch. Those logs are how you learn whether a loop would help. Do not start the loop to discover the branches in production money paths.

Common mistakes

• ReAct over a fixed checklist.
• Agent with no tools.
• Agent with no done predicate.
• Skip validate via thought.
• Swarm as the first architecture.
• Computer use on a stable GUI flow.

Run to execute this in your browser. Nothing is sent to a server.

Invoice is a workflow. Skip-validation is a flag in code, not a thought. Debug-prod with tools and a way to score done may be an agent. No tools, or no done predicate, should not. Read the six prints: three-step list, two-step list, then four tuples of False/True with reasons. The True is debug prod with logs and finish.

has_eval here means “you can say what done looks like,” not the later eval track. A predicate in should_stop counts. A vibe does not.

How agents use this

Ship the cheapest machine that works. If you still need an agent, you now have the six parts, ReAct vs plan, reflection, typed state, HITL, jobs, and traces.

Next track: multiagent — when specialists must talk to each other, not when you wanted a fancier loop.