Agentic workflows: the patterns that actually ship

“Agentic workflow” has become a catch-all for anything where an LLM does more than answer a single prompt. That vagueness is expensive, because the word “agentic” hides the one decision that determines whether the system is reliable: how much of it decides its own next step at runtime, versus how much you decided in advance. Get that call right and these systems are dependable. Get it wrong and you’ve built something impressive in a demo and unpredictable in production.

Workflow or agent: the distinction that governs everything

The clearest framing comes from Anthropic’s Building Effective Agents (December 2024). A workflow orchestrates LLM calls through predefined code paths: you wrote the flow, and the model fills in steps. An agent dynamically directs its own process, choosing tools and deciding what to do next as it runs. The difference is autonomy, and autonomy is a tradeoff, not an upgrade. A true agent handles open-ended problems you couldn’t script in advance. It also costs more, runs slower, and fails in ways that are harder to predict, because you handed control of the flow to the model.

The practical rule that falls out of this: use the least autonomy the problem needs. Most tasks people reach for an agent to solve are actually fixed sequences with some LLM judgment inside them, and a workflow does those more reliably and more cheaply. Reserve genuine agency for the cases that truly can’t be laid out ahead of time.

The five building blocks

Anthropic’s guide describes a small set of composable patterns that cover most real work. They’re worth knowing by name because almost every production system is some arrangement of them:

• Prompt chaining. Break a task into ordered steps where each LLM call works on the previous one’s output. Best when you can decompose the task cleanly and want to check the result at each stage.
• Routing. Classify an input, then send it to a handler specialized for that type. This is how you keep one bloated mega-prompt from trying to do five jobs badly.
• Parallelization. Run independent LLM calls at the same time and combine the results, either splitting a task into pieces or sampling several attempts and voting. Faster, and often more accurate.
• Orchestrator-workers. A central model breaks a task into subtasks at runtime and delegates them to worker calls. Use it when you can’t know the subtasks in advance, but the shape of the work is predictable.
• Evaluator-optimizer. One call generates, another critiques against criteria, and the loop repeats until the output passes. Powerful when you have a clear quality bar and iteration genuinely helps.

Notice that four of the five are workflows. Only the parts where the model decides the structure at runtime are meaningfully agentic. Most production “agentic” systems are mostly these deterministic patterns with a small autonomous core.

What actually breaks in production

The patterns are the easy part. The reasons these systems fail in the wild are consistent, and none of them are about which framework you chose.

No stopping condition. An agent that can loop needs a hard cap on iterations and spend. Without one, a single bad input turns into a runaway that burns tokens until someone notices the bill. This is the first guardrail to build, not the last.

Weak tools. An agentic workflow is only as good as the tools it can call and how well they’re described. Vague tool definitions, tools that fail silently, tools that don’t return useful errors: these cause far more production incidents than model quality does. Most of the engineering in a reliable system is in the tools, not the orchestration.

No observability. When a multi-step flow produces a wrong answer, you have to reconstruct every step to find out why. If you didn’t log the intermediate decisions, you’re debugging blind. Log the full trace from day one.

Non-determinism where you didn’t want it. Handing the model control of a step that could have been ordinary code trades reliability for flexibility you didn’t need. Every step that doesn’t require judgment should be code, not a prompt.

Where the line sits in practice

Running our own multi-agent platform, Vibehub, taught us the unglamorous version of all this. The reliable parts are overwhelmingly deterministic workflow: routing, chained steps, parallel calls, with hard limits and full tracing. The genuinely agentic core is small and tightly guarded, used only where a task truly can’t be scripted ahead of time. That’s not a limitation, it’s the design. The systems that hold up in production are mostly workflow with a little agency, not the reverse.

This shapes how we build. Our AI agent development work starts by pushing as much as possible into deterministic patterns and reserving autonomy for where it earns its cost, and our AI automation work applies the same building blocks to the repetitive processes that slow a team down. The framing to carry away: “agentic” isn’t a quality bar to aim for. It’s a cost to spend deliberately, on the specific steps that can’t be decided any other way.