GPT-5.6 एजेंट्स के साथ लोग जो पाँच गलतियाँ करते हैं (और उन्हें कैसे ठीक करें)

अगर आपने GPT-5.6 एजेंट डिप्लॉय किया है और उसे आत्मविश्वास के साथ किसी खाई में गिरते देखा है, तो आप अकेले नहीं हैं। GPT-5.6 एजेंट्स के साथ लोग जो पाँच गलतियाँ करते हैं, वे कोई अनोखे अपवाद नहीं हैं। जब टीमें एजेंट डिज़ाइन के उबाऊ हिस्सों को छोड़कर सीधे बिल्डिंग पर कूद जाती हैं, तो यही डिफ़ॉल्ट व्यवहार बन जाता है। प्रोडक्शन एजेंट डेमो जैसे नहीं होते। उन्हें असली APIs से काम पड़ता है जो कभी-कभी बंद हो जाते हैं, असली कॉन्टेक्स्ट लिमिट से जो मेमोरी काट देती है, और असली यूज़र्स से जो ऐसे शब्दों में अनुरोध करते हैं जिनका किसी प्रॉम्प्ट में अंदाज़ा नहीं था। ये फ़ेल्योर चुपचाप और बार-बार होते हैं, और एक बार पता चल जाए कि वे कहाँ से आते हैं, तो इन्हें ठीक किया जा सकता है।

एजेंट्स किसी को उम्मीद न हो ऐसे तरीकों से क्यों टूटते हैं

डेमो से प्रोडक्शन तक का अंतर

एजेंट डेमो सफल होने के लिए ऑप्टिमाइज़ किए जाते हैं। वे चुने हुए इनपुट पर चलते हैं, हाथ से चुने गए टूल्स के साथ, भरपूर कॉन्टेक्स्ट के साथ, और एक डेवलपर की निगरानी में। प्रोडक्शन इसके ठीक उलट है। जो एजेंट नोटबुक में काम करता है, वह प्रोडक्शन में फ़ेल होगा, क्योंकि वहाँ लेटेंसी में उछाल आते हैं, टूल APIs 429 लौटाते हैं, टोकन विंडो टास्क के बीच में भर जाती है, और यूज़र्स ऐसे शब्दों में अनुरोध करते हैं जिनका प्रॉम्प्ट ने अनुमान नहीं लगाया था। यह अंतर कोई बग नहीं है। यह एक डिज़ाइन धारणा है जो कभी लिखी ही नहीं गई।

असली प्रोडक्शन एजेंट पाँच अनुमानित पैटर्न में फ़ेल होते हैं। ये बेतरतीब तरीकों से नहीं होते, और न ही किसी रहस्यमय मॉडल फ़ेल्योर से, बल्कि डिज़ाइन के दौरान किए गए उन स्ट्रक्चरल फ़ैसलों से होते हैं जो उस समय ठीक लगे थे। इन पैटर्न को पहचानना उन एजेंट्स को बनाने की पहली सीढ़ी है जो सिर्फ़ डेमो के दौरान नहीं, बल्कि हर दिन काम करें।

हर फ़ेल्योर में एक चीज़ समान क्यों होती है

पाँचों पैटर्न में समान धागा एक ही है: एजेंट को ऐसी चीज़ सँभालने की ज़िम्मेदारी दी गई थी जिसके लिए उसे डिज़ाइन ही नहीं किया गया था। बहुत सारे टूल्स, बहुत कम मेमोरी, अस्पष्ट निर्देश, कोई फ़ॉलबैक प्लान नहीं, कोई इंसानी सहारा नहीं। हर एक ऐसा बिंदु है जहाँ बिल्डर ने मान लिया कि मॉडल खुद समझ लेगा। कभी-कभी वह समझ लेता है। आख़िरकार वह नहीं समझता। कमज़ोर कड़ी मॉडल नहीं है। कमज़ोर कड़ी डिज़ाइन है।

गलती 1: एक साथ बहुत सारे टूल्स असाइन करना

टूल ओवरलोड परफ़ॉर्मेंस को कैसे बिगाड़ता है

