Hermes Kanban: आपके AI एजेंट्स के लिए मिशन कंट्रोल

हर्मीस कानबान का संपूर्ण गाइड: समन्वय मॉडल, एजेंटों के बीच संदर्भ साझाकरण, और लगभग 20 मिनट में 4-एजेंट सॉफ्टवेयर टीम (PM, बैकएंड, फ्रंटएंड, टेस्टर) बनाना

AI एजेंटों को एक टीम की तरह काम करना चाहिए था।

आप लक्ष्य बताते हैं। वे काम बांटते हैं। हर एक वहां से शुरू करता है जहां पिछले ने छोड़ा।

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

हर्मीस कानबान यह ठीक करता है। हर टास्क क्रैश और रीबूट से बच जाता है। हर ब्रीफिंग में ठीक वही होता है जो अगले एजेंट को चाहिए। हर असफलता सेव हो जाती है, ताकि रीट्राई को पता हो कि क्या टूटा था।

आपका मिशन कंट्रोल कुछ इस तरह दिखता है:

कानबान डैशबोर्ड

सबसे अच्छी बात यह है कि पूरी टीम आपके फोन से चलती है। आप टेलीग्राम पर टास्क बनाते और निर्देशित करते हैं, और एजेंट उन्हें उठा लेते हैं जब आप डेस्क से दूर होते हैं।

यह देखें:

इस लेख में हम यह पूरा सेटअप स्क्रैच से बनाएंगे: समन्वय मॉडल, ब्रीफिंग्स, और आपके अपने हार्डवेयर पर चलने वाली 4 सदस्यीय सॉफ्टवेयर टीम — लगभग 20 मिनट में।

इसे प्रदर्शित करने के लिए मैंने एक कार्यशील Google Docs क्लोन बनाया है, जिसमें AI सुविधाएं शामिल हैं, प्रोडक्शन-रेडी बैकएंड है, और इसे इसी एजेंट टीम ने बनाया है।

Google Docs क्लोन डेमो

तो, बिना किसी देरी के, चलिए शुरू करते हैं।

एक एजेंट क्यों काफी नहीं है

मान लीजिए, आप पासवर्ड रीसेट फीचर जोड़ना चाहते हैं। काम तीन डोमेन में बंट जाता है:

• एक बैकएंड डेवलपर जो REST API बनाता है
• एक फ्रंटएंड डेवलपर जो उस API को पढ़ता है और उसके ऊपर UI बनाता है
• एक टेस्टर जो पूरी चीज़ को एंड-टू-एंड वेरिफाई करता है

1 बनाम 3 एजेंट

आप तीनों को एक ही एजेंट से चला सकते हैं, लेकिन कॉन्टेक्स्ट विंडो भर जाती है और एजेंट को याद नहीं रहता कि उसने तीन कदम पहले क्या किया। आप उसे मैनेज करने में जितना समय बचाते हैं, उससे ज़्यादा खर्च कर देते हैं।

काम को अलग-अलग एजेंटों में बांटना जिनमें से हर एक का अपना डोमेन है, एक नई समस्या पैदा करता है: फ्रंटएंड डेवलपर को कैसे पता चलेगा कि बैकएंड डेवलपर ने क्या बनाया? यह साझा-संदर्भ समस्या है जिसे हर्मीस कानबान हल करता है।

मानसिक मॉडल: एक टास्क बोर्ड, लेकिन कॉलम के पीछे एजेंट बैठते हैं

एक टास्क में एक शीर्षक, एक विवरण, एक मालिक और एक स्थिति होती है। कोई इसे उठाता है, बोर्ड पर आगे बढ़ाता है, और बंद करता है। बोर्ड एकमात्र स्रोत है — सिंगल सोर्स ऑफ ट्रूथ।

हर्मीस कानबान उस मॉडल को रखता है और हर कॉलम के पीछे इंसानों की जगह एजेंट रखता है।

हर्मीस कानबान बोर्ड

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

वह सारांश ही पूरी अंतर्दृष्टि है। यही एक समूह एजेंटों को अजनबियों के बजाय एक टीम में बदलता है।

शब्दावली

