OpenAI చెప్పింది: Persistent WebSocket Sessions వల్ల Agent Loop Latency సుమారు 40% తగ్గింది

వేగవంతమైన Agent Loops ఎందుకు ముఖ్యమో

agent-style workflowsను గణనీయంగా వేగవంతం చేయడానికి తమ Responses API వెనుక ఉన్న plumbingను తిరిగి రూపకల్పన చేశామని OpenAI చెబుతోంది. complex tasks సమయంలో tools, models, మరియు API calls మధ్య నిరంతరం ముందుకు-వెనుకకు జరిగే ఆలస్యాన్ని తగ్గించడమే ఈ మార్పు లక్ష్యం.

ఏప్రిల్ 22న ప్రచురితమైన ఒక technical post‌లో, Codex వంటి systems ఒకే assignment‌ను పూర్తిచేయడానికి డజన్ల కొద్దీ sequential requests అవసరం పడవచ్చని కంపెనీ వివరించింది: model తదుపరి ఏం చేయాలో నిర్ణయిస్తుంది, client side‌లో ఒక tool నడుస్తుంది, ఫలితం APIకి పంపబడుతుంది, ఆ చక్రం మళ్లీ మొదలవుతుంది. ఆ pattern‌లో చిన్న overhead కూడా వేగంగా పేరుకుపోతుంది.

OpenAI ప్రకారం, inference స్వయంగా వేగంగా మారేకొద్దీ performance సమస్య మరింత స్పష్టంగా కనిపించింది. Responses APIలోని earlier flagship models సుమారు 65 tokens per second వేగంతో పనిచేశాయని కంపెనీ తెలిపింది. GPT-5.3-Codex-Spark కోసం Cerebras hardwareను ఉపయోగించి 1,000 tokens per second కంటే ఎక్కువ లక్ష్యాన్ని OpenAI పెట్టుకుంది. model generation అంత వేగంగా మారిన తర్వాత, loop‌లోని నెమ్మదైన భాగాలను దాచిపెట్టడం కష్టం అయింది.

Inference Bottleneck నుండి API Bottleneck వరకు

OpenAI agent latencyని మూడు broad stages‌గా విభజిస్తుంది: API service work, model inference, మరియు client-side time. tools execute కావాలి, context assemble కావాలి కాబట్టి client side ఇంకా ముఖ్యమే, కానీ API layer itself ఒక ముఖ్యమైన bottleneckగా మారిందని కంపెనీ చెప్పింది.

ఆ మార్పు వేరే optimization strategyని అవసరం చేసింది. GPU throughput మీద మాత్రమే దృష్టి పెట్టడం బదులు, request path అంతటా frictionను తొలగించడం ప్రారంభించామని OpenAI చెబుతోంది. సుమారు 2025 నవంబర్‌లో, కంపెనీ Responses API కోసం ఒక performance sprint‌ను ప్రారంభించింది. ఇందులో rendered tokens మరియు model configurationను memoryలో cache చేయడం, inference services‌ను మరింత నేరుగా call చేసి అదనపు network hops‌ను తగ్గించడం, అలాగే కొన్ని conversationsను వేగంగా classify చేయడానికి safety stackలోని భాగాలను వేగవంతం చేయడం ఉన్నాయి.

ఈ మార్పులు time to first token‌ను దాదాపు 45% మెరుగుపరిచాయని కంపెనీ తెలిపింది. కానీ కొత్త inference stack వేగాన్ని పూర్తిగా బయటపెట్టడానికి అది ఇంకా సరిపోలేదని OpenAI చెబుతోంది.

WebSocket Shift

ముఖ్యమైన మార్పు architecturalమైనది: వేర్వేరు synchronous API calls శ్రేణిని WebSockets ఉపయోగించే persistent connection‌తో Responses APIకి మార్చడం. ఆచరణలో దీని అర్థం client మరియు API మొత్తం agent loop అంతటా connectedగా ఉండగలగడం, ప్రతి సారి request stateను విడదీయి మళ్లీ నిర్మించాల్సిన అవసరం లేకుండా.

Persistent sessions వల్ల connectionకే useful informationను attach చేసి ఉంచగలిగామని OpenAI చెబుతోంది. దీంతో repeated setup work తగ్గింది, turns మధ్య contextను system మరింత సమర్థవంతంగా reuse చేయగలిగింది. ఫలితంగా end-to-end agent loop speedలో సుమారు 40% మెరుగుదల వచ్చిందని కంపెనీ తెలిపింది.