धारणा यह है कि ज़्यादा टूल्स का मतलब ज़्यादा क्षमता है। व्यवहार में, ज़्यादा टूल्स का मतलब ज़्यादा उलझन है। जब आप किसी GPT-5.6 एजेंट को एक ही कॉन्टेक्स्ट में बीस टूल्स का एक्सेस देते हैं, तो मॉडल को हर टास्क के हर स्टेप पर यह तर्क करना पड़ता है कि कौन-सा टूल लागू होता है। जितने ज़्यादा टूल्स दायरे में होंगे, एजेंट के गलत टूल चुनने, सही टूल को गलत काम में लगाने, या एक ही काम के लिए कई टूल्स को क्रम से चलाने की संभावना उतनी ही बढ़ेगी।

यह GPT-5.6 की कोई ख़ास सीमा नहीं है। यह उस बुनियादी तरीके का हिस्सा है जिससे इंस्ट्रक्शन-फ़ॉलोइंग मॉडल बड़े एक्शन स्पेस पर तर्क करते हैं। जब एक्शन स्पेस बड़ा और ढीले ढंग से बँधा हो, तो हर डिसीज़न स्टेप पर सबऑप्टिमल टूल चुनाव की संभावना बढ़ती है। इसे दस-स्टेप वाले एजेंटिक टास्क में गुणा करें, तो जमा होती गलती दर काफ़ी बड़ी हो जाती है। जो टीम कंपनी के टूल्स के पूरे सेट तक पहुँच वाला एक मोनोलिथिक एजेंट बनाती है, वह उपयोगी फ़ीचर बनाने के बजाय गलत टूल कॉल्स को डीबग करने में ज़्यादा समय लगाएगी।

सही टूल-से-टास्क अनुपात

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

एक व्यावहारिक नियम: अगर आप एक वाक्य में नहीं समझा सकते कि मौजूदा सेट का हर टूल इस ख़ास टास्क के लिए क्यों ज़रूरी है, तो उनमें से एक वहाँ नहीं होना चाहिए। बनाने से पहले छाँटें, डीबग करने के बाद नहीं।

💡 मोटा-मोटा नियम: हर एजेंट इंस्टेंस के लिए टूल कॉन्टेक्स्ट 7 टूल्स तक सीमित रखें। व्यापक वर्कफ़्लो के लिए सीमित टूलसेट वाले सब-एजेंट्स को काम सौंपें। कोऑर्डिनेटर रूटिंग सँभालता है। स्पेशलिस्ट्स एक्ज़ीक्यूशन करते हैं।

गलती 2: कोई असली मेमोरी स्ट्रैटेजी न होना

कॉन्टेक्स्ट विंडो मेमोरी क्यों नहीं है

एजेंट डिज़ाइन में यह सबसे आम गलतफ़हमी है। कॉन्टेक्स्ट विंडो मेमोरी नहीं है। वह एक स्क्रैचपैड है। सेशन खत्म होते ही उसमें मौजूद सब कुछ मिट जाता है, और मल्टी-स्टेप टास्क के दौरान वह तेज़ी से भर जाती है। जो एजेंट तथ्य "याद रखने" के लिए तीस पन्ने का डॉक्यूमेंटेशन कॉन्टेक्स्ट में ठूँस देता है, वह जानकारी ढूँढने में टोकन जला रहा होता है, असली रीज़निंग के लिए कम जगह छोड़ रहा होता है, और लंबे टास्क पर टोकन लिमिट तक पहुँचना तय है।

कॉन्टेक्स्ट विंडो रीज़निंग के लिए है। मेमोरी वह है जो सही समय पर कॉन्टेक्स्ट विंडो को सही जानकारी देती है। ये दो अलग सिस्टम हैं, और एक को दूसरे की जगह इस्तेमाल करने से ऐसे एजेंट बनते हैं जो छोटे टास्क पर काम करते हैं और लंबे टास्क पर टूट जाते हैं। ज़्यादातर टीमें यह कठिन तरीके से तब सीखती हैं जब उनका एजेंट किसी जटिल वर्कफ़्लो के बीच में टास्क की स्थिति खोने लगता है।

स्थायी एजेंट मेमोरी बनाना

