Hermes Agent पूर्ण गाइड: आर्किटेक्चर, सेटअप और सेल्फ-इम्प्रूविंग लूप

एक नई तरह की AI टूलिंग धीरे-धीरे आकार ले रही है: ऐसे एजेंट जो किसी चैट विंडो में नहीं रहते जिसे आप खोलते और बंद करते हैं, बल्कि क्लाउड में लगातार चलते रहते हैं और आपसे एक मैसेंजर के माध्यम से बात करते हैं, एक ऐसे सहकर्मी की तरह जो कभी लॉग ऑफ नहीं करता।

Hermes इस विचार के सबसे दिलचस्प कार्यान्वयनों में से एक है, और इसे OpenClaw जैसे समान एजेंटों से अलग करने वाली चीज़ एक अंतर्निहित स्व-सुधार लूप है – एक ऐसी प्रणाली जो आपकी बातचीत पर नज़र रखती है, उनसे उपयोगी पैटर्न निकालती है, और उन पैटर्न को अपनी मेमोरी और कौशल सेट में स्थायी अपग्रेड में बदल देती है।

यह लेख बताता है कि Hermes कैसे बनाया गया है, इसे कैसे कॉन्फ़िगर किया जाए, और वह स्व-सुधार लूप वास्तव में हुड के नीचे कैसे काम करता है।

Hermes क्या है, और यह OpenClaw से कैसे अलग है

Hermes एक क्लाउड-रेज़िडेंट AI एजेंट है, जो संरचनात्मक रूप से OpenClaw के समान है: यह 24/7 चलता है और आप टर्मिनल या ब्राउज़र टैब के बजाय एक मैसेजिंग ऐप के माध्यम से इसके साथ बातचीत करते हैं।

सार्थक अंतर तीन गुना हैं।

पहला, Hermes बॉक्स से बाहर बिल्ट-इन स्किल्स की एक बहुत बड़ी लाइब्रेरी के साथ आता है, इसलिए आप स्वयं इंटीग्रेशन जोड़ने में कम समय बिताते हैं।

दूसरा, सेटअप प्रक्रिया काफी अधिक सुव्यवस्थित है – एक गाइडेड TUI लगभग सब कुछ संभाल लेता है।

तीसरा, और सबसे महत्वपूर्ण, Hermes निरंतर स्व-सुधार के आसपास डिज़ाइन किया गया है: यह सिर्फ कार्यों को निष्पादित नहीं करता, बल्कि समय के साथ उन्हें बेहतर तरीके से निष्पादित करने के बारे में प्रक्रियात्मक ज्ञान संचित करता है।

इंस्टॉलेशन और प्रारंभिक सेटअप

Hermes को चालू करने के लिए एक ही कमांड की आवश्यकता है।

विंडोज़ पर, आप इसे PowerShell में चलाते हैं:

