25 ChatGPT-5.5 Prompts for Designing and Evaluating OpenAI Agents API Workflows: Sessions, Tools, Sandboxes, Recovery, and Acceptance Tests

How to Use These Prompts Without Confusing Design Review With Runtime Behavior

This prompt masterclass treats ChatGPT-5.5 as a specification-design and critique partner for teams planning OpenAI Agents API workflows. It does not assert that ChatGPT-5.5 is the runtime model for every Agents API application, subagent, tool call, or production deployment. The Agents API documentation describes an OpenAI-managed interface to the Codex harness where developers specify the task, model, tools, and environment; the correct runtime model remains an implementation choice that must be checked against the current OpenAI model documentation and the application’s own latency, cost, safety, and capability requirements.

There is also no official gpt-5.5-mini model identifier documented in the supplied OpenAI model source for this article. If a team wants a smaller, cheaper, lower-latency, or fallback model, it should name only documented model identifiers from the current OpenAI API model list and record the reason for that choice in the workflow specification. A prompt template can ask ChatGPT-5.5 to compare model-selection criteria, but it cannot invent an identifier, authorize access to a model, or prove that a future deployment will have the same model availability as a design notebook.

The 2026 ChatGPT Prompt Engineering Best Practices Guide covers production-grade prompt engineering for frontier AI APIs, including layered prompt architecture, caching, and agentic task optimization. The complete The 2026 ChatGPT Prompt Engineering Best Practices Guide article provides the destination-specific detail for this section’s ChatGPT-5.5 Prompt Engineering decision because this is the strongest match for a marker about ChatGPT-5.5 prompt engineering because it gives broader production prompting practices that support agent workflow prompt design.

Operational rule: use ChatGPT-5.5 to improve the specification before developers build the workflow; do not treat a well-written prompt response as proof that an Agents API session, hosted sandbox, tool integration, subagent, artifact pipeline, or compliance control will behave correctly in production.

The Agents API Facts These Prompts Assume

The Agents API is documented as an OpenAI-managed interface to the Codex harness. OpenAI manages session infrastructure, orchestration, context compaction, and recovery mechanics, while the application remains responsible for workflow design, authorization, tool governance, monitoring, retries, artifact handling, human review, budget controls, and deletion or retention decisions. That split matters because a prompt can help you identify what the platform does for you, but it should also force you to document what your application must still enforce.

The core Agents API concepts used throughout the prompt set are Agent, Environment, Session, and Events or Items. A session preserves configuration, conversation, and saved work across turns. A turn is an asynchronous work cycle. Input sent to an idle session starts a turn, while input sent during an active turn steers the active work. These prompts therefore ask for state diagrams and acceptance tests instead of relying on a single “send request, get answer” mental model.

The event model requires careful handling. OpenAI’s documentation warns that agent.session.idle and a closed event stream are not success conditions. Root-agent outcomes such as agent.session.turn.completed, agent.session.turn.failed, and agent.session.turn.cancelled establish the turn outcome, but even a completed turn does not prove every tool succeeded. This article’s prompts repeatedly require explicit tool-result validation, saved-item inspection, and user-visible failure states because silent partial failure is one of the easiest ways for an agent workflow to look complete while producing unsafe or unusable output.

The Reusable Prompt Contract Used in All 25 Templates

Every prompt in this article follows the same contract so teams can compare outputs across workflow designs. The contract requires the model to identify assumptions, cite the evidence it used from the provided specification, mark unresolved uncertainty, produce acceptance criteria, and call out where a human reviewer must approve high-impact, irreversible, financial, security-sensitive, privacy-sensitive, regulated, or production-changing actions. This structure is intentionally repetitive because agent workflow failures often occur at boundaries: permissions, recovery, artifacts, shared filesystems, and human handoff.

Reusable prompt contract

Role:
You are a critical reviewer of an OpenAI Agents API workflow specification.

Task:
Analyze the proposed workflow before implementation. Do not assume that a session being idle,
a stream closing, or a turn completing proves end-to-end success.

Required response sections:
1. Assumptions explicitly made
2. Evidence found in the supplied specification
3. Uncertainty or missing information
4. Failure modes and abuse cases
5. Acceptance criteria
6. Required telemetry and saved-state checks
7. Human review or approval gates
8. Recommended changes before implementation

Hard constraints:
- Do not invent undocumented model identifiers, permissions, events, prices, limits, or guarantees.
- Do not treat prompts as a way to grant API permissions or bypass administrator controls.
- Do not claim Zero Data Retention for Agents API workflows.
- Do not assign function tools to subagents.
- Require human review for high-impact or irreversible actions.

The contract is not a replacement for engineering design review; it is a forcing function that makes reviewable gaps visible. For example, if a proposed workflow says “retry when the stream disconnects,” the prompt should reject that as incomplete and ask for the saved-session retrieval procedure, item-ID reconciliation, pagination handling, and a bounded retry policy. If a proposed workflow says “the subagent will edit the same files as the coordinator,” the prompt should require a locking, ownership, or merge protocol because OpenAI’s multi-agent documentation states that the coordinator and subagents share one environment filesystem.

30 ChatGPT Prompts for AI Agent Safety Testing provides prompts for red-teaming autonomous systems across areas such as containment verification and privilege escalation detection. The complete 30 ChatGPT Prompts for AI Agent Safety Testing: Red-Team Your Autonomous Systems Before They Red-Team You article provides the destination-specific detail for this section’s Agent Acceptance Testing decision because acceptance testing for agents should include safety and failure-mode checks, making this article directly useful for validating agent behavior before release.

The Evaluation Mindset: Treat Every Agent Workflow as a Stateful System

OpenAI’s evaluation guidance defines evaluation as specifying the task, running representative test inputs, analyzing results, and iterating. For Agents API workflows, that general pattern must be extended to stateful behavior: session creation, environment readiness, streamed events, required actions, tool execution, saved items, follow-up turns, cancellations, disconnected-stream recovery, artifact publication, and cleanup. A prompt that reviews only the final answer misses the main operational risk of agent systems, which is that the path to the answer may include failed tools, missed events, unauthorized network assumptions, or unreconciled intermediate state.

• Specify the task boundary: define the user goal, prohibited actions, allowed tools, expected outputs, and what counts as “done.”
• Specify the state boundary: document how session IDs, turns, items, artifacts, and local application state are stored and reconciled.
• Specify the environment boundary: choose hosted, self-hosted, supported partner, or no filesystem based on required files, tools, packages, network policy, and retention constraints.
• Specify the recovery boundary: define what the client does after stream interruption, turn failure, cancellation, required action, environment failure, or deletion conflict.
• Specify the approval boundary: require human authorization before irreversible operations, privileged tool use, external publication, regulated decisions, financial actions, or destructive file changes.