असली मेमोरी आर्किटेक्चर में तीन लेयर होती हैं:

• वर्किंग मेमोरी: मौजूदा कॉन्टेक्स्ट। टास्क का विवरण, हाल के टूल परिणाम और पिछले कुछ स्टेप। रनटाइम पर यही एकमात्र लेयर है जो कॉन्टेक्स्ट विंडो में रहती है।
• एपिसोडिक मेमोरी: पिछले सेशन या संबंधित टास्क के रिट्रीव किए गए सारांश, जिन्हें वेक्टर समानता खोज के ज़रिए नए सेशन की शुरुआत में लाया जाता है। एजेंट अतीत को सीधे याद नहीं रखता। वह प्रासंगिक चीज़ों का रिट्रीव किया गया सारांश पढ़ता है।
• सिमैंटिक मेमोरी: उन तथ्यों का एक संरचित स्टोर जिनकी एजेंट को सभी टास्क में ज़रूरत होती है। इसे मौजूदा टास्क की ज़रूरत के हिसाब से चुनिंदा रूप से लोड किया जाता है, न कि हर सेशन की शुरुआत में पूरा का पूरा डाल दिया जाता है।

GPT 5.6 Terra और GPT 5.6 Sol जब अच्छी तरह रिट्रीव किया गया कॉन्टेक्स्ट दिए जाते हैं, तो रीज़निंग में मज़बूत होते हैं। वे फ़्लैट कॉन्टेक्स्ट डंप से अपने अतीत को रिट्रीव करने में मज़बूत नहीं हैं। डिज़ाइन का काम रिट्रीवल की तरफ़ है, मॉडल की तरफ़ नहीं। पहले रिट्रीवल पाइपलाइन बनाएँ, फिर मॉडल को उससे जोड़ें।

💡 व्यावहारिक कदम: अपने अगले एजेंट बिल्ड से पहले तीन बॉक्स बनाएँ: वर्किंग मेमोरी, एपिसोडिक स्टोर, सिमैंटिक स्टोर। अगर तीनों सिमट कर "कॉन्टेक्स्ट विंडो" बन जाते हैं, तो आपके सामने एक मेमोरी समस्या है जो प्रोडक्शन में उभरेगी।

गलती 3: ऐसे सिस्टम प्रॉम्प्ट जो सब कुछ कहते हैं और कुछ भी नहीं

कमज़ोर सिस्टम प्रॉम्प्ट की बनावट

कमज़ोर सिस्टम प्रॉम्प्ट लंबा, अस्पष्ट होता है और हर केस को ज़्यादा शब्द लिखकर सँभालने की कोशिश करता है। उसमें "मददगार, सटीक और पेशेवर बनें" और "जवाब देने से पहले चरण-दर-चरण सोचें" जैसी बातें होती हैं। वह यह बताने से पहले कि एजेंट के पास कौन-से टूल हैं या उन्हें कब इस्तेमाल करना है, तीन पैराग्राफ़ एजेंट के व्यक्तित्व के बारे में लिखता है। अस्पष्ट आकांक्षा पर खर्च हर टोकन, किसी ठोस बाधा पर खर्च नहीं हो पाता। कमज़ोर प्रॉम्प्ट पर चलने वाले एजेंट ठीक गलत पलों पर रचनात्मक हो जाते हैं।

कमज़ोर प्रॉम्प्ट की पहचान यह है कि उसके लिए टेस्ट लिखना मुश्किल होता है। अगर आप सिर्फ़ अपने सिस्टम प्रॉम्प्ट के आधार पर कोई ख़ास इनपुट और उसका ख़ास अपेक्षित आउटपुट नहीं बता सकते, तो प्रॉम्प्ट पर्याप्त स्पेसिफ़िक नहीं है। कम स्पेसिफ़िसिटी वाले लंबे प्रॉम्प्ट, उच्च स्पेसिफ़िसिटी वाले छोटे प्रॉम्प्ट से बदतर होते हैं। लंबाई सटीकता नहीं है।

एक टाइट सिस्टम प्रॉम्प्ट कैसा दिखता है