कानबान बोर्ड पर हमारे 6 अलग-अलग कॉलम हैं:

• Triage: मोटे विचार यहां आते हैं, "मुझे auth रेट लिमिटिंग चाहिए" जैसी बातों के लिए पूर्ण स्पेक से पहले।
• Todo: टास्क बन गया लेकिन किसी डिपेंडेंसी का इंतजार है। यह तब तक नहीं हिलेगा जब तक इसका पैरेंट खत्म न हो।
• Ready: डिपेंडेंसी पूरी हो गई, एजेंट के उठाने का इंतजार है।
• In Progress: एजेंट सक्रिय रूप से चल रहा है।
• Blocked: एजेंट एक दीवार पर पहुंच गया और मानव के लिए फ्लैग किया। जब तक आप इसे अनब्लॉक न करें, कुछ नहीं चलेगा।
• Done: समाप्त, पूर्ण रन हिस्ट्री, सारांश और मेटाडेटा संरक्षित।

ऑर्केस्ट्रेटर: एक एजेंट जो बाकियों को मैनेज करता है

ऑर्केस्ट्रेटर एजेंट को प्रोजेक्ट मैनेजर की तरह समझें जो एक उच्च-स्तरीय लक्ष्य पढ़ता है, जांचता है कि कौन से एजेंट मौजूद हैं, लक्ष्य को जुड़े हुए टास्क में तोड़ता है, और पीछे हट जाता है। यह कभी कोड नहीं लिखता या टेस्ट नहीं चलाता। यह समन्वय करता है।

ऑर्केस्ट्रेटर एजेंट

एक नियम जो मायने रखता है: टास्क बनाने से पहले जांचें कि कौन से प्रोफाइल मौजूद हैं। सिस्टम किसी भी ऐसे टास्क को चुपचाप छोड़ देता है जिसका असाइनी किसी वास्तविक प्रोफाइल से मेल नहीं खाता, इसलिए स्टेप जीरो हमेशा kanban_list होता है।

यहां एक सामान्य प्रोजेक्ट मैनेजर टर्न है, जो "पासवर्ड रीसेट फ्लो बनाएं" अनुरोध को एक जुड़ी हुई पाइपलाइन में तोड़ता है:

1kanban_show()
2
3be = kanban_create(title="Password reset backend", assignee="backend-developer",
4    body="Forgot/reset password flow + session invalidation")
5
6fe = kanban_create(title="Password reset UI", assignee="frontend-developer",
7    parents=[be], body="Next.js reset flow using backend API")
8
9qa = kanban_create(title="E2E password reset test", assignee="tester",
10    parents=[fe], body="Validate all acceptance criteria")
11
12kanban_complete(summary="Created backend → frontend → QA dependency pipeline")

इसके बाद, बोर्ड प्रमोशन संभालता है और ब्रीफिंग्स संदर्भ संभालती हैं। जब तीनों खत्म हो जाते हैं, प्रोजेक्ट मैनेजर जागता है, सारांश पढ़ता है, और तय करता है कि काम पूरा हुआ या नहीं। यदि टेस्टर "verdict": "FAIL" लौटाता है, तो यह फिक्स टास्क बनाता है और लूप जारी रहता है।

लेकिन असल में, आपको किसी चीज़ की चिंता करने की ज़रूरत नहीं है। आपको बस टेलीग्राम से एक टास्क डेलिगेट करना है और ऑर्केस्ट्रेटर वहां से संभाल लेता है।

तीन पैटर्न जो आप लगातार इस्तेमाल करेंगे

1. पाइपलाइन: हर टास्क पिछले पर निर्भर करता है। केवल पहला रेडी में शुरू होता है। बाकी सब अपनी बारी का इंतजार करते हैं।

1BACKEND=$(hermes kanban create "Implement auth API" \
2    --assignee backend-developer \
3    --body "POST /register, POST /login, POST /refresh, POST /logout." \
4    --json | jq -r .id)
5
6FRONTEND=$(hermes kanban create "Build auth UI" \
7    --assignee frontend-developer \
8    --parent $BACKEND \
9    --body "Read backend handoff for API shape. Login, register, profile pages." \
10    --json | jq -r .id)
11
12hermes kanban create "Test auth flow end to end" \
13    --assignee tester \
14    --parent $FRONTEND \
15    --body "Cover happy path, wrong password, expired token, session persistence."