Security and compliance reviewers should read each generated prompt response as a draft risk register, not as a control attestation. The prompts can surface missing allowlist entries, secret-placement mistakes, insufficient audit fields, or overbroad tool scopes, but they cannot grant api.agents.read, api.agents.write, or api.responses.write; they cannot make a workspace eligible for a feature; they cannot establish Zero Data Retention where the Agents API documentation says it is not supported; and they cannot prove that an external tool, MCP server, package, or sandbox partner meets an organization’s internal policy.

Product and engineering leaders should use the 25 prompts as a pre-implementation review sequence. Start with the task contract, then design tools and environments, then model events and recovery, then add subagents only where work is genuinely independent, then define acceptance tests, observability, rollout, and rollback. This ordering prevents a common failure pattern: teams begin by asking what an agent can do, when the safer starting question is what the workflow is allowed to do, how success will be verified, and who remains accountable when the model, tool, stream, sandbox, or human handoff does not behave as expected.

Prompts 1–9: Foundation Prompts for Agents API Workflow Design

Use these first nine prompts before implementation to force explicit decisions about what the agent may do, which user authority it is acting under, which tools and environments are allowed, how files become artifacts, and how session events are interpreted. The prompts are written for ChatGPT-5.5 as a design and critique assistant; they do not grant API permissions, create sandbox isolation, prove compliance, or replace engineering, security, legal, or operations review.

Prompt 1: Task Contract for a Stateful Agent Workflow

Purpose: This prompt turns a vague automation idea into a bounded task contract. The Agents API retains state across turns, so the workflow specification must define the objective, allowed continuation behavior, prohibited actions, completion evidence, and what must be reviewed by a human before any high-impact or irreversible step.

Copy-paste prompt:

You are reviewing an OpenAI Agents API workflow design. Create a task contract for this agent.

Required behavior:
- State explicit assumptions and label them as assumptions, not facts.
- Separate evidence from uncertainty.
- Define acceptance criteria that can be tested after a root turn completes.
- Require human review for high-impact, regulated, destructive, financial, security-sensitive, or irreversible actions.
- Do not assume that agent.session.idle, a closed stream, or a completed turn proves every tool succeeded.

Workflow idea:
[PASTE WORKFLOW IDEA]

Users:
[PASTE USER TYPES]

Business goal:
[PASTE BUSINESS GOAL]

Known constraints:
[PASTE CONSTRAINTS]

Return:
1. Task objective
2. In-scope actions
3. Out-of-scope actions
4. Required human approvals
5. Completion evidence
6. Failure and escalation conditions
7. Acceptance tests

Required inputs: Provide the workflow idea, user types, business goal, data classes, irreversible actions, and the expected final deliverable.

Expected output: A task contract that distinguishes a successful business result from a merely completed turn, with review gates and measurable acceptance tests.

Verification checkpoint: Confirm that every destructive or externally visible action has an approval rule, and that completion evidence is based on retrieved session items, tool outputs, or artifacts rather than stream closure alone.

Prompt 2: User and Authorization Boundary

Purpose: This prompt defines whose authority the agent uses and where application authorization must occur. OpenAI’s Agents API requires application API permissions, but the application still owns user identity, entitlement checks, tool authorization, budget controls, and audit decisions.

Copy-paste prompt:

Act as a security architect. Map the user and authorization boundary for this Agents API workflow.

You must:
- State explicit assumptions and separate them from verified requirements.
- Identify evidence needed to prove each authorization decision.
- Define acceptance criteria for permission enforcement.
- Require human review for high-impact or irreversible actions.
- Do not place the application API key inside the agent sandbox.
- Do not treat model reasoning as an authorization decision.

Workflow:
[PASTE WORKFLOW]

User roles:
[PASTE ROLES]

Tools and data sources:
[PASTE TOOLS AND DATA]

Actions that can affect external systems:
[PASTE ACTIONS]

Return:
1. Identity source
2. Entitlement checks before session creation
3. Tool-level authorization checks
4. Per-action approval gates
5. Audit records to emit
6. Denial and escalation paths
7. Acceptance tests

Required inputs: List roles, groups, entitlements, tools, sensitive data, approval policies, and any external system where state can be changed.

Expected output: A boundary map showing which checks happen in the application, which controls apply to tools, and which actions require human confirmation.

Verification checkpoint: Confirm that a denied user or tool action remains denied even if the model recommends proceeding, and that every high-impact external action records the approving identity and supporting evidence.

12 Agentic Workflow Design Patterns for 2026 documents production-tested agent architecture patterns with reference stacks, failure modes, and cost profiles for teams building beyond prototypes. The complete 12 Agentic Workflow Design Patterns for 2026 article provides the destination-specific detail for this section’s Tool Permission Design decision because tool permissions need to be designed within the broader agent workflow architecture, and this playbook is the most relevant allowed target for production agent design patterns involving tool calls.

Prompt 3: Tool Inventory and Permission Matrix

Purpose: This prompt builds a tool inventory that can be reviewed before the agent is connected to real systems. The Agents API can use tools, custom functions, MCP connections, and built-in capabilities, but a completed turn does not prove each tool call achieved its intended business result.

Copy-paste prompt:

Create a tool inventory and permission matrix for an Agents API workflow.

Rules:
- State explicit assumptions and separate evidence from uncertainty.
- For each tool, define allowed inputs, allowed outputs, side effects, rate or budget controls, and human review gates.
- Define acceptance criteria for safe use.
- Require human review for high-impact or irreversible actions.
- Do not claim that successful turn completion proves every tool succeeded.
- Identify which tool failures must stop the workflow.

Workflow:
[PASTE WORKFLOW]

Candidate tools:
[PASTE TOOL LIST]

User roles:
[PASTE ROLES]

Risk constraints:
[PASTE RISKS]

Return a table with:
Tool, purpose, data exposed, side effects, allowed users, required approval, failure handling, audit event, acceptance test.

Required inputs: Provide tool names, data scopes, external side effects, user roles, budgets, and failure policies.

Expected output: A reviewable matrix that separates read-only tools, write-capable tools, privileged administrative tools, and tools that require approval before execution.

Verification checkpoint: Ensure every write-capable tool has an idempotency, approval, or rollback note. If a tool can spend money, modify records, disclose data, or trigger user-facing messages, require explicit approval or a documented policy exception.

Prompt 4: Environment Selection Decision Record

Purpose: This prompt helps decide whether the workflow needs an OpenAI-hosted sandbox, developer-managed infrastructure, a supported sandbox partner, or no execution environment. OpenAI’s hosted environment is a Linux workspace with Python, Node.js, command-line tools, files, packages, skills, plugins, templates, and artifacts, but session creation only means setup has started.

