Claude Code Agent Teams: AI-सहायता प्राप्त विकास का भविष्य

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

इसे बदलने के लिए Claude Code Agent Teams पेश किए गए। विचार यह है कि एक सिंगल सेशन में सबकुछ क्रमवार कराने के बजाय, आप कई विशेषज्ञ एजेंट शुरू करें जो एक साझा टास्क लिस्ट का उपयोग करें, सीधे एक-दूसरे को संदेश भेजें और कार्य समानांतर में निष्पादित करें।

इस लेख में, मैं आपको बताऊंगा कि Agent Teams कैसे काम करते हैं, हर विशेषज्ञ भूमिका क्या करती है, और वास्तविक सॉफ्टवेयर प्रोजेक्ट्स पर उन्हें कैसे समन्वित किया जाए।

Claude Code में नए हैं? हमारे Claude Code 101 कोर्स के साथ एक दोपहर में बुनियादी बातें सीख लें।

Claude Code Agent Teams क्या हैं?

Claude Code Agent Teams एक कोऑर्डिनेशन लेयर है जो कई Claude Code सेशंस को एक ही प्रोजेक्ट पर एक साथ काम करने देती है। एक सेशन टीम लीड की भूमिका लेता है और अन्य सेशंस—जिन्हें टीममेट कहा जाता है—बनाता है ताकि वे काम के विशेष हिस्सों को संभालें।

हर टीममेट अपना अलग संदर्भ विंडो वाला पूर्ण, स्वतंत्र Claude Code इंस्टेंस होता है। वे एक साझा टास्क लिस्ट का उपयोग करते हैं, उपलब्ध होते ही काम को क्लेम करते हैं, और समन्वय की ज़रूरत पर सीधे एक-दूसरे को संदेश भेजते हैं।

यह सेटअप केवल कुछ टर्मिनल टैब खोलकर प्रत्येक में Claude चलाने से कहीं अधिक है। ऐसा करने पर अलग-अलग चैट विंडोज़ एक-दूसरे की प्रगति नहीं देख पातीं और यह तय नहीं कर पातीं कि कौन क्या कर रहा है। दूसरी ओर, एक एजेंट टीम हर सेशन को काम का साझा दृश्य और संचार का माध्यम देती है। लीड सभी को संरेखित रखता है।

व्यावहारिक रूप से, अब आप सेशंस के बीच रिले नहीं रहते। टीम अपना समन्वय खुद संभालती है, और आप केवल दिशा तय करने और परिणाम की समीक्षा करने के लिए हस्तक्षेप करते हैं।

Agent Teams की ज़रूरत क्यों

एक एकल Claude Code सेशन तब तक ठीक काम करता है जब तक प्रोजेक्ट बहुत बड़ा नहीं हो जाता।

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

तीन आम स्थितियाँ हैं जहाँ यह स्पष्ट हो जाता है:

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

समाधान वही है जिस पर मानव टीमें दशकों पहले पहुँची थीं: काम को बाँट दें।

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

यही विचार शोध पर भी लागू होता है। तीन प्रतिस्पर्धी परिकल्पनाओं वाले कार्य तब तेज़ चलते हैं जब तीन टीममेट्स समानांतर में एक-एक सिद्धांत की जाँच करें और फिर नोट्स की तुलना करें—बजाय इसके कि एक सेशन उन्हें क्रमिक रूप से चलाए।

विशेषीकरण आपको गहराई देता है और समानांतरता आपको गति। दोनों मिलकर ऐसा काम संभव बनाते हैं जिस पर एकल सेशन या तो भ्रमित होगा या फिर अत्यधिक समय लेगा।

Claude Code Agent Teams कैसे काम करते हैं

एक टीम सेशन पाँच चरणों से होकर गुजरता है, जिसका ऑर्केस्ट्रेशन Claude Code के भीतर ही संभाला जाता है।

