The pitch for AI agents is that instead of coding a process, you describe a goal, give the model some tools, and let it work out the steps. In demonstrations this is genuinely impressive. In production it separates sharply into cases where it earns its place and cases where it is an unreliable reimplementation of something a workflow engine has done deterministically for twenty years.
The useful distinction is whether the sequence of steps is knowable in advance. If a process always goes validate, then enrich, then route, then notify, that is not an agent - it is a pipeline, and building it as one gives you predictable cost, comprehensible failures and a straightforward audit trail. Handing that same process to a model that decides each step at runtime buys nothing and costs you determinism. A great deal of what is currently labelled agentic is exactly this: a pipeline with unnecessary uncertainty inserted.
Agents earn their place when the path genuinely depends on what is discovered along the way, and the branching is too wide to enumerate. Investigating an alert, where each finding suggests what to check next. Researching a question across sources where the second search depends on the first result. Triaging an unstructured request where the right handling is not apparent until parts of it have been read. In these cases the alternative is not a cleaner pipeline - it is a human doing the same open-ended work.
The architecture that survives production is a hybrid. Deterministic orchestration around the outside - a real workflow engine handling state, retries, timeouts and recovery - with model-driven decisions at the specific points where judgement is needed. This gives you the flexibility where it matters and predictability everywhere else, and it means a failure mid-process can be resumed rather than restarted.
Three constraints belong in any agent system from the start. A hard step limit and cost ceiling per run, because an agent that loops is an agent generating an unbounded bill. Tool permissions scoped to exactly what the task requires, since an agent with broad write access is a system where a reasoning error becomes a data-integrity incident. And a human approval gate before anything consequential and irreversible - money moving, messages sent to customers, records deleted. The gate is not a lack of ambition; it is what makes the system deployable at all in most businesses.
Observability is harder here than in ordinary software and matters more. You need every run replayable: what the agent decided at each step, which tools it called with which arguments, and what came back. Without that, a wrong outcome is uninvestigable, and uninvestigable failures are how a promising pilot quietly loses the confidence of the people meant to rely on it.
The question we would ask before building one: if you removed the autonomy and wrote the steps out explicitly, would the system be measurably worse at the thing you actually care about? If it would be roughly as good, build the pipeline - it will be cheaper, faster and easier to trust. If it would be genuinely worse because the real work is deciding what to do next, then an agent is the right tool, and the constraints above are what make it survivable.
