Agentic Workflows: The Power of Determinism

The industry is drunk on the dream of the fully autonomous agent. We imagine an AI that receives a vague goal—‘increase user engagement’—and navigates a complex world of codebases, APIs, and dashboards with brilliant, unpredictable intuition. We chase this ghost of general intelligence, hoping for magic.

But in production, magic is a liability. Magic is unpredictable, un-debuggable, and expensive. The ‘lazy’ agent that tries to commit with --no-verify isn’t a clever deviant; it’s a probabilistic system failing in a predictable way. The real work of building robust AI systems isn’t about conjuring ghosts. It’s about engineering reliability.

This is where we must draw a hard line between two concepts the industry often conflates: agents and workflows. Getting this distinction right is the difference between a flashy demo and a production-ready system.

Agents Explore. Workflows Execute.

The term ‘agentic’ has become a catch-all for any system where an LLM does more than just chat. This is a sloppy definition that hides a critical architectural choice. Anthropic’s engineering team offers a much clearer distinction:

At Anthropic, we categorize all these variations as agentic systems, but draw an important architectural distinction between workflows and agents:

Workflows are systems where LLMs and tools are orchestrated through predefined code paths. Agents, on the other hand, are systems where LLMs dynamically direct their own processes and tool usage, maintaining control over how they accomplish tasks.

This is the most important definition in agentic AI today.

An agent is a probabilistic explorer. You give it a high-level goal, and it uses its reasoning engine to chart its own course. It decides which tools to use, in what order, based on the unfolding context. It is dynamic, creative, and fundamentally unpredictable.

An agentic workflow is a deterministic executor. We, the engineers, define the exact path of execution. The LLM is not the orchestrator; it is a powerful component within a larger, pre-defined structure. It operates as a sandboxed function, transforming data at a specific step in a pipeline we control.

The Deterministic Advantage

Consider the simple pipeline model:

# Data Source | AI Processor | Structured Output Parser
psql | claude --output-format=json | jq

This is the perfect agentic workflow. The path is fixed. psql runs, its output is piped to claude, whose output is piped to jq. The LLM has no freedom to decide to use mysql instead, or to write its output to a file, or to try to edit the jq command. Its role is strictly constrained: receive text on stdin, transform it according to its prompt, and write JSON to stdout.

This determinism is our advantage.

1. Reliability: You can test a workflow. You can reason about its failure modes. Its structure is static and inspectable. An agent’s ‘reasoning’ process is an opaque, non-deterministic black box. When it fails, you can only guess why.

2. Efficiency: Workflows are cheap. They execute a known sequence of steps without wasting tokens on ‘flailing’ or exploring dead ends. An agent might spend thousands of tokens deciding between ls, find, and grep, only to pick the wrong one. A workflow just executes the correct command because you already encoded that knowledge into the system.

3. Security: The LLM in a workflow is completely sandboxed. It can’t execute arbitrary commands or access unintended resources. It is a text-in, text-out utility. A free-wheeling agent, by its very nature, represents a massive and complex attack surface.

From Discovery to Production

This doesn’t mean autonomous agents are useless. They are incredibly powerful tools for discovery.

The ideal development cycle uses both:

1. Explore with an Agent: Point a highly-capable agent at a novel problem. Let it explore, experiment, and find a solution path. Watch how it uses tools, observe its failures, and learn from its successes. The agent is your scout, mapping unknown territory.
2. Codify into a Workflow: Once the agent discovers a repeatable, valuable process, we must extract it. We codify that sequence of steps into a deterministic script, a Go program, or a fixed pipeline. We replace the agent’s probabilistic reasoning with engineered logic, using the LLM only for the specific, creative transformation steps it excels at.

An agent might figure out that to analyze a prospect, it needs to query the CRM, then use Hunter.io, then format the result. That’s discovery. The production system is a workflow: a script that performs those three steps in that exact order, every single time.

This approach mirrors the ‘rule of three’ I discussed for shipping tool-builders: when an agent identifies a recurring pattern, it’s a signal to build a better, more permanent solution. That solution is an agentic workflow.

Build Workflows, Not Wishes

We are at a crossroads. We can continue chasing the fantasy of the all-powerful, autonomous agent, accepting the chaos and unreliability that comes with it. Or we can get serious about building the next generation of AI-powered software.

That means embracing constraints. It means valuing deterministic execution over probabilistic magic. It means treating the LLM not as a magical brain, but as the most powerful text-transformation component ever created.

Stop waiting for better agents. Start building better workflows.

Stop praying for magic. Start engineering for reliability.