Free tools Windows power users keep installed
One-click scans. No signup required.
Use a state machine when your LLM-backed workflow needs explicit, reviewable control over which step runs next. Keep model judgment inside bounded steps—such as classifying a request or drafting a response—and let application code enforce transitions, approvals, and tool execution. An LLM-led flow remains useful when the next action genuinely needs to be chosen flexibly. OpenAI documents both approaches and supports mixing them; its guidance favors code-defined orchestration for greater predictability, not as a universal guarantee of correctness.
What orchestration decides
Orchestration is the flow of agents in an application: which agents run, in what order, and how the next step is selected. OpenAI’s Agents SDK guide to orchestration describes two broad patterns: an LLM can choose what to do next, or application code can define the flow. The patterns can also be combined.
As an Amazon Associate I earn from qualifying purchases.
That makes “LLM or state machine?” a false binary. The useful design question is which decisions need model flexibility and which need explicit application control.
Choose the control pattern that fits the workflow
| Pattern | Who selects the next step? | Where it fits | Main trade-off |
|---|---|---|---|
| LLM-led orchestration | The model chooses among available actions or agents. | Workflows where the next useful step depends on open-ended interpretation. | More flexibility, but less predictable flow. |
| Code-defined orchestration | Application logic selects the next step according to explicit transitions. | Workflows with bounded stages, fixed policy checks, approvals, or controlled tool execution. | More explicit control, at the cost of maintaining the transitions and their edge cases. |
| Mixed orchestration | Code controls the outer flow; the model makes bounded decisions within a step. | Workflows that need model judgment without delegating the entire process to the model. | Requires a clear boundary between model decisions and application-owned decisions. |
OpenAI says that “orchestrating via code makes tasks more deterministic and predictable, in terms of speed, cost and performance.” This is qualitative guidance in its SDK documentation, not a workload-specific benchmark or a promise that code guarantees correctness. The documentation does not quantify an improvement.
#1 Best Overall
How an explicit workflow can be structured
For an illustrative support-request workflow, code can define the stages and allowed transitions while the model handles interpretation within its assigned stage:
- Validate input: application code checks required fields, size limits, and basic eligibility.
- Classify: the model assigns a category or extracts relevant details; the application validates the result against the expected schema.
- Check policy: application logic determines whether the request is eligible for an action or requires human approval.
- Execute an approved tool action: application code invokes the tool only after the required checks pass.
- Return a terminal result: the workflow records whether it completed, was rejected, or needs human review.
The important property is not the particular sequence. It is that the model does not silently gain authority to skip a required check or execute an action outside the transition rules. If a classification is uncertain, for example, the defined transition can route to review rather than treating the model’s preferred next step as authorization.
Keep runtime choice separate from workflow design
A state machine is an application architecture decision, not a feature synonymous with a particular SDK. OpenAI’s Agents SDK overview says the SDK runs in the application: the application owns deployment, tool implementations, state storage, and approval decisions, while the SDK runs the agent loop and invokes tools.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
The Agents guide and Responses API reference describe other ways to build agent workflows, with different divisions of orchestration and state responsibility. Whichever runtime you choose, decide explicitly which component persists workflow state, grants approvals, invokes tools, and recovers interrupted work. Do not assume that selecting an SDK or API automatically gives your application the state ownership or recovery behavior it needs.
Make handoffs and side effects explicit
Within an agent system, routing also has an ownership dimension. OpenAI’s Agents guide distinguishes a manager pattern, where a central agent retains control and calls specialists as tools, from a handoff, where control passes to a specialist. A manager can centralize controls such as guardrails or rate limits; a handoff lets the specialist focus on its task without the manager retaining control. Neither pattern is universally preferable: choose based on who should own the next decision and where controls must be enforced.
Guardrails are not a rollback mechanism. The Agents SDK guardrails guide says checks can run alongside agents or block execution until they complete. It also warns that a guardrail trip does not undo external side effects that already occurred, retract output already delivered to application code, erase data stored outside SDK control, or change application-owned references to raw provider data.
Rank #4
- Book - powershell for sysadmins: workflow automation made easy
- Language: english
- Binding: paperback
Therefore, put checks that must precede an irreversible action before the tool call. A check that blocks a final response after an external action may prevent that response from being accepted, but it cannot by itself cancel the action. For actions that can be repeated after a retry, design the tool boundary and application state so recovery does not casually repeat an unintended side effect.
Plan for waits, retries, and restarts
A state machine makes transitions explicit, but it does not itself make a process durable. If a workflow may wait for a person or external event, retry work, or resume after a process restart, decide how its state is persisted and how interrupted steps are recovered. OpenAI’s runtime guide identifies durable-execution integrations such as Temporal and Restate for workloads with long waits, retries, or process restarts. These are options to evaluate against the workflow, not mandatory components of every state machine.
Before adopting a durable-execution integration, establish which state it owns, how it interacts with your tool calls, and what recovery behavior the workflow requires. The cited guide names options but does not provide a comparative feature matrix or establish that one is best for a particular application.
A practical decision checklist
- Boundedness: Are the valid stages and transitions known in advance, or does the next step need open-ended model judgment?
- Predictability: Do you need an explicit route through policy checks, approvals, and tool actions?
- Ownership: Which component stores state, makes approval decisions, and decides what happens after a model response?
- Side effects: Which actions change external systems, and what must be checked before those actions run?
- Recovery: Must the workflow survive long waits, retries, or process restarts?
- Maintenance: Can the team keep the explicit transitions, failure paths, and state handling correct as requirements change?
Prefer code-defined transitions where the workflow is bounded and operational control matters. Use LLM-led routing where flexible choice is a real requirement, and use a mixed design when both are. Explicit transitions improve visibility into who decides what happens next, but they do not eliminate model errors, application bugs, or the work of operating the system.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