• उद्देश्य परिभाषित करें: सीधी भाषा में बताएं कि आप क्या चाहते हैं, ठीक वैसे ही जैसे आप किसी जूनियर इंजीनियर को ब्रीफ करते हैं। लीड इसे पढ़ता है और तय करता है कि इसे कैसे तोड़ा जाए।
• काम सौंपें: लीड साझा टास्क लिस्ट बनाता है और नाम, भूमिका और शुरुआती प्रॉम्प्ट के साथ टीममेट्स शुरू करता है। आप टीम संरचना निर्दिष्ट कर सकते हैं या लीड को इसे समझने दें।
• समानांतर निष्पादन: हर टीममेट टास्क क्लेम करता है, उन्हें प्रगति में चिह्नित करता है, पूरा करता है और पूरा होने पर मार्क करता है। निर्भरताएँ स्वतः सम्मानित होती हैं; फ़ाइल लॉकिंग टकरावों को रोकती है। टीममेट्स एक-दूसरे को सीधे संदेश भेज सकते हैं — लीड के माध्यम से रूट करने की ज़रूरत नहीं।
• परिणाम मिलाएँ: लीड तैयार काम को एकत्र करता है, टकराव सुलझाता है, और एकल आउटपुट देता है: PR, रिपोर्ट, रिफैक्टर्ड मॉड्यूल, या जो भी उद्देश्य हो।
• परिणाम की समीक्षा: आप अंतिम परिणाम की समीक्षा किसी पुल रिक्वेस्ट की तरह करते हैं: डिफ़ पढ़ें, कोड चलाएँ, टेस्ट जाँचें।

Agent Teams की विशिष्ट भूमिकाएँ

भूमिकाएँ एजेंट टीम का ढाँचा देती हैं। इनके बिना आप सामान्य सेशंस के साथ ओवरलैपिंग काम पाते हैं। Claude Code कोई तय सूची नहीं देता — आप अपनी ब्रीफ में भूमिकाएँ परिभाषित करते हैं या लीड को .claude/agents/ के तहत सहेजी गई सबएजेंट परिभाषा की ओर इंगित करते हैं।

Planning Agent

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

व्यवहार में, टीम लीड अक्सर यही भूमिका खुद निभाता है। आप काम पर्याप्त बड़ा होने पर समर्पित प्लानिंग टीममेट भी चला सकते हैं।

Coding Agent

कोडिंग एजेंट इम्प्लीमेंटेशन लिखता है। ज़्यादातर टीममेट्स कोडिंग एजेंट होंगे, प्रत्येक काम के अलग हिस्से—बैकएंड, फ्रंटएंड, डेटाबेस, AI फीचर्स—का स्वामित्व लेते हुए। कुंजी है स्कोप का ओवरलैप न होना: एक ही फ़ाइल संपादित करने वाले दो टीममेट्स एक-दूसरे को ओवरराइट करेंगे।

कोडिंग एजेंट सस्ते मॉडलों पर भी अच्छा काम करते हैं। कई प्रैक्टिशनर्स लीड को Opus पर और टीममेट्स को Sonnet पर चलाते हैं, क्योंकि निष्पादन को समन्वय जितनी गहरी तर्क-शक्ति की ज़रूरत नहीं होती।

Testing Agent

टेस्टिंग एजेंट टेस्ट लिखता और चलाता है। यह सहमत API कॉन्ट्रैक्ट के आधार पर काम कर सकता है, जबकि कोडिंग टीममेट एंडपॉइंट बना रहा हो—ताकि कोड आते ही टेस्ट पहले से मौजूद हों।

आप पूरी सेशन के दौरान टेस्टिंग टीममेट चलता रख सकते हैं, जो हर बार किसी कोडिंग टीममेट के टास्क पूरा करने पर सूट फिर से चलाए।

Review Agent

रीव्यू एजेंट डिफ़ पढ़ता है और बग्स, स्टाइल मुद्दों, छूटे हुए एज केस और सिक्योरिटी समस्याओं को फ़्लैग करता है। दो अलग-अलग लेंस—एक सिक्योरिटी के लिए, एक परफ़ॉर्मेंस के लिए—के साथ समीक्षा को दो टीममेट्स में बाँटना खास तौर पर अच्छा काम करता है, और लीड उनकी फ़ाइंडिंग्स को मिलाता है।

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

Documentation Agent