GPT-5.6 एजेंट के लिए एक मज़बूत सिस्टम प्रॉम्प्ट में चार सेक्शन होते हैं और उनके अलावा कुछ नहीं:

1. भूमिका: एक वाक्य। यह एजेंट क्या करता है और, सबसे अहम, क्या नहीं करता।

2. टूल्स: हर टूल का एक-लाइन विवरण कि उसे कब इस्तेमाल करना है और कब नहीं। पैराग्राफ़ नहीं। हर टूल के लिए एक लाइन। मॉडल को निबंध नहीं चाहिए। उसे एक साफ़ संकेत चाहिए।

3. आउटपुट फ़ॉर्मेट: एजेंट ठीक-ठीक क्या लौटाता है और किस संरचना में। लागू हो तो JSON स्कीमा। किसी भी अस्पष्टता की स्थिति में एक छोटा उदाहरण आउटपुट।

4. बाधाएँ: कठोर नियम। वे चीज़ें जो एजेंट यूज़र के माँगने पर भी कभी नहीं करता। स्पेसिफ़िक, आकांक्षात्मक नहीं। "टूल X से डेटा तब तक न लौटाएँ जब तक Y को पहले वैलिडेट न किया गया हो" एक बाधा है। "हमेशा पेशेवर रहें" नहीं है।

बस यही पूरा प्रॉम्प्ट है। छोटा, स्पेसिफ़िक और टेस्ट करने लायक। बाकी काम मॉडल सँभाल लेता है। जब एजेंट गलत व्यवहार करे, तो और शब्द जोड़ने की इच्छा को रोकें। ज़्यादातर गलत व्यवहार विरोधाभासी या अस्पष्ट निर्देशों से आता है, कम निर्देशों से नहीं। मात्रा के लिए नहीं, स्पष्टता के लिए संपादन करें।

गलती 4: टूल फ़ेल होने पर कोई रिकवरी नहीं

टूल फ़ेल्योर सामान्य हैं, एज केस नहीं

APIs एरर लौटाते हैं। रेट लिमिट लगती हैं। बाहरी सेवाएँ मेंटेनेंस के लिए बंद हो जाती हैं या पीक घंटों में अप्रत्याशित लोड झेलती हैं। मल्टी-स्टेप टास्क चलाने वाला GPT-5.6 एजेंट प्रोडक्शन में टूल फ़ेल्योर का सामना करेगा। कभी-कभार नहीं। नियमित रूप से। सवाल यह नहीं है कि आपके एजेंट के टूल फ़ेल होंगे या नहीं। सवाल यह है कि जब वे फ़ेल होंगे, तो एजेंट क्या करता है।

एजेंट डिज़ाइन में स्पष्ट रिकवरी प्लान के बिना, डिफ़ॉल्ट व्यवहार अप्रत्याशित होता है। कभी मॉडल उसी फ़ेल कॉल पर अनिश्चित काल तक रीट्राई करता रहता है, जब तक सेशन टाइम आउट न हो जाए। कभी वह गैप भरने के लिए एक परिणाम हैलुसिनेट कर देता है और ऐसे आगे बढ़ता है मानो टूल ने वैध डेटा लौटाया हो। कभी वह चुपचाप एक स्टेप छोड़कर आगे बढ़ जाता है, जिससे टास्क स्थिति में ऐसा गैप रह जाता है जो बाद में सिर्फ़ एक उलझाने वाली डाउनस्ट्रीम एरर के रूप में सामने आता है। असली यूज़र्स जिस सिस्टम पर निर्भर हैं, उसमें इनमें से कोई भी स्वीकार्य नहीं है।

फ़ॉलबैक चेन डिज़ाइन करना

आपके एजेंट के टूलसेट में हर टूल का एक दस्तावेज़ीकृत फ़ेल्योर मोड और एक परिभाषित प्रतिक्रिया होनी चाहिए। पैटर्न सीधा है और सेट के हर टूल के लिए साफ़-साफ़ लिखने लायक है:

1. प्राथमिक कॉल: सामान्य पैरामीटर के साथ पसंदीदा टूल इस्तेमाल करें।
2. बैकऑफ़ के साथ रीट्राई: अगर टूल कोई अस्थायी एरर (429, 503, टाइमआउट) लौटाता है, तो एक तय अंतराल रुकें और एक बार फिर कोशिश करें।
3. फ़ॉलबैक टूल: अगर रीट्राई भी फ़ेल हो, तो जहाँ विकल्प मौजूद हो वहाँ दूसरे टूल या डेटा स्रोत पर जाएँ।
4. सुरक्षित रुकावट: अगर कोई फ़ॉलबैक नहीं है, तो ऑर्केस्ट्रेटर को एक संरचित फ़ेल्योर रिपोर्ट लौटाएँ जिसमें मौजूदा टास्क स्थिति सुरक्षित हो, ताकि टास्क बिना प्रगति खोए फिर से शुरू हो सके या किसी इंसान को सौंपा जा सके।

एजेंट को कभी भी गैप भरने के लिए टूल परिणाम हैलुसिनेट नहीं करना चाहिए। यह सिस्टम प्रॉम्प्ट में एक कठोर बाधा है, न कि ऐसी चीज़ जिस पर दबाव में मॉडल के सही व्यवहार पर भरोसा किया जाए। इसे स्पष्ट रूप से लिखें। इसे स्पष्ट रूप से टेस्ट करें।

💡 डिज़ाइन सुझाव: अपने एजेंट के टूलसेट में एक report_failure टूल जोड़ें। एजेंट को मनमाने ढंग से अंदाज़ा लगाने की जगह साफ़ और स्पष्ट तरीके से एस्केलेट करने का रास्ता दें। जो एजेंट सुरक्षित तरीके से फ़ेल नहीं हो सकते, वे आख़िरकार सबसे बुरे समय पर बुरी तरह फ़ेल हो जाएँगे।

गलती 5: एजेंट के आउटपुट को अंतिम सच मानना

एजेंटिक हैलुसिनेशन एक अलग समस्या है

सामान्य LLM हैलुसिनेशन एक समस्या है। एजेंटिक हैलुसिनेशन समस्या की एक अलग श्रेणी है। जब एजेंट हैलुसिनेट करता है, तो वह सिर्फ़ एक गलत वाक्य नहीं बनाता। वह एक गलत वाक्य बनाता है और फिर उस पर कार्रवाई करता है, उसके आधार पर टूल कॉल करता है, उसे मेमोरी में स्टोर करता है, और अगले स्टेप तक आगे बढ़ा देता है। जब तक हैलुसिनेशन एक दिखाई देने वाली एरर के रूप में सामने आता है, तब तक वह पाँच डाउनस्ट्रीम फ़ैसलों को प्रभावित कर चुका हो सकता है, जो सभी सही लगे होंगे क्योंकि वे हैलुसिनेटेड आधार के साथ आंतरिक रूप से सुसंगत थे।

एजेंटिक टास्क पर GPT-5.6 मॉडल का कॉन्फ़िडेंस आम तौर पर ऊँचा होता है। यह ज़्यादातर एक ताकत है, लेकिन इससे हैलुसिनेटेड स्टेप पकड़ना कठिन हो जाता है, क्योंकि वे बिल्कुल सही स्टेप जैसे दिखते हैं। एक मॉडल जो "मुझे यकीन नहीं है" लिखता है, उसे पकड़ना आसान है। एक मॉडल जो पूरे आत्मविश्वास के साथ एक विश्वसनीय-सा लगने वाला लेकिन गलत टूल कॉल और साफ़ JSON आउटपुट बनाता है, उसे पकड़ना आसान नहीं है। ऐसे सिस्टम बनाने के लिए, जो यह पकड़ सकें, स्ट्रक्चरल फ़ैसलों की ज़रूरत होती है, सिर्फ़ बेहतर प्रॉम्प्टिंग की नहीं।

मानव रिव्यू अब भी कहाँ ज़रूरी है

