हर वह चीज़ जो आपको Hermes Agent को समझने और कस्टमाइज़ करने के लिए चाहिए। स्व-विकसित होने वाली स्किल्स, तीन-स्तरीय मेमोरी, GEPA ऑप्टिमाइज़ेशन, और 1 से 10 एजेंट तक जो आपके लिए 24/7 काम करते हैं।
Hermes Agent ने दो महीनों में 90,000 GitHub स्टार पार कर लिए। डेवलपर्स चुपचाप पर्सनल AI एजेंट बना रहे हैं जो उनके वर्कफ़्लो को सीखते हैं, उनके कॉन्टेक्सेक्स्ट को याद रखते हैं, और 24/7 चलते हैं।
हर AI एजेंट जो आपने आपने इस्तेमाल किया है, उसमें एक ही समस्या है: जैसे ही आपका सेशन खत्म होता है, वह सब कुछ भूल जाता है।
आपकी कोडिंग प्राथमिकताएँ, वे प्रोजेक्ट कन्वेंशन जिन्हें आपने तीन बार सुधारा, वह फिक्स जो उसने कल 10 मिने 10 मिनट में निकाला था। सब खत्म। अगले सेशन में आप फिर शुरू से शुरू करते हैं।
Nous Research का Hermes Agent एक मौलिक रूप से अलग दृष्टिकोण अपनाता है। यह एक लर्निंग लूप के साथ आता है जो:
- सेशनों के बीच याद रखता है
- अपनी खुद की पुन: उपयोग योग्य स्किल्स लिखता है
- उन्हें बैकग्राउंड में प्रून करता है
- और उन्हें GEPA नामक एक विकासवादी इंजन के माध्यम से ऑफ़लाइन मान्य करता है
कोई अन्य ओपन-सोर्स एजेंट इन तीनों को एक साथ नहीं जोड़ता। OpenClaw भी नहीं।
यह गाइड बताती है कि यह लर्निंग लूप कैसे काम करता है, प्रत्येक मेमोरी लेयर क्या करती है, और सब कुछ स्क्रैच से कैसे कॉन्फ़िगर करें।
अंत तक, आपके मशीन पर तीन पूरी तरहत एजेंट चल रहे होंगे: एक प्रोग्रामर (जो आपके Claude Code का उपयोग करता है), एक डीप रिसर्चर, और एक डिज़ाइनर, प्रत्येक अपने व्यक्तित्व, मेमोरी, स्किल्स और Telegram बॉट के साथ।
यह देखें:
<payloadblk_1" type="upload" />
पूरा सेटअप मिनटों में हो जाता है और यहाँ सब कुछ आपके अपने हार्डवेयर पर दोहराया जा सकता है।
नोट: इस गाइड के सभी चित्र Pixel द्वारा डिज़ाइन किए गए हैं, जो उन Hermes एजेंटों में से एक है जिन्हें आप अंत तक बनाना सीखेंगे। पढ़ते समय उन पर नज़रें।
चलिए शुरू करते हैं!
कैसे पढ़ें
दो भाग: पहले सिद्धांत, फिर व्यावहारिक।
समय कम है? "सेटअप और चालू करना" पर जाएँ। कमांड स्वतंत्र रूप से काम करते हैं।
लेकिन सिद्धांत लाभदायी है। यह जानना कि स्किल्स कैसे स्व-विकसित होती हैं, मेमोरी कैसे बनती है, और GEPA कब काम आता है, Hermes को एक चैटबॉट के रूप में उपयोग करने और इस्तेमाल करने और इसे ऐसी चीज़ के रूप में उपयोग करने के बीच का अंतर है जो संयोजित होती है।
आगे क्या है:
- Hermes Agent वास्तव में क्या है। परिचय, साथ ही OpenClaw से तुलना।
- यह कैसे बना है। एक आरेख में आर्किटेक्चर।
- मेमोरी से पहले: एजेंट कौन है? SOUL.md, पहचान परत।
- मेमोरी सिस्टम। तीन स्तर, तीन गतियाँ।
- स्व-विकसित स्किल्स। एजेंट द्वारा लिखित प्लेबुक्स और क्यूरेटर।
- GEPA। ऑफ़लाइन स्किल ऑप्टिमाइज़ेशन।
- सेटअप और चालू करना। इंस्टॉल, Telegram, पहला एजेंट।
- कई एजेंट चलाना। प्रोफ़ाइलें, तीन व्यक्तिताएँ, शेड्यूल डाइजेस्ट।
- अपनी आवश्यकताओं के अनुसार एजेंटों को कस्टमाइज़ करना।
Hermes क्या है, और इसे आर्किटेक्चरली क्या अलग बनाता है
एक पंक्ति में: एक एजेंट जो जितना अधिक आप उपयोग करते हैं, उतना बेहतर होता जाता है।
इसे वास्तविक बनाता है कि तीन आमतौर पर अलग-अलग क्षमताएँ एक फ्रेमवर्क में हैं: रनटाइम स्किल लर्निंग, स्थायी बहु-परत मेमोरी, और एक वैकल्पिक वेट-ट्रेनिंग पाइपलाइन। कोई अन्य ओपन-सोर्स एजेंट तीनों नहीं भेजता।
ओपन इकोसिस्टम में सब सबसे करीबी तुलना OpenClaw है। दोनों स्थायी, मैसेजिंग-अनुकूल हैं, लेकिन वे विपरीत आर्किटेक्चरल विकल्प चुनते हैं।
Kilo ब्लॉग से एक साफ फ्रेमिंग इसे पकड़ती है: "Hermes एक लर्निंग एजेंट के चारों ओर एक गेटवे पैकेज करता है। OpenClaw एक मैसेजिंग गेटवे के चारों चारों ओर एक एजेंट पैकेज करता है।"
<payloadblk_2" type="upload" />
यह कैसे बना है
लर्निंग लूप के समझ में आने से पहले, आपको एक बुनियादी चित्र चाहिए कि Hermes कैसे संरचित है।
सब कुछ run_agent.py स्क्रिप्ट में एक AIAgent क्लास के माध्यम से बहता है। CLI, मैसेजिंग गेटवे, बैच रनर, IDE इंटीग्रेशन: वे सभी एक ही कोर एजेंट में प्रवेशन बिंदु हैं।
यही वह चीज़ है जो प्लेटफ़ॉर्म-अज्ञेय कहानी को वास्तव में काम कराती है।
<payloadblk_3" type="upload" />
कोर लूप ReAct-शैली और सिंक्रोत है। सिंक्रोनस है। सिस्टम प्रॉम्प्ट बनाएँ, जाँचें कि कंप्रेशन की आवश्यकता है या नहीं, एक बाधित API कॉल करें, किसी भी टूल कॉल को निष्पादित करें, फिर से लूप करें।
कुछ विवरण जो बाद में मायने रखते हैं:
- एजेंट छह अलग-अलग स्थानों पर कमांड चला सकता है। लोकल टर्मिनल, Docker, SSH, Modal, Daytona, या Singularity। एक ही कोड, बस एक कॉन्फ़िगरेशन बदलाव। अपने लैपटॉप से क्लाउड GPU सर्वर पर निष्पादन को स्थानांतरित करें बिना कुछ और कुछ छुए।
- यह लगभग किसी भी मॉडल के साथ काम करता है। एक अनुवाद परत किसी भी प्रदाता को तीन API फ़ॉर्मेट में से एक के माध्यम से रूट करती है। यही कारण है कि आप एक कमांड से आप Claude से GPT से Gemini से लोकल Ollama पर स्विच कर सकते हैं और कुछ नहीं टूटता।
- एजेंट की प्रति कार्य 90 टर्न की हार्ड सीम सीमा है। इसके बिना, एक एजेंट जो लूप में फंस गया है (एक विफल API को पुन: प्रयास करना, एक ही फ़ाइल को फिर से पढ़ना) चुपचुपचाप आपके क्रेडिट जला देगा। उप-एजेंट एक ही बजट साझा करते हैं, इसलिए एक भगोड़ी प्रतिनिधि श्रृंखला भी चुपके से नहीं निकल सकती।
यह पर्याप्त मचान है। अब दिलचस्प हिस्सा।
मेमोरी से पहले: एजेंट कौन है?
मेमोरी और स्व-विकसित स्किल्स पर जाने से पहले, एक परत है जो दोनों के ऊपर बैठती है: पहच्छा।
मेमोरी वहै जो एजेंट जानता है। स्किल्स वह हैं जो वह करता है। लेकिन कोई भी आपको नहीं बताता कि जब वह आता है तो वह कौन है। पहचान परत के बिना, हर एजेंट एक ही एजेंट की तरह लगता है जो अलग-अलग टोपी पहनता है।
Hermes इसे एक फ़ाइल से हल करता है: SOUL.md।
यह ~/.hermes/SOUL.md पर रहता है और सिस्टम प्रॉम्प्ट में स्लॉट #1 स्लॉट पर कब्जा करता है, कुछ और लोड होने से पहले। यह एजेंट के व्यक्तित्व, लहजे, संचार शैली और कठोर सीमाओं को परिभाषित करता है।
SOUL.md हाड-लेखित और स्थिर है। आप इसे एक बार लिखते हैं, समय के दौरान ट्वीक करते हैं, और यह हर प्रोजेक्ट और हर सेशन में सुसंगत रहता है। यदि फ़ाइल गायब है, तो Hermes एक अंतर्निहित डिफ़ॉल्ट पहचान पर वापस आ जाता है।
यह स्व-सुधार कहानी के लिए क्यों मायने रखता है? क्योंकि जो कुछ भी आता है (एजेंट द्वारा लिखी गई मेमोरी, वह स्किल्स जो वह बनाता है, ज्ञान को समेकित करने का तरीका) इस पहचान के लेंस के माध्यमें होता है।
SOUL.md निश्चित फ्रेम है। मेम है। मेमोरी और स्किल्स उसके अंदर चलने वाले हिस्से हैं।
मेमोरी सिस्टम: तीन स्तर, तीन गतियाँ
Hermes के पास एक "मेमोरी" नहीं है। इसकी तीन परतें हैं, प्रत्येक एक अलग उद्देश्य के लिए डिज़ाइन की गई है।
<payloadblk_4" type="upload" />
स्तर 1: दो छोटी Markdown फ़ाइलें।
कोर में डिस्क पर संग्रहीत दो फ़ाइलें हैं:
- MEMORY.md (2,200 वर्ण अधिकतम) में एजेंट के आपके वातावरण, प्रोजेक्ट कन्वेंशन, टूल क्वर्क और सीखे गए पाठों के बारे में नोट्स हैं।
- USER.md (1,375 वर्ण अधिकतम) में आपकतम) में आपकी प्रोफ़ाइल है: नाम, संचार प्राथमिकताएँ, कौशल स्तर, और बचने वाली चीज़ें।
दोनों को एक सेशन शुरू होने पर एक जमे हुए स्नैपशॉट के रूप में सिस्टम प्रॉम्प्ट में इंजे डाला जाता है। यदि एजेंट सेशन के बीच में एक नई मेमोरी एंट्री लिखता है, तो वह परिवर्तन तुरंत डिस्क पर बना रहता है लेकिन अगले सेशन तक सिस्टम प्रॉम्प्ट में दिखाई नहीं देगा।
जब मेमोरी भर जाती है (~80% क्षमता, सिस्टम प्रॉम्प्ट हेडर में प्रतिशत के रूप में दिखाया गया है), तो एजेंट को समेकित करना होता है।
यह संबंधित प्रविष्टियों को सघन, अधिक जानकारी से भरपूर संस्करणों में विलय करता है, ताकि केवल उपयोगी जानकारी ही बचे।
स्तर 2: पूर्ण-पाठ सत्र खोज।
हर बातचीत (CLI और मैसेजिंग) को पूर्ण-पाठ खोज के साथ SQLite में संग्रहीत किया जाता है। एजेंट पिछले हफ्तों की बातचीत को यहाँ से खोज सकता है।
ट्रेडऑफ़ स्पष्ट है: स्तर 1 हमेशा कॉन्टेक्स्ट में है लेकिन छोटा है। स्तर 2 की असीमित क्षमता है लेकिन इसके लिए एक सक्रिय खोज प्लस LLM सारांश की आवश्यकता है।
महत्वपूर्ण तथ्य मेमोरी में रहते हैं। बाकी सब कुछ मांग पर खोजा जा सकता है।
स्तर 3: बाहरी मेमोरी प्रदाता (8 प्लगइन्स)।
गहरी स्थायी मेमोरी के लिए, Hermes 8 प्लग करने योग्य प्रदाताओं के साथ आता है जो अंतर्निहित मेमोरी के साथ चलते हैं (इसे कभी प्रतिस्थापित नहीं करते)। एक बार में केवल एक सक्रिय हो सकता है।
जब कोई बाहरी प्रदाता सक्रिय होता है, तो Hermes स्वचालित रूप से प्रत्येक टर्न से पहलेखित प्रासंगिक यादों को प्रीफ़ेच करता है, प्रत्येक प्रतिक्रिया के बाद बातचीत के टर्न को सिंक करता है, और सत्र समाप्त होने पर यादें यादें निकालता है।
<payloadblk_5" type="upload" />
स्व-विकसित स्किल्स: एजेंट अपनी खुद की प्लेबुक्स लिखता है
मेमोरी तथ्यों को संभालती है। स्किल्स प्रक्रियाओं को संभालती हैं।
स्किल्स YAML फ्रंटमैटर के साथ Markdown फ़ें हैं, और एजेंट की प्रक्रियात्मक मेमेमोरी के रूप में कार्य करती हैं: वह न कि वह क्या जानता है, बल्कि वह चीज़ें कैसे करता है।
यहाँ एक स्किल की शारीरिक रचना है:
टोकन लागत कम रखने के लिए, स्किल्स प्रगतिशील प्रकटीकरण का उपयोग करती हैं:
<payloadblk_6" type="upload" />
- स्तर 0: एजेंट केवल नाम + विवरण देखता है (~3k टोकन पूरी सूची के लिए)
- स्तर 1: जब उसे वास्तव में एक की आवश्यकता होती है तो यह पूरी स्किल सामग्री लोड करता है
- स्तर 2: यह एक स्किल के भीतर विशिष्ट संदर्भ फ़ाइलों में जा सकता है
स्व-सुधार लूप।
यह मुख्य अंतर है। एजेंट skill_manage टूल का उपयोग करके स्वायत्त रूप से अपनी खुद की स्किल्स बनाता है। स्किल निर्माण तब होता है जब:
- एजेंट एक जटिल कार्य पूरा करता है (5+ टूल कॉल)
- यह त्रुटियों या गतिरोधों से टकराता है और काम करने का रास्ता ढूंढता है
- उपयोगकर्ता इसके दृष्टिकोण को सुधारता है
- यह एक गैर-तुच्छ वर्कफ़्लो की खोज करता है
तो लूप इस तरह काम करता है: एजेंट एक समस्या का सामना करता है → परीक्षण और त्रुटि के माध्यम से हल करता है → सफल दृष्टिकोण को SKILL.md फ़ाइल के रूप में सहेजता है → अगली बार जब यह एक समान समस्या का सामना करता है, तो यह स्किल लोड करता है और सिद्ध प्रक्रिया का पालन करता है शुरू से दृष्टिकोण को फिर से खोजने के बजाय।
टूल छह क्रियाओं का समर्थन करता है: create, patch (लक्षित सुधार, पसंदीदा क्योंकि यह टोकन-कुशल है), edit (पूर्ण पुनर्लेखन), delete, write_file, write_file, और remove_file।
<payloadblk_7" type="upload" />
क्यूरेटर: स्किल्स के लिए कचरा संग्रह।
रखरखाव के बिना, एजेंट-निर्मित स्किल्स जमा जमा हो जाती हैं। आप दर्जनों संकीर्ण, ओवरलैपिंग प्लेबुक्स के साथ समाप्त होते हैं जो टोकन बर्बाद करती हैं और सूची को प्रदूषित करती हैं।
क्यूरेटर एक पृष्ठभूमि रखरखाव प्रणाली है जो इसे संभालती है। यह एक निष्क्रियता जाँच पर चलता है (क्रॉन डेमॉन नहीं): यदि पिछले रन के बाद से 7 दिन बीत चुके हैं और एजेंट 2+ घंटे से निष्क्रिय है, तो एजेंट का एक पृष्ठभूमि कांटी अपने स्वयं के प्रॉम्प्ट कैश के साथ शुरू होती है, सक्रिय बातचीत को कभी नहीं छूती।
यह दो चरणों में काम करता है:
- स्वचालित संक्रमण (निर्धारित, कोई LLM नहीं): 30 दिनों तक उपयोग न की गई स्किल्स बासी हो जाती जाती हैं। 90 दिनों तक उपयोग न की गई स्किल्स संग्रहीत हो जाती हैं।
- LLM समीक्षा (8 पुनरावधियों तक): एक फोर्क किया गया एजेंट सभी एजेंट-निर्मित स्किल्स का सर्वेक्षण करता है और प्रति-स्किल तय करता है कि रखना, पैच करना, समेकित करना या संग्रहीत करना है।
दो महत्वपूर्ण बाधाएँ:
- क्यूरेटर कभी भी बंडल या हब-इंस्टॉल की गई स्किल्स को नहीं छूता। केवल एजेंट-लेखित।
- यह कभी स्वचालित रूप से हटाता नहीं है। सबसे बुरा परिणाम संग्रह है ~/.hermes/skills/.archive/ में, जो एक कमांड से पुनर्प्राप्त किया जा सकता है।
प्रत्येक क्यूरेटर पास से पहले, Hermes पूरी पूरी स्किल्स निर्देशिका का tar.gz स्नैपशॉट लेता है। रोलबैक एक कमांड है, और रोलबैक स्वयं प्रतिवर्ती हैं।
आप hermes curator pin <skill> के साथ महत्वपूर्ण स्किल्स को पिन भी कर सकते हैं ताकि उन्हें संग्रह और विलोप से बचाया जा सके। पैच और संपादन अभी भी होते हैं, इसलिए एजेंट एक पिन की गई स्किल में सुधार कर सकता है बिना आपको इसे अनपिन करने की आवश्यकता के।
<payloadblk_8" type="upload" />
GEPA: निष्पादन ट्रेस के साथ ऑफ़लाइन स्किल्स विकसित करना
यहाँ यह दिलचस्प हो जाता है।
एजेंट के अंदर लर्निंग लूप (स्किल निर्माण + क्यूरेटर) की एक ज्ञात कमजोरी है:
- एजेंट आत्म-प्रशंसा की ओर प्रवृत्त होता है। यह लगभग हमेशा सोचता है कि इसने अच्छा प्रदर्शन किया, भले ही उसने नहीं किया। सामुदायिक प्रतिक्रिया ने इसकी पुष्टि की है।
- वही सिस्टम जो स्वचालित रूप से स्किल्स उत्पन्न करता है, मैन्युअल कस्टमाइज़ेशन को बदतर संस्करणों के साथ ओवरराइट भी कर सकता है।
यहाँ GEPA आता है।
GEPA (Genetic-Pareto Prompt Evolution) Hermes रनटाइम में निर्मित नहीं है। यह एक साथी रिपॉजिटरी (NousResearch/hermes-agent-self-evolution) में रहता है और एक ऑफ़लाइन ऑप्टिमाइज़ेशन पाइपलाइन के रूप में काम करता है। ICLR 2026 Oral पेपर के रूप में प्रकाशित, MIT लाइसेंस।
मुख्य विचार: एजेंट से पूछने के बजाय "क्या आपने अच्छा किया?", GEPA निष्पादन ट्रेस पढ़ता है यह समझने के लिए चीज़ें क्यों विफल हुईं, फिर विकासवादी खोज के माध्यम से लक्षित सुधार प्रस्तावित करता है।
पाइपलाइन:
- Hermes रिपॉजी से वर्तमान स्किल पढ़ें
- एक मूल्यांकन डेटासेट उत्पन्न करें (Claude Opus के माध्यम से सिंथेटिक टेस्ट केस, SQLite से वास्तविक सत्र इतिहास, या हाथ से क्यूरेट किए गए गोल्डन सेट)
- GEPA ऑप्टिमाइज़र चलाएं: निष्पादन ट्रेस पढ़ें → विफलता बिंदुओं को समझें → उम्मीदवार वेरिएंट उत्पन्न करें
- रूब्रिक के साथ LLM-ए-जज स्कोरिंग का उपयोग करके उम्मीदवारों का मूल्यांकन करें (बाइनरी पास/फेल नहीं)
- बाधा गेट गेट लागू करें: पूर्ण टेस्ट सूट 100% पास होना चाहिए, स्किल्स 15KB से कम रहें, कैशिंग संगतता संरक्षित हो, अर्थपर उद्देश्य न बदले
- सबसे अच्छा वेरिएंट Hermes रिपॉजिटरी के खिलाफ PR के रूप में जाता है। कभी सीधा कमिट नहीं।
कोई GPU आवश्यक नहीं। सब कुछ API कॉल के माध्यम से चलता है। लागत: लगभग $2-10 प्रति ऑप्टिमाइज़ेशन रन।
यह कुछ ऐसा है जिसे शुरू शुरू में छोड़ा जा सकता है, लेकिन जब आप एक दीवार से टकराते हैं और फाइनट्यूनिंग (RL/GRPO) पर समय और पैसा खर्च नहीं करना चाहते हैं तो यह अत्यधिक प्रभावी है।
<payloadblk_9" type="upload" />
मैंने हाल ही में GEPA पर एक लेख लिखा है।
पूर्ण फाइन-ट्यूनिंग या RL-आधारित फाइन-ट्यूनिंग पर जाने से पहले यह एक बढ़िया विकल्प है।
<payloadblk_10" type="upload" />
ठीक है, संक्षेप में:
SOUL.md पहचान सेट करता है। रनटाइम लूप अनुभ
.