Copy-paste prompt:

Prepare an environment selection decision record for an Agents API workflow.

You must:
- State explicit assumptions.
- Separate source-backed facts from unknowns needing documentation review.
- Define acceptance criteria for environment readiness.
- Require human review for high-impact or irreversible actions.
- Do not assume session creation means the environment is connected.
- Do not assume a template preserves a running workspace.

Workflow:
[PASTE WORKFLOW]

Code execution needs:
[PASTE NEEDS]

Files and artifacts:
[PASTE FILE REQUIREMENTS]

Network and secrets:
[PASTE REQUIREMENTS]

Compliance constraints:
[PASTE CONSTRAINTS]

Compare:
1. OpenAI-hosted sandbox
2. Developer infrastructure
3. Supported sandbox partner
4. No environment

Return recommendation, risks, readiness checks, and acceptance tests.

Required inputs: Include code execution needs, package requirements, data sensitivity, network destinations, artifact requirements, and residency or retention constraints.

Expected output: A decision record with a recommended environment, rejected alternatives, readiness events to wait for, and operational risks.

Verification checkpoint: If the hosted sandbox is selected, require the environment state to reach connected before work depends on it; treat failed as an environment error requiring inspection.

Prompt 5: Network Policy and Egress Allowlist

Purpose: This prompt designs the sandbox network policy. OpenAI documents hosted network modes as enabled, disabled, or restricted. Restricted mode allows only exact hostnames and does not accept wildcards, protocols, paths, or ports; redirects and subdomains require separate entries.

Copy-paste prompt:

Design a network policy for an OpenAI-hosted Agents API sandbox.

Requirements:
- State explicit assumptions and separate evidence from uncertainty.
- Identify every required outbound hostname.
- Define acceptance criteria for network access.
- Require human review for high-impact or irreversible actions that depend on external systems.
- In restricted mode, use exact hostnames only: no protocols, paths, ports, or wildcards.
- Include redirect destinations and subdomains separately when needed.
- Do not broaden an inherited template network policy.

Workflow:
[PASTE WORKFLOW]

External services:
[PASTE SERVICES]

MCP or tool needs:
[PASTE NEEDS]

Data sensitivity:
[PASTE DATA CLASSES]

Return:
1. Recommended mode
2. Hostname allowlist
3. Justification per host
4. Denied destinations
5. Test plan
6. Monitoring and incident response notes

Required inputs: Provide external services, required hostnames, MCP requirements, data sensitivity, and whether the workflow can operate offline.

Expected output: A network decision with an exact-host allowlist, rejection rationale for unnecessary egress, and tests for redirects, subdomains, and denied destinations.

Verification checkpoint: Confirm that restricted mode contains only exact hostnames, separately includes required redirect and subdomain hosts, rejects paths, protocols, ports, and wildcards, and does not broaden inherited template policy.

How to Set Up OpenAI Codex Windows Sandbox for Secure AI-Assisted Development explains setting up an elevated Windows Sandbox tailored for AI-assisted development with a focus on security. The complete How to Set Up OpenAI Codex Windows Sandbox for Secure AI-Assisted Development article provides the destination-specific detail for this section’s Sandbox Threat Modeling decision because the marker concerns sandbox risk and isolation, and this target gives concrete context on secure sandboxed environments for AI-assisted workflows.

Prompt 6: Secret Handling and Credential Placement

Purpose: This prompt prevents accidental leakage of application API keys and privileged credentials into the sandbox. The application API key should remain outside the agent environment; the agent should receive only the minimum scoped credentials or tool access needed for the task.

Copy-paste prompt:

Review secret handling for this Agents API workflow.

You must:
- State explicit assumptions and distinguish them from verified facts.
- Separate evidence from uncertainty.
- Define acceptance criteria for secret minimization.
- Require human review for high-impact or irreversible actions.
- Do not embed the application API key in the sandbox.
- Identify secrets that can be avoided by using server-side tool mediation.

Workflow:
[PASTE WORKFLOW]

Credentials under consideration:
[PASTE CREDENTIALS]

Tools:
[PASTE TOOLS]

Environment variables:
[PASTE ENV VARS]

Return:
1. Secrets that must stay only on the application server
2. Secrets or tokens allowed in the environment, if any
3. Scope and lifetime recommendations
4. Rotation and revocation procedure
5. Logging redaction rules
6. Acceptance tests

Required inputs: List API keys, OAuth tokens, database credentials, environment variables, tool mediation options, rotation policy, and audit requirements.

Expected output: A credential placement plan that separates server-only secrets from task-scoped environment values and defines revocation behavior.

Verification checkpoint: Search the proposed design for application API keys, administrator credentials, broad database credentials, or long-lived secrets inside sandbox configuration. Any such placement requires redesign or a documented exception.

Prompt 7: File and Artifact Plan

Purpose: This prompt defines how the agent receives files, writes outputs, and preserves deliverables. In the OpenAI-hosted sandbox, /workspace is the working directory, files persist across turns while the sandbox exists, and files under /workspace/outputs are published as immutable artifacts after a turn completes.

Copy-paste prompt:

Create a file and artifact plan for an Agents API workflow.

Requirements:
- State explicit assumptions and separate evidence from uncertainty.
- Define acceptance criteria for required files and final artifacts.
- Require human review before publishing, sending, deleting, or externally using high-impact artifacts.
- Distinguish live workspace files from published immutable artifacts.
- Do not assume artifact deletion deletes the live workspace file.
- Plan how artifacts are downloaded before session deletion when needed.

Workflow:
[PASTE WORKFLOW]

Input files:
[PASTE INPUT FILES]

Expected outputs:
[PASTE OUTPUTS]

Review requirements:
[PASTE REVIEW RULES]

Return:
1. Input file plan
2. Working directory conventions
3. Output paths
4. Artifact naming rules
5. Validation checks
6. Download and retention procedure
7. Acceptance tests

Required inputs: Provide input files, expected output formats, artifact consumers, retention rules, review requirements, and cleanup obligations.

Expected output: A file lifecycle plan that explains where files are staged, how outputs are validated, which artifacts are published, and when they are downloaded or deleted.

Verification checkpoint: Confirm that required deliverables are written under /workspace/outputs when using the hosted sandbox, and that artifact review occurs before customer-facing or regulated use.

Prompt 8: Session State Model

Purpose: This prompt designs the local application state that must be stored around an Agents API session. A session preserves configuration, conversation, and saved work; follow-up inputs reuse the same session, and applications should store session IDs with their own conversation state.

Copy-paste prompt:

Design the session state model for an Agents API application.