ऑटोनॉमी को अधिकतम करने के लिए सभी ह्यूमन-इन-द-लूप स्टेप हटाने की प्रवृत्ति समझ में आती है, और आम तौर पर गलत होती है। सही सवाल यह नहीं है कि "क्या हम इंसानों को हटा सकते हैं?" बल्कि यह है कि "किन बिंदुओं पर ह्यूमन रिव्यू लेटेंसी की लागत से ज़्यादा विश्वसनीयता जोड़ता है?" उच्च-दाँव वाले फ़ैसले, नए टास्क प्रकार, और वे आउटपुट जो बाहर भेजे जाएँगे, ये स्पष्ट चेकपॉइंट हैं। एक ज्ञात वर्कफ़्लो के भीतर रूटीन, अच्छी तरह टेस्ट किए गए सबटास्क वे जगहें हैं जहाँ ऑटोनॉमी उपयुक्त है।

आर्किटेक्चर को यह अंतर स्पष्ट रूप से दिखाना चाहिए। सारी चीज़ों को एक ही ऑटोनॉमी पॉलिसी में समेट देंगे, तो या तो जोखिम भरी कार्रवाइयों को ज़रूरत से ज़्यादा मंज़ूरी देंगे, या सुरक्षित कार्रवाइयों को ज़रूरत से ज़्यादा रोकेंगे।

GPT-5.6 मॉडल जो PicassoIA पर चलाने लायक हैं

PicassoIA आपको लोकल सेटअप या API कॉन्फ़िगरेशन के बिना पूरे GPT-5.6 परिवार तक सीधी पहुँच देता है। हर वैरिएंट एजेंटिक वर्कफ़्लो के अलग हिस्से के लिए ऑप्टिमाइज़ है, और सही काम के लिए सही वैरिएंट चुनना ऊपर बताई गई गलतियों से बचने के व्यावहारिक तरीकों में से एक है।

तेज़ इटरेशन चक्रों के लिए GPT 5.6 Luna

GPT 5.6 Luna परिवार का स्पीड-ऑप्टिमाइज़्ड मॉडल है। यह रिस्पॉन्स लेटेंसी को प्राथमिकता देता है, इसलिए मल्टी-एजेंट सिस्टम की कोऑर्डिनेशन लेयर, छोटे प्लानिंग स्टेप्स, और ऐसे किसी भी सबटास्क के लिए यह सही विकल्प है जहाँ टर्नअराउंड टाइम संपूर्ण रीज़निंग गहराई से ज़्यादा मायने रखता है। अगर आप एक कोऑर्डिनेटर एजेंट चला रहे हैं जो टास्क को स्पेशलिस्ट सब-एजेंट्स को रूट करता है, तो Luna भारी इनफ़रेंस में समय गँवाए बिना वह रूटिंग सँभालता है। डेवलपमेंट के दौरान तेज़ प्रॉम्प्ट इटरेशन के लिए भी यह सही मॉडल है, जहाँ किसी डिज़ाइन को पक्का करने से पहले तेज़ फ़ीडबैक चक्र चाहिए।

प्रोडक्शन-स्तर आउटपुट के लिए GPT 5.6 Terra

GPT 5.6 Terra ऐसे आउटपुट के लिए बना है जो पहली बार में ही सही होने चाहिए। यह ज़्यादा साफ़, अधिक सुसंगत संरचित आउटपुट बनाता है, जो तब मायने रखता है जब आपका एजेंट डाउनस्ट्रीम सिस्टम्स के लिए JSON बना रहा हो, ऐसा टेक्स्ट ड्राफ़्ट कर रहा हो जो यूज़र्स तक पहुँचेगा, या ऐसे सारांश बना रहा हो जो किसी दूसरे मॉडल के कॉन्टेक्स्ट में जाएँगे। जब गलत आउटपुट की लागत कुछ सौ मिलीसेकंड अतिरिक्त लगने से ज़्यादा हो, तो Terra वह मॉडल है जिसे इस्तेमाल करें। अगर आपके एजेंट का आउटपुट सीधे प्रोडक्शन वर्कफ़्लो में जाता है, तो उस लेयर के लिए Terra ही वह वैरिएंट है।

जटिल रीज़निंग चेन के लिए GPT 5.6 Sol