వినియోగదారుల కోసం దీని ప్రాధాన్యం స్పష్టమే. ఒక coding లేదా research agent పని ముగించడానికి అనేక tool calls అవసరమైతే, ప్రతి cycle నుండి overhead తగ్గించడం ఒక stageను మాత్రమే వేగవంతం చేయడానికంటే ఎక్కువ ప్రభావం చూపుతుంది. ఒకప్పుడు చర్యల మధ్య ఆగిపోయినట్లు అనిపించిన workflow, ఇప్పుడు live interactionకి దగ్గరగా అనిపించవచ్చు.

OpenAI ఏమి Optimize చేసింది

• ఖరీదైన setup workను పునరావృతం చేయకుండా ఉండేందుకు connection-scoped caching.
• API services మరియు inference services మధ్య అనవసర network hopsను తగ్గించడం.
• Moderation మరియు classification pipelineలోని కొన్ని భాగాల్లో వేగవంతమైన safety checks.
• బహుళ-turn tool use ఖర్చును తగ్గించడానికి persistent WebSocket channel.

ఈ పని పరిశ్రమలో జరుగుతున్న పెద్ద మార్పుకు ప్రతిస్పందనగా OpenAI పేర్కొంది: inference ఇప్పుడు తగినంత వేగంగా మారుతోంది, కాబట్టి చుట్టూ ఉన్న systemsనే perceived product qualityను ఎక్కువగా నిర్ణయిస్తున్నాయి. అటువంటి పరిస్థితిలో, model వేగంగా ఆలోచించగలదు, కానీ orchestration layers వెనుకబడితే అనుభవం ఇంకా నెమ్మదిగానే అనిపిస్తుంది.

Codex దాటితే ఎందుకు ముఖ్యం

OpenAI ఈ సమస్యను Codex ఉదాహరణతో చూపించినప్పటికీ, దాని ప్రభావం ఏ tool-using agentకైనా వర్తిస్తుంది. Enterprise assistants, customer-service systems, research copilots, మరియు software agents అన్నీ ఒక long model completion కంటే అనేక చిన్న interactions మీద ఆధారపడతాయి. అందువల్ల persistent sessions మరియు తక్కువ orchestration overhead raw benchmark performance जित్తేనే కీలకంగా మారవచ్చు.

ఈ post మారుతున్న competitive landscape‌ను కూడా చూపిస్తుంది. సంవత్సరాలుగా model vendors మెరుగైన reasoning మరియు పెద్ద context windowsపై దృష్టి పెట్టారు. కానీ ఇప్పుడు వారు systems engineeringలో కూడా పోటీ పడుతున్నారు: throughput, responsiveness, safety latency, మరియు external toolsతో modelను loopలో ఎంత సమర్థవంతంగా ఉంచగలుగుతారన్న విషయంలో.

Model చుట్టూ ఉన్న infrastructure ఇప్పుడు తనదైన ఒక product feature అని OpenAI సందేశం. inference speeds ఇంకా పెరుగుతూనే ఉంటే, అది మరింత నిజం అవుతుంది.

పెద్ద సంకేతం

లోతైన takeaway కేవలం WebSockets repeated synchronous calls కంటే వేగవంతమైనవి అనే విషయం మాత్రమే కాదు. agent products నిజమైన real-time software systems‌గా రూపాంతరం చెందుతున్నాయి; వాటి performance APIs, caches, safety layers, మరియు tool runtimes మధ్య coordinationపై ఆధారపడి ఉంటుంది.

ఈ update ఒక engineering footnote కంటే ఎక్కువ. AI usabilityలో తదుపరి లాభాలు ప్రతి individual step‌ను మరింత smarter చేయడం కంటే, model steps మధ్య frictionను తగ్గించడం ద్వారా రావచ్చని ఇది సూచిస్తోంది. agentic systems ఎక్కువ పొడవైన మరియు సంక్లిష్టమైన tasksను చేపట్టే కొద్దీ, అవి experimentalగా అనిపించాలా లేదా operationalగా అనిపించాలా అన్నది ఈ తేడానే నిర్ణయించవచ్చు.

ఈ article OpenAI reporting ఆధారంగా ఉంది. మూల article చదవండి.