डॉक्यूमेंटेशन एजेंट डॉकस्ट्रिंग्स, README अपडेट और आर्किटेक्चर नोट्स या API रेफरेंस जैसी लंबी दस्तावेज़ीकरण लिखता है। यह आख़िरी चलने वाले टीममेट के लिए अच्छा उम्मीदवार है—क्योंकि कोडिंग और टेस्टिंग के पूरा होते-होते काम की अंतिम आकृति स्पष्ट हो जाती है।

विशेषीकरण परिणाम कैसे सुधारता है

एक सामान्य प्रयोजन सेशन को एक साथ इम्प्लीमेंटेशन, टेस्ट, डॉक्यूमेंटेशन और समीक्षा फीडबैक संदर्भ में रखना पड़ता है। एक विशेषज्ञ टीममेट केवल वही लोड करता है जिसकी उसे ज़रूरत है, जिससे उसका संदर्भ छोटा और तर्क केंद्रित रहता है। विशेषीकरण डिबगिंग भी आसान बनाता है: कुछ गड़बड़ होने पर आपको ठीक-ठीक पता होता है किस सेशन को देखना है।

Agent Teams के साथ समानांतर विकास

समानांतरता ही एजेंट टीम का मूल उद्देश्य है।

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

यहाँ तीन संयोजन हैं जो समानांतर में विशेष रूप से अच्छे चलते हैं।

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

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

बड़े कोडबेस के लिए Claude Code Agent Teams

बड़े कोडबेस में एजेंट टीमें “अच्छा-होना” से ज़्यादा “ज़रूरी-होना” होती हैं।

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

Agent teams में, हर टीममेट केवल अपने हिस्से से संबंधित फाइलें लोड करता है, इसलिए प्रति टीममेट संदर्भ विंडो छोटी और केंद्रित रहती है। पूरी टीम मिलकर पूरे रिपॉज़िटरी पर तर्क कर सकती है, पर किसी एक सेशन को ऐसा करने की ज़रूरत नहीं पड़ती।

यह तीन स्थितियों में सबसे अधिक मायने रखता है:

• क्रॉस-कटिंग बदलाव: कई मॉड्यूल्स में दर्जनों फाइलों को छूने वाला रिफैक्टर एक सेशन के लिए ट्रैक नहीं करना कठिन है। इसे मॉड्यूल के हिसाब से बाँटकर हर मॉड्यूल एक टीममेट को देने से हर एक का स्कोप संभालने योग्य रहता है।
• रिपॉज़िटरी-व्यापी ऑडिट: बड़े कोडबेस पर सिक्योरिटी रिव्यू या परफ़ॉर्मेंस ऑडिट को समानांतर में कई टीममेट्स चलाने का लाभ मिलता है, हर एक रिपॉज़िटरी के अलग हिस्से को देखता है। फिर लीड उनकी फ़ाइंडिंग्स को एक रिपोर्ट में जोड़ता है।
• लंबे समय चलने वाले प्रोजेक्ट्स: बहु-साप्ताहिक प्रोजेक्ट इतना संदर्भ इकट्ठा कर लेता है जिसे एक सेशन संभाल नहीं सकता। Agent teams आपको काम को चेकपॉइंट्स में बाँटने देती हैं, जहाँ हर चेकपॉइंट एक टीममेट के पास होता है जिसे पहले की सारी चीज़ें याद रखने की ज़रूरत नहीं।

इसकी एक कीमत है।

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

प्रोजेक्ट जितना बड़ा, Agent teams से उतना लाभ। पर अति न करें—छोटे बग फिक्स के लिए एकल सेशन सस्ता और उतना ही प्रभावी है।

Agent Teams और Claude Tag

एजेंट टीमें अकेली जगह नहीं हैं जहाँ Anthropic यह फिर से सोच रहा है कि AI टीम वर्कफ़्लो में कैसे फिट बैठता है।

Claude Tag एक अलग फ़ीचर है जो Claude को Slack में एक साझा संगठनात्मक प्रतिभागी के रूप में लाता है। आप किसी चैनल में @Claude को टैग करते हैं, और Claude आपके संगठन के टूल्स और चैनल के संदर्भ का उपयोग करके काम संभालता है। यह जो चर्चा हुई है उसे याद रखता है, स्वयं फॉलो-अप करता है, और आपके संगठन की पहचान के तहत काम करता है।

