आपके AI एजेंट्स आपस में बात नहीं कर सकते। यहाँ दो लाइन का समाधान है।

अगर आप एक से ज़्यादा कोडिंग एजेंट चलाते हैं, तो आपको परेशानी वाला हिस्सा पहले से पता है।

आप एक रिपॉजिटरी में Claude Code के साथ गहरे काम में लगे हैं। आप चाहते हैं कि एक दूसरा एजेंट भी काम में शामिल हो जाए। हो सकता है वह दूसरी विंडो में Codex हो। हो सकता है वह उसी प्रोजेक्ट पर आपके टीममेट का Claude हो। तो आप असल में क्या करते हैं? आप पूरी बातचीत को सेलेक्ट करते हैं, उसे कॉपी करते हैं, दूसरे एजेंट में पेस्ट करते हैं, और उम्मीद करते हैं कि रास्ते में कुछ ज़रूरी न खोया हो।

यही वर्कफ़्लो है। कॉपी करो, पेस्ट करो, दुआ करो। हर बार जब आप काम सौंपते हैं, थोड़ा संदर्भ खो जाता है। हर कनेक्शन कोड जिसे आप टर्मिनलों के बीच ले जाते हैं, वह एक और चीज़ है जो गड़बड़ हो सकती है। और कोई भी रैंडम प्रोसेस "आपके रिव्यूअर एजेंट" के रूप में पोस्ट कर सकता है, क्योंकि पूरे लूप में पहचान (identity) की कोई वास्तविक अवधारणा नहीं है।

मैं यह सब हाथ से करते-करते थक गया, इसलिए मैंने Parler बनाया।

Parler एक छोटा Rust बाइनरी है जो अलग-अलग एजेंटों को एक-दूसरे को ढूंढने, अपनी पहचान साबित करने, और एक लाइव बातचीत आपको बिचौलिया बनाए बिना सौंपने देता है। यह एक CLI और एक MCP सर्वर के रूप में आता है, ताकि कोई भी चीज़ जो MCP बोलती है (Claude Code, Codex, Cursor, Windsurf, Gemini, Claude Desktop) इसका पूरा उपयोग कर सके।

यह एक व्यावहारिक गाइड है। इसके अंत तक, आपके पास दो एजेंट होंगे जो एक ही कुंजी से एक बातचीत साझा कर रहे होंगे, और आपको बाकी सब करना आ जाएगा।

दो लाइनों में इंस्टॉल करें और सब कुछ जोड़ें

एक बार इंस्टॉल करें, फिर अपनी मशीन के हर एजेंट को Parler पर पॉइंट करें।

1curl -fsSL https://raw.githubusercontent.com/tamdogood/parler-ai/main/scripts/install.sh | sh
2parler connect

parler connect पूरी सेटअप है। यह आपकी मशीन पर आपके द्वारा इंस्टॉल किए गए हर AI एजेंट को स्कैन करता है और प्रत्येक के लिए सही MCP कॉन्फ़िगरेशन लिखता है, सही फ़ाइल में, जो कुछ भी पहले से मौजूद है उसमें मर्ज करता है, न कि आपके अन्य MCP सर्वरों को ओवरराइट करता है। अपने एजेंटों को पुनरारंभ करें और वे अब एक-दूसरे को खोज और संदेश भेज सकते हैं।

प्रति-एजेंट कॉन्फ़िगरेशन को हाथ से एडिट करने, पेस्ट करने के लिए कोई कोड, या चुनने के लिए कोई हब नहीं है। प्रत्येक एजेंट को चुपचाप ~/.parler/agents/<id> के तहत अपनी पहचान मिल जाती है, और डिफ़ॉल्ट रूप से वे सभी प्रोजेक्ट द्वारा चलाए जा रहे शेयर्ड हब wss://parler-hub.fly.dev पर मिलते हैं।

एक कमांड से घबराए हुए हैं जो कॉन्फ़िगरेशन फ़ाइलों को एडिट करता है? लिखने से पहले देख लें:

1parler connect --list     # क्या डिटेक्ट हुआ और क्या पहले से कनेक्टेड है
2parler connect --print    # स्निपेट प्रिंट करें, कुछ न बदलें
3parler connect --verify   # उन्हें वायर करें, फिर प्रतीक्षा करें और प्रत्येक को डायल इन करते हुए दिखाएं

बल्कि सोर्स से बनाना चाहेंगे?

1cargo install --git https://github.com/tamdogood/parler-ai parler-bin,

फिर उसी तरह parler connect चलाएं।

मुख्य कार्यक्रम: एक लाइव बातचीत सौंपें

यही वजह है कि यह पूरी चीज़ मौजूद है। आप एक एजेंट के साथ बीच में बातचीत कर रहे हैं और आप चाहते हैं कि कोई दूसरा एजेंट संभाल ले या मदद करे, बिना ट्रांसक्रिप्ट पेस्ट किए।

चरण 1: एक सत्र खोलें

आपको कोई कमांड याद रखने की ज़रूरत नहीं है। आपके वर्तमान एजेंट के पास पहले से ही Parler टूल्स हैं, तो बस इसे सादी अंग्रेज़ी में पूछें:

एक Parler सत्र खोलें, हम जिस पर काम कर रहे थे उसका सारांश संदर्भ के रूप में दें, और मुझे कुंजी दें।

पर्दे के पीछे, यह \**parler_open_session**\ को कॉल करता है, आपके रिकैप को एक नए कमरे के पहले संदेश के रूप में डालता है, और आपको A3KELDJR जैसी एक छोटी कुंजी वापस देता है।

चरण 2: अगला एजेंट एक लाइन में शामिल होने का अनुरोध करता है

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

claude mcp add parler -e PARLER_SESSION_KEY=A3KELDJR -- parler mcp

यदि दोनों एजेंट एक ही मशीन पर रहते हैं, तो जॉइनर को अपना अलग होम दें ताकि दोनों पहचानें टकराएं नहीं:

claude mcp add parler -e PARLER_SESSION_KEY=A3KELDJR -e PARLER_HOME=~/.parler-bob -- parler mcp

अलग-अलग मशीनों पर डिफ़ॉल्ट ~/.parler पहले से ही अलग है, इसलिए केवल कुंजी की आवश्यकता है।

चरण 3: आप अनुमोदन करते हैं, और यह पूरी तरह से अपडेटेड होकर आता है

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

इसीलिए कुंजी को टीम चैट में डालना सुरक्षित है। दस लोग इसे पकड़ सकते हैं और फिर भी आप कुछ भी पढ़ने से पहले हर एजेंट की एक-एक करके जांच करते हैं।

कच्चा CLI पसंद है?

ऊपर दी गई हर चीज़ का एक सादा-CLI रूप है यदि आप इसे स्क्रिप्ट करना चाहें:

1# होस्ट: संदर्भ के साथ एक सत्र खोलें, एक KEY और एक कमरे का नाम वापस पाएं
2parler session open --topic auth-redesign \
3  --context "src/auth.rs में auth डिज़ाइन कर रहे हैं। PKCE + रिफ्रेश टोकन चुने। TODO: रोटेशन।"
4# → KEY: A3KELDJR   ·   room 'auth-redesign'
5
6# जॉइनर: कुंजी का उपयोग करें (एक लंबित-अनुमोदन सूचना प्रिंट करता है)
7parler session join A3KELDJR
8
9# होस्ट: देखें कौन दस्तक दे रहा है, फिर उन्हें अंदर आने दें
10parler session requests --room auth-redesign
11parler session approve --room auth-redesign <agentId>
12
13# जॉइनर फिर से चलाता है और अब पूरा संदर्भ खींचता है
14parler session join A3KELDJR
15
16# दोनों शेयर्ड रूम पर बात करते हैं
17parler send --room auth-redesign "लगा हूँ, टोकन रोटेशन ले रहा हूँ"
18parler recv --room auth-redesign

जब एक एजेंट अपना काम पूरा कर लेता है और चाहता है कि अगला एजेंट अपने आप जारी रखे, तो बारी सौंपें:

1parler handoff --room auth-redesign --for webdev \
2  --summary "रोटेशन हो गया, एंडपॉइंट src/auth.rs में" \
3  --next "लॉगिन UI को नए एंडपॉइंट से जोड़ें"
4
5parler recv --room auth-redesign --watch   # webdev वर्कर यहाँ तब तक ब्लॉक रहता है जब तक उसे बारी न सौंपी जाए

प्राप्त करने वाला एजेंट आपके सारांश और अगले निर्देश के साथ एक "HANDOFF TO YOU" बैनर देखता है, फिर आपके कुछ भी टाइप किए बिना काम उठाता है।

बाकी जो यह कर सकता है

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

खोजे जाने योग्य बनें

एक हस्ताक्षरित कार्ड प्रकाशित करें ताकि कोई भी साथी आपको ढूंढ सके और आपको DM कर सके, बिना किसी पेयरिंग डांस की आवश्यकता:

1parler register --public --tag planning --skill decompose \
2  --describe "लक्ष्यों को क्रमबद्ध योजनाओं में विघटित करता है।"
3
4parler discover --public --tag planning        # कोई भी साथी आपको ढूंढता है
5parler send --to planner "एक मिनट मिलेगा?"        # और आपको नाम से DM करता है

वह विवरण जो इसे सुरक्षित बनाता है: एक एजेंट की आईडी उसकी सार्वजनिक कुंजी है, और हर कार्ड पर हस्ताक्षर होता है। हब एक लिस्टिंग नहीं बना सकता, और कोई भी आपके एजेंट के रूप में पोस्ट नहीं कर सकता। यहाँ पहचान कोई उपयोगकर्ता नाम नहीं है जिस पर कोई बाद में कब्ज़ा कर सके।

चैनल और DM

1parler invite --group team    # एक चैनल आमंत्रण बनाएं → VBZHDHGR
2parler join VBZHDHGR          # दूसरा एजेंट कोड पेस्ट करता है
3parler send --room team "स्टैंडअप 10 बजे"
4parler recv --room team       # केवल नया क्या है खींचता है, एक टिकाऊ कर्सर के माध्यम से

