OpenAI WebSocket Mode for Responses API

The second major feature group is the warmup request capability, enabled by sending `response.create` with the `generate: false` parameter. This feature allows developers to preload request state—including tools, instructions, and custom messages—before the actual generation turn begins. The warmup request returns a response ID without producing model output, but it primes the server so that the subsequent generated turn starts faster. This is particularly useful when the upcoming turn’s configuration is known in advance, as it effectively decouples state preparation from inference. The returned ID can be chained via `previous_response_id` in the next real turn, ensuring that the connection-local in-memory cache retains the prepared context. This optimization reduces startup latency in scenarios where tool definitions or system messages are static across multiple turns.

The third feature group addresses context management through two distinct mechanisms: server-side compaction and the standalone `/responses/compact` endpoint. Server-side compaction, enabled via the `context_management` parameter with a `compact_threshold`, automatically condenses the conversation during normal response generation. In WebSocket mode, this works transparently—developers continue by sending the latest `previous_response_id` and only new items. The standalone compaction endpoint offers a separate path: it returns a fully compacted input window rather than a response ID. After compaction, a new response must be created on the WebSocket using that compacted window as the base `input`, plus subsequent user or tool items. This approach provides explicit control over context size, preventing token limits from breaking long-running workflows while retaining the latency benefits of the WebSocket connection.

Overall, the WebSocket mode operates through a straightforward yet powerful workflow. A client opens a WebSocket connection to `wss://api.openai.com/v1/responses` with an authorization header. The first turn is initiated by sending a `response.create` event that includes the model, input, and tools. Subsequent turns simply send new `response.create` events containing the `previous_response_id` of the most recent response and only the incremental input. The server maintains a connection-local in-memory cache of the latest response, enabling fast continuation. The connection stays active for up to 60 minutes before it must be re-established; upon reconnection, developers can either chain from a persisted response ID (if `store=true`) or start a fresh session with full context. Error conditions such as `previous_response_not_found` or `websocket_connection_limit_reached` are signaled through structured error events.

Concrete use cases for this mode include agentic coding assistants that repeatedly invoke functions like `find_fizz_buzz()` and then optimize the result based on further instructions. Another scenario is orchestration loops where an AI agent coordinates multiple external tools—web search, database queries, and file operations—in a single continuous session. Developers building real-time customer support bots that require immediate tool lookups and response generation will also benefit from the reduced latency. The outcome in each case is faster end-to-end execution: complex workflows that previously took tens of seconds can complete in a fraction of the time, enabling more natural and engaging user interactions. For example, a coding assistant that must call a function, analyze its output, and then refactor the code can complete the entire loop within moments.

The target audience includes backend developers and ML engineers working with OpenAI’s API to build production-grade AI agents. The technology stack requires a WebSocket client library (such as the Python `websockets` library) and familiarity with the Responses API’s event model. Use cases span industries from software development to customer service automation. While specific pricing details are not enumerated here, the mode uses the same underlying model pricing as standard Responses API calls. The key takeaway is that the OpenAI WebSocket Mode for the Responses API provides a low-latency WebSocket API that makes real-time, multi-turn agentic workflows practical, reducing overhead by up to 40% and enabling developers to create more responsive and efficient AI applications.

Updated 2026-03-02