You must:
- State explicit assumptions and separate evidence from uncertainty.
- Define acceptance criteria for state persistence and recovery.
- Require human review for high-impact or irreversible actions.
- Store session IDs with application conversation records.
- Treat turns as asynchronous work cycles.
- Do not blindly retry after a disconnect; inspect saved session, turn, and item state first.
- Account for paginated list endpoints when retrieving saved items.

Workflow:
[PASTE WORKFLOW]

Application records:
[PASTE RECORD TYPES]

Session lifecycle:
[PASTE LIFECYCLE]

Recovery requirements:
[PASTE REQUIREMENTS]

Return:
1. State entities
2. Session-to-user mapping
3. Turn status fields
4. Item reconciliation keys
5. Retry and cancellation rules
6. Cleanup rules
7. Acceptance tests

Required inputs: Include user conversation records, session lifecycle rules, persistence store, retry policy, cancellation policy, and cleanup triggers.

Expected output: A state model that records session IDs, root-turn outcomes, saved item IDs, buffered events, cancellation decisions, and cleanup status.

Verification checkpoint: Verify that the model distinguishes cancellation from failure, preserves prior work after cancellation, and retrieves saved items before retrying interrupted work.

Prompt 9: Event-State Machine for Turns and Recovery

Purpose: This prompt converts Agents API event handling into a deterministic state machine. OpenAI’s session event guidance requires applications to distinguish root-agent outcomes from subagent events, handle requires_action, and avoid treating agent.session.idle or stream closure as success.

Copy-paste prompt:

Create an event-state machine for this Agents API workflow.

Rules:
- State explicit assumptions and separate evidence from uncertainty.
- Define acceptance criteria for each terminal and nonterminal state.
- Require human review for high-impact or irreversible actions.
- Subscribe to the stream before sending follow-up input.
- Do not treat agent.session.idle or a closed stream as success.
- Use root agent.session.turn.completed, agent.session.turn.failed, and agent.session.turn.cancelled for root turn outcome.
- On agent.session.requires_action, inspect required_actions and provide function results or connect the environment.
- For disconnected streams, open a new stream, buffer events, retrieve session and saved items, rebuild by item ID, then resume live handling.

Workflow:
[PASTE WORKFLOW]

Events to handle:
[PASTE EVENTS]

Required actions:
[PASTE REQUIRED ACTIONS]

Return:
1. State diagram in text
2. Event-to-transition table
3. Terminal states
4. Recovery algorithm
5. Acceptance tests

Required inputs: Provide expected events, required-action types, stream handling design, persistence store, subagent usage, and retry rules.

Expected output: A transition table that separates active, requires-action, completed, failed, cancelled, idle, disconnected, and recovered states, with item-ID reconciliation.

Verification checkpoint: Confirm that success requires the root turn outcome plus workflow-specific acceptance checks. If subagents are used, the design must not treat a coordination item completion as proof that a subagent finished.

Prompts 10–18: Recovery, Delegation, Budgets, Approval Gates, and Failure Injection

The next nine templates move from static design review into operational evaluation. They assume the workflow is stateful: a session can survive across turns, a stream can disconnect without cancelling the underlying task, a required action can pause progress until the application responds, and a completed root turn still needs tool-level and artifact-level verification before a user-facing success message is safe.

Prompt 10: Required-Action Handling Contract

Purpose: Use this prompt when the workflow may pause on agent.session.requires_action. The design must specify how the application inspects required_actions, supplies function results when appropriate, connects an environment when required, rejects unsafe requests, and records the decision for later audit or incident review.

Copy-paste prompt:

You are reviewing an OpenAI Agents API workflow design for required-action handling.

Create a required-action handling contract that includes:
1. Explicit assumptions about session state, user authorization, tool availability, and environment readiness.
2. A separation between evidence from the workflow specification and uncertainties that must be confirmed in implementation.
3. A decision tree for each expected required action: fulfill, ask user, route to human reviewer, reject, cancel turn, or continue with degraded behavior.
4. Acceptance criteria for safe handling of required_actions, including logging, timeout behavior, validation of function results, and user-visible status messages.
5. A human-review requirement for any high-impact, regulated, financially material, security-sensitive, destructive, or irreversible action.
6. A warning that agent.session.idle, stream closure, or root turn completion is not by itself proof that every required action or tool operation succeeded.

Return a concise contract, an edge-case table, and test cases.

Required inputs:

• List of expected required actions and the application component responsible for each response.
• User roles, authorization checks, and conditions that require escalation.
• Timeout policy for pending required actions and cancellation policy for abandoned turns.

Expected output: A decision contract that prevents the frontend from treating required actions as ordinary assistant text and prevents the backend from auto-fulfilling sensitive requests without authorization.

Verification checkpoint: Confirm that the design names the exact local state transition for requires_action, the evidence reviewers receive, and the failure response if the action cannot be safely fulfilled.

Prompt 11: Disconnected-Stream Recovery Plan

Purpose: Use this prompt before implementing event streaming. OpenAI’s session event guidance says streams do not replay missed events, so a resilient client must reconnect, buffer new events, retrieve session and saved items, reconcile by item ID, handle pagination, and resume live processing instead of blindly retrying the task.

ChatGPT Outages in July 2026 analyzes reported ChatGPT outages and offers guidance for diagnosing incidents and building AI workflows that are more resilient to service disruptions. The complete ChatGPT Outages in July 2026: What Happened, Why It Matters, and How to Build AI-Resilient Workflows article provides the destination-specific detail for this section’s Resilient Event Streams decision because resilient event-stream handling depends on outage-aware recovery patterns, so this article adds useful context for fault-tolerant agent workflow design.

Copy-paste prompt:

You are designing disconnected-stream recovery for an OpenAI Agents API session.

Produce a recovery plan that includes:
1. Explicit assumptions about when streams may disconnect, whether the turn continues, and where the application stores session IDs.
2. A separation of evidence from official event/session behavior versus uncertainties that require implementation testing.
3. A step-by-step algorithm: open a new stream, buffer incoming events, retrieve the session, page through saved items as needed, rebuild local state keyed by item ID, apply buffered updates, then resume live event handling.
4. Rules that forbid blind retry until saved turn state and items have been inspected.
5. Acceptance criteria for recognizing root turn completed, failed, and cancelled outcomes while still verifying tool and artifact success separately.
6. Human review for high-impact or irreversible work when recovery cannot prove whether an external side effect occurred.

Return pseudocode, a state-reconciliation checklist, and failure-mode tests.

Required inputs:

• Session ID storage location and conversation-state schema.
• Local event store, item store, and pagination strategy.
• Definitions of duplicate, missing, stale, and conflicting item updates.

Expected output: A recovery procedure that distinguishes disconnected observation from cancelled execution and preserves completed work already saved in the session.

