OpenAI ускорила Codex‑агентов на 40%: как WebSocket‑режим в Responses API выжимает максимум из 1000 токенов в секунду — VogueTech

Что нового

OpenAI серьёзно разогнала агентные сценарии в Responses API — прежде всего для Codex и моделей серии GPT‑5.x.

Главные изменения:

WebSocket‑режим в Responses API вместо серии обычных HTTP‑запросов.
До 40% ускорения end‑to‑end для агентных воркфлоу по данным ранних пользователей.
Видимая разница в скорости генерации:
- старые флагманские модели вроде GPT‑5 и GPT‑5.2 работали примерно на 65 токенов в секунду (TPS);
- новый быстрый кодовый движок GPT‑5.3‑Codex‑Spark целится в 1000+ TPS и уже показывает пики до 4000 TPS на продовом трафике.
Сокращение времени до первого токена (TTFT) примерно на 45% за счёт оптимизаций в API‑слое.
Поддержка привычного интерфейса: тот же response.create, плюс поле previous_response_id для продолжения контекста.

Кто уже пользуется и что у них по цифрам:

Codex перевёл большую часть своего трафика в WebSocket‑режим и получил заметное снижение задержек.
Vercel встроил WebSocket‑режим в AI SDK и увидел до 40% уменьшения латентности.
Cline ускорил многофайловые сценарии разработки на 39%.
Cursor сделал работу с моделями OpenAI до 30% быстрее.

WebSocket‑режим стал одной из самых серьёзных доработок Responses API со времени его запуска в марте 2025 года.

Как это работает

Где раньше тормозило

Типичный цикл Codex‑агента выглядит так:

Модель решает, что делать дальше.
Агент вызывает локальный инструмент (например, тесты или линтер).
Агент отправляет результат инструмента обратно в Responses API.
Модель делает следующий шаг.

Раньше каждый шаг — это отдельный HTTP‑запрос:

нужно снова валидировать запрос,
прогнать safety‑классификаторы,
собрать контекст, включая длинную историю диалога,
токенизировать вход,
запустить инференс.

Пока инференс был узким местом (LLM на GPU выдавали ~65 TPS), накладные расходы API почти не чувствовались. Но с переходом на специализированные чипы Cerebras, которые разгоняют GPT‑5.3‑Codex‑Spark до 1000+ TPS, стало видно, что:

GPU ждут, пока CPU‑слой API закончит рутину;
на длинных диалогах время на обработку истории растёт с каждым шагом.

Оптимизации до WebSocket‑режима

Осенью 2025 года OpenAI провела спринт по ускорению Responses API. В критический путь для одного запроса добавили несколько оптимизаций:

Кэширование отрендеренных токенов и конфигурации модели в памяти.
- Для многошаговых ответов не нужно каждый раз заново токенизировать и ходить по сети за конфигом.
Меньше сетевых прыжков.
- Убрали часть промежуточных сервисов (например, отдельную обработку разрешения картинок) и стали напрямую ходить в сервис инференса.
Ускоренный safety‑стек.
- Некоторые классификаторы научились проверять диалог быстрее.

Это дало около 45% улучшения TTFT. Но для GPT‑5.3‑Codex‑Spark этого всё равно не хватало: при такой скорости инференса накладные расходы API стали слишком заметными.

Корневая проблема — архитектура: Responses API относился к каждому запросу как к независимому. Даже если диалог почти не менялся, API каждый раз полностью пересобирал состояние.

Переход к постоянному соединению

Дальше команда пересмотрела транспорт:

вместо множества HTTP‑запросов — одно длительное соединение;
вместо пересылки всей истории — инкрементальные обновления и кэширование состояния в памяти.

OpenAI рассматривала WebSockets и gRPC bidirectional streaming. В итоге выбрали WebSockets по двум причинам:

это просто транспорт сообщений,
можно сохранить существующий формат входа/выхода Responses API.

Первый прототип

В прототипе один агентный прогон моделировался как один длинный Response:

Responses API запускал инференс и асинхронно блокировался в момент, когда модель вызывала инструмент.
API отправлял клиенту событие response.done с описанием вызова инструмента.
Клиент выполнял инструмент локально и присылал обратно response.append с результатом.
Инференс продолжался с учётом этого результата.

По сути, локальный инструмент работал так же, как хостed‑инструмент в облаке:

модель "звонит" в сервис (но в нашем случае — в клиента по WebSocket),
получает ответ,
подмешивает его в контекст и идёт дальше.

Этот подход сильно уменьшал повторную работу API:

пред‑инференсные шаги выполнялись один раз в начале;
дальше шло ожидание инструментов;
пост‑обработка выполнялась один раз в конце.

Минус — непривычная форма API. Разработчикам пришлось бы переписывать интеграции под новый режим взаимодействия.

Финальный дизайн: быстро, но знакомо

В релизной версии OpenAI вернулась к знакомому интерфейсу:

всё так же используется response.create с привычным телом запроса;
для продолжения контекста добавилось поле previous_response_id.

Как это выглядит под капотом на WebSocket‑соединении:

сервер хранит кэш состояния по соединению в памяти;
когда приходит новый response.create с previous_response_id, Responses API:
- достаёт состояние из кэша,
- не пересобирает историю диалога с нуля,
- использует уже подготовленные артефакты.

В кэше лежит:

