Claude Fable 5.1 precise tool use, मज़बूत प्लानिंग और लॉन्ग-कॉन्टेक्स्ट रीज़निंग को एक साथ लाकर AI एजेंट डेवलपमेंट का नया स्तर तय करता है, ताकि आप ऐसे ऑटोनॉमस सिस्टम बना सकें जो सचमुच काम करें। यह आर्टिकल आर्किटेक्चर को समझाता है, दिखाता है कि मॉडल को कैसे जोड़ें, और उन असली पैटर्न को देखता है जो एजेंट को प्रोडक्शन के लिए तैयार बनाते हैं।
अगर आप ऐसे मॉडल का इंतज़ार कर रहे थे जो मल्टी-स्टेप एजेंट लूप को तीसरे tool call पर बिखरे बिना सँभाल सके, तो Claude Fable 5.1 आपके ध्यान देने लायक है। Anthropic ने Fable को खास तौर पर एजेंटिक वर्कलोड के लिए बनाया है, और 5.1 वर्ज़न इस फ़ोकस को और कसता है: तेज़ tool-call रिज़ॉल्यूशन, लंबे कॉन्टेक्स्ट में मज़बूत इंस्ट्रक्शन पालन, और उल्लेखनीय रूप से कम हैलुसिनेटेड फ़ंक्शन कॉल। नतीजा यह है कि मॉडल चैटबॉट से ज़्यादा इन्फ़्रास्ट्रक्चर की तरह बर्ताव करता है, और प्रोडक्शन एजेंट सिस्टम को ठीक यही चाहिए।
ज़्यादातर LLM सवालों के जवाब दे सकते हैं। बहुत कम ऐसे हैं जो टूल कॉल्स का क्रम भरोसे के साथ चला सकें, अपने आउटपुट की जाँच कर सकें, कुछ गलत होने पर पीछे लौट सकें, और बिना इंसानी धक्के के काम पूरा कर सकें। यही वह अंतर है जिसे Fable भरता है।
Anthropic ने Claude Fable 5 को इन बातों पर ख़ास ज़ोर देकर ट्रेन किया है:
Claude Sonnet 5 प्रति टोकन तेज़ और सस्ता है। एजेंटिक काम के लिए यह अंतर ख़ास है: Sonnet छोटे, साफ़ परिभाषित कामों और सरल टूल स्कीमा में अच्छा चलता है। Fable उन परिस्थितियों के लिए बना है जहाँ एजेंट को तीन स्टेप आगे की योजना बनानी हो, एक साथ दस टूल मेमोरी में रखने हों, और यह तय करना हो कि कौन-सा टूल छोड़ना है।
💡 Sonnet की जगह Fable कब चुनें: अगर आपका एजेंट लूप 5 से ज़्यादा स्टेप चलाता है या 6 से ज़्यादा टूल इस्तेमाल करता है, तो Fable की इंस्ट्रक्शन-फ़ॉलोइंग की बढ़त नापने योग्य रूप से फ़ायदेमंद होती है। सिंगल-कॉल वाले सरल ऑटोमेशन के लिए Claude Sonnet 4.6 किफ़ायती विकल्प है।
| क्षमता | Claude Fable 5.1 | सामान्य चैट LLM |
|---|---|---|
| Parallel tool calls | हाँ, स्ट्रक्चर्ड आउटपुट के साथ | असंगत |
| Error recovery | बिल्ट-इन retry लॉजिक | मैन्युअल प्रॉम्प्ट इंजीनियरिंग की ज़रूरत |
| लंबे कॉन्टेक्स्ट में इंस्ट्रक्शन पालन | 128k टोकन पर स्थिर | लगभग 20k के बाद गिरावट |
ये फ़र्क मार्केटिंग के दावे नहीं हैं। ये असली वर्कलोड पर टूटे एजेंट लूप में नापने योग्य कमी, कम गलत टूल कॉल्स और छोटे डीबगिंग सेशन के रूप में दिखते हैं।
भरोसेमंद एजेंट बनाना दिखने से ज़्यादा कठिन है। विफलताएँ तीन समस्याओं के इर्द-गिर्द जमा होती हैं: मॉडल अपनी योजना का ट्रैक खो देता है, गलत पैरामीटर के साथ टूल कॉल करता है, और टूल फ़ेल होने पर दोहराव वाले लूप में फँस जाता है। ये प्रॉम्प्ट इंजीनियरिंग की समस्याएँ नहीं हैं। ये मॉडल की क्षमता की समस्याएँ हैं।
एजेंट को यह सोचना पड़ता है कि उसे क्या हासिल करना है, उसे अलग-अलग टूल कॉल में तोड़ना है, और नतीजे आने पर अपनी योजना अपडेट करनी है। यह दबाव में काम करने वाली वर्किंग मेमोरी का एक रूप है। ज़्यादातर मॉडल यहीं कमज़ोर पड़ते हैं, क्योंकि उन्हें मुख्य रूप से सवाल-जवाब के जोड़ों पर ट्रेन किया गया था, न कि बार-बार दोहराए जाने वाले टास्क निष्पादन पर।
Claude Fable 5 को सिंथेटिक और असली एजेंटिक ट्रैजेक्टरी पर ट्रेन किया गया था, यानी इसने ऐसी हज़ारों मिसालें देखी हैं जहाँ बीच निष्पादन में योजना बदलनी पड़ी। यह अनुभव लंबे टास्क होराइज़न पर उल्लेखनीय रूप से ज़्यादा स्थिर प्लानिंग में दिखता है। जो प्लान दूसरे मॉडलों में स्टेप 7 पर बिखर जाते हैं, वे Fable में अक्सर स्टेप 15 तक टिके रहते हैं।
हर एजेंटिक फ़्रेमवर्क इस बात पर निर्भर करता है कि मॉडल वैध टूल कॉल बनाए। एक भी गलत JSON ऑब्जेक्ट पूरे लूप को तोड़ देता है। Fable साफ़ स्ट्रक्चर्ड आउटपुट ऐसी दर पर देता है जो अपने से दोगुने आकार के मॉडलों से मुकाबला करती है। व्यवहार में इसका मतलब है:
प्रोडक्शन में ये बचत तेज़ी से बढ़ती जाती है। जो एजेंट रोज़ 50 टास्क चलाता है और हर टास्क में 10 स्टेप होते हैं, उसे पहली कोशिश वाली टूल कॉल की सटीकता में 5% सुधार से भारी फ़ायदा होता है।
लंबे कॉन्टेक्स्ट वाले LLM की एक शर्मनाक छिपी सच्चाई यह है कि कॉन्टेक्स्ट विंडो भरने के साथ इंस्ट्रक्शन का पालन घटता है। जो मॉडल टोकन 0 पर 20-टूल स्कीमा को पूरी तरह मानता है, वह टोकन 50,000 तक आते-आते टूल के नाम हैलुसिनेट करने लग सकता है। Fable की ट्रेनिंग में खास तौर पर इस गिरावट को निशाना बनाया गया, ताकि पूरी 128k कॉन्टेक्स्ट विंडो में उसका पालन ऊँचा रहे।
Claude Fable 5 सीधे PicassoIA पर उपलब्ध है, यानी आप API keys सेट किए बिना और अलग बिलिंग संभाले बिना अपने एजेंट प्रॉम्प्ट आज़मा सकते हैं। सीधा रास्ता यह है:
PicassoIA पर Claude Fable 5 पेज पर जाएँ और मॉडल चुनें। आपको एक साफ़ इंटरफ़ेस मिलेगा जिसमें पूरी कॉन्टेक्स्ट विंडो तुरंत उपलब्ध होगी।
एजेंट के सिस्टम प्रॉम्प्ट चैट प्रॉम्प्ट से अलग होते हैं। उन्हें साफ़ बताना होता है कि लक्ष्य क्या है, कौन-से टूल उपलब्ध हैं, आउटपुट का फ़ॉर्मेट क्या होना चाहिए, और रुकने की शर्त क्या है। एक न्यूनतम लेकिन असरदार ढाँचा कुछ ऐसा दिखता है:
You are an autonomous research agent.
Your goal: [TASK]
Tools available: [TOOL LIST WITH SCHEMAS]
Rules:
1. Call one tool at a time.
2. After each result, check whether the goal is met.
3. Stop when you have a final answer.
Output format: JSON with keys "status" and "result".
यहाँ विशिष्टता ऐच्छिक नहीं है। Fable सबसे अच्छा तब चलता है जब सिस्टम प्रॉम्प्ट उसे एक सक्षम लेकिन शब्दश: पालन करने वाले निष्पादक की तरह ले, बातचीत करने वाले साथी की तरह नहीं।
PicassoIA पर अपना एजेंट चलाने से पहले ये चीज़ें एडजस्ट करें:
न्यूनतम एजेंट लूप में चार हिस्से होते हैं: एक सिस्टम प्रॉम्प्ट, टूल डेफ़िनिशन का सेट, एक एक्ज़ीक्यूशन लूप, और एक रुकने की शर्त। हर हिस्सा क्या करता है और क्यों ज़रूरी है, यह नीचे है।
Anthropic SDK के साथ Python में बनाया जा सकने वाला सबसे सरल एजेंट कुछ ऐसा दिखता है:
import anthropic
client = anthropic.Anthropic()
tools = [
{
"name": "search_web",
"description": "Search the internet for current information",
"input_schema": {
"type": "object",
"properties": {
"query": {"type": "string", "description": "The search query"}
},
"required": ["query"]
}
}
]
messages = [{"role": "user", "content": "Find the current price of gold."}]
while True:
response = client.messages.create(
model="claude-fable-5-20250801",
max_tokens=1024,
tools=tools,
messages=messages
)
if response.stop_reason == "end_turn":
print(response.content[0].text)
break
for block in response.content:
if block.type == "tool_use":
result = execute_tool(block.name, block.input)
messages.append({"role": "assistant", "content": response.content})
messages.append({"role": "user", "content": [{
"type": "tool_result",
"tool_use_id": block.id,
"content": result
}]})
यह लूप तब तक चलता रहता है जब तक मॉडल stop_reason = "end_turn" नहीं बनाता, जो संकेत देता है कि उसने टास्क पूरा कर लिया है। बाकी सब हिसाब-किताब है।
बिना मेमोरी वाले एजेंट काम दोहराते हैं। दो आम पैटर्न ये हैं:
इन-कॉन्टेक्स्ट मेमोरी: हर टर्न पर पूरे हो चुके स्टेप्स का चलता सारांश सिस्टम प्रॉम्प्ट में जोड़ें। 15 स्टेप से कम वाले टास्क के लिए अच्छा काम करता है। इसकी कीमत टोकन लागत है, क्योंकि हर स्टेप के साथ सारांश बढ़ता है।
बाहरी मेमोरी: पूरे हो चुके स्टेप्स को डेटाबेस में लिखें और एक read_memory टूल के ज़रिए प्रासंगिक स्टेप वापस लाएँ। यह किसी भी लंबाई के टास्क तक स्केल होती है। इसकी कीमत आपके टूल इम्प्लीमेंटेशन में बढ़ी हुई जटिलता है।
ज़्यादातर ऐप्लिकेशन के लिए इन-कॉन्टेक्स्ट मेमोरी से शुरू करें, और बाहरी मेमोरी पर तभी जाएँ जब कॉन्टेक्स्ट की लागत बजट की समस्या बन जाए। बाहरी मेमोरी का इंफ़्रास्ट्रक्चर तभी बनाएँ जब उसकी सच में ज़रूरत हो।
Anthropic SDK में टूल एक JSON स्कीमा होता है जिसके साथ एक Python फ़ंक्शन जुड़ा होता है। मॉडल तय करता है कि उसे कब कॉल करना है; आपका कोड तय करता है कि वह क्या करेगा। प्रोडक्शन एजेंट के लिए आम टूल ये हैं:
इन सबका पैटर्न एक ही है: स्कीमा परिभाषित करें, फ़ंक्शन लागू करें, और अपने एक्ज़ीक्यूशन लूप में टूल के नाम को फ़ंक्शन से जोड़ें। कौन-सा टूल कब कॉल करना है, इसका फ़ैसला Fable संभालता है।
डेमो में चलने वाले टॉय एजेंट और प्रोडक्शन में भरोसे से चलने वाले एजेंट के बीच का फ़ासला ज़्यादातर एज केस हैंडलिंग का है। ये वे पैटर्न हैं जो यह फ़ासला पाटते हैं।
रिसर्च एजेंट एक सवाल लेता है, जानकारी खोजता है, नतीजों को जोड़ता है और एक स्ट्रक्चर्ड रिपोर्ट बनाता है। आर्किटेक्चर यह है:
Claude Fable 5 प्लानिंग और सिंथेसिस में खास तौर पर अच्छा है। ज़्यादा मात्रा वाले सर्च लूप के लिए, गुणवत्ता खोए बिना लागत घटाने के लिए अलग-अलग सर्च Claude 4.5 Sonnet पर भेजें।
💡 लागत अनुकूलन: प्लानिंग और सिंथेसिस के लिए Fable इस्तेमाल करें। अलग-अलग सर्च कॉल के लिए तेज़ और सस्ता मॉडल इस्तेमाल करें। यह हाइब्रिड पैटर्न रिसर्च वर्कलोड पर लागत 40-60% घटाता है, बिना किसी नापने योग्य गुणवत्ता की हानि के।
कोड एजेंट एक स्पेसिफ़िकेशन लेता है, कोड लिखता है, उसे सैंडबॉक्स में चलाता है, एरर ठीक करता है और काम करने वाला आउटपुट लौटाता है। मुख्य चुनौती यह है कि एजेंट को अपना कोड सुधारने के लिए एक्ज़ीक्यूशन एरर आउटपुट देखना पड़ता है। इसके लिए एक ऐसा सैंडबॉक्स्ड एक्ज़ीक्यूशन टूल चाहिए जो stdout और stderr दोनों कैप्चर करे और उन्हें टूल नतीजों के रूप में वापस दे।
जटिल कोड जनरेशन के लिए, जहाँ पहली कोशिश में सटीकता गति से ज़्यादा मायने रखती है, Claude Opus 4.7 पर विचार करने लायक है। बार-बार फ़िक्स-और-रन चक्रों के लिए Fable का सेल्फ़-करेक्शन व्यवहार ज़्यादा व्यावहारिक फ़िट है।
जब एक ही एजेंट लूप बहुत लंबा या बहुत व्यापक हो जाए, तो उसे विशेषज्ञ सब-एजेंट्स में बाँट दें:
यह आर्किटेक्चर स्वाभाविक रूप से स्केल होता है। हर सब-एजेंट अपना लूप स्वतंत्र रूप से चलाता है। ऑर्केस्ट्रेटर नतीजों का इंतज़ार करता है और उन्हें अगले स्टेज पर भेजता है। एक सब-एजेंट की विफलता पूरी पाइपलाइन को नहीं गिराती।
हर LLM एजेंटिक इस्तेमाल के लिए नहीं बना है। यहाँ देखें कि Claude Fable 5 PicassoIA पर उपलब्ध विकल्पों के मुकाबले कैसा ठहरता है।
GPT 5 रीज़निंग में बेहद सक्षम है और ठोस टूल कॉल बनाता है। व्यावहारिक फ़र्क लंबे कॉन्टेक्स्ट में पालन और एरर रिकवरी में दिखता है। Fable को एजेंटिक ट्रैजेक्टरी पर खास तौर पर ट्रेन किया गया था; GPT 5 एक जनरलिस्ट मॉडल है जिसका एजेंटिक प्रदर्शन मजबूत है। 10 से ज़्यादा स्टेप वाले एंटरप्राइज़ एजेंट वर्कलोड के लिए, Fable की विशेष ट्रेनिंग उसे विश्वसनीयता में बढ़त देती है।
DeepSeek R1 एक चेन-ऑफ़-थॉट रीज़निंग मॉडल है जो गणित, तर्क और स्टेप-दर-स्टेप समस्या हल करने में उत्कृष्ट है। ऐसे एजेंट वर्कलोड के लिए, जो मुख्य रूप से रीज़निंग-भारी हों और बाहरी टूल कॉल कम हों, R1 आज़माने लायक है। जब एजेंट को 5 या ज़्यादा बाहरी टूल कॉल करने और उनके नतीजे भरोसे से संभालने हों, तब Fable की टूल-यूज़ ट्रेनिंग बेहतर विकल्प है।
Kimi K2.6 खुद को एजेंट-फ़र्स्ट मॉडल के रूप में पेश करता है और एजेंटिक बेंचमार्क पर मजबूत प्रदर्शन दिखाता है। यह Fable का एक वास्तविक विकल्प है, खासकर उन उपयोगकर्ताओं के लिए जो अपने खास टास्क पर व्यवहार की तुलना करना चाहते हैं। दोनों मॉडल PicassoIA पर उपलब्ध हैं, इसलिए एक ही वर्कलोड पर इन्हें साथ-साथ चलाना आसान है।
| मॉडल | एजेंटिक फ़ोकस | टूल-कॉल विश्वसनीयता | लागत टियर |
|---|---|---|---|
| Claude Fable 5.1 | बहुत ज़्यादा | उत्कृष्ट | मध्यम |
| GPT 5 | ज़्यादा | बहुत अच्छी | मध्यम-ऊँची |
| DeepSeek R1 | मध्यम | अच्छी | कम |
| Kimi K2.6 | बहुत ज़्यादा | बहुत अच्छी | मध्यम |
ज़्यादातर एजेंट विफलताएँ फ़ैसलों की एक छोटी-सी सूची तक पहुँचती हैं।
नए एजेंट बिल्डर्स 1,500 शब्दों के सिस्टम प्रॉम्प्ट लिखते हैं, जिनमें जटिल शर्तें और प्राथमिकता-क्रम भरे होते हैं। Fable को इसकी ज़रूरत नहीं है। साफ़ टूल डेफ़िनिशन वाला 200 शब्दों का कसा हुआ सिस्टम प्रॉम्प्ट लगातार फूले हुए प्रॉम्प्ट से बेहतर प्रदर्शन करता है। सिस्टम प्रॉम्प्ट में ज़्यादा शब्द होने से मॉडल के गलत समय पर गलत निर्देश पर ध्यान देने की संभावना बढ़ जाती है।
20 स्टेप चलाने वाला और 128k कॉन्टेक्स्ट विंडो वाला एजेंट API क्रेडिट में प्रति रन $0.50 से $2.00 तक खर्च कर सकता है। प्रोडक्शन में यह जल्दी जुड़ जाता है। अपने एजेंट लूप को शुरुआत में ही प्रोफ़ाइल करें, पहचानें कि कौन-से स्टेप सबसे ज़्यादा टोकन खाते हैं, और जहाँ टास्क इजाज़त दे वहाँ महँगी कॉल्स की जगह सस्ती मॉडल कॉल्स लगाएँ। Claude 4.5 Haiku उन हल्के इंटरमीडिएट स्टेप्स के लिए अच्छा विकल्प है जहाँ ऊँची क्षमता की ज़रूरत नहीं होती।
स्पष्ट रुकने की शर्त के बिना एजेंट अनिश्चित काल तक लूप करते रहते हैं या टोकन लिमिट तक पहुँच जाते हैं। अपने सिस्टम प्रॉम्प्ट में हमेशा तीन चीज़ें परिभाषित करें: सफलता कैसी दिखती है, विफलता कैसी दिखती है, और स्टेप की अधिकतम संख्या क्या है। फिर मॉडल से स्वतंत्र, ऐप्लिकेशन लेवल पर स्टेप सीमा को सुरक्षा जाल की तरह लागू करें।
जब कोई एजेंट गलत नतीजे देता है, तो निदान लगभग हमेशा चार कारणों में से किसी एक की ओर इशारा करता है।
सिस्टम प्रॉम्प्ट अस्पष्ट है: प्रॉम्प्ट में ही सही व्यवहार का एक ठोस उदाहरण जोड़ें। Fable इन-प्रॉम्प्ट उदाहरणों पर अच्छी प्रतिक्रिया देता है, जिनमें बिल्कुल दिखाया गया हो कि आउटपुट कैसा दिखना चाहिए।
टूल स्कीमा अधूरा है: इनपुट फ़ील्ड पर विवरण न होने से Fable पैरामीटर के अर्थ का अनुमान लगाने लगता है। हर टूल स्कीमा के हर फ़ील्ड में साफ़ और खास विवरण होना चाहिए।
कॉन्टेक्स्ट बहुत लंबा है: अगर आपका एजेंट 20 या ज़्यादा स्टेप चलाता है, तो पहले के निर्देश कमज़ोर पड़ जाते हैं। हर 10 स्टेप पर बातचीत के इतिहास का सारांश बनाएँ और उसे संक्षिप्त करें, ताकि प्रभावी कॉन्टेक्स्ट लंबाई रीसेट हो और मॉडल का ध्यान उन बातों पर रहे जो मायने रखती हैं।
टूल आउटपुट संरचित नहीं है: कच्चा HTML, बड़े JSON ब्लॉब या बाइनरी आउटपुट, जिन्हें मॉडल को पार्स करना पड़े, सब कुछ धीमा करता है और गलतियाँ लाता है। टूल आउटपुट को पहले से प्रोसेस करें, ताकि वह केवल वही लौटाए जो एजेंट को चाहिए, और जहाँ संभव हो सादे टेक्स्ट में।
डीबगिंग के लिए हर टूल कॉल और उसके नतीजे का लॉग रखना अनिवार्य है। उस लॉग के बिना विफलताओं का निदान सिर्फ़ अनुमान है।
किसी एजेंट को असली यूज़र के सामने रखने या असली डेटा से जोड़ने से पहले, इस सूची से गुज़रें:
आखिरी बिंदु अक्सर छूट जाता है। सिर्फ़ इसलिए कि Fable भरोसेमंद टूल कॉल बनाता है, इसका मतलब यह नहीं कि टूल के आउटपुट हमेशा मान्य हों। एजेंट के उन पर कार्य करने से पहले बाहरी टूल से लौटे हर डेटा की जाँच करें। पुराना डेटा या गलत फ़ॉर्मेट वाला जवाब ऐसी कैस्केडिंग विफलताएँ ला सकता है, जिन्हें उचित लॉगिंग के बिना ट्रेस करना मुश्किल होता है।
Claude Fable 5 को अपने खास इस्तेमाल के लिए परखने का सबसे तेज़ रास्ता है उसे किसी असली टास्क पर चलाना। PicassoIA आपको Fable के साथ दर्जनों दूसरे LLM का सीधा एक्सेस देता है, जिनमें GPT 5, Kimi K2.6, DeepSeek R1, Gemini 3 Pro और Grok 4 शामिल हैं, सब एक ही इंटरफ़ेस से, बिना अलग-अलग API सब्सक्रिप्शन संभाले।
एक ही टूल वाले 3-स्टेप एजेंट से शुरुआत करें। उसका टोकन उपयोग प्रोफ़ाइल करें। अपने असली वर्कलोड पर Fable के आउटपुट की गुणवत्ता की तुलना विकल्पों से करें। असली टास्क से जुटाया गया मॉडल तुलना डेटा किसी भी बेंचमार्क स्कोर से कहीं ज़्यादा काम का होगा।
पूरी मॉडल सूची देखने और आज ही Claude Fable 5.1 के साथ बनाना शुरू करने के लिए picassoia.com/en/all-models पर जाएँ।
अपनी भाषा चुनें
