मैं आपको चरण-दर-चरण दिखाने जा रहा हूँ कि कैसे लगातार Claude Code, Codex, OpenCode या आप जो भी हार्नेस इस्तेमाल कर रहे हैं, उससे सबसे अच्छे आउटपुट प्राप्त करें...
क्योंकि हार्नेस सिर्फ वह ऐप है जिसमें आप अपने एजेंट के निर्देश टाइप करते हैं, वह कॉकपिट जिसमें आप बैठते हैं।
सहज प्रवृत्ति यह है कि एक बेहतर मॉडल का पीछा किया जाए जिसे उसके अंदर डाला जा सके (FABLE 5 का उपयोग करते हुए LOL)।
असली बढ़त आपको कहीं और मिल सकती है, इस तथ्य में कि आप एक ही मॉडल पर रुक गए।
और समय इस गलती को पहले से कहीं अधिक महंगा बना रहा है... क्योंकि सबसे अच्छा एकल मॉडल एक चलता-फिरता लक्ष्य बन गया है जिस पर आप भरोसा नहीं कर सकते:
- Fable 5 लगभग एक सप्ताह के लिए वापस आ रहा है और फिर इतना महंगा हो जाएगा कि खरीदा नहीं जा सकेगा
- Mythos 5 सरकार द्वारा अनुमोदित कंपनियों की एक छोटी सूची तक सीमित है
- GPT-5.6 Sol लगभग 20 अनुमोदित फर्मों को दिया गया और किसी और को नहीं
इसलिए अपने पूरे ऑपरेशन को उस मॉडल पर दांव लगाना जो इस महीने "सर्वश्रेष्ठ" है, उस पल हार जाता है जब वह प्रतिबंधित हो जाता है।
तो समाधान फ्रंटियर LLMs का एक मर्ज है, कुछ मॉडल एक साथ काम कर रहे हैं, एक मॉडल के बजाय जो सब कुछ अकेले करता है।
यही वह चीज़ है जो औसत आउटपुट को सर्वश्रेष्ठ से अलग करती है, और यह पहली चीज़ है जो मैं अब हर प्रोजेक्ट पर सेट करता हूँ।
यदि आप सीखना चाहते हैं कि इन टूल्स का अधिकतम लाभ कैसे उठाया जाए और उनसे वास्तविक पैसा कैसे कमाया जाए, तो रियल टाइम AI ops समुदाय इसी के लिए बनाया गया है: weeklyaiops.com
धीमी, दयनीय आगे-पीछे की प्रक्रिया
देखिए एक सामान्य प्रोजेक्ट कैसे चलता है, अड़चन ठीक बीच में बैठी है:
आप एक हार्नेस खोलते हैं और उसे कार्य सौंपते हैं
फिर आप उसकी योजना लेते हैं, उसे दूसरे मॉडल में पेस्ट करते हैं, और पूछते हैं "क्या यह सही है"
दूसरा मॉडल खामियां ढूंढता है, इसलिए आप उन नोट्स को वापस पहले मॉडल के पास ले जाते हैं
आप दोपहर एक संदेशवाहक के रूप में बिताते हैं, दो मॉडलों के बीच संदर्भ ले जाते हुए जो एक-दूसरे से बात नहीं कर सकते
आइए ईमानदार रहें, यह आगे-पीछे की प्रक्रिया एक बहुत बड़ा दर्द है...
मैं इस चक्र को बहुत अच्छी तरह से जानता हूँ, आप Claude से Codex की योजना की जांच करवाते हैं, फिर खामियों को वापस दूसरी तरफ ले जाते हैं, और दिन दो मॉडलों के बीच नोट्स ले जाने में गायब हो जाता है।
क्यों AI का एक मर्ज आपके पसंदीदा मॉडल को हरा देता है
एक कारण है कि दूसरा मॉडल लगातार उन चीजों को पकड़ लेता है जो पहले ने मिस कर दीं...
जो मॉडल काम की समीक्षा करता है, वह उस मॉडल के अंधे धब्बों को साझा करता है जिसने इसे बनाया, क्योंकि वे एक ही स्थानों पर विफल होते हैं।
इसलिए एक मॉडल से खुद की जांच करने के लिए कहने पर आपको उसी बग पर एक आत्मविश्वासपूर्ण "मुझे तो ठीक लग रहा है" मिलता है जो उसने लिखा होता।
एक परिषद (council) संरचनात्मक रूप से इसे ठीक करती है, किसी बेहतर प्रॉम्प्ट से नहीं - क्योंकि अलग-अलग मॉडल एक-दूसरे की कमजोरियों को कवर करते हैं।
और इसका प्रमाण वास्तविक शोध पत्रों द्वारा समर्थित है:
Sakana के एक शोध दल ने एक समन्वयक (coordinator) बनाया जो इतना छोटा है कि लैपटॉप पर चल सकता है, एक मॉडल जो आपके प्रश्न का कभी उत्तर नहीं देता।
यह प्रश्न पढ़ता है
तय करता है कि कौन सा बड़ा मॉडल प्रत्येक भाग को संभाले
और काम बांट देता है
उन्होंने इसे GPT-5, Gemini और Claude पर लगाया, और इसने अकेले ही तीनों को हरा दिया...
फिर उन्होंने समन्वय के लिए एक शीर्ष-स्तरीय मॉडल को अंदर डालने की कोशिश की, और इसने और भी बुरा किया lol
तो कंडक्टर को आपका सबसे मजबूत मॉडल होने की आवश्यकता नहीं है, लेकिन इसे समस्या को पढ़ने और उसे उस व्यक्ति के पास भेजने की आवश्यकता है जो उस भाग के लिए सबसे अच्छा है।
तीन भूमिकाएँ, और वह जो छूट जाती है
समन्वयक प्रत्येक मॉडल को एक बार में एक काम देता है:
विचारक (thinker): कार्य को तोड़ें, योजना बनाएं, उसमें खामियां निकालें
कार्यकर्ता (worker): काम करें, ड्राफ्ट, कोड, नंबर, जो भी डिलिवरेबल है
सत्यापनकर्ता (verifier): परिणाम का मूल्यांकन करें और कहें "भेज दो" या "इसे ठीक करो"
सत्यापनकर्ता को छोड़ दिया जाता है, और यह सबसे महत्वपूर्ण है।
काम तब समाप्त नहीं होता जब कोई मॉडल कुछ तैयार करता है... यह तब समाप्त होता है जब कोई सत्यापनकर्ता उस पर हस्ताक्षर करता है।
वह एक नियम, एक स्पष्ट "पूर्ण" शर्त, एक ऐसे चक्र के बीच का पूरा अंतर है जो समाप्त होता है और एक जो हमेशा के लिए चक्कर लगाता रहता है।
आगे-पीछे की प्रक्रिया को एक परिषद को सौंपें
अब एक समन्वयक जोड़ना एक और परत की तरह लग सकता है जिसे प्रबंधित करना है।
लेकिन वास्तव में यह इसका उल्टा है, जो परत आप निकालते हैं वह वह है जो आप थे।
तो समाधान सरल है, आप समन्वय को ही सौंप देते हैं: आप संदेशवाहक बनना बंद कर देते हैं और एक समन्वयक को आपके लिए विचारक, कार्यकर्ता और सत्यापनकर्ता का चक्र चलाने देते हैं।
मैं अब इसके लिए Fugu का उपयोग करता हूँ (sakana.ai/fugu), और स्पष्ट कर दूं, यह प्रायोजित नहीं है, मुझे बस यह पसंद है।
यह उस शोध का उत्पादीकृत संस्करण है, आप अपने हार्नेस को उसी तरह इसकी ओर इंगित करते हैं जैसे आप किसी अन्य मॉडल की ओर करते हैं, और यह एक एकल अनुरोध के पीछे परिषद चलाता है।
मैं इस बारे में ईमानदार रहूंगा कि यह क्या है, क्योंकि यह महत्वपूर्ण है।
यह कुछ दिन पुराना है, इसमें समय लगता है क्योंकि यह वास्तव में एक परिषद चला रहा है न कि नकली, और यह सत्यापनकर्ता के रूप में सबसे मजबूत है, वह जो भेजने से पहले काम को भूनता है।
$20 में आप अंदर आ जाते हैं, यदि आप जुलाई के अंत से पहले शुरू करते हैं तो एक मुफ्त दूसरा महीना मिलता है।
मैं इसे आँख बंद करके नहीं मानता, मैं परिषद पैटर्न पर भरोसा करता हूँ, और यह सबसे आसान तरीका है जो मुझे उस पैटर्न को बिना देखभाल किए चलाने का मिला है।
अब आइए किसी भी एजेंट हार्नेस के साथ लगातार सर्वश्रेष्ठ आउटपुट प्राप्त करने के लिए चरण-दर-चरण वर्कफ़्लो में आते हैं:
परिषद को शुरुआत और अंत में चलाएं
मैं परिषद को हर प्रोजेक्ट पर दो क्षणों में लाता हूँ, बिल्कुल शुरुआत और डिलीवरी।
एक वास्तविक काम की कल्पना करें, एक न्यूज़लेटर लॉन्च करना, एक लीड लिस्ट बनाना, एक लैंडिंग पेज भेजना।
1. पहले साक्षात्कार लें - कोई भी काम शुरू होने से पहले, अपने एजेंट से गहराई से आपका साक्षात्कार करवाएं (मैट का ग्रिल-मी एक स्किल है जो एजेंट को आपसे हर चीज़ के बारे में सवाल करने पर मजबूर करता है), उस साक्षात्कार की गहराई उसके बाद की हर चीज़ की सीमा निर्धारित करती है
2. परिषद बुलाएं - योजना बनाने के लिए, समन्वयक मल्टी-मॉडल भाग को संभालता है ताकि आप अब टूल्स के बीच पेस्ट न कर रहे हों
3. लूप को परिभाषित करें - लक्ष्य और रुकने की शर्त पहले से निर्धारित करें ताकि यह आपके हर कदम देखे बिना चल सके
4. भूमिका के अनुसार प्रतिनिधि बनाएं - सही कार्य को सही जगह भेजें और सबएजेंट पर झुकें (सबएजेंट सिर्फ एक सहायक एजेंट है जिसे मुख्य एजेंट काम सौंपता है)
5. डिलीवरी पर भूनें - जब काम पूरा दिखे, तो इसे बाहर जाने से पहले तोड़ने के लिए परिषद के माध्यम से वापस भेजें
एक ही लूप, दो सिरे, शुरुआत में योजना और अंत में भूनना - यही पूरा इंजन है, और इसने गहराई से बदल दिया कि मैं कितनी तेजी से कुछ भेज सकता हूँ जिस पर मुझे भरोसा है।
परिषद इंजन है, सेटअप इसे तेज रखता है
एक इंजन केवल उतना ही अच्छा होता है जितनी उसके आसपास की मशीन...
तो यहाँ छह चालें हैं जो परिषद में प्रत्येक एजेंट को अपना सर्वश्रेष्ठ उत्पादन करने में रखती हैं, उनमें से कोई भी जटिल नहीं है।
1. अपनी खुद की स्किल्स बनाएं, लाइब्रेरी डाउनलोड न करें
एक स्किल आपके एजेंट द्वारा पुन: उपयोग किए जा सकने वाले निर्देशों का एक सहेजा गया सेट है, एक रेसिपी की तरह जिसका वह अनुसरण करता है (उदाहरणों के साथ एक मार्कडाउन फ़ाइल से अधिक कुछ नहीं...)
प्रलोभन किसी और द्वारा प्रकाशित स्किल्स की एक बड़ी लाइब्रेरी लेना और बस इसे चलाना है।
मैं उससे बचूंगा, लगभग एक तिहाई सार्वजनिक स्किल्स में सुरक्षा दोष होता है... यदि बदतर नहीं lol
और साफ वाले भी किसी और के संदर्भ हैं, आपके नहीं, एक स्किल तभी मदद करती है जब आपने व्यक्तिगत रूप से उस दीवार को मारा हो जिसे वह हल करती है।
उससे पहले, यह सिर्फ शोर है जो एजेंट की मेमोरी को भर रहा है।
तो यह मेरा कहना है: उन कुछ का निर्माण करें जिनकी आपको वास्तव में आवश्यकता है, अपने स्वयं के असफल रन से लिए गए, यहीं असली बढ़त रहती है।
2. डिफ़ॉल्ट रूप से छोटे CLI का उपयोग करें, MCP सर्वर का नहीं
पहले दो त्वरित शब्द, MCP आपके एजेंट में अतिरिक्त टूल जोड़ने का एक तरीका है, और CLI एक छोटा कमांड है जिसे आप टेक्स्ट विंडो में चलाते हैं।
प्रतिवर्त हर चीज़ के लिए MCP जोड़ना है, और प्रत्येक आपके पहला प्रश्न पूछने से पहले ही अपनी पूरी निर्देश पत्रिका को एजेंट की मेमोरी में लोड करता है।
वे टूल विवरण शुरू में 100,000 से अधिक शब्दों की मेमोरी खा सकते हैं, वास्तविक काम को बाहर कर देते हैं।
इसलिए रोजमर्रा के कार्यों के लिए, इसके बजाय एक छोटे CLI तक पहुंचें, यह हल्का है, एजेंट पहले से ही जानता है कि कमांड कैसे चलाना है, और इसका आउटपुट मेमोरी को बंद किए बिना एक फ़ाइल में आता है।
प्रिंटिंग-प्रेस नामक एक टूल (printingpress.dev) एक एकल प्रॉम्प्ट से किसी भी सेवा के लिए इनमें से एक लिखेगा... इसका दुरुपयोग करें।
MCP को उन कामों के लिए रखें जिन्हें वास्तव में उनकी आवश्यकता है, साझा लॉगिन, बहुत सारे उपयोगकर्ता, एक लाइव कनेक्शन जिसे खुला रहना है।
नियम CLI-प्रथम है, CLI-केवल नहीं।
3. निर्देश फ़ाइल को हल्का रखें
आपका एजेंट प्रत्येक कार्य से पहले एक निर्देश फ़ाइल पढ़ता है, आमतौर पर AGENTS.md या CLAUDE.md।
आग्रह इसे हर उस चीज़ से भरने का है जिसके बारे में आप सोच सकते हैं, और एजेंट कम का पालन करता है, अधिक का नहीं।
एक मॉडल लगभग 150 से 200 निर्देशों का विश्वसनीय रूप से पालन करता है, फिर वह उन्हें गिराना शुरू कर देता है।
अपनी फ़ाइल को 100 लाइनों से कम रखें - यह इस तरह बेहतर काम करता है।
4. संदर्भ साफ़ करें, मेमोरी को फ़ाइलों में रखें
संदर्भ विंडो आपके एजेंट की अल्पकालिक मेमोरी है, और यह भर जाती है और भरने पर बेवकूफ हो जाती है।
Claude Opus 4.8 एक बढ़िया उदाहरण है... यह एक असाधारण मॉडल है, लेकिन जैसे ही आप 300-400k टोकन तक पहुंचते हैं, आपको 100% संदर्भ साफ़ करना चाहिए - कॉम्पैक्टिंग का उपयोग न करें।
इसलिए इसे बार-बार साफ़ करें, और जो मेमोरी मायने रखती है उसे फ़ाइलों में रखें।
एक learnings.md जिसे एजेंट सत्र की शुरुआत में पढ़ता है और अंत में अपडेट करता है, हर बार, तब भी जब वह सोचता है कि कुछ भी नहीं बदला है।
प्रत्येक कमिट के बाद उन नोट्स को अपडेट करवाएं, एक कमिट काम का एक सहेजा गया चेकपॉइंट है।
स्थायी नियम निर्देश फ़ाइल में रहते हैं, जो चीजें वह रास्ते में सीखता है वे learnings में रहती हैं, और यदि आप प्रत्येक रन के बाद अपनी नियम फ़ाइल को संपादित कर रहे हैं, तो आपने इसमें गलत चीजें डाल दी हैं।
मैंने अपने लिए /before-clear नामक एक स्किल बनाई, यह बस प्रोजेक्ट में एक चेकपॉइंट बनाता है, एक अस्थायी फ़ाइल जिसे एजेंट पहले पढ़ता है... इसमें एक बहुत ही सरल टू-डू है, पिछले सत्र में क्या हुआ और अगला सबसे जरूरी कार्य क्या है, इसका संक्षिप्त सारांश।
मैं शायद ही कभी एक सत्र से दूसरे सत्र में कोई महत्वपूर्ण संदर्भ खोता हूँ।
5. कुछ नियम लिखें, प्रत्येक सादा
स्पष्ट नियमों की एक छोटी सूची चतुर नियमों के एक बड़े ढेर से कहीं बेहतर है।
एक बार जब नियम फ़ाइल लंबी हो जाती है, तो नियम एक-दूसरे से प्रतिस्पर्धा करने लगते हैं, और एजेंट को अनुमान लगाना पड़ता है कि कौन सा जीतता है।
प्रत्येक नियम को उसी तरह लिखें जैसे आप एक नए कर्मचारी को बताएंगे, एक पंक्ति, एक अर्थ, व्याख्या करने की कोई गुंजाइश नहीं।
जब नियम स्पष्ट होता है तो एजेंट उसका पालन करता है, जब यह अस्पष्ट होता है तो एजेंट तात्कालिक रूप से काम करता है, और तात्कालिक रूप से काम करना ठीक वही है जहाँ आपके आउटपुट बग़ल में चले जाते हैं।
6. भारी काम को सबएजेंट को सौंपें
गंदे, महंगे काम को सबएजेंट पर डालें, विशेष रूप से वह सब कुछ जो ब्राउज़र को छूता है।
मुख्य एजेंट से ब्राउज़र चलाना सिर्फ स्क्रीनशॉट पर बहुत सारा संदर्भ जला सकता है।
उसी काम को एक सबएजेंट को सौंपें और वह "हो गया, यहाँ सारांश है" एक या दो पंक्तियों में वापस आता है।
मुख्य एजेंट कंडक्टर बना रहता है, सहायक पहुंचते हैं, और आपकी मुख्य मेमोरी साफ रहती है।
यह फिर से परिषद का विचार है, एक स्तर नीचे, आप सब कुछ खुद करने के बजाय काम का समन्वय करते हैं।
संपूर्ण ऑपरेटिंग सिस्टम, एक ब्लॉक में
सबसे अच्छा मॉडल लगातार प्रतिबंधित होता जा रहा है, इसलिए एक मॉडल आपकी नींव नहीं हो सकता
समन्वय को एक परिषद को सौंपें: विचारक योजना बनाता है, कार्यकर्ता निर्माण करता है, सत्यापनकर्ता हस्ताक्षर करता है
सत्यापनकर्ता रुकने की शर्त है, काम तब पूरा होता है जब वह कहता है, पहले नहीं
परिषद को दो बार चलाएं, शुरुआत में योजना बनाने के लिए और डिलीवरी पर भूनने के लिए
मैं इसे चलाने के लिए Fugu का उपयोग करता हूँ, $20 आज़माने के लिए, प्रायोजित नहीं, जल्दी होने के बारे में ईमानदार
फिर प्रत्येक एजेंट को तेज रखें:
अपनी खुद की स्किल्स बनाएं, लाइब्रेरी डाउनलोड न करें
CLI-प्रथम, MCP केवल तभी जब आपको वास्तव में उनकी आवश्यकता हो
निर्देश फ़ाइल 100 लाइनों से कम
संदर्भ को बार-बार साफ़ करें, मेमोरी को फ़ाइलों में रखें
कुछ नियम, प्रत्येक सादा
भारी काम को सबएजेंट को सौंपें
उसके ऊपर बाकी सब कुछ शुद्ध अनुकूलन है जिसे आप शायद तब तक नोटिस भी नहीं करेंगे जब तक आप सॉफ्टवेयर इंजीनियर न हों।
इस तरह आप अपने लिए एक ऑपरेटिंग सिस्टम बनाते हैं जो प्रदर्शन करता है, Fable 5 के साथ या उसके बिना...
वैसे भी, मैं दुनिया का सबसे अच्छा AI समुदाय बना रहा हूँ, क्या आप मेरे साथ शामिल होंगे?
