OpenAI

For the hypothetical client repair, the engineer needs the actual repository and its test runner. Codex CLI can inspect files, edit code and run commands from the terminal. If the work should continue away from that computer, Codex Cloud starts a task from a published environment. Each task has its own workspace and can continue while the engineer’s computer sleeps. The prepared environment determines which project files and tools are available. It is the starting point, not a replacement for an existing task’s working state, as the cloud-environment guide explains.

The incident-lookup application has a different job. It needs to send a request, obtain information and carry the answer back into its own workflow. The Responses API combines model output with built-in tools such as web and file search, plus calls to the application’s own functions. OpenAI recommends it for new projects while continuing to support Chat Completions. A returned item may be a message or a tool call, so the client cannot assume every output is text ready to show the responder. The Responses migration reference describes those typed items.

After the lookup returns, something has to carry its result into the next model request. That coordinating code is the agent runtime. With the Agents API, OpenAI runs the managed Codex harness, the software that coordinates the agent’s work. It manages sessions, orchestration, shortening long context through compaction, and recovery. The application still supplies its tools and chooses the environment where execution happens. A managed session does not automatically know how to query the team’s incident system.

With the Agents SDK, that runtime runs inside the application instead. It provides reusable agents, tools and handoffs between agents; the team owns deployment and tool integration. State can live in the application’s storage or supported API conversation state. For the incident lookup, the choice is therefore also about who keeps the work moving and where its record lives. The runtime comparison separates those responsibilities.

Follow a hypothetical incident note into that workflow. Excluding it from model training answers one question about its use, but not how long a service stores it or whether a connected tool receives a copy. The account, the feature that keeps the conversation going and the destination of a tool call each matter to that same piece of text.

The October 6 documentation check recorded the following account-specific controls: personal ChatGPT and Codex content could be used for model improvement, with an opt-out for new conversations and tasks. Codex had a separate Include environments control that the ChatGPT or Privacy Portal setting did not change. ChatGPT Business, Enterprise, Edu and API inputs and outputs were excluded from improvement by default. Providing consumer feedback could make the associated conversation eligible even after opt-out. Those distinctions came from the model-improvement guidance; they have not been freshly confirmed for this revision. Before submitting a sensitive note, confirm the current controls for the account you are using. Its treatment depends on where you submit it, not simply on the OpenAI name.

Now suppose the application sends the note through the API. Abuse monitoring logs can include prompts and responses and normally remain for up to 30 days, with stated exceptions. A feature may also retain application state so it can continue the work. Zero Data Retention and Modified Abuse Monitoring require approval, and eligibility and state retention vary by endpoint. Conversations, for example, remain until deleted and are not eligible for Zero Data Retention. The endpoint retention table is where those differences become specific to the request.

A tool call can take the note farther. Remote servers connected through Model Context Protocol, or MCP, supply tools through a common interface; data sent to them follows those services’ data-residency policies. Keeping a conversation out of training does not settle what that other service does with the content it receives.

The Agents API data limits add another practical distinction. Managed sessions retain state so work can continue, currently support data residency only in the United States and do not support Zero Data Retention. That remains true with a self-hosted sandbox. Running the execution environment yourself changes where that execution happens; it does not give the managed session a different storage policy. Decide whether the incident note belongs in that session before sending it.

The incident application is ready to prepare a handoff, but its next request does not go through. Before sending it again, find out what ran out: room for more requests, room for more tokens, the units of text the model processes, or the spending allowance. A wait can help with temporary throttling. It cannot refill an exhausted budget.

Request and token limits vary by model, organization and project. A 429 error can also mean a configured hard spend limit was reached, so the status number alone does not choose the next step. For temporary throttling, honor a valid Retry-After delay and account for retries already made by the installed software development kit, or SDK. Unsuccessful requests still count toward per-minute limits. If both the application and its SDK keep retrying, one delayed handoff can generate more traffic than intended. The rate-limit guide explains the headers, SDK differences and limits on both attempts and total retry time.

Repeated handoffs can reuse some processing without reusing yesterday’s incident. Prompt caching works on a matching input prefix, the unchanged beginning of the request. Stable instructions and service references can go there, with current observations after them. For GPT-5.6 and later, the default 30-minute cache setting charges writes at 1.25 times the ordinary input-token rate. Reads cost 0.1 times that rate on most models and 0.05 times on GPT-6.1 Sol. These models allow explicit and implicit breakpoints, places chosen by the application or the service to mark reusable prefixes. The default minimum lifetime is 30 minutes and is refreshed by reuse; entries may remain longer. Earlier models have different controls and prices. The caching reference keeps those generation-specific rules distinct.

A cache hit still leaves the responder waiting for a useful handoff. The worked caching guide compares spending across all attempts with the handoffs reviewers accept. Saving processing on an answer that needs to be rebuilt is a different result from saving the engineer work.

If the application moves from reading the incident to changing a service, the function handler becomes especially important. In function calling, the model returns a call; the application executes the handler and sends its output back. A read-only lookup and a handler that changes state therefore have different consequences. In a hypothetical rollback, approval names the deployment and the revision reviewed. If the write times out, the application needs a destination readback before another attempt because the rollback may already have happened. The production-agent guide follows that bounded action through the uncertainty.

The observation that comes back has a time attached, too. Yesterday’s healthy result may belong in a historical incident account, but summarizing it neatly does not establish recovery now. The monitoring-freshness guide follows collection, evaluation and delivery: an urgent recovery decision needs observations recent enough for that decision. The handoff should leave the next responder knowing what was seen and when, not merely what the model said.