Verification checkpoint: Require a test where the stream disconnects during tool execution, the reconnect path retrieves multiple pages of saved items, and the client does not submit duplicate follow-up input until reconciliation completes.

Prompt 12: Idempotency and Side-Effect Control

Purpose: Use this prompt for workflows that call external systems, write files, publish artifacts, send notifications, update tickets, modify records, or invoke tools with side effects. The goal is to define idempotency before retries, recovery, or human approvals introduce duplicate operations.

Copy-paste prompt:

You are reviewing idempotency for an OpenAI Agents API workflow with tools and possible external side effects.

Create an idempotency design that includes:
1. Explicit assumptions about which operations are read-only, reversible, destructive, financially material, or externally visible.
2. A separation of confirmed design facts from uncertainties, especially unknown tool retry behavior and external-system commit semantics.
3. Idempotency keys, deduplication records, request fingerprints, result reconciliation, and operator runbooks for ambiguous outcomes.
4. Acceptance criteria proving that retries, stream recovery, and follow-up turns cannot duplicate irreversible actions without detection.
5. Human review for high-impact or irreversible operations when the system cannot prove whether the first attempt committed.
6. A warning that root turn completion does not prove every tool succeeded and that tool-specific receipts or saved artifacts must be checked.

Return an operation matrix, idempotency-key strategy, and duplicate-side-effect test plan.

Required inputs:

• Tool list with side-effect classification and external identifiers.
• Storage available for idempotency keys, receipts, and reconciliation records.
• Business rules for when a duplicate is harmless, recoverable, or reportable.

Expected output: A side-effect control matrix that forces every non-read-only operation to have a deduplication, confirmation, or human-escalation path.

Verification checkpoint: Inspect whether the design handles the ambiguous case where the stream disconnects after a tool call is sent but before the application observes the result.

Prompt 13: Retry Limits, Backoff, and Escalation

Purpose: Use this prompt to prevent retry loops that amplify cost, duplicate work, or mask a real outage. The hosted sandbox documentation notes that deleting a busy session can return 409 and should be retried with bounded delay; the same bounded-thinking pattern should apply to stream reconnection, transient tool errors, environment readiness checks, and artifact downloads.

Copy-paste prompt:

You are designing retry limits for an OpenAI Agents API workflow.

Produce a retry policy that includes:
1. Explicit assumptions about transient failures, permanent failures, rate or quota responses, busy-session responses, environment setup failures, and network disconnects.
2. A separation between evidence from documented API behavior and uncertainties that require service-specific testing.
3. Maximum attempts, backoff intervals, jitter rules if used, total elapsed-time limits, and escalation criteria for each retryable operation.
4. Non-retryable conditions, including authorization failures, validation failures, unsafe required actions, and ambiguous irreversible side effects.
5. Acceptance criteria for stopping retries, preserving session state, notifying users, and creating an operator-visible incident.
6. Human review for high-impact or irreversible actions before any retry that could duplicate or compound an external side effect.

Return a retry matrix, escalation flow, and test scenarios.

Required inputs:

• Operations to retry: create session, wait for environment readiness, reconnect stream, submit follow-up input, cancel turn, delete session, download artifacts, and call external tools.
• Maximum acceptable latency and cost for each operation.
• Incident routing path when retry limits are exhausted.

Expected output: A bounded retry policy that makes failure visible instead of converting every error into another autonomous attempt.

Verification checkpoint: Confirm that the policy explicitly says closing an event stream does not cancel the task and that cancellation requires an intentional cancellation operation in the workflow design.

Prompt 14: Subagent Decomposition Review

Purpose: Use this prompt before enabling multi-agent delegation. OpenAI’s multi-agent guidance positions subagents for independent tasks; short tasks and tightly dependent sequences should stay with the coordinator, and a completed coordination item is not proof that a subagent finished its work.

Copy-paste prompt:

You are evaluating whether an OpenAI Agents API workflow should use subagents.

Create a subagent decomposition review that includes:
1. Explicit assumptions about the coordinator role, candidate subagent tasks, dependencies, shared tools, shared credentials, and shared environment filesystem.
2. A separation of evidence from the workflow brief versus uncertainties that need prototype validation.
3. A dependency graph that marks which tasks are independent enough to delegate and which should remain with the main agent.
4. A concurrency recommendation, including whether the configured max_concurrent_subagents value is justified and positive when delegation is enabled.
5. Acceptance criteria for subagent completion that rely on saved turns/items, outputs, and coordinator verification rather than only coordination-item completion.
6. Human review for high-impact or irreversible conclusions produced by subagents before user delivery or tool execution.

Return a delegation matrix, anti-pattern list, and verification tests.

Required inputs:

• Candidate task list with dependencies, expected duration, and shared resources.
• Allowed tools, MCP connections, command-line needs, and any function-tool requirements.
• Coordinator acceptance criteria for combining subagent outputs.

Expected output: A decomposition plan that rejects subagents for dependent chains and flags any design that assumes each subagent receives a separate sandbox.

Verification checkpoint: Check that the output states subagents share one environment filesystem and do not support function tools, so any function-tool-dependent task must remain outside the subagent plan or be redesigned.

Prompt 15: Shared-Filesystem Coordination Plan

Purpose: Use this prompt when the coordinator and subagents may read or edit files. In multi-agent mode, agents share one environment filesystem; creating a subagent does not create a separate workspace, so file paths, locks, merge rules, and artifact boundaries must be designed explicitly.

Copy-paste prompt:

You are designing shared-filesystem coordination for an OpenAI Agents API multi-agent workflow.

Create a coordination plan that includes:
1. Explicit assumptions about the shared workspace, /workspace working directory, files supplied at session creation, generated files, and outputs intended for publication.
2. A separation of confirmed facts from uncertainties, including unknown file-write order, partial writes, and concurrent edits.
3. Directory conventions, ownership rules, lock files or manifest files if used, merge procedures, and conflict-resolution rules for coordinator and subagents.
4. Rules for placing final artifacts under /workspace/outputs only when they are ready to be published after a turn.
5. Acceptance criteria for file integrity, artifact completeness, and attribution of command results to the correct turn or subagent where needed.
6. Human review for high-impact or irreversible artifacts before publication, distribution, or external use.

Return a filesystem map, coordination protocol, and race-condition tests.

Required inputs:

• Expected input files, generated intermediate files, and final artifact names.
• Subagent responsibilities and directories each subagent may modify.
• Validation commands or checksums used before final artifacts are published.

Expected output: A practical filesystem contract that prevents two agents from overwriting the same working file and prevents draft files from being published as final artifacts.