iex (irm

https://hermes-agent.nousresearch.com/install.ps1

लिनक्स, macOS, या WSL पर, समकक्ष है:

curl -fsSL

https://hermes-agent.nousresearch.com/install.sh | bash

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

मॉडल चुनना और रूट करना

सेटअप में पहला वास्तविक निर्णय यह है कि कौन सा LLM प्रदाता एजेंट के "दिमाग" को शक्ति प्रदान करेगा। प्रमाणीकरण रॉ API कुंजियों के बजाय OAuth के माध्यम से होता है, जो एक अलग API कुंजी उत्पन्न करने के बजाय मौजूदा Claude Code या Codex CLI सत्र के माध्यम से लॉग इन करने में सक्षम बनाता है।

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

जो कार्य इस प्रकार के ओवरराइड का समर्थन करते हैं वे हैं:

• vision – इमेज विश्लेषण और विवरण
• web_extract – लंबे वेब पेजों का सारांश
• compression – ओवरफ़्लो हो रहे बातचीत संदर्भ को संपीड़ित करना
• title_generation – सत्र शीर्षक उत्पन्न करना
• curator – पृष्ठभूमि एजेंट जो स्व-सुधार लूप के लिए जिम्मेदार है
• kanban_decomposer – Kanban मोड में बड़े कार्यों को उप-कार्यों में तोड़ना
• goal_judge – एजेंट जो जाँचता है कि /goal वास्तव में प्राप्त हुआ है या नहीं

यह सीधे config.yaml में कॉन्फ़िगर किया गया है, उदाहरण के लिए:

1# Primary model for chat and complex reasoning
2model:
3  provider: "anthropic"
4  default: "claude-4-8-sonnet"
5  auxiliary:
6    vision:
7      provider: "gemini"
8      model: "gemini-2.5-flash"
9    compression:
10      provider: "custom"
11      base_url: "http://localhost:11434/v1"
12      api_key: "none"
13      model: "qwen2.5:32b"

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

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

यह भी ध्यान देने योग्य है कि यदि आप कोडिंग गुणवत्ता का त्याग किए बिना बातचीत के मॉडल पर पैसे बचाना चाहते हैं, तो Hermes /claude_code और /codex कमांड का समर्थन करता है जो कोडिंग कार्यों को सीधे उन CLI टूल्स को सौंपते हैं, न कि कॉन्फ़िगर किए गए चैट मॉडल के साथ संभालते हैं।

टर्मिनल बैकएंड

आर्किटेक्चर का एक मुख्य टुकड़ा टर्मिनल बैकएंड एनवायरनमेंट है, जो यह निर्धारित करता है कि शेल कमांड और Python स्क्रिप्ट वास्तव में कहाँ और कैसे निष्पादित होते हैं, और एजेंट आपके फ़ाइलसिस्टम को कैसे छूता है। Hermes पाँच का समर्थन करता है।

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

यहाँ सुरक्षा पूरी तरह से एक अंतर्निहित अनुमोदन प्रणाली पर निर्भर करती है जो विनाशकारी कमांड (एक rm -rf /, एक DROP TABLE) को इंटरसेप्ट करती है और उन्हें चलाने से पहले स्पष्ट अनुमति मांगती है।

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

Daytona AI कोडिंग एजेंटों के लिए उद्देश्य-निर्मित एक कंटेनर-प्रबंधन परत है; यह सीधे Docker चलाने की तुलना में तेज़ है और स्वचालित रूप से एनवायरनमेंट सेटअप और निर्भरता इंस्टॉलेशन को संभालता है।

अधिकांश व्यक्तिगत उपयोग के मामलों के लिए, Local वास्तव में पर्याप्त है – अन्य विकल्प मुख्य रूप से मायने रखते हैं यदि आप अविश्वसनीय कोड चला रहे हैं या टीम स्तर पर काम कर रहे हैं।

मैसेजिंग गेटवे और टूल कॉन्फ़िगरेशन

टर्मिनल बैकएंड के बाद, सेटअप यह चुनने के लिए आगे बढ़ता है कि आप वास्तव में एजेंट से कहाँ बात करेंगे – Telegram सबसे पॉलिश विकल्प होने के नाते। इसे चुनने पर आपको एक सीधा लिंक मिलता है जो एक पूर्व-कॉन्फ़िगर बॉट को स्पिन करता है; इसमें कोई मैनुअल बॉट-टोकन सेटअप शामिल नहीं है।

शेष सेटअप व्यक्तिगत टूल और उनके संबंधित प्रदाताओं को सक्षम करने के माध्यम से चलता है – ब्राउज़र ऑटोमेशन, इमेज जनरेशन, टेक्स्ट-टू-स्पीच, और वेब सर्च। वेब सर्च के लिए विशेष रूप से, सेल्फ-होस्टेड Firecrawl या Exa एजेंट-उन्मुख स्क्रेपिंग और रिट्रीवल के लिए मजबूत विकल्प के रूप में सामने आते हैं।

X सर्च को सक्षम करने के लिए Grok सब्सक्रिप्शन की आवश्यकता होती है, जो मेनू में इसे ढूंढने से पहले जानने लायक है।

जानने लायक स्लैश कमांड

Hermes स्लैश कमांड की एक लंबी सूची के साथ आता है, अधिकांश नाम से स्वयं-व्याख्यात्मक हैं, लेकिन कुछ विशेष रूप से उल्लेख करने योग्य हैं।

1. /background <prompt> आपके मुख्य सत्र को बाधित किए बिना पृष्ठभूमि में एक कार्य चलाता है।
2. /goal एक दीर्घकालिक उद्देश्य निर्धारित करता है जिसकी ओर एजेंट लगातार काम करता है, रोकने, फिर से शुरू करने, साफ़ करने या स्थिति जांचने के लिए उप-कमांड के साथ;
3. /subgoal एक सक्रिय लक्ष्य के अंतर्गत छोटे उद्देश्यों का प्रबंधन करता है।
4. /kanban कई स्वतंत्र एजेंटों में अतुल्यकालिक, लंबे समय तक चलने वाले कार्य को व्यवस्थित करता है – एक वास्तविक Kanban बोर्ड की तरह कार्य करता है जहाँ कार्यों का एक पूल वर्कर एजेंटों के बीच वितरित किया जाता है और उनके बीच सौंपे जाने पर to-do, in-progress, और done के माध्यम से चलता है।

डेवलपमेंट पक्ष पर, /github_pr_workflow ब्रांच-टू-मर्ज चक्र को CI सहित संभालता है, /github_code_review पुल रिक्वेस्ट की समीक्षा करता है, और /codebase_inspection रिपॉजिटरी के भाषा विभाजन और लाइन काउंट का विश्लेषण करता है। /dogfood एक समर्पित QA मोड है जो वेब ऐप में बग ढूंढता है और साक्ष्य-समर्थित रिपोर्ट तैयार करता है। /spike पूर्ण विकास के लिए प्रतिबद्ध होने से पहले एक विचार को मान्य करने के लिए एक त्वरित, डिस्पोजेबल प्रयोग चलाता है, और /systematic_debugging चार चरणों में बग के माध्यम से काम करता है, समाधान का प्रयास करने से पहले मूल कारण को समझता है।

कुछ इंटीग्रेशन-विशिष्ट कमांड भी हैं – /notion, /obsidian, /airtable, /google_workspace, /arxiv, /blogwatcher, /polymarket, /ocr_and_documents, /youtube_content – प्रत्येक एक विशिष्ट बाहरी सेवा या वर्कफ़्लो को लपेटता है, साथ ही /bundles, जो छोटी YAML कॉन्फ़िगरेशन फ़ाइलों के माध्यम से एक ही स्लैश कमांड के तहत कई मौजूदा स्किल्स को समूहित करता है।

क्रॉन जॉब और वेबहुक

दो ऑटोमेशन प्रिमिटिव विशेष ध्यान देने योग्य हैं।

• क्रॉन जॉब आपको एक स्क्रिप्ट को टाइमर पर चलाने का शेड्यूल करने देते हैं; यदि आप एक बनाते समय -no-agent पास करते हैं, तो Hermes एक सादा Python या bash स्क्रिप्ट निष्पादित करेगा और बिना कोई LLM टोकन खर्च किए अपना आउटपुट आपके मैसेंजर को अग्रेषित करेगा।
• वेबहुक अधिक शक्तिशाली टुकड़ा है: वे एजेंट को टाइमर के बजाय बाहरी घटनाओं पर प्रतिक्रिया करने देते हैं। आप एक वेबहुक कॉन्फ़िगर कर सकते हैं ताकि, उदाहरण के लिए, एक नया GitHub पुल रिक्वेस्ट स्वचालित रूप से एक विशिष्ट प्रॉम्प्ट और स्किल सेट के साथ एक एजेंट को ट्रिगर करे – प्रति PR शून्य मैन्युअल हस्तक्षेप के साथ प्रभावी रूप से एक ऑन-कॉल रिव्यूअर एजेंट खड़ा करना।

कॉन्टेक्स्ट इंजन

कॉन्टेक्स्ट इंजन यह नियंत्रित करता है कि एक बार यह मॉडल की टोकन सीमा के करीब पहुंचने पर Hermes बातचीत के इतिहास को कैसे संपीड़ित और प्रबंधित करता है, और दो विकल्प हैं।

• डिफ़ॉल्ट, जिसे Compressor कहा जाता है, एक लंबी बातचीत के मध्य भाग पर लॉसी सारांश लागू करता है।
• विकल्प, LCM (Lossless Context Management), संरचनात्मक रूप से भिन्न दृष्टिकोण अपनाता है: एक टेक्स्ट सारांश तैयार करने के बजाय, यह बातचीत के प्रमुख बिंदुओं का एक निर्देशित अचक्रीय ग्राफ बनाता है, जिससे एजेंट एक उच्च-स्तरीय, भारी संपीड़ित दृश्य से उन विशिष्ट मूल संदेशों तक नेविगेट कर सकता है जो इसका समर्थन करते हैं।

मेमोरी इंजन

बाहरी मेमोरी प्रदाता Hermes के अंतर्निहित स्थानीय मेमोरी फ़ाइलों, MEMORY.md और USER.md के साथ चलते हैं, जो सिमैंटिक सर्च और नॉलेज ग्राफ जैसी क्षमताओं को जोड़ते हैं।

कई को सीधे सेटअप TUI के माध्यम से कॉन्फ़िगर किया जा सकता है।

1. Honcho एक विस्तृत उपयोगकर्ता प्रोफ़ाइल मॉडलिंग के आसपास बनाया गया है, दो परतों में अवलोकनों को संश्लेषित करने के लिए पृष्ठभूमि LLM कॉल का उपयोग करता है: सत्र सारांश और प्रोफाइल की एक आधार परत, और एक द्वंद्वात्मक परत जो उपयोगकर्ता की वर्तमान आवश्यकताओं का विश्लेषण करती है।
2. OpenViking एक संदर्भ डेटाबेस है जो फ़ाइलसिस्टम-शैली ज्ञान पदानुक्रम बनाता है, स्तरीय संदर्भ पुनर्प्राप्ति का समर्थन करता है और प्रत्येक सत्र के अंत में निकाले गए तथ्यों को स्वचालित रूप से छह श्रेणियों – घटनाओं, पैटर्न, प्राथमिकताओं, इत्यादि – में सॉर्ट करता है।
3. Mem0 एक पूरी तरह से प्रबंधित क्लाउड मेमोरी सेवा है; तथ्य निष्कर्षण LLM के माध्यम से सर्वर-साइड होता है, और इसमें सिमैंटिक सर्च, परिणाम रीरैंकिंग और स्वचालित डिडुप्लिकेशन शामिल है, हालांकि क्लाउड-होस्टेड होने के कारण यह आवर्ती लागत वाला एकमात्र विकल्प भी है।
4. Hindsight एक अधिक उन्नत दीर्घकालिक मेमोरी सिस्टम है जो एक नॉलेज ग्राफ पर बनाया गया है, GraphRAG शैली में। यह सत्रों से संस्थाओं को निकालता है, उनके बीच संबंध बनाता है, और टूल कॉल सहित पूर्ण वार्तालाप मोड़ को संरक्षित करता है, जिसमें मेमोरी चार श्रेणियों में विभाजित होती है: दुनिया के बारे में तथ्य, एजेंट का अपना अनुभव, राय और अवलोकन।
5. Holographic एक स्थानीय, SQLite-आधारित तथ्य भंडार है जिसमें कोई बाहरी निर्भरता नहीं है, जिसमें संग्रहीत तथ्यों के लिए एक ट्रस्ट-स्कोरिंग प्रणाली और बीजगणितीय, रचनात्मक प्रश्नों का समर्थन करने के लिए Holographic Reduced Representations का उपयोग शामिल है, जिसमें इसके ज्ञानकोष के भीतर स्वचालित रूप से विरोधाभासों का पता लगाने की क्षमता है।
6. RetainDB टीम मेमोरी के लिए एक क्लाउड API है, जो वेक्टर, BM25 और रीरैंकिंग विधियों में हाइब्रिड सर्च प्रदान करता है, मेमोरी सात अलग-अलग प्रकारों में विभाजित है और स्टोरेज को कुशल रखने के लिए डेल्टा कम्प्रेशन है।
7. ByteRover एक पोर्टेबल, स्थानीय मेमोरी सिस्टम है जो CLI के माध्यम से एक्सेस किया जाता है, एक पदानुक्रमित ज्ञान वृक्ष बनाता है और लॉसी कम्प्रेशन को उन्हें संदर्भ से गिराने का मौका मिलने से पहले महत्वपूर्ण तथ्यों को निकालता है।
8. Supermemory एक ग्राफ API के साथ सिमैंटिक दीर्घकालिक मेमोरी प्रदान करता है: यह अपने ज्ञान ग्राफ को बनाने के लिए बातचीत समाप्त होने के बाद पूर्ण सत्र लॉग को अंतर्ग्रहण करता है, वर्तमान मोड़ से संदूषण से बचने के लिए समय-समय पर याद किए गए तथ्यों को साफ करता है, और प्रति एजेंट प्रोफ़ाइल अलग-अलग कंटेनरों में मेमोरी को अलग कर सकता है।

दिन-प्रतिदिन के उपयोग के लिए, डिफ़ॉल्ट स्थानीय मेमोरी अधिकांश लोगों के लिए वास्तव में पर्याप्त है – भारी सिस्टम वास्तविक संसाधन लागत, विशेष रूप से स्थानीय रूप से होस्ट किए गए विकल्पों के लिए RAM, का व्यापार उस क्षमता के लिए करते हैं जिसकी अधिकांश वर्कफ़्लो को अभी आवश्यकता नहीं है।

स्व-सुधार लूप

यह वह विशेषता है जो Hermes को पारंपरिक एजेंट से सबसे अलग करती है: अतुल्यकालिक पृष्ठभूमि प्रक्रियाओं का एक सेट जो लगातार आपकी बातचीत का विश्लेषण करता है, उनसे उपयोगी पैटर्न निकालता है, और उन पैटर्न को दीर्घकालिक मेमोरी और प्रक्रियात्मक मेमोरी (स्किल्स) में लिखता है – फिर उस संचित ज्ञान को बनाए रखता है ताकि यह समय के साथ खराब न हो। पूरी प्रणाली आपके मुख्य चैट के समानांतर चलती है और तीन घटकों से बनी है: एक ट्रिगर सिस्टम, एक पृष्ठभूमि समीक्षा एजेंट और एक क्यूरेटर।

• ट्रिगर सिस्टम

Hermes प्रत्येक संदेश का वास्तविक समय में विश्लेषण नहीं करता, क्योंकि इससे बिना किसी लाभ के टोकन जलेंगे। इसके बजाय, यह दो काउंटरों पर निर्भर करता है जो एक सीमा पार करने पर एक चिंतन पास को ट्रिगर करते हैं।

एक मेमोरी ट्रिगर हर दस उपयोगकर्ता प्रॉम्प्ट पर फायर करता है, यह जाँचता है कि क्या बचत करने योग्य नए तथ्य बातचीत में दिखाई दिए हैं।

एक स्किल ट्रिगर एक ही मोड़ के भीतर हर दस टूल-कॉल पुनरावृत्तियों पर फायर करता है, इस सिद्धांत पर कि यदि एजेंट ने अभी-अभी परीक्षण और त्रुटि से एक समस्या से जूझते हुए इतने सारे कदम बिताए हैं, तो वह अनुभव विश्लेषण करने और संभवतः पुन: प्रयोज्य स्किल में बदलने के लायक है।

एक बार जब कोई भी काउंटर अपनी सीमा से टकराता है, तो एक आंतरिक फ़ंक्शन फायर करता है, वर्तमान बातचीत का एक स्नैपशॉट एक पृष्ठभूमि समीक्षा प्रक्रिया को सौंपता है।

• पृष्ठभूमि समीक्षा एजेंट

यह स्नैपशॉट एक पूरी तरह से अलग, पृथक एजेंट प्रक्रिया में जाता है जो आपके मुख्य सत्र को बाधित किए बिना समानांतर में चलता है। यह दो दिशाओं में काम करता है।

1. घोषणात्मक पक्ष पर, यदि यह नई उपयोगकर्ता प्राथमिकताओं या एनवायरनमेंट विवरणों को नोटिस करता है – Supabase के लिए प्राथमिकता, Python 3.12 पर पिन किया गया प्रोजेक्ट – तो यह MEMORY.md या USER.md को अपडेट करता है, इस पर निर्भर करता है कि तथ्य किस फ़ाइल में है।
2. प्रक्रियात्मक पक्ष पर, यदि यह पता लगाता है कि एजेंट ने अभी-अभी एक गैर-तुच्छ समस्या हल की है या एक जटिल प्रक्रिया तैयार की है, तो यह एक नई स्किल बना सकता है, मौजूदा को संपादित कर सकता है, एक लक्षित पैच लागू कर सकता है, या एक को पूरी तरह हटा सकता है। इसके द्वारा बनाई गई कोई भी स्किल स्पष्ट रूप से एजेंट-जनरेटेड के रूप में टैग की जाती है, ताकि इसकी उत्पत्ति हमेशा पता लगाने योग्य हो।

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

• क्यूरेटर

अनियंत्रित छोड़ दिया गया, यह प्रक्रिया अंततः सैकड़ों स्किल्स उत्पन्न कर सकती है, कुछ अनावश्यक, कुछ पुरानी।

क्यूरेटर उस ज्ञानकोष को खराब होने से बचाने के लिए मौजूद है। यह तभी शुरू होता है जब दो स्थितियाँ एक साथ होती हैं: इसके अंतिम चलने के बाद पर्याप्त समय बीत चुका है (डिफ़ॉल्ट रूप से सात दिन), और मुख्य एजेंट पर्याप्त समय से निष्क्रिय है (डिफ़ॉल्ट रूप से दो घंटे) ताकि एक भारी रखरखाव पास सक्रिय कार्य में हस्तक्षेप न करे।

कोई भी बदलाव करने से पहले, यह स्वचालित रूप से संपूर्ण स्किल्स निर्देशिका का बैकअप लेता है, ताकि किसी भी असंतोषजनक परिणाम को एक ही टर्मिनल कमांड के माध्यम से वापस लाया जा सके।

क्यूरेटर का काम दो चरणों में होता है:

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

प्रत्येक स्किल के लिए, क्यूरेटर इसे वैसे ही रखने का निर्णय लेता है यदि यह अभी भी सटीक और उपयोगी है, इसे ठीक करता है यदि इसमें त्रुटियाँ या पुरानी विधियाँ हैं, इसे दूसरी स्किल के साथ मर्ज करता है जो मूल रूप से एक ही जमीन को कवर करती है (संबंधित स्क्रिप्ट, इवल, या संदर्भ फ़ाइलों को सही ढंग से स्थानांतरित करना और प्रक्रिया में सापेक्ष पथों को फिर से लिखना), या इसे पूरी तरह से संग्रहित करता है।

चक्र के अंत में, यह एक विस्तृत रिपोर्ट तैयार करता है जिसमें एक नाम बदलने का मानचित्र शामिल है जो दिखाता है कि किसी भी मर्ज के बाद पुराने स्किल नाम नए लोगों में कैसे मैप हुए, ताकि प्रत्येक निर्णय के पीछे का तर्क पूरी तरह से ऑडिट करने योग्य हो।

Hermes का अच्छी तरह से उपयोग करना

इस तरह के क्लाउड एजेंट वास्तव में किसी भी प्रक्रिया के लिए मूल्यवान हैं जिसे आप 24/7 चला सकते हैं – कोडिंग कार्य एक उल्लेखनीय अपवाद होने के नाते – बशर्ते आपने वास्तव में उस प्रक्रिया को सावधानीपूर्वक डिजिटलीकृत किया हो और उसके चारों ओर एक ठोस स्किल बनाई हो, जिसमें इवल्यूएशन शामिल हों।

जो वर्कफ़्लो अच्छे परिणाम देता है वह कुछ इस तरह दिखता है:

1. स्वयं को विस्तार से रिकॉर्ड करके शुरू करें, प्रक्रिया के माध्यम से पूर्ण शुरुआत से अंत तक चलते हुए, आदर्श रूप से एक डिक्टेशन टूल का उपयोग करके ताकि आप इसे सटीक रूप से कैप्चर करें – और यह चरण तभी काम करता है जब आप वास्तव में प्रक्रिया को समझते हैं या इसकी ठीक से शोध किया है।
2. उस रिकॉर्डिंग या उन नोट्स को लें और उन्हें एक कोडिंग एजेंट में एक स्किल-क्रिएशन टूल का उपयोग करके पहला ड्राफ्ट तैयार करने के लिए फीड करें; यह अभी तक सौंपने के लिए पर्याप्त नहीं होगा, विशेष रूप से किसी भी जटिल चीज़ के लिए।
3. इवल्स में बनाएँ – संदर्भ समाधान जो एक सही परिणाम का प्रतिनिधित्व करते हैं – क्योंकि वे आपको वास्तव में मापने देते हैं कि क्या स्किल अच्छा प्रदर्शन कर रही है, अनुमान लगाने के बजाय।
4. स्किल को एक परीक्षण सेटिंग में चलाएँ और आप जो देखते हैं उसके आधार पर इवल्स और स्किल सामग्री दोनों को परिष्कृत करें, उस संपादन का अधिकांश भाग हाथ से करें न कि इसे सौंपकर।
5. केवल एक बार जब स्किल लगातार और नियतात्मक रूप से व्यवहार करती है, तो इसे हमेशा चालू एजेंट को सौंपा जाना चाहिए। यदि प्रक्रिया किसी बाहरी सेवा पर निर्भर करती है, तो यह जाँचने लायक है कि क्या कोई मौजूदा MCP सर्वर या CLI पहले से ही इसे कवर करता है, इसे खरोंच से बनाने से पहले।

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

तीन सिद्धांत उपयोग के मामलों में धारण करते प्रतीत होते हैं: कोडिंग कार्य को बिना पर्यवेक्षण के 24/7 क्लाउड एजेंट को आउटसोर्स न करें, एजेंट वास्तव में क्या उत्पादन करता है, इसकी समीक्षा करने के लिए एक मानव को लूप में रखें, और स्किल रिफाइनमेंट को चल रहे काम के रूप में मानें न कि कुछ ऐसा जिसे आप एक बार खत्म करके चले जाते हैं।

यदि यह उपयोगी था – इसे बुकमार्क करें। आप इस पर वापस आना चाहेंगे।

इस तरह की और अधिक जानकारी के लिए @ScottyBeamIO को फ़ॉलो करें

कोई बकवास नहीं, सिर्फ वही जो वास्तव में काम करता है।