GPT 5.6 Sol GPT-5.6 परिवार का डीप-रीज़निंग वैरिएंट है। यह ऐसे टास्क सँभालता है जिनमें एक्सटेंडेड रीज़निंग चेन, जटिल कोड जनरेशन और मल्टी-स्टेप समस्या विभाजन चाहिए। अगर आपका एजेंट कई डेटा स्रोतों पर काम कर रहा है, डिपेंडेंट स्टेप्स का लंबा क्रम प्लान कर रहा है, या प्रोडक्शन कोड बना रहा है, तो उस लेयर के लिए Sol मॉडल है। जब सही रीज़निंग तेज़ी से पाने से ज़्यादा मायने रखती है, तो अतिरिक्त इनफ़रेंस समय उचित है।

GPT-5.6 परिवार से आगे, PicassoIA पर दूसरे मज़बूत LLM भी चलते हैं जिन्हें मल्टी-मॉडल वर्कफ़्लो में जोड़ना उपयोगी है। Claude Fable 5 कोडिंग-भारी एजेंट टास्क के लिए असाधारण है। DeepSeek R1 विस्तृत रीज़निंग ट्रेस बनाता है जो एजेंट के फ़ैसलों को ऑडिट योग्य बनाता है, और यह सीधे गलती 5 से जुड़ा है। Kimi K2.6 में मज़बूत टूल-यूज़ आर्किटेक्चर है जो जटिल एजेंटिक पाइपलाइन को अच्छी तरह सँभालता है। Grok 4 उन समस्याओं को सँभालता है जिनमें कार्रवाई से पहले गहरे तार्किक विभाजन की ज़रूरत होती है।

उन टास्क के लिए जहाँ आप चाहते हैं कि एजेंट कोई कार्रवाई करने से पहले विस्तार से सोचे, GPT 5 Pro में बिल्ट-इन एक्सटेंडेड थिंकिंग है। टेक्स्ट और इमेज विश्लेषण दोनों वाले मल्टीमॉडल एजेंटिक टास्क के लिए, Claude Opus 4.7 दोनों मोडैलिटी को सँभालता है और दोनों पर मज़बूत रीज़निंग देता है।

मॉडल को एजेंट की भूमिका से मिलाना

ऐसा कुछ बनाएँ जो सच में शिप हो

GPT-5.6 एजेंट्स के साथ लोग जो पाँच गलतियाँ करते हैं, वे मॉडल के गलत इस्तेमाल के बारे में नहीं हैं। वे मॉडल के चारों ओर के सिस्टम को गलत डिज़ाइन करने के बारे में हैं। टूल स्कोप, मेमोरी आर्किटेक्चर, प्रॉम्प्ट की स्पेसिफ़िसिटी, एरर रिकवरी और आउटपुट वैलिडेशन वैकल्पिक इंजीनियरिंग चिंताएँ नहीं हैं। वही एक नियंत्रित रन में प्रभावित करने वाले एजेंट और ऐसे एजेंट के बीच का फ़र्क हैं जो बिना किसी डेवलपर की निगरानी के हर दिन भरोसेमंद काम करता है।

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

PicassoIA GPT-5.6 मॉडल्स को साथ-साथ चलाना और टेस्ट करना, यह देखना कि हर वैरिएंट एक ही टास्क को कैसे सँभालता है, और वह हैंड्स-ऑन समझ बनाना आसान बनाता है जो समय के साथ बेहतर एजेंटिक डिज़ाइन फ़ैसलों की ओर ले जाती है। आप अभी GPT 5.6 Luna, GPT 5.6 Terra और GPT 5.6 Sol तक पहुँच सकते हैं, साथ ही picassoia.com/en/all-models पर लार्ज लैंग्वेज मॉडल्स की पूरी लाइब्रेरी भी।

अगर आप ऐसे एजेंट शिप करते आ रहे हैं जो ज़्यादातर काम करते हैं, तो अब उन्हें वापस जाकर इस तरह डिज़ाइन करने का अच्छा समय है कि वे भरोसे के साथ काम करें। पाँच पैटर्न अच्छी तरह समझे जा चुके हैं। हल जटिल नहीं हैं। एकमात्र सवाल यह है कि आप उन्हें अपनी अगली प्रोडक्शन फ़ेल्योर से पहले लागू करते हैं या बाद में।