कल्पना कीजिए कि एक ऐसी दुनिया है जहाँ आपके पास एक सुपर-स्मार्ट रोबोट सहायक है जो आपके लिए कंप्यूटर कोड लिख सकता है। यह एक प्रतिभाशाली प्रशिक्षु (apprentice) रखने जैसा है जो किसी भी अन्य व्यक्ति से तेज़ टाइप कर सकता है और जिसे लाखों प्रोग्रामिंग ट्रिक्स पता हैं। लेकिन यहाँ एक पेंच है: यह रोबोट थोड़ा "लोगों को खुश करने वाला" (people pleaser) है। यदि आप इसे कहते हैं, "इस टूटे हुए बटन को ठीक करो," तो यह खुशी-खुशी बटन को ठीक कर देगा। लेकिन अगर बटन इसलिए टूटा था क्योंकि कोई गुप्त नियम था जो आपने इसे कभी नहीं बताया (जैसे "मंगलवार को बटन को लाल न होने दें"), तो रोबोट बटन को ठीक करते समय अनजाने में उस गुप्त नियम को तोड़ सकता है। यदि आप इसे पकड़ नहीं पाते हैं, तो अगली बार भी रोबोट वही गलती दोहरा सकता है, क्योंकि उसे केवल विशिष्ट सुधार याद रहता है, उसके पीछे का कारण नहीं। यह वास्तविक दुनिया में "कोडिंग एजेंटों" की समस्या है: वे छेदों को भरने में माहिर हैं, लेकिन वे इस बात को गहराई से नहीं सीख पाते कि एक सिस्टम को कैसे व्यवहार करना चाहिए, जब तक कि उन्हें स्पष्ट रूप से सिखाया न जाए।

यह शोध पत्र, जिसे मुनेस कैसल और एरिक रूबेक ने लिखा है, इसी समस्या पर प्रहार करता है। यह एक नया तरीका पेश करता है जिसे "काउंटरएग्जांपल-सप्लीमेंटेड स्केच के विरुद्ध एजेंटिक सिंथेसिस" (Agentic Synthesis against Counterexample-Supplemented Sketches) कहा जाता है। इसे एक कठोर प्रशिक्षण शिविर के रूप में सोचें। AI को केवल अनुमान लगाने और जांचने देने के बजाय, यह विधि एक इंसान को एक सख्त कोच के रूप में कार्य करने के लिए मजबूर करती है। जब AI कोई ऐसी गलती करता है जो किसी छिपे हुए नियम को तोड़ती है, तो इंसान केवल यह नहीं कहता कि "इसे ठीक करो।" वे कहते हैं, "यहाँ गलती है, यहाँ सही उत्तर है, और यहाँ वह नियम है जिसे तुमने तोड़ा है।" इसके बाद AI को फिर से प्रयास करने की अनुमति मिलने से पहले अपने स्वयं के "निर्देश मैनुअल" (जिसे स्केच कहा जाता है) को उस नए नियम को शामिल करने के लिए फिर से लिखना पड़ता है। यह पेपर इस विचार का परीक्षण "कैटसिंथ" (CatSynth) नामक एक नकली ब्राउज़र ऐप के साथ करता है और पाता है कि यह विधि AI को नियमों को बेहतर ढंग से सीखने में मदद करती है, बजाय इसके कि उसे केवल पिछले गलतियों की एक सूची दिखाई जाए, हालांकि लेखक सावधानी बरतते हुए कहते हैं कि यह एक विशिष्ट प्रयोग पर आधारित है, न कि हर स्थिति के लिए एक जादुई समाधान।

स्केच और नियम पुस्तिका की कहानी

कल्पना कीजिए कि आप एक ऐसा रोबोट बनाने की कोशिश कर रहे हैं जो एक परिवार के लिए एकदम सही बिल्ली चुनता है। आप रोबोट को एक "स्केच" देते हैं। इस कहानी में, स्केच कोई चित्र नहीं है; यह एक अधूरा, आधा लिखा हुआ निर्देश मैनुअल है। यह कहता है जैसे, "बिल्ली रोएंदार होनी चाहिए," और "बिल्ली मिलनसार होनी चाहिए।" लेकिन इसमें सबसे महत्वपूर्ण हिस्सा गायब है: "बिल्ली पर्शियन नहीं हो सकती क्योंकि परिवार को बिल्ली से एलर्जी है।"

शुरुआत में, रोबोट (कोडिंग एजेंट) स्केच को देखता है और कहता है, "ठीक है, पर्शियन रोएंदार और मिलनसार होती हैं! मैं एक पर्शियन चुनूँगा!" वह यह करने के लिए कोड लिखता है। लेकिन फिर, एक मानव विशेषज्ञ (Subject-Matter Expert) परिणाम को देखता है और कहता है, "ओह, रुकिए! यह तो आपदा है। परिवार को एलर्जी है। आपने गलत बिल्ली चुनी है।"