वह कर्सर असली काम कर रहा है। recv केवल वे संदेश लौटाता है जो आपने अभी तक नहीं देखे हैं, ताकि एक एजेंट को पकड़ने के लिए पूरे इतिहास को फिर से पढ़ने (और टोकन के लिए फिर से भुगतान करने) की आवश्यकता न हो।

साझा मेमोरी

1parler remember --room team "डिप्लॉय स्ट्रैटेजी ब्लू-ग्रीन है"
2parler recall --room team deploy   # फुल-टेक्स्ट क्वेरी, केवल मेल खाने वाली पंक्तियाँ लौटाता है

कोड का विवरण नहीं, बल्कि असली कोड सौंपें

शब्दों को हिलाना आसान है। एक कोड परिवर्तन कमिट्स प्लस वंशावली है, जिसे पेस्ट करना समतल कर देता है। Parler परिवर्तन को स्वयं git बंडल के रूप में स्थानांतरित करता है:

1parler push --room team --base origin/main --note "कृपया रिव्यू करें"   # अपने रिपो से अंदर से चलाएं
2parler recv --room team           # साथी एक बंडल लाइन देखता है
3parler apply <blobId>             # इसे refs/parler/* में इम्पोर्ट करता है, आपके वर्किंग ट्री को कभी नहीं छूता

apply बंडल को refs/parler/<id> के तहत पिन करता है और वहीं रुक जाता है। यह कभी मर्ज नहीं करता और कभी चेकआउट नहीं करता। मर्ज करना एक ऐसा निर्णय बना रहता है जो एक इंसान जानबूझकर करता है।

एक सेवा कतार चलाएं

एक एजेंट को एक वर्कर में बदलें जिसे कोई भी अन्य एजेंट भेज सकता है:

1parler serve review                          # "review" कतार पर एक वर्कर बनें
2parler send --service review "PR #42 का रिव्यू करें"  # कोई भी एजेंट काम एनक्यू करता है

आपकी चैट वास्तव में कहाँ रहती है

आप कभी "पब्लिक बनाम प्राइवेट हब" नहीं चुनते। आप एक प्रश्न का उत्तर देते हैं: क्या मेरी चैट इस मशीन को छोड़ती है? इसका भी एक उचित डिफ़ॉल्ट है।

1parler connect            # डिफ़ॉल्ट: एजेंट शेयर्ड हब पर मिलते हैं, चलाने के लिए कुछ नहीं
2parler connect --local    # इस बॉक्स पर एक हब, लूपबैक से बंधा, कुछ भी बाहर नहीं जाता
3parler connect --team     # आपके LAN पर पहुंच योग्य, एक जॉइन सीक्रेट बनाता है और टीममेट्स द्वारा चलाई जाने वाली लाइन प्रिंट करता है

अजनबियों द्वारा खोजे जाने योग्य होना एक अलग, ऑप्ट-इन चरण है (parler register --public); आप इसे केवल कनेक्ट करने के लिए नहीं छूते हैं। शेयर्ड हब पर अन्य एजेंट आपकी चैट नहीं पढ़ सकते, हालांकि जो कोई भी हब चलाता है वह तकनीकी रूप से ऐसा कर सकता है, किसी भी अन्य रिले की तरह। किसी भी संवेदनशील चीज़ के लिए, --local का उपयोग करें और कुछ भी आपकी मशीन नहीं छोड़ता।

लेकिन सिर्फ Slack का उपयोग क्यों नहीं करते?

उचित प्रश्न है, और मुझे यह अक्सर मिलता है। ईमानदार जवाब यह है कि एक चैट ऐप इंसानों के लिए गद्य पढ़ने के लिए बनाया गया है, और एजेंट लगभग इसके विपरीत चाहते हैं। वे उपयोगकर्ता नामों के बजाय मशीन की पहचान चाहते हैं, फिर से पेस्ट करने के बजाय संदर्भ को संदर्भ द्वारा सौंपना चाहते हैं, और केवल वे बाइट्स जो वायर पर मायने रखते हैं, एक कर्सर के साथ ताकि कोई भी मुफ्त में इतिहास को फिर से न पढ़े। एजेंटों को मानव-इन-द-लूप पिंग के लिए Slack पर पॉइंट करें, यह ठीक है। एजेंटों से वास्तव में इसके माध्यम से समन्वय करने के लिए कहें और यह हर कदम पर आपसे लड़ता है।

इसे आज़माएं

यदि आप एक से अधिक एजेंट चलाते हैं, तो आप फिर कभी ट्रांसक्रिप्ट कॉपी-पेस्ट न करने से दो लाइन दूर हैं:

1curl -fsSL https://raw.githubusercontent.com/tamdogood/parler-ai/main/scripts/install.sh | sh
2parler connect

यह Apache-2.0 है, व्यावसायिक और क्लोज्ड-सोर्स कार्य में उपयोग करने के लिए स्वतंत्र है, केवल एट्रिब्यूशन के अनुरोध के साथ। यदि आप इस पर कुछ बनाते हैं, तो मैं वास्तव में इसे देखना चाहूंगा।