Verification checkpoint: Require a test where two subagents attempt to update adjacent outputs at the same time and the coordinator must detect conflicts before anything is moved into /workspace/outputs.

Prompt 16: Budget Limits and Cost-Aware Stop Conditions

Purpose: Use this prompt to define budget controls before the workflow runs in a hosted environment or calls expensive tools. OpenAI-hosted sandboxes can incur container charges separately from model usage, and tools or third-party infrastructure may have their own costs; a design review should therefore specify cost ceilings without inventing prices or assuming a public-beta feature is free to operate.

Copy-paste prompt:

You are designing budget controls for an OpenAI Agents API workflow.

Create a budget and stop-condition plan that includes:
1. Explicit assumptions about model usage, tool usage, hosted sandbox/container time, third-party services, artifact storage/downloads, and human-review cost.
2. A separation between known billing categories and uncertainties that must be verified against current account pricing and provider contracts.
3. Per-session, per-turn, per-user, per-project, and per-environment budget limits where applicable.
4. Stop, degrade, ask-for-approval, and cancel-turn behaviors when budget thresholds are reached.
5. Acceptance criteria showing users receive accurate status and operators receive enough telemetry to investigate spend.
6. Human review for high-impact or irreversible actions when a budget overrun could pressure the system into skipping validation.

Return a budget matrix, threshold policy, and cost-failure tests.

Required inputs:

• Business value of a successful run and maximum acceptable spend per workflow.
• Known billing categories for models, tools, hosted containers, partner sandboxes, and external APIs.
• Telemetry available for measuring turn duration, tool calls, retries, subagents, and artifact publication.

Expected output: A budget policy that makes cost a first-class acceptance criterion rather than an after-the-fact invoice surprise.

Verification checkpoint: Ensure the prompt output does not claim exact prices, free execution, or universal limits; it should instruct the team to verify current pricing and account-specific terms before deployment.

Prompt 17: Human Approval Gate Design

Purpose: Use this prompt for workflows that can affect money, access, production systems, legal obligations, regulated work, security posture, or user trust. Human approval should be designed as an explicit gate with evidence, authority, timeout behavior, and audit records, not as an informal “ask someone if it looks risky” instruction.

Copy-paste prompt:

You are designing human approval gates for an OpenAI Agents API workflow.

Create an approval-gate specification that includes:
1. Explicit assumptions about high-impact, irreversible, regulated, destructive, security-sensitive, and externally visible actions.
2. A separation of evidence available from session items, tool outputs, artifacts, logs, and user input versus uncertainties that reviewers must resolve.
3. Approval triggers, reviewer roles, required evidence packet, allowed decisions, rejection handling, timeout behavior, and escalation path.
4. Rules preventing the agent or application from bypassing approval through follow-up input, retry, stream recovery, or subagent delegation.
5. Acceptance criteria for auditability, reviewer accountability, user messaging, and safe cancellation.
6. Human review for every high-impact or irreversible action, with no prompt-based claim that review can be eliminated.

Return an approval matrix, reviewer checklist, and bypass-resistance tests.

Required inputs:

• Action inventory with impact classification and required approver role.
• Evidence sources reviewers can inspect before approving or rejecting.
• Policy for stale approvals when session state changes after review.

Expected output: A gate design that blocks sensitive execution until an authorized person has reviewed the relevant session state, tool evidence, and known uncertainties.

Verification checkpoint: Test a scenario where a subagent recommends an irreversible action and the coordinator attempts to proceed; the workflow must require approval based on the final action, not on which agent proposed it.

Prompt 18: Failure Injection and Acceptance-Test Matrix

Purpose: Use this prompt to turn the previous design work into concrete acceptance tests. The matrix should include stream disconnects, required-action timeouts, environment setup failure, tool failure, subagent coordination ambiguity, shared-file conflicts, budget exhaustion, artifact validation failure, cancellation, and cleanup under a busy session.

Copy-paste prompt:

You are creating failure-injection acceptance tests for an OpenAI Agents API workflow.

Build a test matrix that includes:
1. Explicit assumptions about session lifecycle, environment readiness, event streaming, required actions, tools, subagents, filesystem use, artifacts, budgets, and cleanup.
2. A separation between documented behavior, implementation evidence, and uncertainties that must be validated in staging.
3. Failure injections for disconnected streams, missed events, paginated saved-item recovery, tool errors, ambiguous side effects, required-action timeout, subagent noncompletion, shared-file overwrite, budget threshold breach, artifact corruption, cancellation, and bounded cleanup retry.
4. Acceptance criteria for each test, including expected user status, local state transition, operator log, retry decision, and human-review trigger.
5. Human review for any injected failure involving high-impact or irreversible actions.
6. A warning that passing happy-path root turn completion is insufficient unless tool outputs, saved items, and artifacts meet the workflow contract.

Return a table with test ID, injected failure, setup, expected event/state handling, acceptance criteria, and owner.

Required inputs:

• Workflow state machine and event-handling design from earlier prompts.
• Tool catalog, side-effect classification, subagent plan, filesystem plan, and budget policy.
• Staging environment constraints and the evidence required before production rollout.

Expected output: A failure-injection suite that proves the application can preserve state, stop safely, recover selectively, and escalate when uncertainty remains.

Verification checkpoint: Do not accept a test matrix that only verifies successful completion. At least one test must prove that the client refuses blind retry after stream loss, and at least one test must prove that cleanup uses bounded retry when a busy session cannot be deleted immediately.

Prompts 19–25: Production Readiness, Evidence, Privacy, Security, Evals, Rollout, and Rollback

Prompts 19–25 move the workflow from design review into production-readiness review. Use ChatGPT-5.5 as a specification critic and test-design assistant, not as proof that the Agents API workflow is safe, compliant, or operationally complete. The Agents API can preserve session state, stream events, call tools, use environments, and coordinate subagents, but your application still owns monitoring, authorization, evidence retention, privacy review, acceptance thresholds, incident handling, and human approval for high-impact or irreversible actions.

Prompt 19: Observability Plan for Sessions, Turns, Tools, and Artifacts

Purpose: Use this prompt to convert the workflow specification into an observability plan that distinguishes session health, root-turn outcomes, tool outcomes, required-action pauses, subagent activity, artifact publication, and user-visible completion. The key design rule is that agent.session.idle, a closed stream, or even a completed root turn must not be treated as proof that every tool succeeded.

Copy-paste prompt:

You are reviewing an OpenAI Agents API workflow for production observability. 
Given the workflow below, produce an observability plan with explicit assumptions, evidence-backed conclusions, uncertainty, acceptance criteria, and human review points for high-impact or irreversible actions.

Workflow:
[PASTE WORKFLOW SPECIFICATION]

