एक प्रबंधित एजेंट क्या है?

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

एक प्रबंधित एजेंट क्या है?

एक प्रबंधित एजेंट एक एजेंट लूप है जो आपके बजाय Anthropic के इंफ्रास्ट्रक्चर पर चलता है। आप एजेंट को एक बार वर्णित करते हैं, आप इसे काम करने के लिए एक वातावरण देते हैं, और आप एक सेशन शुरू करते हैं। Anthropic लूप चलाता है, और आप बस इवेंट्स को वापस स्ट्रीम करते हैं जैसे यह काम करता है।

प्रबंधित एजेंट्स हर API खाते के लिए डिफ़ॉल्ट रूप से सक्षम हैं — कोई विशेष एक्सेस की आवश्यकता नहीं है।

चार प्राइमिटिव्स

चार प्राइमिटिव्स हैं, और वे क्रम में आते हैं:

• Agent — व्यक्तित्व: मॉडल, सिस्टम प्रॉम्प्ट, और टूलसेट। यह कई रन्स में पुन: उपयोग योग्य है।
• Environment — जहां एजेंट चलता है: क्लाउड या स्थानीय, नेटवर्किंग कॉन्फ़िग, आदि।
• Session — एक निश्चित वातावरण के अंदर एजेंट का एक एकल रन। सेशन काम की इकाई है।
• Events — अंदर और बाहर बहने वाले संदेश: एजेंट की क्रियाएं, टूल कॉल्स, परिणाम, उत्तर।

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

एक एजेंट को एक सेशन से जुड़ा हुआ दिखाने वाला आर्किटेक्चर आरेख, जो एक वातावरण चलाता है, परिणाम आपके ऐप को एक इवेंट स्ट्रीम के माध्यम से वापस बहते हैं

यहां बदलाव पर ध्यान दें: आप एक while लूप नहीं चला रहे हैं। आप इवेंट्स भेज रहे हैं और इवेंट्स पढ़ रहे हैं।

सबसे छोटा संभव प्रबंधित एजेंट

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

टूल्स के लिए, हम एजेंट टूलसेट का उपयोग करेंगे — Anthropic का बंडल किया गया फाइल, bash, और वेब टूल्स। वे इस कार्य के लिए ठीक काम करते हैं, इसलिए हमें कोई टूल्स स्वयं परिभाषित नहीं करने हैं।

चरण 1: एजेंट बनाएं

पहले, हम एजेंट बनाते हैं। tools सरणी में परिभाषित एजेंट टूलसेट पर ध्यान दें — यह बंडल किया गया टूलसेट है:

import anthropic

client = anthropic. Anthropic()

agent = client. beta. agents. create( name="Line Counter", model="claude-opus-4-8", system="You are a helpful agent that completes small file tasks. ", tools=[ {"type": "agent_toolset_20260401", "default_config": {"enabled": True}} ], )

याद रखें: एजेंट पुन: उपयोग योग्य है। इसे एक बार बनाएं और कई सेशन्स में चलाएं।

चरण 2: वातावरण बनाएं

अगला, वातावरण। यह कंटेनर टेम्पलेट को स्पिन करता है — क्लाउड, अप्रतिबंधित नेटवर्किंग के साथ। यह सैंडबॉक्स है जहां फाइल वास्तव में लिखी जाती है:

environment = client. beta. environments. create( name="line-counter-env", config={ "type": "cloud", "networking": {"type": "unrestricted"}, }, )

चरण 3: सेशन बनाएं

फिर हम अपने एजेंट और वातावरण के साथ एक सेशन बनाते हैं, साथ ही एक वैकल्पिक शीर्षक। सेशन काम की इकाई है:

session = client. beta. sessions. create( agent=agent. id, environment_id=environment. id, title="Count lines demo", )

चरण 4: स्ट्रीम खोलें, फिर किकऑफ भेजें

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

