The word agent is doing heavy lifting in this year's procurement decks. Underneath it, two very different systems are being sold. A workflow follows a path someone designed: the LLM reads, classifies, extracts, or drafts at fixed points, and the sequence never changes. An agent chooses its own next action: it decides what to look at, which tool to call, and when it is done. Most of the successful agent deployments we have shipped are, honestly, workflows with agency in one or two places where the path genuinely cannot be known in advance. That is not a confession. It is the design principle that separates the systems still running in production from the demos that got quietly retired.
Agency is a cost, not a feature. Buy it only where the path cannot be known in advance.
The test that settles it
Ask the person who does the job today to draw the flowchart. If they can enumerate the steps, the branches, and the finish line, you are building a workflow, and an LLM makes individual boxes smarter: reading a bank statement, scoring a support ticket against a rubric, drafting the summary a human signs off. If they answer it depends, and what it depends on only emerges while doing the work, you are in agent territory. An insurance support QA system we built looks impressively agentic from the outside, yet its evaluation rubric is fixed: that is a workflow with LLM judgment at the nodes, and it is reliable precisely because of that shape. A travel concierge that plans and books multi-leg trips through live conversation is the opposite case: the user reshapes the goal mid-flight, so the system must decide its own next step. That one earned its agency.
Where agency actually earns its cost
- Open-ended discovery: research tasks where each finding decides what to examine next, the way competitive intelligence drills from a market scan into specific evidence. No flowchart survives contact with that.
- Conversational goal refinement: when the objective itself changes as the user talks, a scripted flow either rails the user or collapses. Itinerary planning and complex quoting live here.
- Cross-system orchestration with unknowable sequence: when which system to touch next depends on what the last one returned, enumeration explodes and delegation wins.
- Exception handling above a complexity floor: the happy path stays a workflow; a bounded agent works the long tail of weird cases and escalates what it cannot resolve.
What production agency requires
The gap between an agent demo and an agent in production is a list of unglamorous engineering, and skipping any item on it is how agents end up in the news:
- A bounded action space: an allowlist of typed tools the agent may call, not a browser and good intentions. What the agent cannot do is the most important part of its design.
- Human gates on irreversible actions: anything that books, pays, sends, or deletes goes through confirmation, with the agent preparing the action and a person or policy releasing it.
- Trajectory evaluation: scoring the path the agent took, not just its final answer, against a golden set of tasks. An agent that reaches right answers through fragile paths fails silently the day the environment shifts.
- Per-step observability: every tool call, input, and decision in an audit trail. When an agent misbehaves, replaying the trajectory is the difference between a fix and a shrug.
- Cost and latency budgets with kill switches: agents that loop are agents that burn money. Budgets per task, enforced in the runtime, not in the postmortem.
- Guardrails at both ends: input screening before the agent reasons, output validation before anything leaves the system. The agent is a component, not a trust boundary.
The architecture that keeps you sane
The pattern that survives production is a planner with specialists: a coordinating layer that decomposes the goal and routes to narrow agents, each with a small tool set and a clear contract, connected by deterministic glue. We wrote about why a single do-everything agent hits a ceiling as scope grows; the summary is that specialisation is as useful for agents as it is for people. Two more habits pay for themselves: externalise state, so a crashed run resumes instead of restarting, and give every agentic branch a workflow fallback, so when confidence drops the system degrades to the scripted path rather than improvising. And almost every enterprise agent stands on retrieval: if the knowledge it acts on is wrong, nothing downstream matters, which is why the knowledge base is its own build, not a footnote to the agent.
A build sequence that avoids the demo trap
- Draw the flowchart with the people who do the work, and mark the branches they genuinely cannot enumerate. Those marks are your agency budget; everything else is workflow.
- Ship the workflow version first. It delivers value in weeks, and its metrics become the baseline any agency must beat.
- Add agency to one marked branch, behind the same evaluation gates: a golden task set, trajectory scoring, and a fallback to the scripted path.
- Harden before you widen: guardrails, audit trails, budgets, and human gates on anything irreversible, while the blast radius is still one branch.
- Expand on evidence. Each new branch earns agency by the baseline it beats, not by the roadmap slide it appeared on. A working first system on this sequence fits inside a 6 to 12 week build.
The teams disappointed by agents this year mostly bought agency everywhere and reliability nowhere. The teams compounding value bought it surgically, in the two or three places their process genuinely cannot be scripted, on top of a boring, observable workflow. That is less exciting than an autonomous everything-machine, and it is why it works. It is also how we scope AI consulting engagements: flowchart first, agency where it earns its keep, and evaluation gates the whole way down.
