# OpenAI WebSocket Mode for Responses API: How to Use It and Why It's a Game-Changer for AI Agents (2026) OpenAI has officially launched **WebSocket mode** for its Responses API (`wss://api.openai.com/v1/responses`) — a persistent, low-latency connection designed specifically for long-running agentic workflows. If you're building AI agents that loop through dozens of tool calls, this is the most impactful infrastructure update OpenAI has shipped in recent months. * * * ## What Is WebSocket Mode for the Responses API? Unlike the traditional HTTP REST approach where every turn opens a brand-new connection, WebSocket mode lets your agent maintain a **single persistent connection** to `/v1/responses` across the entire workflow. Each new turn sends only **incremental inputs** (new user messages or tool outputs) along with a `previous_response_id` reference — no need to resend full conversation history. This is made possible by a **connection-local in-memory cache** that the server keeps for your most recent response on that socket. > **Key distinction:** This is different from the existing OpenAI Realtime API (`wss://api.openai.com/v1/realtime`), which handles speech-to-speech audio. The new WebSocket mode is for the **text/chat Responses API**, aimed at orchestration, agentic coding, and tool-heavy pipelines. * * * ## Why This Matters: Performance Gains The old pattern — HTTP polling with full context resent each turn — adds significant overhead in agents that call many tools. WebSocket mode directly fixes this.

Workflow Type	HTTP REST Pattern	WebSocket Mode
Single turn Q&A	Fine	Fine
5–10 tool call loop	Moderate overhead	Faster
20+ tool call chain	High overhead, slow	Up to ~40% faster
ZDR / `store=false`	Works	Fully compatible
Parallel runs	N/A	Multiple connections needed

