हाइब्रिड रीज़निंग एजेंट: लेटेंट सोच, टेक्स्ट में एक्शन

LLM एजेंट के बारे में एक असहज सच्चाई यह है: वे जो ज़्यादातर टोकन बनाते हैं, वह महंगा फ़िलर होता है। गणित का सवाल हल करने वाला reasoning एजेंट बड़े आराम से “मैं सवाल दोबारा पढ़ता हूँ” और “अब तक मुझे यह मिला है कि...” जैसे वाक्य पूरी inference कीमत पर लिख डालता है, यानी असली अंकगणित जितना ही compute वह भाषण की भूमिका पर भी खर्च करता है। लेटेंट रीज़निंग, यानी टेक्स्ट में सोचने की बजाय मॉडल की hidden states के भीतर सोचना, हमेशा से स्पष्ट समाधान रहा है, और Hybrid Reasoning Agents पर आया नया पेपर दिखाता है कि यह अब आख़िरकार व्यावहारिक हो गया है। लेकिन इस स्पष्ट समाधान की एक कीमत है जिसे इस क्षेत्र का कोई भी व्यक्ति पसंद नहीं करता: अब आप पढ़ नहीं सकते कि मॉडल क्या सोच रहा है।

मैंने कई सालों तक टीमों को chain-of-thought को सस्ता बनाने की कोशिश करते देखा है। हर तरीका एक ही दीवार से टकराता है, और यह समझना ज़रूरी है कि हाइब्रिड तरीका अलग कैसे है, और मैं फिर भी उसे वहाँ तैनात नहीं करूँगा जहाँ चुपचाप होने वाली गलती बर्दाश्त न हो सके।

टेक्स्ट-आधारित Chain-of-Thought टोकन क्यों बर्बाद करता है

Chain-of-thought एक सचमुच शानदार खोज थी। मॉडल को बीच के चरण लिखने दो, और गणित, तर्क और multi-hop सवालों पर सटीकता नाटकीय रूप से बढ़ जाती है। समस्या यह है कि कंप्यूटेशन के लिए भाषा एक घटिया serialization format है। शब्द lossy होते हैं, दोहराव से भरे होते हैं, और, आपके inference बिल के लिए सबसे अहम बात, क्रमिक होते हैं।

सोचिए जब मॉडल हल करने से पहले “समस्या को दोबारा बताता है”, तब क्या होता है। यह कुछ सौ टोकन होते हैं, जो एक-एक करके बनते हैं, और हर एक के लिए पूरा forward pass लगता है, जबकि इनमें जानकारी लगभग शून्य होती है, क्योंकि समस्या का कथन पहले से context में है। आज के reasoning मॉडल ऐसी चीज़ों से भरे पड़े हैं। मौजूदा पीढ़ी के मॉडल का reasoning trace जिसने भी देखा है, उसने आत्म-आश्वासन, दोहराव और हिचकिचाहट के अनुच्छेद देखे होंगे, जिन्हें कोई इंसानी इंजीनियर बस शोर कहेगा। tool calls वाले agentic कामों में हालत और बुरी है: मॉडल बताता है कि वह क्या करने वाला है, फिर करता है, फिर बताता है कि उसने अभी क्या किया।

यह अर्थशास्त्र agent के पैमाने पर और बढ़ जाता है। जो एजेंट हर tool call से पहले लंबी reasoning भूमिका के साथ दस tool calls करता है, वह अपने token budget का 80% तक narration पर खर्च कर सकता है। अगर आप प्रति टोकन भुगतान करते हैं, और आप करते ही हैं, तो यह असली पैसा है। यह latency भी है, और उन एजेंट्स के लिए बहुत मायने रखती है जिनका इंतज़ार इंसान कर रहे हैं। यही दबाव सस्ते, तेज़ inference tiers की ओर धकेल रहा है: असली बाधा बुद्धिमत्ता नहीं, बल्कि उसे शब्दों में व्यक्त करने की लागत है।

असफल प्रयास: Truncation, Distillation और शुद्ध Latent Reasoning

इस क्षेत्र ने तीन दिशाओं से इस पर हमला किया, और हर एक उल्लेखनीय तरीके से टूटा।

प्रयास 1: बस कम टोकन बनाओ

Budget forcing, length penalties, terse-reasoning fine-tunes, यानी सबसे सीधा तरीका है कि मॉडल टेक्स्ट में कम सोचे। एक हद तक यह काम करता है, फिर सटीकता अचानक गिर जाती है। लंबा trace पूरी तरह बेकार नहीं होता; उसकी कुछ दोहराव वाली बातें भी भार उठाती हैं। अंधाधुंध compression फ़िलर के साथ कंप्यूटेशन भी फेंक देता है, और बाहर से आप बता नहीं सकते कि कौन-सा क्या था।