ये दोनों फ़ीचर अलग-अलग समन्वय समस्याएँ हल करते हैं। एजेंट टीमें एक डेवलपर की मशीन पर एक केंद्रित कार्य के लिए कई Claude Code सेशंस का समन्वय करती हैं। Claude Tag दिनों और हफ्तों में Slack में इंसानी टीम के बीच एक Claude पहचान का समन्वय करता है। लेकिन दिशा एक ही है: AI एक ऐसे टूल से, जिसे कोई एक व्यक्ति अलग-थलग उपयोग करता है, टीम के मौजूदा वर्कफ़्लो के भीतर काम करने वाले प्रतिभागी में बदल रहा है।

इससे AI को जिन चीज़ों में अच्छा होना चाहिए, वे बदलती हैं।

एक अकेला सहायक मजबूत जनरलिस्ट होना चाहिए, लेकिन एक समन्वित सिस्टम को मजबूत विशेषज्ञ होना चाहिए जो योजना बना सके, हैंड-ऑफ कर सके, मदद माँग सके, और अन्य एजेंटों व मनुष्यों के साथ संरेखित रह सके। Agent teams यह Claude Code वर्कफ़्लो के लिए करती हैं, और Claude Tag इसे Slack वर्कफ़्लो में दृश्य बनाता है।

Agent Teams बनाने के सर्वोत्तम अभ्यास

एक अच्छी एजेंट टीम सेटअप का अधिकतर हिस्सा शुरू में सेटअप पर निर्भर है। टीम खुद तेज़ है, पर आपका समय खराब स्कोप वाले कार्यों और अस्पष्ट भूमिकाओं में नष्ट होगा।

यहाँ कुछ सर्वश्रेष्ठ अभ्यास हैं:

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

• समानांतर करने से पहले कार्यों का विघटन करें: पहले योजना, फिर समानांतर। काम को स्पष्ट इनपुट, आउटपुट और निर्भरताओं वाले टास्क्स में तोड़ने के लिए एक प्लानिंग पास चलाएँ, फिर योजना को टीम को निष्पादन के लिए दें। एक योजना कुछ हज़ार टोकन्स की पड़ती है, पर गलत दिशा में जाने वाली टीम सैकड़ों हज़ारों की पड़ सकती है।

• CLAUDE.md के ज़रिये मानक साझा करें: हर टीममेट शुरू में वर्किंग डायरेक्टरी की CLAUDE.md पढ़ता है, इसलिए अपनी साझा परंपराएँ—कोड स्टाइल, फाइल लेआउट, टेस्टिंग अप्रोच, और कमिट मैसेज फॉर्मैट—वहीं रखें।

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

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

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

• सामान्य ऑपरेशंस अग्रिम-स्वीकृत करें: टीममेट्स से आने वाले परमिशन प्रॉम्प्ट्स लीड तक बबल होते हैं, और चार टीममेट्स वाली टीम चार गुना प्रॉम्प्ट्स दे सकती है। टीम स्पॉन करने से पहले अपनी permissions.allow सूची सेट करें ताकि फाइल पढ़ना या टेस्ट चलाना जैसे रूटीन ऑपरेशंस काम में व्यवधान न डालें।

• मॉडल को भूमिका से मिलाएँ: लीड को Opus जैसे मजबूत मॉडल पर चलाएँ, क्योंकि समन्वय गहरी तर्क-शक्ति से लाभान्वित होता है, और टीममेट्स को निष्पादन के लिए Sonnet पर चलाएँ।

और संक्षेप में: विस्तृत कार्य योजना बनाइए, टीम को वैसे ब्रीफ कीजिए जैसे आप जूनियर इंजीनियरों के छोटे समूह को करते हैं, उन्हें स्पष्ट स्कोप और साझा मानक दीजिए, और अंत में उनके काम की जाँच कीजिए। आपका सेटअप जितना एक वास्तविक इंजीनियरिंग टीम के कामकाज के करीब होगा, एजेंट टीम उतना ही बेहतर प्रदर्शन करेगी।