पुराने तरीके में, इंसान केवल कह सकता था, "ठीक है, इसे ठीक करो, कोई दूसरी बिल्ली चुनो।" रोबोट फिर एक अलग बिल्ली चुन लेता, शायद एक सियामी (Siamese)। लेकिन रोबोट वास्तव में एलर्जी के बारे में नियम नहीं सीख पाता। वह केवल यह याद रखता कि "इस विशिष्ट परिवार के लिए पर्शियन न चुनें।" अगली बार, यदि परिवार एलर्जी के बारे में अपना विचार बदल देता है लेकिन रोबोट को पता नहीं होता, या यदि एलर्जी वाला कोई नया परिवार आता है, तो रोबोट वही गलती फिर से कर सकता है।

यह पेपर एक अलग, अधिक सख्त लूप का प्रस्ताव करता है। जब मानव विशेषज्ञ कहता है, "गलत बिल्ली!", तो वे केवल आउटपुट को ठीक नहीं करते। वे एक अदालत में न्यायाधीश की तरह कार्य करते हैं। वे कहते हैं:

1. गलती: "आपने एक पर्शियन चुनी।"
2. सुधार: "सही बिल्ली साइबेरियन (Siberian) है।"
3. नियम: "वह नियम जिसे आपने तोड़ा है वह है: 'कठोर नियम (जैसे एलर्जी) हमेशा नरम प्राथमिकताओं (जैसे रोएंदार होना) पर हावी होने चाहिए।'"

फिर, एक मानव "ऑपरेटर" (बॉस) को इसे स्पष्ट रूप से मंजूरी देनी होती है। वे कहते हैं, "हाँ, यह अब एक वास्तविक नियम है।" एक बार साइन होने के बाद, रोबोट को इस नए नियम को शामिल करने के लिए अपने स्केच को फिर से लिखना अनिवार्य है। रोबोट केवल कोड को पैच नहीं कर सकता; उसे अपने मैनुअल को अपडेट करना ही होगा।

दो-चरणीय जाँच: रीप्ले और कंपेयर

यह सुनिश्चित करने के लिए कि रोबोट ने सबक वास्तव में सीखा है, यह पेपर एक चतुर दो-चरणीय परीक्षण का उपयोग करता है, जैसे सुरक्षा गार्ड गेट पर आगंतुक की जाँच करता है।

1. रीप्ले (The "क्या आपने गड़बड़ी ठीक की?" जाँच): यह जाँचता है कि क्या रोबोट का नया उत्तर वास्तव में तत्काल समस्या को हल करता है। क्या रोबोट ने एक रोएंदारी और मिलनसार बिल्ली चुनी? यदि हाँ, तो "रीप्ले" पास हो जाता है।
2. कंपेयर (The "क्या आपने नियमों का पालन किया?" जाँच): यह पेचीदा हिस्सा है। यह जाँचता है कि क्या रोबोट ने नए नियम के आधार पर सही बस्तियाँ चुनी। क्या उसने पर्शियन के बजाय साइबेरियन चुनी? क्या उसे एलर्जी याद रही? यदि रोबोट ने एक रोएंदारी पर्शियन चुनी जिसने "रोएंदार" वाली समस्या को हल किया लेकिन "एलर्जी" वाले नियम को तोड़ दिया, तो "कंपेयर" विफल हो जाता है।

पेपर इसे "गेट" (Gate) कहता है। यदि रोबोट दोनों पास करता है, तो वह आगे बढ़ता है। यदि वह कंपेयर में विफल होता है, तो इसका मतलब है कि रोबोट ने सतही समस्या को ठीक किया लेकिन गहरे नियम को अनदेखा कर दिया। रोबोट को वापस जाकर अपने स्केच को फिर से ठीक करना होगा।

कैटसिंथ (CatSynth) प्रयोग

लेखकों ने इसका परीक्षण कैटसिंथ नामक एक नकली प्रोजेक्ट के साथ किया। उन्होंने एक परिदृश्य बनाया जहाँ एक रोबोट को प्राथमिकताओं (बड़ी, रोएंदारी, स्नेही) की सूची और एक कठोर नियम (ऐसी बिल्लियाँ नहीं जो एलर्जी पैदा करती हैं) के आधार पर बिल्ली चुननी थी।

उन्होंने एक सिमुलेशन चलाया जहाँ रोबोट ने 14 अलग-अलग "फ्रोजन" मामलों (वे परिदृश्य जो प्रयोग से पहले तय कर दिए गए थे) को हल करने की कोशिश की।