प्रयास 2: शुद्ध Latent Reasoning

ज़्यादा सुरुचिपूर्ण विचार यह है कि सोचने वाले टोकन बनाए ही न जाएँ। मॉडल के output embeddings को वापस input के रूप में डालो, असतत शब्दों की जगह एक लगातार “thought vector”, और मॉडल को उत्तर देने से पहले कई चरणों तक भीतर ही भीतर सोचने दो। COCONUT जैसे शोध ने दिखाया कि यह कुछ कामों पर टेक्स्ट chain-of-thought के बराबर या उससे बेहतर हो सकता है, वह भी forward passes के एक हिस्से में। लेकिन एजेंट्स के लिए शुद्ध latent reasoning की दो घातक समस्याएँ हैं। पहली, बाहरी दुनिया टेक्स्ट में बोलती है: tool APIs string arguments लेते हैं, search engines queries लेते हैं, उपयोगकर्ता जवाब गद्य में चाहते हैं। जो मॉडल केवल vectors में सोचता है, उसे सीमा पर हर चीज़ का अनुवाद करना पड़ता है, और गलतियाँ इसी अनुवाद में छिपती हैं। दूसरी, और इसी पर लोग बहस करते हैं, सोच एक black box बन जाती है। आप reasoning trace पूरी तरह खो देते हैं, जबकि फ़िलहाल वही एकमात्र ठीक-ठाक खिड़की है यह समझने की कि मॉडल ने कुछ क्यों किया।

प्रयास 3: Pause tokens और फ़िलर कंप्यूटेशन

एक शांत धारा ने बेमतलब “pause” tokens डालकर मॉडल को बिना अतिरिक्त सामग्री के अतिरिक्त compute देने की कोशिश की। नतीजे अधिक से अधिक मिश्रित रहे, और यह कभी प्रयोगशाला से बाहर नहीं निकला। पता चला कि बीच के टोकन की सामग्री computation को दिशा देने में मायने रखती है, सिर्फ़ उनका होना नहीं।

जो सचमुच काम करता है: Hybrid Reasoning Agents

HybridAgent पेपर वह व्यावहारिक रुख लेता है जो मैं और शोध में देखना चाहता हूँ: latent और text reasoning में से चुनना बंद करो, और मॉडल को generation के बीच में बदलने दो। आंतरिक computation के समय latent में सोचो; tool को कॉल करने, उसका आउटपुट पढ़ने, या किसी इंसान को समझाने की ज़रूरत हो तो text पर जाओ।

आर्किटेक्चर के तीन हिस्से समझने लायक हैं। HybridLink नाम का एक हल्का module संक्रमण संभालता है, यानी latent segment की अंतिम hidden state को ऐसे रूप में बदलता है जिससे text-mode मॉडल आगे बढ़ सके, और उलटा भी। एक continuous working memory पूरे hybrid context को turns के पार रखती है, ताकि पहले turn के latent विचार पाँचवें turn में भी उपलब्ध रहें, न कि text सारांश में सिकुड़ जाएँ। और training के मामले में दो चरण हैं: HybridSFT बैकबोन को HybridLink के साथ तालमेल बिठाना सिखाता है, फिर HybridRL reinforcement learning से सिखाता है कि कब हर mode अपनी कीमत के लायक है।

मेरी राय में यही असली योगदान है। कठिन समस्या कभी यह नहीं थी कि “क्या मॉडल latent space में सोच सकता है”, हम जानते थे कि सोच सकता है। कठिन समस्या policy है: किसी काम के कौन-से हिस्से सस्ती अपारदर्शी computation के हक़दार हैं और कौन-से महँगे, जाँचे जा सकने वाले text के। यह policy RL से, असली task rewards के विरुद्ध सीखना ही वह तरीका है जिससे कुछ ऐसा बनता है जो सचमुच काम करे, न कि सिर्फ़ demo में चले।

रिपोर्ट किए गए आँकड़े प्रभावशाली हैं: गणित, विज्ञान, चिकित्सा, search और agentic reasoning में फैले 11 benchmarks पर hybrid agent text-आधारित और latent दोनों baselines से लगभग 10% बेहतर प्रदर्शन का दावा करता है, साथ में 35–55% token में कमी, 1.8–2.6 गुना तेज़ inference और लगभग 3 गुना लागत बचत। एक पेपर के benchmark दावों को सावधानी से लेना चाहिए, benchmarks अक्सर असली workloads की तस्वीर नहीं दिखाते, लेकिन परिणाम की दिशा सिद्धांत से मेल खाती है। अगर trace का ज़्यादातर हिस्सा फ़िलर है, तो उसका ज़्यादातर हिस्सा हटाने से मुख्यतः लागत घटनी चाहिए, क्षमता नहीं।