आप यह हाथ से नहीं चलाते। आप प्रोजेक्ट को टेलीग्राम पर प्रोजेक्ट मैनेजर को बताते हैं और वह आपके लिए ये टास्क बना देता है। अंदरूनी तौर पर यह ऊपर जैसा दिखता है।

जब बैकएंड एजेंट kanban_complete() कॉल करता है, फ्रंटएंड टास्क बैकएंड के काम के साथ रेडी पर चला जाता है।

2. मानव-इन-द-लूप: हर ब्लॉकर असफलता नहीं होती। कभी-कभी एजेंट कोई वास्तविक समस्या ढूंढ लेता है और पूछने के लिए रुक जाता है।

1kanban_block(reason="review-required: password strength check missing, "
2           "reset tokens aren't single-use (can be replayed within 30 min)")

आप डैशबोर्ड पर ब्लॉक देखते हैं। आप समस्या की जांच करते हैं, उसे ठीक करते हैं, और टास्क को अनब्लॉक करते हैं:

1hermes kanban unblock $IMPL

आप यह टर्मिनल में भी नहीं चलाते, बस कानबान बोर्ड पर कमेंट करते हैं या टेलीग्राम पर मैसेज करते हैं, और सिस्टम इसे अनब्लॉक कर देता है।

सिस्टम अगले साइकल पर एजेंट को पुनः शुरू करता है। दूसरा रन kanban_show() कॉल करता है और देखता है कि पहला प्रयास क्यों ब्लॉक हुआ था। उसे ठीक-ठीक पता होता है कि क्या ठीक करना है; वह स्क्रैच से शुरू नहीं कर रहा।

3. ट्राइएज स्पेसिफायर।

जब आपके पास पूर्ण स्पेक के बजाय एक मोटा विचार हो, तो इसे बोर्ड पर डालें और किसी भी एजेंट के उठाने से पहले सिस्टम को इसे विस्तृत करने दें।

1# Drop a rough idea
2hermes kanban create "auth needs rate limiting" --triage --assignee backend-developer
3
4# Flesh it out before the dispatcher picks it up
5hermes kanban specify $TASK_ID

specify कमांड तीन-शब्दों वाले शीर्षक को एक पूर्ण टास्क में बदल देता है जिसमें एक लक्ष्य, एक दृष्टिकोण और स्वीकृति मानदंड होते हैं। जो एजेंट इसे उठाता है, उसे एक वास्तविक ब्रीफ मिलता है।

सेटअप: लगभग 20 मिनट में चार प्रोफाइल

चार एजेंट, एक साझा बोर्ड, प्रोजेक्ट मैनेजर टेलीग्राम पर पहुंच योग्य।

चरण 1: प्रोफाइल बनाएं।

1hermes profile create project-manager --clone
2hermes profile create backend-developer --clone
3hermes profile create frontend-developer --clone
4hermes profile create tester --clone

--clone आपके डिफ़ॉल्ट प्रोफाइल के कॉन्फ़िग को शुरुआती बिंदु के रूप में कॉपी करता है।

चरण 2: हर एजेंट को एक व्यक्तित्व दें

1. प्रोजेक्ट मैनेजर ~/.hermes/profiles/project-manager/SOUL.md पर:

1# Soul
2
3You are the project manager for a software development team. Your job
4is to take a user’s app idea, break it into clear tasks, assign them
5to the right team members, and track progress on the Kanban board.
6You do not write code yourself. You manage the work.

2. बैकएंड डेवलपर ~/.hermes/profiles/backend-developer/SOUL.md पर:

1# Soul
2
3You are the backend developer on a software team. You build and manage
4the entire backend using InsForge — database, auth, storage, edge
5functions, and deployment.

3. फ्रंटएंड डेवलपर ~/.hermes/profiles/frontend-developer/SOUL.md पर:

1# Soul
2
3You are the frontend developer on a software team. You build the UI —
4components, pages, and user flows — and connect them to the backend
5using the APIs and SDK methods the backend-developer has set up.

4. टेस्टर ~/.hermes/profiles/tester/SOUL.md पर:

1# Soul
2
3You are the tester on a software team. You test completed features
4end-to-end, verify acceptance criteria are met, and report bugs
5clearly back to the Kanban board so they can be fixed.

चरण 3: एजेंट स्किल्स जोड़ें

स्किल्स चरण-दर-चरण गाइड हैं, विशिष्ट निर्देश कि किसी प्रकार का काम कैसे करना है। इन्हें अपने एजेंटों के लिए जॉब ट्रेनिंग समझें। आइए इन्हें एक-एक करके सूचीबद्ध करें:

InsForge

InsForge (ओपन-सोर्स, Apache 2.0) एजेंटों के लिए स्किल्स और CLI का उपयोग करके बैकएंड कॉन्टेक्स्ट इंजीनियरिंग लेयर के रूप में कार्य करता है। हमारा बैकएंड डेवलपर एजेंट प्रोफाइल प्रोजेक्ट्स के लिए रेडी-टू-यूज़ बैकएंड सेवा पाने के लिए इस स्किल का उपयोग करता है।

पहले, InsForge स्किल्स टैप जोड़ें:

1hermes skills tap add InsForge/insforge-skills

फिर बैकएंड स्किल्स इंस्टॉल करें:

1hermes -p backend-developer skills install InsForge/insforge-skills/insforge --force

उसी तरह हम अन्य को insforge-cli (इन्फ्रास्ट्रक्चर कमांड), insforge-debug (विफलता निदान), और insforge-integrations (थर्ड-पार्टी auth प्रदाता) के रूप में इंस्टॉल करते हैं।

यहां बताया गया है कि कैसे बैकएंड डेवलपर एजेंट InsForge पर हमारा प्रोजेक्ट बैकएंड बनाने के लिए स्किल का उपयोग करता है।

पहले बैकएंड डेवलपर एजेंट InsForge में "Google Docs Clone" नामक एक प्रोजेक्ट बनाता है।

डैशबोर्ड प्रोजेक्ट आंकड़े दिखाता है जैसे उपयोगकर्ताओं की संख्या, डेटाबेस में टेबल, स्टोरेज, और auth, दस्तावेज़ हैंडलिंग आदि से संबंधित तैनात जावास्क्रिप्ट/टाइपस्क्रिप्ट कोड के साथ एज फंक्शन की सूची।

तो यदि आप एक AI बैकएंड इंजीनियर बना रहे हैं, तो InsForge ज़रूर देखें →

(स्टार 🌟 करना न भूलें)

स्किल्स हब से और स्किल्स

हर्मीस एक स्किल्स हब भी बनाए रखता है जिसमें 18 श्रेणियों में 687 स्किल्स हैं: 87 बिल्ट-इन, 79 वैकल्पिक, 16 एंथ्रोपिक से (फ्रंटएंड-डिज़ाइन, पीडीएफ, पीपीटीएक्स, डॉक्स, एमसीपी-बिल्डर, और अधिक), और 505 लोबहब से।

फ्रंटएंड डेवलपर के लिए, frontend-design इंस्टॉल करें। टेस्टर के लिए, webapp-testing इंस्टॉल करें। दोनों हब में शिप होते हैं।

चरण 4: बोर्ड इनिशियलाइज़ करें और गेटवे शुरू करें।

hermes kanban init ~/.hermes/kanban.db बनाता है, SQLite डेटाबेस जो हर टास्क, संदर्भ और रन हिस्ट्री रखता है।

फिर प्रोजेक्ट मैनेजर प्रोफाइल के तहत चैट गेटवे सेट करें। टेलीग्राम पर @BotFather से एक बॉट टोकन लें और @userinfobot से अपना उपयोगकर्ता आईडी, फिर:

1hermes kanban init
2hermes -p project-manager gateway setup
3hermes -p project-manager gateway start

कनेक्शन 24/7 चलता है, सिस्टम को जीवित रखता है, और प्रोजेक्ट मैनेजर को टेलीग्राम पर पहुंच योग्य बनाता है।

