A production AI agent is a control loop, not a single prompt: it calls a model, handles tool requests or handoffs, pauses when approval is needed, and stops only when its work is complete or cannot continue. Make that loop explicit by defining who owns each piece of state, what triggers every transition, what must be saved, and how an interrupted run resumes.
What an agent state machine needs to represent
A useful state machine describes both where a workflow is and what must happen next. The labels below are a design model, not a set of SDK-mandated enum values. Adapt them to the application, but give every transition a defined trigger, persisted state, side effect, and retry or completion condition.
As an Amazon Associate I earn from qualifying purchases.
| State | Meaning | Typical next transition |
|---|---|---|
ready |
The workflow has enough input and context to begin or continue a turn. | Start a model call. |
model_call |
The current agent is being run against the model. | Inspect the result for a final answer, tool request, handoff, or interruption. |
tool_pending |
The model has requested a tool action, but the application has not executed it yet. | Validate the request and either run it or pause for approval. |
tool_running |
The application is carrying out an approved tool action. | Record the result and continue the agent loop, or move to failure handling. |
handoff |
Control of the current conversation branch is moving to a specialist agent. | Run the receiving agent with the handoff context. |
awaiting_approval |
A tool action or other step requires human review before the workflow can proceed. | Persist the interruption and wait for an approval decision. |
resumable |
A saved workflow snapshot and its pending work can be continued. | Restore the snapshot and follow the application’s decision for the outcome or retry. |
completed |
The workflow has reached a final user-facing answer and has no further tool work. | Return the answer and close the run. |
failed |
The workflow cannot proceed under its current conditions. | Apply a defined recovery path or report the failure. |
These states make a key distinction visible: an agent that has stopped to wait is not necessarily finished. In particular, an approval interruption is an intentionally incomplete result, not a final answer. The OpenAI Agents SDK results-and-state guidance describes interruption data for pending tool calls and a saved state that can be supplied again after approval or rejection. The application should decide what each decision means for its policy—for example, whether to resume, cancel, or ask the user for a different instruction.
Free tools Windows power users keep installed
One-click scans. No signup required.
How one agent turn moves through the loop
The OpenAI Agents SDK describes one SDK run as one application-level turn. Within that turn, the application calls the current agent, examines the result, executes requested tools and continues, changes agents after a handoff, or returns when there is a final answer with no further tool work. Treating the run as a loop prevents a common design mistake: assuming that one model response necessarily ends the workflow.
#1 Best Overall
- Start or restore the turn. Load the conversation context and workflow state from the strategy your application uses. If this is a continuation, restore the prior state rather than creating a parallel history accidentally.
- Call the current agent. Record enough information to identify the active agent and the point in the workflow. The model response may be final, may request a tool, may hand off control, or may leave the run interrupted.
- Classify the result. A final answer with no more tool work ends the turn. A tool request moves to validation and execution. A handoff changes the active agent. An approval interruption must be persisted and exposed for review rather than presented as completion.
- Execute or pause. Apply application policy before carrying out a requested action. If approval is required, save the pending call and the state needed to resume; otherwise execute the tool and capture its result.
- Continue from the new state. Feed tool results or handoff context into the next run as appropriate, and repeat until the workflow reaches a final answer, a pause, or a failure state.
- Persist and report the outcome. Save the state required for any later continuation. Return a final answer only when the workflow has actually completed; for a pause or failure, report that status in a way the caller can handle.
For each transition, specify four things in the implementation: its trigger, the state to persist, the side effect to perform, and the condition for retry or completion. This keeps retries from silently repeating an external action and makes it easier to distinguish a model call that needs another turn from work that has already finished.
Choose one owner for conversation continuation
Context can live in different places: in application-managed replay history, a persisted SDK session, a server-managed conversation ID, or a previous response ID. These are alternative continuation strategies, not interchangeable labels for the same storage. In most cases, choose one strategy for a conversation and make its owner clear.
| Continuation strategy | Where continuation context is managed | Architectural consideration |
|---|---|---|
| Application-owned history | The application retains and supplies replay history. | The application controls what is replayed and must keep its history consistent with the workflow. |
| Persisted session | A session stores state for continuation. | Define how the session is saved and associated with the application’s conversation. |
| Server-managed conversation ID | The server associates subsequent work with a conversation ID. | Keep the ID linked to the correct application-level conversation and workflow. |
| Previous response ID | A later response continues from a prior response ID. | Persist and pass the correct prior response reference when continuing. |
Mixing application replay with server-managed conversation state can duplicate context unless the application reconciles the two deliberately. Decide which source is authoritative, how it is updated after a tool result or handoff, and what identifiers must be stored to resume. A conversation ID or response ID can preserve conversational context; by itself, it does not establish that long-running work will survive process restarts or wait safely for a human.
Decide who controls the answer when agents work together
A handoff and an agent used as a tool are different control contracts. In a handoff, a specialist takes over the conversation branch. When the manager invokes a specialist as a tool, the manager remains responsible for producing the final user-facing answer. The OpenAI orchestration guidance frames the first design choice as deciding who owns that answer at each branch.
- Use a handoff when the specialist should take control of that branch of work. Make clear what context transfers and what responsibility the receiving agent takes on.
- Use a specialist as a tool when the manager should retain control, request bounded work from a specialist, and integrate its result into the final answer.
- Add an agent only for a reason. A specialist is most defensible when it materially improves capability or policy isolation, clarifies the prompt, or makes traces easier to interpret. Keep its scope narrow enough that its ownership and output are understandable.
For either pattern, specify what happens if the specialist cannot complete its task, returns an unusable result, or requests more work. The key design question is not simply which agents exist; it is who can advance the workflow and who is accountable for its final response.
Model approval pauses and recovery explicitly
A pause needs durable, resumable information, not just a message saying that review is required. Persist the pending action, the workflow context needed to interpret it, and the information required to continue. When a decision arrives, apply the application’s approval or rejection policy and pass the saved state back into the workflow if it should resume.
- Approval required: hold the action, save the interruption state, and present the request for review.
- Approved: continue according to policy, including executing the pending action when that is the intended next step.
- Rejected: continue according to the rejection policy, which may cancel the action or require a different instruction.
- Execution error: record the failure and decide whether the specific action is safe to retry, needs human attention, or should end the workflow.
- Process interruption: restore saved workflow state and determine whether any in-flight side effect completed before attempting it again.
The last check matters because an application may not know from its own process state whether an external action happened before a crash. Design side effects and retries so that recovery does not blindly repeat consequential work. The exact safeguards depend on the tool and application; the SDK’s loop alone does not determine them.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
When conversational state is not enough
A small agent loop may fit in ordinary application code. Make the workflow graph and persistence boundary more explicit when branching, long waits, approval gates, retries, or process restarts are central requirements. A saved conversation context supports continuation, but durable orchestration addresses a different operational need: coordinating work that must survive beyond the current run or process.
The OpenAI Agents SDK runtime guide names Dapr, Temporal, and Restate as integrations for durable or long-running use cases. That is an architectural option, not a universal prescription: the guide does not establish a comparative benchmark or identify one integration as the winner for every application. Evaluate whether the chosen execution layer can persist the workflow state and coordinate the pauses, retries, and recovery behavior your system requires.
Rank #4
- Book - powershell for sysadmins: workflow automation made easy
- Language: english
- Binding: paperback
Make the workflow observable without ignoring data policy
Operational visibility helps explain why an agent reached a state, what tool work it attempted, and where a handoff or guardrail changed the path. OpenAI Agents SDK tracing can record model calls, tool calls, handoffs, and guardrails. Use those events to make transitions inspectable, and decide how trace data fits the organization’s data-retention requirements.
OpenAI’s tracing documentation states that tracing is unavailable for organizations using OpenAI APIs under a Zero Data Retention policy. If that policy applies, do not make the architecture depend on this tracing service; plan another way to capture the operational events needed to diagnose the workflow while respecting the organization’s requirements.
Quick wins for a faster PC:
Scan for outdated or missing drivers - takes under a minuteDriver Scan →Clear out junk files and repair common Windows errorsFree Scan →Quick Recap
A practical design checklist
- Name the states that matter to the application, including waiting, completion, and failure—not only model and tool execution.
- For every transition, define its trigger, persisted state, side effect, and retry or completion condition.
- Choose the owner of conversation continuation and avoid mixing histories unless they are reconciled intentionally.
- Specify who owns the final answer at every agent branch, and distinguish specialist handoffs from manager-controlled tool calls.
- Save the information needed to resume approval pauses, long waits, and recoverable failures.
- Decide which work must survive a process restart and evaluate durable orchestration when that requirement exceeds simple conversation continuation.
- Make model calls, tool execution, handoffs, approvals, and failures observable within the applicable data policy.
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.