The in-memory cache is the key. Instead of re-hydrating context from disk on every turn, the server reuses connection-local state for continuation — making each round-trip meaningfully faster in long agent loops. * * * ## How to Connect: Step-by-Step ### Step 1 — Open the Connection Install the `websocket-client` library if using Python (`pip install websocket-client`), then connect with your API key: ```python from websocket import create_connection import json, os ws = create_connection( "wss://api.openai.com/v1/responses", header=[ f"Authorization: Bearer {os.environ['OPENAI_API_KEY']}", ], ) ``` ### Step 2 — Send Your First `response.create` Fire the first turn with the full system prompt, tools, and the user's initial message: ```python ws.send(json.dumps({ "type": "response.create", "model": "gpt-5.2", "store": False, "input": [ { "type": "message", "role": "user", "content": [{"type": "input_text", "text": "Find the fizz_buzz() function in my codebase."}] } ], "tools": [ # your tool definitions here ] })) ``` ### Step 3 — Continue Turns Incrementally For every follow-up turn, only send new inputs + chain from the previous response ID. **Never resend full conversation history.** ```python ws.send(json.dumps({ "type": "response.create", "model": "gpt-5.2", "store": False, "previous_response_id": "resp_abc123", "input": [ { "type": "function_call_output", "call_id": "call_xyz", "output": "{ 'result': 'function found at line 42' }", }, { "type": "message", "role": "user", "content": [{"type": "input_text", "text": "Now optimize it for performance."}], } ], "tools": [] })) ``` ### Step 4 — Warm Up for Faster First-Turn Response Pre-warm the connection with `generate: false` to load context into cache before the user speaks: ```python ws.send(json.dumps({ "type": "response.create", "model": "gpt-5.2", "store": False, "generate": False, "input": [ {"type": "message", "role": "system", "content": [{"type": "input_text", "text": "You are a helpful booking assistant."}]} ], "tools": [] })) ``` * * * ## Integrating With Voice Agents The WebSocket Responses API is the **orchestration brain** of your voice agent pipeline. Here's the full architecture: ```plaintext User speaks ↓ [STT — Whisper / Deepgram] ↓ (transcript text) [Responses API WebSocket] ← persistent connection ↓ (text + tool calls) [Tool Execution Layer] (calendar, CRM, search, etc.) ↓ (tool result) [Responses API WebSocket] ← incremental continuation ↓ (final text response) [TTS — OpenAI TTS / ElevenLabs] ↓ User hears response ``` **Why not just use the Realtime API for everything?** The Realtime API (`/v1/realtime`) is best for native speech-to-speech without intermediate text. But if you need custom tool execution logic, text processing middleware, or `store=false` ZDR compliance, the **Responses API WebSocket + STT + TTS** pattern gives you far more control. * * * ## Key Use Cases ### 1\. Agentic Coding Assistants An AI coding agent that runs `read_file → analyze → edit → run_tests → fix → run_tests` in a loop is exactly what this is built for. With 20+ tool call chains being up to 40% faster, coding agents like Cursor-style tools benefit enormously. ### 2\. Voice-Based Customer Support Bots Phone bots (built with Twilio, Plivo, or Exotel) can now use the Responses API WebSocket as the brain — keeping one persistent connection open per call session, handling CRM lookups, booking confirmations, and escalation logic through tool calls, all over a single socket. ### 3\. Real-Time Orchestration Pipelines Multi-agent orchestration systems — where a supervisor agent delegates tasks to sub-agents — benefit from incremental input continuation. Each delegation round trip doesn't re-upload the full context. ### 4\. Long-Running Research Agents An agent that browses the web, reads documents, calls search APIs, and synthesizes answers can now run a full 30–50 step pipeline without latency overhead accumulating at every turn. ### 5\. AI Tutors and Learning Bots Educational platforms running multi-turn Socratic dialogue with code execution and adaptive questioning can maintain session state on one persistent connection per student, with clean ZDR compliance for student data privacy. * * * ## How It Improves Existing Agents * **No repeated context uploads** — only new items are sent per turn, not the full thread * **Connection-local cache** — the server reuses in-memory state instead of loading from disk on each turn * **ZDR-compatible** — works with `store=false`, so no conversation data is persisted to OpenAI servers * **Warmup support** — pre-load tools and instructions before the user's first message to eliminate cold-start latency * **Sequential safety** — runs are executed one at a time on a connection, preventing race conditions * * * ## Connection Limits and Error Handling * **Max 60 minutes** per WebSocket connection — implement a reconnect handler that resumes from the last `response_id` * **No multiplexing** — if you need parallel agent runs, open separate connections * `previous_response_not_found` — returned when the cached ID is missing; handle by sending full context again or using `/responses/compact` first ```python def reconnect_and_continue(last_response_id, full_context): ws = create_connection( "wss://api.openai.com/v1/responses", header=[f"Authorization: Bearer {os.environ['OPENAI_API_KEY']}"] ) ws.send(json.dumps({ "type": "response.create", "model": "gpt-5.2", "store": True, "previous_response_id": last_response_id, "input": full_context, "tools": [] })) return ws ``` * * * ## `/responses/compact` — Your Context Window Safety Net For very long agent runs that approach context limits, use `/responses/compact` to compress history, then start a fresh chain: ```python compacted = client.responses.compact(model="gpt-5.2", input=long_input_array) ws.send(json.dumps({ "type": "response.create", "model": "gpt-5.2", "store": False, "previous_response_id": None, "input": [ *compacted.output, {"type": "message", "role": "user", "content": [{"type": "input_text", "text": "Continue from here."}]} ], "tools": [] })) ``` * * * ## Quick Reference: Which Transport to Use

Scenario	Best Transport
Browser voice app (mic input)	WebRTC (`/v1/realtime`)
Server-to-server speech-to-speech	WebSocket Realtime API
Server agent with many tool calls	WebSocket Responses API (new)
Simple single-turn chat	HTTP REST `/v1/responses`
Long agentic coding / research runs	WebSocket Responses API (new)

OpenAI's new WebSocket mode for the Responses API marks a clear architectural shift — from stateless HTTP calls to stateful, session-aware agent connections. For any developer building production AI agents in 2026, this is the right transport layer to adopt now.