предыдущий объект response;
прошлые входные и выходные элементы;
определения инструментов и namespace‑ы;
отрендеренные токены и другие артефакты семплинга.

За счёт этого OpenAI получила несколько важных оптимизаций:

Safety и валидация только по новым данным.
- Классификаторы и валидаторы работают не по всей истории, а по свежему фрагменту.
Кэш токенов.
- API не токенизирует заново уже отрендеренную часть, а просто дописывает новые токены.
Повторное использование логики маршрутизации модели.
- Удачный выбор конкретного сервиса/шарда сохраняется и переиспользуется.
Параллельная пост‑обработка.
- Неблокирующие задачи после инференса (например, биллинг) можно перекрывать следующими запросами.

Цель — максимально приблизиться по скорости к первому прототипу с одним длинным Response, но без ломки привычного API.

Что это значит для вас

Кому это реально поможет

Разработчикам код‑агентов и IDE‑интеграций

Если вы строите:
- автодополнение кода с анализом проекта,
- агентов, которые сами правят файлы и гоняют тесты,
- ассистентов для работы с несколькими файлами и репозиториями,
— WebSocket‑режим снижает общее время цикла на до 40%. Это уже чувствуется как "другой класс отзывчивости".
Командам, у которых много инструментов в цепочке

Чем больше шагов "модель → инструмент → модель" в вашем пайплайне, тем сильнее вы выигрываете:
- меньше накладных расходов на HTTP;
- меньше повторной обработки истории;
- лучше масштабирование при росте длины сессии.
Продуктам уровня Codex, Cursor, Cline, Vercel AI SDK

Если вы строите сервис поверх OpenAI и у вас:
- много одновременных пользователей,
- длинные сессии,
- сложные агентные сценарии,
— переход на WebSocket‑режим Responses API даёт:
- до 30–40% снижения латентности по реальным кейсам;
- возможность раскрыть потенциал быстрого инференса GPT‑5.3‑Codex‑Spark с 1000–4000 TPS.

Где эффект будет меньше

Простые чаты и короткие запросы.
- Если вы делаете обычный чат‑бот с короткими запросами и ответами, выигрыш будет, но не драматический.
- Основной профит WebSocket‑режима — на длинных агентных сессиях.
Редкие, одиночные запросы.
- Если ваш сервис делает по одному запросу раз в несколько минут, постоянное соединение и кэш не дают большого преимущества.

Практические советы по использованию

Переходите на WebSocket‑режим, если у вас есть:
- цепочки из нескольких tool calls;
- многотуровые диалоги с моделью;
- сложные сценарии редактирования кода или документов.
Используйте previous_response_id.
- Стройте логику так, чтобы каждый следующий шаг ссылался на предыдущий Response.
- Не пересылайте лишнюю историю, дайте Responses API работать с кэшем.
Следите за длиной сессий.
- Очень длинные сессии — это не только память, но и потенциальные задержки.
- Логично периодически "обнулять" контекст, если старые шаги уже не нужны.
Заложите fallback на HTTP.
- WebSocket‑режим удобен, но держите возможность откатиться на обычные HTTP‑запросы, если что-то пойдёт не так в проде.

Доступность из России

OpenAI официально не работает на российском рынке. Для прямой работы с Responses API и WebSocket‑режимом в большинстве случаев понадобится:

зарубежный аккаунт OpenAI,
платёжный метод, который OpenAI принимает,
часто — VPN или инфраструктура за пределами России (сервер, прокси, облако).

Если вы делаете продукт для глобальной аудитории, проще разворачивать интеграции в зарубежных облаках и обращаться к OpenAI оттуда.

Место на рынке

Прямых численных сравнений с другими вендорами OpenAI не приводит, но по самим цифрам внутри экосистемы видно следующее.

Внутри линейки OpenAI

Старые флагманы GPT‑5 / GPT‑5.2: порядка 65 TPS.
Новый быстрый кодовый движок GPT‑5.3‑Codex‑Spark:
- цель — 1000+ TPS,
- реальные пики — до 4000 TPS на боевом трафике Codex.

WebSocket‑режим Responses API нужен именно для того, чтобы API‑слой успевал за таким инференсом и не превращался в главный тормоз.

По отзывам партнёров:

Vercel AI SDK: до 40% меньше латентности.
Cline: многофайловые сценарии разработки на 39% быстрее.
Cursor: работа с моделями OpenAI до 30% быстрее.

То есть WebSocket‑режим уже стал стандартом для тех, кто строит серьёзные кодовые инструменты на базе OpenAI.

По отношению к другим игрокам

В исходных данных нет конкретных цифр по скорости или ценам конкурентов, поэтому можно зафиксировать только тенденцию внутри экосистемы OpenAI:

как только инференс разогнали с десятков TPS до тысяч TPS,
стало критично ускорять всё вокруг — транспорт, кэш, safety, биллинг.

WebSocket‑режим в Responses API — это шаг к тому, чтобы агентные сценарии перестали упираться в CPU‑слой и сеть и начали реально использовать потенциал быстрых моделей вроде GPT‑5.3‑Codex‑Spark.

Для разработчика это означает простую вещь: если вы строите серьёзный агентный продукт на OpenAI, WebSocket‑режим Responses API становится не "приятным бонусом", а базовым требованием к нормальной скорости работы.