एक एजेंट वास्तव में क्या है

आपने API कॉल किए हैं, लेकिन एक एकल कॉल केवल एक प्रतिक्रिया देता है। यदि आप एक वर्कफ़्लो को स्वचालित करना चाहते हैं, तो Claude को कार्य करने, परिणाम देखने, अगला निर्णय लेने और आगे बढ़ने की आवश्यकता है। यह पैटर्न वह है जिसे लोग agentic workflows के बारे में बात करते हैं।

एक एजेंट वास्तव में क्या है

एक agent Claude का एक स्वायत्त संस्करण है, जो बीच में कोई मानव के बिना मैसेजिंग लूप के दोनों पक्षों को चलाता है। एक एजेंट एक कार्य प्राप्त करता है, एक टूल चुनता है, और तब तक कोड को लूप में निष्पादित करता है जब तक Claude यह तय न कर ले कि कार्य पूरा हो गया है।

एजेंट लूप को लागू करने का सबसे आसान तरीका इस तरह दिखता है:

• उपलब्ध टूल के साथ Claude को एक संदेश भेजें।
• Claude या तो एक अंतिम उत्तर के साथ या आपके द्वारा परिभाषित एक टूल का उपयोग करने के लिए एक अनुरोध के साथ प्रतिक्रिया देता है।
• आपका कोड उस टूल को निष्पादित करता है।
• आप परिणाम को Claude को वापस भेजते हैं।
• तब तक दोहराएं जब तक stop reason end_turn न हो।

इसे एक बातचीत के रूप में सोचें जहां बारी-बारी से होता है: उपयोगकर्ता शुरुआत करता है, एजेंट एक टूल कॉल करता है, टूल एक परिणाम देता है, और एजेंट तब तक आगे बढ़ता है जब तक इसके पास एक उत्तर न हो।

एक न्यूनतम कार्यशील उदाहरण

इस लूप को अंत तक चलाने के लिए बिना डेटाबेस या UI को खींचे, हम get_weather नामक एक नकली टूल को वायर करेंगे और Claude से पूछेंगे कि आज Austin में क्या पहनें। Claude के पास अपने आप से मौसम जानने का कोई तरीका नहीं है, इसलिए इसे टूल को कॉल करना होगा, परिणाम पढ़ना होगा, और फिर आपको एक उत्तर देना होगा।

यहाँ पूरी स्क्रिप्ट है:

import anthropic

client = anthropic. Anthropic()

tools = [ { "name": "get_weather", "description": "Get the current weather for a city. ", "input_schema": { "type": "object", "properties": { "city": { "type": "string", "description": "The city to get weather for", } }, "required": ["city"], }, } ]

def run_tool(name, tool_input): if name == "get_weather": return f"Weather in {tool_input['city']}: 95F, sunny" raise ValueError(f"Unknown tool: {name}")

messages = [ {"role": "user", "content": "What should I wear in Austin today? "} ]

while True: response = client. messages. create( model="claude-sonnet-4-6", max_tokens=1024, tools=tools, messages=messages, )

if response. stop_reason == "end_turn":

for block in response. content: if block. type == "text": print(block. text) break

if response. stop_reason == "tool_use":

tool_results = [] for block in response. content: if block. type == "tool_use": result = run_tool(block. name, block. input) tool_results. append( { "type": "tool_result", "tool_use_id": block. id, "content": result, } )

messages. append({"role": "assistant", "content": response. content}) messages. append({"role": "user", "content": tool_results})

ध्यान देने के लिए तीन बातें:

• tools array Claude को बताता है कि क्या उपलब्ध है: एक नाम, एक विवरण, और इनपुट के लिए एक JSON स्कीमा।
• run_tool केवल एक hardcoded lookup है। एक वास्तविक ऐप में, यह आपके डेटाबेस, एक API, आदि को हिट करेगा।
• loop एजेंट लूप है। प्रत्येक पुनरावृत्ति संदेशों को Claude को भेजता है और प्रतिक्रिया के stop reason पर स्विच करता है। end_turn पर, Claude पूरा हो गया है — अंतिम पाठ प्रिंट करें और तोड़ें। tool_use पर, tool use blocks खोजें, प्रत्येक को चलाएं, सहायक की प्रतिक्रिया और आपके tool results को messages में वापस डालें, और लूप करें ताकि Claude जवाब दे सके।

इसे चलाना

जब आप स्क्रिप्ट चलाते हैं, तो आप दो बारी देखेंगे:

• Turn one: stop reason tool_use है। Claude Austin के लिए get_weather का अनुरोध करता है, और आपका कोड तापमान और स्थितियां देता है।
• Turn two: stop reason end_turn है, और Claude आपको कुछ हल्का और सांस लेने योग्य पहनने के लिए कहता है।

एजेंट लूप का टर्मिनल आउटपुट: turn 1 tool_use के साथ रुकता है और Austin के लिए get_weather कॉल करता है, फिर turn 2 end_turn के साथ रुकता है और Claude अपनी अंतिम कपड़ों की सिफारिशें प्रिंट करता है

दो API कॉल, एक tool निष्पादन, एक अंतिम उत्तर। यह पूरा लूप है। Claude API के साथ जो कुछ भी आप बनाते हैं वह इसके समान होगा।

उत्पादन में समान लूप

एक वास्तविक वातावरण में, यह समान लूप कुछ जैसे एक auto-review endpoint को शक्ति देता है: एक compliance agent जो एक संरचनात्मक रिपोर्ट पढ़ता है, एक टूल के माध्यम से प्रासंगिक building codes को देखता है, और जैसे-जैसे यह काम करता है, जोखिम निष्कर्षों को डेटाबेस में वापस लिखता है।

एक compliance review dashboard जो अपलोड की गई संरचनात्मक रिपोर्ट सूचीबद्ध करता है, प्रत्येक के साथ एक Run auto-review बटन जो एजेंट को शुरू करता है

लूप का आकार वह है जो आपने अभी चलाया है। अंतर ये हैं:

• नकली मौसम lookup के बजाय वास्तविक tools।
• परिणाम server-sent events के रूप में UI में वापस आते हैं।
• निष्कर्ष एक risk-finding table में persist होते हैं।

एक चलते हुए compliance agent का review trace: building-code library को खोजने और लूप के पुनरावृत्ति के रूप में विशिष्ट code sections को देखने के लिए दर्जनों tool कॉल

सारांश

• एक agent Claude in a loop है: observe, decide, act, repeat।
• लूप सरल है: tools के साथ संदेश भेजें, कोई भी tool चलाएं जो Claude अनुरोध करता है, परिणाम को वापस फीड करें, और तब रुकें जब stop reason end_turn हो।
• आप लूप और tools के मालिक हैं। Claude reasoning का मालिक है।
• समान लूप आकार एक नकली मौसम demo से एक production compliance agent तक स्केल करता है — केवल tools और plumbing बदलते हैं।
• जब आप लूप के मालिक नहीं होना चाहते हैं, तो managed agents Anthropic के infrastructure पर आपके लिए इस सटीक लूप को चलाते हैं।