चरण 5: अपना पहला प्रोजेक्ट भेजें।

प्रोजेक्ट मैनेजर को संदेश भेजें कि आप क्या बनवाना चाहते हैं। यह लक्ष्य को टास्क में तोड़ता है, उन्हें डिपेंडेंसी लिंक के साथ बनाता है, और सिस्टम उन्हें क्रम में चलाता है।

डैशबोर्ड

hermes dashboard चलाएं और http://127.0.0.1:9119 खोलें। आपको प्रति स्थिति एक कॉलम मिलता है और वेबसॉकेट पर लाइव अपडेट बिना रिफ्रेश की आवश्यकता के।

0:20

हर्मीस कानबान डैशबोर्ड

दो नियंत्रण जानने लायक हैं। Lanes by profile रनिंग कॉलम को असाइनी के अनुसार उप-समूहित करता है, ताकि आप एक नज़र में देख सकें कि कौन सा एजेंट किसका मालिक है। Nudge dispatcher 60 सेकंड इंतजार करने के बजाय तुरंत एक पास चलाता है, जो टास्क को अनब्लॉक करने के तुरंत बाद मदद करता है।

किसी भी कार्ड पर क्लिक करके उसकी ड्रॉअर खोलें पूर्ण रन हिस्ट्री, हर प्रयास के परिणाम और मेटाडेटा, और शीर्षक, असाइनी, प्राथमिकता और डिपेंडेंसी के लिए संपादन योग्य फील्ड देखने के लिए।

किन बातों का ध्यान रखें

गंभीर वर्कलोड से पहले जानने योग्य तीन विफलता मोड।

1. डेटाबेस ओवरलोड। 2 से 4 एजेंटों के समानांतर आप कभी इससे नहीं टकराएंगे। 10+ एजेंटों के उच्च आवृत्ति पर लिखने पर, चीजें धीमी हो जाती हैं। इसे hermes kanban dispatch --max 4 से सीमित करें।

2. स्क्रैच वर्कस्पेस डिलीट। स्क्रैच वर्कस्पेस में सेव की गई फाइलें टास्क के डन मार्क होते ही गायब हो जाती हैं, क्योंकि स्क्रैच डिज़ाइन से मिटा दिया जाता है। कोडिंग टास्क के लिए वर्कट्री का उपयोग करें, या प्रोजेक्ट फोल्डर पथ को टास्क विवरण में डालें ताकि एजेंट को पता चले कि कहाँ सेव करना है।

3. लोकल मॉडल सैचुरेशन। लोकल मॉडल (Ollama, लोकल GPU) के खिलाफ, सिस्टम एक साथ कई एजेंट लॉन्च कर सकता है और GPU को ओवरव्हेल्म कर सकता है, जो जनरेशन को धीमा करता है और ऑटो-स्टॉप को ट्रिगर करता है। लोकल सेटअप के लिए, hermes kanban dispatch --max 2। API-समर्थित मॉडल जैसे Claude या GPT-4o के लिए, यह शायद ही कभी समस्या होती है।

पूरी तस्वीर

हर टुकड़े का एक काम है:

• SOUL.md एजेंट की निश्चित पहचान है: वह कौन है और वह कैसे सोचता है।
• Skills विशिष्ट प्रकार के काम के लिए चरण-दर-चरण निर्देश हैं।
• Memory वह है जो एजेंट आपके वातावरण के बारे में सेशनों के बीच जानता है।
• Kanban समन्वय परत है: साझा स्थिति, संदर्भ स्थानांतरण, और किसी भी बिंदु पर मानव-इन-द-लूप।

चार प्रोफाइल, चार SOUL.md फाइलें, एक गेटवे स्टार्ट। प्रोजेक्ट मैनेजर को टेलीग्राम पर बताएं कि आप क्या बनवाना चाहते हैं और बोर्ड को भरते हुए देखें।

यदि आप वीडियो से बेहतर सीखते हैं, तो हर्मीस कानबान का पूर्ण वॉकथ्रू कुछ दिनों में YouTube और X पर आ रहा है।

पढ़ने के लिए धन्यवाद।