| TL;DR: Enterprises need both: right brain = agents (judgment, context, exception-handling) and left brain = workflows (deterministic, auditable execution). You also need a backbone to support them — Temporal provides durable orchestration (state, retries, audit history) so workflows run reliably and agents can safely operate over long-running, failure-prone processes. |
Why “agentic vs deterministic” is the wrong binary#
Enterprise teams are right to be cautious about “agentic” systems in regulated environments. Not because intelligence is unwelcome, but because mission‑critical transactions demand repeatability, auditability, and safe recovery when the real world misbehaves.
“Workflows offer predictability and consistency for well-defined tasks, whereas agents are the better option when flexibility and model-driven decision-making are needed at scale.” — Anthropic, Building Effective Agents
A common framing says: if an automation is agentic, it must be non‑deterministic—and if it’s non‑deterministic, it can’t be trusted with finance. That’s a false binary. Anthropic has been clear in its own guidance: there are parts of a process where flexible reasoning is valuable, and parts where only deterministic execution is acceptable. The winning architecture is hybrid — agents orchestrate and adapt, while deterministic systems execute the business steps that must be exact.
Deterministic code isn’t enough without durability#
The practical question is what you use as that deterministic execution layer. A script can be perfectly deterministic and still be unsafe in production if it isn’t durable. If a process crashes after posting a ledger entry but before initiating a payment, “just retry” can become “double charge.” If a container restarts mid‑flow, state can be lost. If an external API flakes, manual repair becomes routine. Determinism without durability is still a reliability risk.
Think of the everyday systems people already expect to be durable: a bank transfer shouldn’t happen twice because an app crashed; an online order shouldn’t disappear after payment; a hospital shouldn’t lose a patient’s treatment state during an outage; and a travel booking should resume correctly if one provider times out. In each case, the process must remember what has already happened, recover safely, and continue without duplicating critical actions.
Temporal as the execution layer agents can rely on#
This is where Temporal fits: it’s the backbone supporting both workflows and agents. It preserves execution state and manages retries so long-running business processes can continue when services fail or approvals take days.
Temporal supports these systems in two complementary perspectives:
1) Deterministic, reliable workflows for mission‑critical transactions#
Temporal gives teams a way to encode business processes as reusable workflows with predictable behavior — the “left brain” layer that ensures steps execute exactly. The workflow logic is designed to be repeatable and testable, while the backbone hardens execution for real production conditions (timeouts, retries, and clear boundaries around external calls). For regulated environments, this same structure supports strong operational controls: auditable execution history, enforceable approvals, and security boundaries that keep sensitive actions constrained to explicitly defined steps.
2) Durable orchestration for long‑running, multi‑turn agentic systems#
Agents are especially useful when a task requires interpreting intent or adapting to unexpected information. That work may span multiple interactions and long pauses, making reliability and continuity essential. Temporal (the backbone) makes agentic orchestration durable by persisting the workflow state outside the model. Instead of depending on an agent to “remember” everything in a context window, you can treat Temporal as the system of record for progress, decisions, and handoffs — so the agent can safely resume after restarts without losing critical context. Long-running tool calls, like batch jobs and large-file processing, are more exposed to timeouts and failures, so agent systems need to handle completion beyond a synchronous request–response cycle. Human delays also require durable state, so the agent can resume when input arrives rather than start over.
When you combine this with an agent, you get the best of both worlds.
OpenAI describes the same tradeoff in its guidance on agent orchestration:
“Orchestration refers to the flow of agents in your app. Which agents run, in what order, and how do they decide what happens next? … While orchestrating via LLM is powerful, orchestrating via code makes tasks more deterministic and predictable, in terms of speed, cost and performance.” — OpenAI Agents SDK, Agent orchestration (docs, repo)
The agent becomes the adaptive control plane. It can interpret intent (“pay these invoices,” “reconcile this batch,” “issue refunds for disputes”), pull in context, ask clarifying questions, and decide which business process should run. It can handle ambiguity, choose tools, and manage human checkpoints—approval flows, exception queues, and escalations—without forcing every edge case into a rigid decision tree.
Temporal Nexus connects agents and long-running business processes in both directions. An agent can invoke a business process—such as initiating a payment or fulfilling an order—and receive its result even when completion takes hours or days. Conversely, a business workflow can invoke an agent-backed service to assess an exception, interpret a document, or recommend the next action, then continue with explicit business logic. Nexus makes these interactions durable across team and namespace boundaries, allowing agents and workflows to call on each other through well-defined service contracts.
Once the agent has enough information—or reaches a point where human approval is required—it can start or signal a workflow to carry the process forward, from validation through payment and settlement.
Whether the process takes seconds, days, or months, Temporal’s durable execution preserves its state across every handoff and pause. Failures and unavailable services are handled with controlled retries and recovery, so progress is not lost and the intended result is eventually delivered without every participant having to manage that complexity. The “right brain” remains adaptive, the “left brain” remains dependable, and Temporal keeps them working together even when the real world misbehaves.
Enterprise reference architecture#
This diagram is a practical way to structure an enterprise-grade “hybrid agent” system so you get flexibility and control.
As the diagram above suggests, enterprises get the best outcomes when they separate agentic reasoning (“right brain”) from deterministic business execution (“left brain”) — and use Temporal as the backbone supporting both.
But a brain needs a body to turn intent into action. Domain services and third-party systems provide the hands and feet—moving money, checking identities, and fulfilling orders. Temporal coordinates this execution, preserving workflow state, managing retries, and helping each step recover safely when a service fails. Temporal Nexus provides the durable hand-off between agents and long-running business processes: an agent can start a process and receive its result even hours or days later, while a workflow can call an agent-backed service and continue when it responds.
This builds on well-established distributed-systems principles, applied to modern, multi-turn agentic applications. In real enterprises, the happy path is never the only path: services fail, dependencies throttle, people take time to approve, and deployments happen mid-run. Agents can own the thinking—intent, routing, and exception handling—while workflows own the logic—explicit business steps. Temporal preserves the truth of execution: progress, state, and audit history. Together, Temporal and Nexus make those hand-offs durable, so the system can resume reliably when the agent restarts or a workflow spans hours or days.
Example: an accounts payable payment run#
A concrete example is an accounts payable payment run. The agent can review inbound invoices, flag anomalies, and draft a proposed batch for approval. After approval, it calls a tool to execute the transaction steps and monitor settlement, backed by a Temporal Workflow for durability and reliable completion despite transient failures. If a payment provider is down, Temporal handles retries and waiting. If an application is redeployed mid‑batch, the workflow resumes. If something fails after partial progress, the workflow history preserves the truth of what happened so the system can recover without guesswork. The agent stays focused on explaining status, resolving exceptions, and coordinating the human side—while the workflow engine reliably carries the transaction to completion.
Example: recovering from a disrupted trip#
Imagine a flight is cancelled while a traveller is already on the way to the airport. An agent can interpret the traveller’s priorities — arrive before an important meeting, avoid an overnight stop, keep the family seated together — and compare imperfect alternatives across airlines, hotels, and ground transport. Once the traveller chooses an option, deterministic workflows take over: reserve the new flight, confirm availability, process any fare difference, cancel the old booking, request refunds, update loyalty records, and send the itinerary. If an airline API times out halfway through, Temporal preserves what has already succeeded and safely continues or compensates without creating duplicate bookings or charges. The agent handles judgment and conversation; the workflow handles the transaction.
Don’t “determinize” the agent–give it a deterministic backbone#
That combination is the core message: right-brain agents are not a replacement for left-brain workflows — and neither is sufficient without a resilient backbone. Temporal is that backbone: it makes workflow execution durable, and it gives agents a reliable substrate to operate over long‑running, failure‑prone processes where correctness, auditability, and recovery are non‑negotiable.
If you want agents in finance, the path isn’t to make the agent “more deterministic.” It’s to keep the agent adaptive, keep the workflows explicit, and use Temporal as the backbone that lets both behave safely under failure.