• परिणाम: 14 में से 8 मामलों में, रोबोट का प्रारंभिक अनुमान गलत था क्योंकि उसने एक नियम मिस कर दिया था। ये 8 मामले "काउंटरएग्जांपल" बन गए।
• प्रक्रिया: इन 8 गलतियों में से प्रत्येक के लिए, एक इंसान ने सुधार को मंजूरी दी, रोबोट ने अपने स्केच को अपडेट किया, और रोबोट ने फिर से प्रयास किया।
• परीक्षण: रोबोट के सीखने के बाद, लेखकों ने इसे 21 नए, छिपे हुए मामलों (ऐसे मामले जो उसने पहले कभी नहीं देखे थे) पर परखा।

यहाँ उन्हें क्या मिला:

• जब उन्होंने केवल अंतिम, विकसित स्केच (वह जिसमें सभी नियम अपडेट किए गए थे) का उपयोग करके रोबोट के कोड को फिर से बनाया, तो रोब सहित 21 में से 19 मामलों में सही रहा।
• जब उन्होंने रोबोट को उसका मूल स्केच और पिछली सभी उदाहरणों की एक लंबी सूची दिखाकर फिर से बनाने की कोशिश की (जिसे "रीप्ले-ऑल" विधि कहा जाता है), तो रोबोट 21 में से केवल 15 मामलों में सही रहा।

यह सुझाव देता है कि रोबोट को नियम सिखाना और उन्हें अपने स्केच में लिखना, केवल गलतियों का इतिहास दिखाने की तुलना में अधिक प्रभावी था। नियमों को सीखने वाला रोबोट नई स्थितियों में बेहतर प्रदर्शन करता है।

इसका क्या अर्थ है (और क्या नहीं)

यह पेपर परिणामों को बहुत अधिक बढ़ा-चढ़ाकर बताने से बचता है। वे दावा नहीं करते कि यह सभी AI कोडिंग समस्याओं को हमेशा के लिए ठीक करने का "परफेक्ट" तरीका है। वे स्वीकार करते हैं कि यह एक विशिष्ट मॉडल (GPT-5.4-mini) और समस्याओं के एक विशिष्ट क्रम के साथ एक सिमुलेशन था। उन्हें नहीं पता कि क्या यह एक अलग रोबोट या नियमों के एक अलग सेट के साथ बिल्कुल उसी तरह काम करेगा।

हालाँकि, प्रयोग कुछ महत्वपूर्ण संकेत देता है: AI को केवल "क्या" (उदाहरण) के बजाय "क्यों" (नियम) सिखाना बेहतर है।

यदि आप केवल एक AI को "X न करें" की सूची दिखाते हैं, तो वह सूची को याद कर सकता है लेकिन पैटर्न को मिस कर सकता है। लेकिन यदि आप उसे हर बार अपने निर्देश मैनुअल (स्केच) को अपडेट करने और फिर उसके पुराने कोड को फेंककर और उस मैनुअल से नया बनाने के लिए मजबूर करते हैं, तो आपको एक स्मार्ट, अधिक विश्वसनीय AI मिलता है।

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

निष्कर्ष

अंत में, यह पेपर इस बारे में एक मार्गदर्शिका है कि AI को "विश्वसनीय लेकिन गलत" सुधारक बनने से कैसे रोका जाए। यह तर्क देता है कि जब AI कोई गलती करता है, तो हमें केवल कोड को पैच नहीं करना चाहिए। हमें उस गलती को एक ऐसे सबक के रूप में देखना चाहिए जो दुनिया के प्रति AI की मौलिक समझ को बदल देता है। "स्केच" का उपयोग करके जो नियमों को रखता है, एक "गेट" का उपयोग करके जो काम की जाँच करता है, और एक इंसान का उपयोग करके जो पाठों को मंजूरी देता है, हम ऐसा AI बना सकते हैं जो केवल सही उत्तर का अनुमान नहीं लगाता, बल्कि वास्तव में समझता है कि वह क्यों सही है।

लेखक निष्कर्ष निकालते हैं कि हालांकि इस पद्धति ने उनके सिमुलेशन में हर समस्या को हल नहीं किया (रोबोट अभी भी 21 में से 2 गलतियाँ करता रहा), इसने साबित कर दिया कि "विकसित स्केच" (evolved Sketch) ने उदाहरणों के साधारण इतिहास की तुलना में ज्ञान को बेहतर ढंग से संजोया। यह एक कदम है जो AI कोडिंग को एक अनुशासित प्रशिक्षुता (apprenticeship) के करीब लाता है और भाग्यशाली अनुमान से दूर ले जाता है।