कोड में Latent Reasoning असल में कैसा दिखता है

तकनीकी रूप से चाल सुनने से सरल है। Text mode में आप एक token सैंपल करते हैं, उसे embed करते हैं और वापस डालते हैं। Latent mode में आप सैंपलिंग छोड़ देते हैं और मॉडल का अपना output vector, शायद एक छोटे projection से गुजारकर, सीधे अगले input के रूप में वापस डाल देते हैं। एक विशेष control token या सीखा हुआ gate तय करता है कि आप किस mode में हैं। योजनाबद्ध रूप से:

def hybrid_step(hidden_state, mode_gate, hybrid_link):
mode = mode_gate(hidden_state)  # learned: LATENT or TEXT
if mode == LATENT:
# No sampling. Feed the continuous thought back in.
next_input = hybrid_link.latent_in(hidden_state)
return next_input, None  # nothing human-readable emitted
# TEXT mode: normal autoregression
logits = lm_head(hidden_state)
token = sample(logits)
next_input = hybrid_link.text_in(embed(token))
return next_input, token  # inspectable output

असली system में working memory और training की मशीनरी भी जुड़ती है, लेकिन मूल लूप यही है। ध्यान दें कि यह आपके serving stack के लिए क्या संकेत देता है: latent steps भी पूरे forward passes ही हैं। आप token गिनती बचाते हैं, यानी output की लंबाई, context की वृद्धि, और लंबे traces से KV-cache पर दबाव, प्रति step compute नहीं। 2 गुना से ज़्यादा inference speedup मुख्यतः छोटे sequences और कम autoregressive text decoding से आता है, मुफ़्त सोच से नहीं। पेपर पर एक टिप्पणीकर्ता ने सुझाया कि latent path को text generation के समानांतर चलाया जाए, क्योंकि forward pass के लिए वैसे भी भुगतान हो ही रहा है। यह सचमुच दिलचस्प विचार है, और यह बताता है कि यह design space अभी कितना नया है।

इंटरप्रेटेबिलिटी की वह कीमत जिसे कोई चुकाना नहीं चाहता

अब वह हिस्सा जिसे छोड़ना मेरी लापरवाही होगी। Reasoning trace सिर्फ़ debugging की सुविधा नहीं, बल्कि एक safety mechanism है। जब कोई एजेंट production में कुछ अजीब करता है, तो सबसे पहले आप उसका trace पढ़ते हैं। जब alignment researchers deceptive behavior खोजते हैं, तो वे ऐसी reasoning ढूँढते हैं जो अंतिम उत्तर से टकराती हो। सोच को vectors में ले जाओ, और ये दोनों workflows अँधेरे में चले जाते हैं।

पेपर कहता है कि continuous working memory latent विचारों को “सीधे निरीक्षण योग्य” बनाती है। मैं इसे तकनीकी रूप से सही लेकिन व्यावहारिक रूप से भ्रामक मानूँगा। आप vectors का निरीक्षण वैसे ही कर सकते हैं जैसे किसी भी hidden state का: probing classifiers, decoder projections, embedding space में nearest-neighbor विश्लेषण से। यह research-grade tooling है, on-call workflow नहीं। यह log file पढ़ने और core dump पर debugger लगाने का फ़र्क है। हममें से कुछ लोग interpretability के अति-दावों पर पहले से संदेह करते रहे हैं, और एक working-memory buffer इस मूल असमानता को नहीं बदलता: text हर किसी के लिए पठनीय है, latents लगभग किसी के लिए नहीं।

एक कम चर्चित विफलता का तरीका भी है: चुपचाप त्रुटि का फैलना। Text trace में गलत बीच का चरण दिखता है और कभी-कभी मॉडल खुद उसे सुधार लेता है जब वह उसे दोबारा पढ़ता है। गलत latent विचार working memory में बिना किसी text निशान के फैलता रहता है। एजेंट का अंतिम उत्तर उतना ही धाराप्रवाह दिखता है, चाहे उसका latent विचार-विमर्श सही था या कचरा। production में एजेंट चलाने वाली टीमों के लिए यह सीधे containment बनाम monitoring के ट्रेड-ऑफ़ से जुड़ता है: hybrid agents आपको containment की ओर झुकाते हैं, क्योंकि monitoring अचानक बहुत कठिन हो गई है।

इस पेपर पर चर्चा में खुलकर कहा गया कि शोध समुदाय के कुछ हिस्सों में latent reasoning इन्हीं कारणों से अनौपचारिक रूप से वर्जित मानी जाती थी। वह वर्जना अब साफ़ तौर पर ख़त्म हो चुकी है। मुझे नहीं लगता कि यह अपने आप में बुरा है, लेकिन efficiency के आँकड़ों का जश्न मनाने वाले लोगों को ईमानदारी से मानना चाहिए कि वे उन आँकड़ों के लिए interpretability खर्च कर रहे हैं।

