Agentic AI vs. workflow automation: what's actually different

'Agentic AI' has become the default pitch for anything that involves more than one API call, and it's led to a specific, expensive failure mode: teams building an LLM agent with open-ended tool access for a task that a deterministic workflow engine, Airflow, Temporal, or even a plain state machine, would have handled more reliably, more cheaply, and with actual debuggability. The inverse mistake also happens, less often but just as expensively: forcing a rigid DAG onto a problem whose branching logic genuinely can't be enumerated in advance.

The structural difference: a workflow engine executes a graph of steps you defined in advance, where the branching logic is explicit and finite (if X then step A, else step B). An agentic system decides its own next step at runtime based on reasoning over the current state, which means the space of possible execution paths isn't fully enumerable ahead of time. That's the entire value proposition of agentic AI, handling genuinely open-ended branching, and it's also the entire cost, because a non-enumerable path space is structurally harder to test, harder to bound, and harder to debug when it goes wrong.

We were brought into an engagement where a client had built an 'agentic' customer-onboarding assistant: the agent decided, turn by turn, whether to collect a document, run a verification check, or escalate to a human. In practice, the onboarding flow had exactly six real paths through it, determined by two boolean facts about the customer known at the start of the conversation. The 'reasoning' the agent was doing at each turn was reconstructing logic that could have been a lookup table. Worse, because the agent's next-step decision was a fresh LLM call every turn, the flow occasionally took a path that wasn't one of the six valid ones, inventing a step that didn't exist in the actual compliance process. We replaced it with a Temporal workflow: the six real paths became six explicit branches, each step deterministic and independently testable, with an LLM call used only for the one genuinely unstructured step, parsing free-text answers into structured fields. Onboarding completion time dropped 40% and the 'the agent did something not in our compliance process' incident category went to zero, because that category of error was no longer structurally possible.

The opposite case: a client's internal support system routed engineering questions through a rigid ticket-classification DAG that had accumulated over 200 manually maintained branching rules, most of which existed to handle one specific historical edge case each. The maintenance burden was enormous, and new categories of question routinely fell through every branch into a generic 'unclassified' bucket that a human had to triage by hand. This was the actual agentic-shaped problem: the space of incoming questions wasn't enumerable, and the branching logic needed to reason about novel phrasing, not match against 200 accumulated regexes. We replaced the DAG with a LangGraph-based agent with access to a bounded set of tools (search the knowledge base, check system status, escalate to the right team) and explicit termination conditions. The 200-rule DAG became roughly 15 lines of tool definitions and a system prompt, unclassified-bucket volume dropped 85%, and adding a new question category no longer required a code change.

The decision test we actually use: can you draw the full set of paths through this task on a whiteboard in under ten minutes, with a defined end state for each? If yes, it's a workflow problem, and an agent will make it slower, more expensive per execution, and harder to debug than the DAG you should have built. If the branching genuinely depends on reasoning over unstructured input where the path space can't be enumerated in advance, that's the actual case for agentic reasoning, and it's worth pairing with the governance and guardrails work that bounded autonomy requires, since an agent with genuinely open-ended decision-making needs explicit tool permissioning, not just a good prompt.

The generalizable lesson: agentic AI's value is proportional to how genuinely unenumerable the task's branching logic is. Most 'agentic' features we're asked to build turn out to be workflows wearing an agent's clothing, and the fix is almost always a relief to the team maintaining it. Deterministic systems are boring to operate, and boring is exactly what you want for anything with a compliance or reliability requirement attached.