व्यवहार में Claude Code Agent Team

यहाँ पूरी प्रक्रिया शुरुआत से अंत तक है।

मैं एक छोटा उदाहरण दिखाऊँगा: FastAPI में एक "hello world" REST API जो SQLite डेटाबेस से संदेश पढ़ता है, साथ में एक छोटा HTML पेज जो API को कॉल करके नतीजा दिखाता है। ऐप में एक बैकएंड रूट, एक डेटाबेस लेयर, एक स्टैटिक फ्रंटएंड और एक रीडमी डॉक्यूमेंटेशन है—जो इसे चार-सदस्यीय टीम के लिए उपयुक्त बनाता है।

एजेंट टीमें सक्षम करें

एजेंट टीमें एक प्रयोगात्मक फ़ीचर हैं और डिफ़ॉल्ट रूप से बंद रहती हैं। आप इन्हें एक एनवायरनमेंट वेरिएबल सेट करके चालू करते हैं—या तो अपने शेल में या Claude Code सेटिंग्स फाइल में।

सेटिंग्स फाइल ~/.claude/settings.json पर है। इसे खोलें और जोड़ें:

{
  "env": {
    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
  }
}

यदि आप सेटिंग्स फाइल संपादित नहीं करना चाहते, तो Claude Code शुरू करने से पहले आप अपने शेल में यह वेरिएबल सेट कर सकते हैं:

export CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1

दोनों तरीके काम करते हैं। एक बार वेरिएबल सेट होने पर, जब आप कहेंगे तो Claude Code टीम-संबंधित प्रॉम्प्ट्स को पहचानेगा और कोऑर्डिनेशन लेयर शुरू करेगा।

Claude Code शुरू करें और टीम को ब्रीफ करें

प्रोजेक्ट के लिए खाली डायरेक्टरी बनाएँ और उसके भीतर Claude Code शुरू करें:

mkdir hello-api && cd hello-api
claude

अब आप टीम को ब्रीफ करें। प्रॉम्प्ट साधारण प्राकृतिक भाषा में है, लेकिन आप भूमिकाओं और सीमाओं के बारे में जितने विशिष्ट होंगे, टीम उतना बेहतर प्रदर्शन करेगी। hello world API के लिए प्रॉम्प्ट यह है:

Create an agent team to build a small "hello world" REST API.

The project is a FastAPI service that returns a greeting from a SQLite
database, plus a tiny HTML page that calls the API and shows the result.
- One teammate on the database: create app/db.py with a sqlite3 connection
  to a greetings.db file. Define a get_greeting() function that returns
  the message column from the first row. On import, create the table if
  it doesn't exist and seed it with "Hello, World!" if empty.
- One teammate on the backend: build a FastAPI app in app/main.py with
  a GET /greeting endpoint that calls get_greeting() from app/db.py.
  Add permissive CORS and mount the static/ directory at the root so
  the HTML page is served from the same origin.
- One teammate on the frontend: build static/index.html as a single page
  that fetches /greeting on load, shows a spinner while loading, displays
  the greeting in a centered card on success, and shows an error message
  on failure. Inline the CSS and JavaScript.
- One teammate on docs: write README.md with installation, run, and
  open-in-browser steps, plus an API reference table. Also create
  requirements.txt with fastapi and uvicorn[standard].
Use Sonnet for each teammate. Require plan approval before any teammate
makes changes.

इस प्रॉम्प्ट में तीन बातें ध्यान देने लायक हैं। फ़ाइल सीमाएँ (app/db.py, app/main.py, static/index.html, README.md, requirements.txt) ओवरलैप रोकती हैं। मॉडल का चुनाव (Sonnet) टोकन लागत को संभाल में रखता है। और plan approval हर टीममेट को कोई भी कोड लिखने से पहले अपनी योजना दिखाने को बाध्य करता है, जो आपको गलतफहमी दूर करने के लिए एक चेकपॉइंट देता है।

देखें टीम कैसे काम करती है