Your plan must cover:
1. Session identifiers that must be stored with application conversation state.
2. Root turn events that define completed, failed, and cancelled outcomes.
3. Required-action detection and alerting.
4. Tool-call start, completion, failure, timeout, and side-effect evidence.
5. Subagent creation, coordination, and completion evidence, without assuming coordination-item completion means subagent success.
6. Artifact publication and download verification.
7. Metrics, logs, traces, alerts, dashboards, and operator runbooks.
8. What evidence is unavailable from streams and must be retrieved from saved session items.
9. Acceptance criteria for launch.
10. Human review requirements before irreversible external actions.

Required inputs: Provide the workflow goal, event types the client handles, tool list, environment type, artifact rules, subagent usage, required-action behavior, and user-facing success message.

Expected output: Expect a table of signals, sources, owners, severity levels, and acceptance thresholds, plus a list of missing telemetry that would block rollout.

Verification checkpoint: Reject the answer if it treats stream closure, idle state, or turn completion as complete workflow success without separate tool and artifact evidence.

Prompt 20: Evidence Logging and Audit-Ready Decision Record

Purpose: Use this prompt to define what evidence the application must retain so reviewers can reconstruct why an agent made a recommendation, called a tool, paused for action, retried work, or produced an artifact. Evidence logging is especially important when saved session items are the recovery source after missed stream events, because streams do not replay prior events.

Copy-paste prompt:

You are designing an evidence log for an OpenAI Agents API workflow. 
Create an audit-ready decision record template that separates assumptions, direct evidence, inferred conclusions, uncertainty, acceptance criteria, and human review requirements for high-impact or irreversible actions.

Workflow:
[PASTE WORKFLOW SPECIFICATION]

Include fields for:
- Application request ID, session ID, turn ID, item IDs, artifact IDs, and user/account context.
- Input summary and policy-relevant constraints.
- Tool calls requested, authorized, denied, completed, failed, or retried.
- Required actions and function results supplied by the application.
- Environment readiness and sandbox/network assumptions.
- Subagent tasks, shared-filesystem coordination notes, and command attribution.
- Artifact paths, publication status, download status, and retention decision.
- Operator decisions, approval timestamps, and unresolved uncertainty.
- Acceptance criteria proving the log is sufficient for incident review.

Required inputs: Provide compliance requirements, logging destinations, retention limits, user identifiers, tool side effects, approval workflow, and incident-review expectations.

Expected output: Expect a structured decision-record schema and a minimum-evidence checklist for normal completion, failure, cancellation, disconnected-stream recovery, and rollback.

Verification checkpoint: Confirm the schema avoids storing unnecessary secrets, raw credentials, or excessive personal data, and that it records uncertainty rather than converting model output into unsupported facts.

Prompt 21: Privacy, Residency, Retention, and Deletion Review

Purpose: Use this prompt before production review to identify privacy and retention conflicts. The Agents API documentation states that Agents API state is retained across turns, sessions can be deleted, published artifacts can be deleted, current data residency support is United States only, and Zero Data Retention is not supported for the Agents API; selecting a self-hosted sandbox does not make Agents API use ZDR-eligible.

Copy-paste prompt:

You are conducting a privacy, residency, and retention review for an OpenAI Agents API workflow.
Analyze the workflow below and produce explicit assumptions, evidence-backed findings, uncertainty, acceptance criteria, and human review requirements for high-impact, regulated, or irreversible actions.

Workflow:
[PASTE WORKFLOW SPECIFICATION]

Review:
1. Data categories entering the session, tools, environment, logs, artifacts, and saved items.
2. Whether any data category conflicts with United States-only Agents API residency.
3. Why this workflow must not assume Agents API Zero Data Retention.
4. Session deletion, artifact download, artifact deletion, and application-log retention steps.
5. Whether self-hosting changes environment control without changing Agents API retention eligibility.
6. Minimization rules for prompts, files, environment variables, logs, and artifacts.
7. User notice, consent, contractual review, and escalation requirements.
8. Acceptance criteria before production processing.

Required inputs: Provide data classification, jurisdictional constraints, customer commitments, artifact policy, session-deletion triggers, application-log policy, and whether the environment is hosted, self-hosted, or none.

Expected output: Expect a privacy decision record with blockers, mitigations, deletion workflow, retention owners, and questions for legal, security, or compliance teams.

Verification checkpoint: Reject any response that claims self-hosting provides ZDR, expands data residency, or removes the need to delete sessions and artifacts when policy requires cleanup.

Prompt 22: Security Red Team and Abuse-Case Review

Purpose: Use this prompt to challenge tool permissions, sandbox configuration, network egress, prompt-injection exposure, secret placement, and human approvals. For OpenAI-hosted environments, restricted network mode allows exact hostnames only and inherited template policy cannot be broadened by an override, so red-team cases should test denied egress as well as allowed egress.

Copy-paste prompt:

You are the security red team for an OpenAI Agents API workflow.
Create an adversarial test plan with explicit assumptions, evidence versus uncertainty, acceptance criteria, and mandatory human review for high-impact or irreversible actions.

Workflow:
[PASTE WORKFLOW SPECIFICATION]

Test at minimum:
- Prompt injection through user input, files, tool outputs, web content, and prior session context.
- Attempts to access secrets, API keys, environment variables, or unauthorized files.
- Network egress attempts outside the allowlist, including redirects and subdomains.
- Tool-call abuse, privilege escalation, confused-deputy behavior, and unsafe retries.
- Subagent misuse in a shared filesystem and attempts to overwrite another agent's work.
- Function-result spoofing or missing required-action validation.
- Artifact poisoning, oversized outputs, sensitive-data publication, and deletion mistakes.
- Operator bypass of approval gates.
Return prioritized findings, exploit narratives, mitigations, residual risk, and launch-blocking acceptance criteria.

Required inputs: Provide threat model, users, tools, credentials, network policy, file permissions, approval gates, logging plan, and incident escalation path.

Expected output: Expect attack scenarios mapped to controls, with pass/fail tests that engineering and security teams can automate or run manually.

Verification checkpoint: Confirm the red-team plan includes both model-behavior attacks and application-control attacks; prompts alone cannot enforce authorization or security boundaries.

Prompt 23: Representative Evaluation Dataset and Acceptance Tests

Purpose: Use this prompt to build an evaluation dataset that reflects real workflow states, not only ideal prompts. OpenAI’s evaluation guidance frames evaluation as specifying the task, running representative test inputs, analyzing results, and iterating; for Agents API workflows, representative cases should include session continuity, tool failures, required actions, artifact handling, cancellation, and disconnected-stream recovery.

Copy-paste prompt:

