Choose workflows where determinism is cheap, agents where it's expensive

The workflow-versus-agent question gets treated as a technology choice. It's an economics question. If you can enumerate the paths through a task in advance, a deterministic workflow is cheaper to run, cheaper to test, and cheaper to audit — full stop. Agent autonomy is what you buy when enumeration itself becomes the expensive part. Spend it there and nowhere else.

The distinction underneath is who owns control flow. In Anthropic's taxonomy, prompt chaining, routing, parallelization, orchestrator-workers, and evaluator-optimizer are all workflows: the developer wrote the graph, and LLM calls fill in the nodes. An agent is the case where the model directs its own control flow — it decides, step by step, what happens next. That single difference determines which engineering tradition you inherit.

What determinism buys you

A workflow inherits two decades of distributed-systems machinery essentially for free. The durable-execution ecosystem — Temporal, Hatchet, Inngest, Restate — gives you deterministic replay from state snapshots, exactly-once step semantics via idempotency keys, dead-letter queues with exponential backoff, and a step-executions audit table recording every attempt. You can write a test that asserts the graph's behavior. You can show an auditor exactly which branch fired and why. You can distinguish transient from permanent failures per step and retry mechanically. All of this exists because the path was enumerable; the tooling is a dividend paid on determinism.

The cost asymmetry shows up at the individual decision, too. A decision-tree router resolves in about a millisecond; LLM-driven routing runs around 500ms and costs tokens on every call. Tiered dispatch — a fast classifier for high-confidence cases, the LLM only for ambiguous ones — cuts mean routing latency 5–10× precisely because most decisions in most business processes are enumerable. Every step you can write down is a step you stop paying a model to improvise.

So when do you buy autonomy? When the branching factor defeats you. Open-ended debugging, research synthesis, tasks where the next step genuinely depends on what the last step uncovered — writing the decision tree for these means enumerating a combinatorial space, and the tree is stale the day you finish it. At that point, supervising an agent's judgment (budgets, stopping conditions, review gates) is cheaper than encoding the judgment yourself. The bar should be explicit: one decision framework I keep returning to demands a 15–25% improvement on the KPI before accepting multi-agent complexity over a simpler architecture. Autonomy has to pay rent.

Production systems are hybrids

The dichotomy is cleaner in blog posts than in systems. What actually ships is a deterministic workflow on the outside — auditable, replayable, signal-interruptible — with agents embedded inside bounded steps: "here is the failing test suite, you have this budget and these tools, return a diff." The workflow provides checkpoints and recovery; the agent provides judgment inside a step whose blast radius the workflow already bounded. Patterns like pause-replay-resume and mid-execution replanning even let the deterministic shell revise its own plan when an inner step surfaces new information — enumeration where it's cheap, judgment where it isn't, on the same run.

The honest complication: the boundary moves, and it moves in both directions. As models improve, supervision gets cheaper, and some paths you'd painstakingly enumerate today will be better left to an agent next year. And enumeration carries its own hidden cost — rule trees are brittle to intent combinations nobody foresaw, and a workflow that no longer matches reality fails confidently. So treat the workflow-agent split as a decision you revisit, not a doctrine. But revisit it with the ledger open: determinism's dividends are large, boring, and easy to forget until you're debugging an agent that improvised its way through a step a five-line DAG would have handled.