with client. beta. sessions. events. stream(session_id=session. id) as stream:

client. beta. sessions. events. send( session_id=session. id, events=[ { "type": "user. message", "content": [ { "type": "text", "text": "Create a file in the temp directory, " "count its lines, and report back. ", } ], } ], )

ध्यान दें कि यह events है — बहुवचन। इवेंट्स इस API में सब कुछ कैसे बहते हैं।

चरण 5: स्ट्रीम का उपभोग करें

अंत में, हम स्ट्रीम का उपभोग करते हैं। इस डेमो के लिए तीन इवेंट प्रकार महत्वपूर्ण हैं:

• agent. message — Claude का पाठ
• agent. tool_use — Claude ने कौन सा टूल चुना
• session. status_idle — एजेंट पूरा हो गया

for event in stream: if event. type == "agent. message": for block in event. content: if block. type == "text": print(block. text, end="", flush=True) elif event. type == "agent. tool_use": print(f"\n[tool] {event. name}") elif event. type == "session. status_idle": print("\n--- Agent done ---") break

इसे चलाएं, और आउटपुट एजेंट है जो जोर से सोच रहा है — वास्तविक पाठ, जो टूल्स यह चुनता है, और एक अंतिम उत्तर। यह सब Anthropic के कंटेनर के अंदर चल रहा है, आपके नहीं:

प्रबंधित एजेंट रन का टर्मिनल आउटपुट: एजेंट, वातावरण, और सेशन IDs बनाए जाते हैं, फिर इवेंट स्ट्रीम एजेंट को फाइल लिखते हुए, अपने टूल्स चलाते हुए, और रिपोर्ट करते हुए दिखाती है कि फाइल में 3 लाइनें हैं

ट्रेड-ऑफ

आमतौर पर एजेंट्स के साथ, हमारे पास अपना स्वयं का लूप होता है जहां हमें सब कुछ नियंत्रित करना होता है। प्रबंधित एजेंट्स के साथ, आप उस लूप, सैंडबॉक्स, और पुनरारंभ क्षमता को डेलीगेट करते हैं — और बस इवेंट स्ट्रीम का उपभोग करते हैं जैसे यह आता है।

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

एक प्रबंधित एजेंट द्वारा संचालित एक फाइलशेयर क्लीनअप वेब ऐप, जो फोल्डर ट्री को व्यवस्थित किए जाने के साथ-साथ एजेंट की इवेंट्स का एक लाइव गतिविधि फीड दिखाता है जैसे यह फाइलों को स्थानांतरित और संग्रहीत करता है

सारांश

• प्रबंधित एजेंट्स एजेंट लूप हैं, आपके लिए चलाए जाते हैं — आपके सर्वर के बजाय Anthropic के इंफ्रास्ट्रक्चर पर।
• प्रवाह है: एक एजेंट बनाएं, एक वातावरण बनाएं, एक सेशन बनाएं, इवेंट्स में भेजें, और इवेंट्स बाहर स्ट्रीम करें।
• एजेंट (मॉडल, सिस्टम प्रॉम्प्ट, टूलसेट) रन्स में पुन: उपयोग योग्य है; सेशन एक एकल रन है; इवेंट्स यह है कि सब कुछ कैसे बहता है।
• अपने किकऑफ संदेश भेजने से पहले इवेंट स्ट्रीम खोलें — यह केवल उन इवेंट्स को डिलीवर करती है जो इसके खुलने के बाद होती हैं।
• तीन इवेंट्स देखें: agent. message (पाठ), agent. tool_use (टूल पिक्स), और session. status_idle (पूरा)।
• प्रबंधित एजेंट्स तक पहुंचें जब लूप बहुत लंबे समय तक चलेगा, बहुत अधिक करेगा, या एक हिचकी से बचना होगा। एक मैनुअल लूप तक पहुंचें जब आप पूर्ण नियंत्रण चाहते हैं।