प्रॉम्प्ट सबमिट करने के बाद, लीड काम को टास्क्स में तोड़ता है और टीममेट्स शुरू करता है। आपको टर्मिनल के नीचे एक एजेंट पैनल दिखेगा, जिसमें प्रति टीममेट एक पंक्ति होगी।

बने हुए एजेंट्स

हर पंक्ति टीममेट का नाम और वह क्या कर रहा है दिखाती है। लीड साझा टास्क लिस्ट भरता है और निर्भरताओं के आधार पर टास्क असाइन या रिलीज़ करता है। बैकएंड टीममेट डेटाबेस लेयर का इंतज़ार करता है क्योंकि वह उससे get_greeting() इम्पोर्ट करता है। डॉक्यूमेंटेशन टीममेट तब तक प्रतीक्षा करता है जब तक बाकी काम इतना आगे न बढ़ जाए कि वह सटीक वर्णन कर सके।

आप टास्क लिस्ट भी देख सकते हैं। Ctrl+T दबाकर इसे टॉगल करें। सूची हर टास्क, उसकी स्थिति (पेंडिंग, प्रगति में, या पूर्ण) और उसका मालिक टीममेट दिखाती है।

टीममेट्स के बीच जाएँ

हर टीममेट एक पूर्ण Claude Code सेशन है, और आप किसी से भी बात कर सकते हैं।

एजेंट पैनल में, ऊपर-नीचे एरो से किसी टीममेट का चयन करें, फिर उसका ट्रांसक्रिप्ट खोलने के लिए Enter दबाएँ। अब आप उस टीममेट के सेशन में हैं, और जो भी आप टाइप करेंगे वह लीड को नहीं बल्कि उसी टीममेट को जाएगा। यही तरीका है जिससे आप किसी विशेष टीममेट को अतिरिक्त संदर्भ दे सकते हैं या उसकी दिशा बिना बाकी टीम को शामिल किए बदल सकते हैं।

वापस लीड पर लौटने के लिए Esc दबाएँ।

पटऱी से उतरे टीममेट को पुनर्निर्देशित करें

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

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

डेटाबेस एजेंट अनुमोदन

आप प्रस्तावित स्कीमा और अप्रोच पढ़ सकते हैं, फिर फीडबैक के साथ अनुमोदित या अस्वीकृत कर सकते हैं। यदि योजना में कुछ कमी है, तो आप “raw sqlite3 की जगह SQLAlchemy का उपयोग करें” जैसा उत्तर दे सकते हैं और टीममेट पुन: योजना बनाएगा।

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

समाप्त करें और समीक्षा करें

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

अंतिम लीड निर्देश

इस बिंदु पर, आप काम की समीक्षा करते हैं। आप अपने संपादक में जेनरेटेड फाइलें खोलकर डिफ़्स पढ़ सकते हैं।

जेनरेटेड app/main.py फाइल

आप उस डेटाबेस का भी निरीक्षण कर सकते हैं जिसे डेटाबेस एजेंट ने बनाया और सीड किया है।

greetings टेबल

फिर डिपेंडेंसी इंस्टॉल करें, uvicorn app.main:app --reload चलाएँ, और अपने ब्राउज़र में http://localhost:8000 खोलें ताकि एंड-टू-एंड पूरी स्टैक के काम करने की पुष्टि हो सके।

अंतिम ऐप

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

बस इतना ही!

निष्कर्ष

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

बड़ी तस्वीर यह है कि AI-सहायता प्राप्त विकास एकल से समन्वित की ओर बढ़ रहा है। Claude Code में आज यह बदलाव Agent teams के रूप में दिखता है, और यही पैटर्न Slack के लिए Claude Tag में भी उभर रहा है। जो डेवलपर्स अभी से इस पर सहज हो जाते हैं, वे संदर्भ सीमाओं से जूझने में कम और वास्तविक फीचर्स बनाने में अधिक समय लगाएंगे।

क्या आप Generative AI में प्रमाणित होना चाहते हैं? यहाँ देखें 2026 की सर्वश्रेष्ठ Generative AI प्रमाणपत्र, जिनमें शीर्ष कोर्स, तैयारी के सुझाव और FAQs शामिल हैं।