You are designing a representative evaluation dataset for an OpenAI Agents API workflow.
Create test cases with explicit assumptions, evidence requirements, uncertainty labels, acceptance criteria, and human review requirements for high-impact or irreversible actions.

Workflow:
[PASTE WORKFLOW SPECIFICATION]

Build a dataset covering:
1. Happy-path sessions with valid tools and artifacts.
2. Invalid, ambiguous, malicious, and out-of-scope user requests.
3. Required-action pauses and function-result validation.
4. Tool failures, partial tool success, timeout, cancellation, and bounded retry.
5. Disconnected stream recovery using saved items and item-ID reconciliation.
6. Hosted environment setup not yet connected or failed.
7. Network deny cases and artifact sensitivity cases.
8. Multi-agent independent tasks and shared-filesystem conflicts.
9. Budget exhaustion and user-visible fallback behavior.
10. Human approval cases.

Return dataset fields, labels, expected outcomes, scoring rubric, minimum pass thresholds, and unresolved uncertainty.

Required inputs: Provide target users, task contract, known failure modes, tool permissions, environment configuration, budget policy, safety requirements, and production traffic examples that can be safely transformed into test cases.

Expected output: Expect a dataset blueprint with positive, negative, adversarial, and recovery cases, plus criteria for adding new cases after incidents.

Verification checkpoint: Reject datasets that contain only successful examples or that score final text quality while ignoring events, tools, artifacts, and recovery state.

Prompt 24: Rollout Gates and Production Readiness Decision

Purpose: Use this prompt to turn engineering, privacy, security, eval, and operations evidence into explicit rollout gates. A production gate should require evidence that the application handles asynchronous turns, failed and cancelled outcomes, required actions, pagination of saved items, artifact retrieval, budget limits, and human review where necessary.

Copy-paste prompt:

You are chairing a production readiness review for an OpenAI Agents API workflow.
Create a rollout-gate decision memo with explicit assumptions, evidence-backed findings, uncertainty, acceptance criteria, and human review requirements for high-impact or irreversible actions.

Workflow and evidence:
[PASTE WORKFLOW SPECIFICATION, TEST RESULTS, SECURITY REVIEW, PRIVACY REVIEW, OBSERVABILITY PLAN]

Decide:
- Which gates are passed, blocked, or conditionally accepted.
- Required mitigations before internal pilot, limited customer exposure, or broader rollout.
- Monitoring and alert thresholds for session failures, turn failures, required-action stalls, tool errors, recovery events, artifact failures, and budget stops.
- Approval requirements for irreversible external actions.
- Rollback triggers and owner responsibilities.
- Residual risks that must be accepted by named accountable roles.

Return a launch decision, not a generic checklist.

Required inputs: Provide acceptance-test results, unresolved bugs, security findings, privacy findings, SLO or support targets, operational staffing, and stakeholder approval requirements.

Expected output: Expect a gate-by-gate memo identifying blockers, conditional approvals, monitoring obligations, and named owners for each residual risk.

Verification checkpoint: The memo must not approve launch solely because a demo completed; it must require operational evidence across failures, recovery, security, privacy, cost, and review controls.

The Codex Research Operations Playbook covers supervised agent operations, including concurrent agent sessions, experiment queues, human intervention, and safety pause gates. The complete The Codex Research Operations Playbook: Concurrent Agent Sessions, Experiment Queues, Human Intervention, and Safety Pause Gates article provides the destination-specific detail for this section’s Production Agent Rollout Gates decision because this is the closest semantic match because rollout gates for production agents rely on human intervention points and safety pause gates before scaling or continuing automation.

Prompt 25: Rollback, Post-Incident Review, and Continuous Improvement

Purpose: Use this prompt to prepare for the moment when an agent workflow behaves incorrectly, exceeds cost expectations, mishandles a tool, loses stream continuity, publishes the wrong artifact, or requires emergency disablement. Rollback design should preserve evidence, stop new risk, avoid blind retries, and improve the eval dataset after the incident.

Copy-paste prompt:

You are designing rollback and post-incident improvement for an OpenAI Agents API workflow.
Create an incident playbook with explicit assumptions, evidence versus uncertainty, acceptance criteria, and human review requirements for high-impact or irreversible actions.

Workflow:
[PASTE WORKFLOW SPECIFICATION]

Incident scenarios:
- Root turn failed, cancelled, or stalled.
- Stream disconnected before local state was complete.
- Required action was missed or supplied incorrectly.
- Tool performed an unintended side effect.
- Subagents conflicted in the shared filesystem.
- Sensitive or incorrect artifact was published.
- Network, environment, or budget policy failed.
- User-facing output was materially wrong.

For each scenario, define detection, immediate containment, session/item/artifact evidence collection, customer or stakeholder communication, rollback steps, deletion or preservation decision, root-cause analysis, eval-case additions, prompt/spec changes, and relaunch gates.

Required inputs: Provide incident severity levels, feature flags or disablement controls, evidence-log schema, session and artifact policy, support workflow, legal/compliance escalation rules, and owners.

Expected output: Expect a scenario-based incident playbook that distinguishes cancellation, retry, session deletion, artifact deletion, customer notification, and permanent design change.

Verification checkpoint: Reject any playbook that recommends retrying after a disconnect without first retrieving saved session state, saved items, turn status, and relevant artifact evidence.

Implementation Guidance: Version Prompts Like Production Specifications

Treat each prompt in this masterclass as a versioned design artifact. Store the prompt text, model used for design assistance, input workflow specification, generated output, reviewer comments, acceptance decision, and follow-up changes in the same repository or governance system that stores architecture decisions. This practice prevents teams from approving an agent workflow based on an untraceable conversation that cannot be reproduced during an audit or incident review.

Use ChatGPT-5.5 to critique specifications, generate test ideas, and expose missing assumptions; do not represent the prompt output as a permission grant, compliance certification, production monitoring substitute, or runtime guarantee. The runtime model, application authorization layer, environment configuration, and operational controls remain separate implementation choices.

Acceptance Scorecard for the Full 25-Prompt Review

A useful scorecard combines qualitative launch judgment with concrete evidence. Score each category only after reviewers inspect the underlying logs, saved items, test runs, artifacts, and approval records; the model-generated summary should make review faster, not replace the review.

For final approval, require a written decision that names accepted residual risks and records who can reopen the gate after a blocked finding. This prevents the prompt-review process from becoming a one-time checklist and turns it into a repeatable operating control for future Agents API workflow changes.

Useful Links

• OpenAI API documentation: GPT-5.5 model
• OpenAI Agents API overview
• OpenAI Agents API quickstart
• OpenAI Agents API sessions guide
• OpenAI Agents API session events guide
• OpenAI Agents API multi-agent guide
• OpenAI-hosted Agents API environments guide