पेपर और आपके GPU के बीच का फ़ासला

कोड, weights और डेटा सार्वजनिक हैं, जो वाकई शानदार है। इससे तुरंत एक वास्तविकता-जाँच भी सामने आई। कुछ ही घंटों में, released मॉडल स्थानीय रूप से चलाने वाले practitioners ने degenerate व्यवहार की रिपोर्ट की: एक quantized 8B build “पोप कौन है” के जवाब में text-mode reasoning का वही अनुच्छेद हमेशा दोहराता रहा, और एक 14B build एक सामान्य search-and-summarize कार्य पर पाँच मिनट तक उसी अनुच्छेद के रूपांतरणों में घूमता रहा, जबकि तुलनीय मॉडल उसे ठीक से संभाल लेते हैं।

हो सकता है ये quantization के artifacts हों, या chat-template की गड़बड़ी हो। नए architecture के लिए llama.cpp समर्थन हमेशा जुआ होता है। लेकिन मुझे शक है कि looping की विफलता संयोग नहीं है। Mode-switching एक सीखा हुआ व्यवहार है, और सीखे हुए व्यवहार वही हैं जो quantization और distribution shift सबसे पहले तोड़ते हैं। जिस मॉडल की latent-text policy थोड़ी भी गड़बड़ है, वह ज़ोर से विफल नहीं होता; वह कभी यह तय ही नहीं करता कि सोचना बंद करे। production एजेंट के लिए यह गलत उत्तर से कहीं गंदी विफलता है, क्योंकि यह बिना रुके budget जलाती है। अगर आज आप agent loops बना रहे हैं, तो यह एक और तर्क है कि हर model call के चारों ओर सख़्त turn और token budgets रखें, जैसा agentic CLIs अपने loops कैसे संरचित करते हैं उस पर चर्चा में दिखता है, चाहे आप कोई भी reasoning paradigm अपनाएँ।

क्या आपको परवाह करनी चाहिए? एक व्यावहारिक इंजीनियर का फ़ैसला

हाँ, लेकिन एक संकेत-चिह्न के रूप में, निर्भरता के रूप में नहीं। मेरी ईमानदार राय:

• दक्षता का तर्क वास्तविक और संरचनात्मक है। Text आंतरिक computation के लिए एक खराब माध्यम है, और जैसे-जैसे एजेंट लंबे क्षितिज वाले होंगे, narration पर token का बोझ ही बढ़ेगा। कुछ रूप का latent reasoning production मॉडलों में आने ही वाला है, चाहे हम पसंद करें या नहीं; फ़्रंटियर labs का अपारदर्शी “reasoning summary” तरीका पहले ही इस रास्ते पर एक कदम है।
• Interpretability की कीमत भी वास्तविक है, और फ़िलहाल कम आंकी जा रही है। अगर आपके उपयोग-मामले में यह ऑडिट करना ज़रूरी है कि एजेंट ने कुछ क्यों किया, जैसे चिकित्सा, वित्त, या कोई भी नियंत्रित क्षेत्र, तो text traces एक ऐसी सुविधा है जो आप अपने जोखिम पर छोड़ते हैं।
• मौजूदा artifacts research-grade हैं। सरल prompts पर degenerate loops, quantization का अनिश्चित व्यवहार, और एक mode-switching policy जिसे आसानी से निरीक्षण नहीं किया जा सकता, ऐसी चीज़ें नहीं हैं जिन्हें आप customer-facing API के पीछे डालें।
• Hybrid ढाँचा सही दिशा में है। शुद्ध latent reasoning tool APIs और उपयोगकर्ताओं के सामने कभी टिक नहीं पाता; शुद्ध text reasoning inference बिल के सामने नहीं टिक सकता। दोनों के बीच सीखी हुई सीमा ही वह जगह है जहाँ यह पहुँचेगा।

गहरी बात यह है कि “शब्दों में सोचना” हमेशा इस बात का संयोग था कि हमने इन मॉडलों को कैसे प्रशिक्षित किया, सोच का कोई नियम नहीं। कोई प्रमेय नहीं कहता कि मशीन सोच के लिए भाषा सही दानेदारी है; आश्चर्य यह है कि यह जितना अच्छा चला, चला। Hybrid reasoning agents उस आगे के भविष्य का पहला विश्वसनीय खाका हैं: ऐसे मॉडल जो निजी तौर पर विचार करते हैं और तभी बोलते हैं जब बोलना ही काम हो। क्या हम उस भविष्य को बनाते हुए मशीन का काम जाँचने की क्षमता खोए बिना बना सकते हैं, मेरे हिसाब से यही इस समय एजेंट डिज़ाइन में सबसे महत्वपूर्ण खुला प्रश्न है।