GPT-5.6 और Fable 5 के साथ एक AI एजेंट स्टैक बनाएं

फेबल 5 + GPT-5.6: एजेंट स्टैक का A से Z निर्माण जो आपके सोते समय शिप करता है

यह पूर्ण निर्माण है, क्रम से, प्रत्येक भाग के बाद एक चेकपॉइंट के साथ।

इन 12 निर्माणों को भूलने से पहले बुकमार्क कर लें।

परिचय

आपके पास अब तक के दो सबसे सक्षम मॉडल सामान्य रूप से उपलब्ध हैं, और फिर भी आप उनमें से एक का उपयोग एक बार में, हाथ से कर रहे हैं।

पिछले महीने में तीन चीजें बदल गईं।

क्लॉड फेबल 5 चरणों के बीच योजना बनाता है, अपने स्वयं के उप-एजेंट भेजता है, और अपने स्वयं के आउटपुट की पुष्टि करता है। $10 प्रति मिलियन टोकन इनपुट, $50 आउटपुट।
GPT-5.6 9 जुलाई को शिप हुआ तीन स्थायी स्तरों के रूप में। सोल $5 और $30 पर, टेरा सोल के आधे मूल्य पर, लूना $1 और $6 पर। OpenAI अब रूटिंग निर्णय को ही उत्पाद के रूप में बेचता है।
फेबल 5 ने जून के 19 दिन एक निर्यात आदेश के तहत निलंबित बिताए। उपलब्धता अब एक ऐसी चीज है जो आपके साथ घटित होती है।

सामान्य रूप से चलाए जाने पर, ये मॉडल प्रभावशाली गलत चीजें उत्पन्न करने का एक महंगा तरीका हैं।

एक सिस्टम के अंदर चलाए जाने पर, वे एक कर्मचारी के सबसे करीबी चीज हैं जिसे आप किराए पर ले सकते हैं। Anthropic के एंटरप्राइज़ आंकड़े Claude Code को प्रति सक्रिय दिन प्रति डेवलपर लगभग $13 पर रखते हैं। OpenAI Codex को $100 से $200 प्रति माह पर रखता है।

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

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

इसे क्रम में पढ़ें, जाँच करते हुए। प्रत्येक निर्माण में 10 से 20 मिनट लगते हैं, कुल मिलाकर लगभग दो घंटे। अंत में 30 दिन वह शेड्यूल है जिसके दौरान सिस्टम आपके बिना चलने का अधिकार अर्जित करता है।

तीन सिद्धांत नीचे दिए गए प्रत्येक डिज़ाइन निर्णय की भविष्यवाणी करते हैं:

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

मानचित्र, और सामान्य वाला गलत क्यों है

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

मानक चित्र swyx का Loopcraft स्टैक है: पांच लूप एक दूसरे के अंदर नेस्टेड, निष्पादन टास्क के अंदर प्रोडक्ट के अंदर सिस्टम के अंदर निगरानी के अंदर, प्रत्येक का अपना निकास। यह अब तक किसी के द्वारा खींचा गया सबसे अच्छा है।

मैंने इसका हफ्तों तक उपयोग किया। फिर मैंने इसके खिलाफ निर्माण करने की कोशिश की, और यह चार जगहों पर टूट गया।

1) समस्या एक: लूप नेस्टेड नहीं होते हैं।

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

आप चार परतों को खोले बिना हाथ से एक टोकन स्ट्रीम को बाधित कर सकते हैं। यह एक कंटेनमेंट की तस्वीर है जो एक ऐसी प्रणाली पर खींची गई है जो हैंडओवर करती है।

2) समस्या दो: अंतहीन खींचा गया लूप एक बिल है।

मूल प्रोडक्ट लूप को उस तरह खींचता है। व्यवहार में यह एक बजट पर, एक चेकपॉइंट पर, या किसी के धैर्य खोने पर समाप्त होता है।

इसे "डिज़ाइन द्वारा कोई नहीं" कहना उस सटीक स्थान को छुपाता है जहां से एजेंट सिस्टम से पैसा लीक होता है: एक लूप जिसे कोई नहीं बताया गया कि कैसे छोड़ना है।

3) समस्या तीन: कोई निरस्त नहीं है।

हर परत का एक सुखद अंत होता है और कोई दुखद अंत नहीं। वास्तविक लूप को दोनों की आवश्यकता होती है: यह कैसे बंद होता है जब यह काम करता है, और यह कैसे रुकता है जब यह नहीं कर सकता।

हर भगोड़ा बिल जो मैंने देखा है, वह एक परिभाषित निकास और एक अपरिभाषित निरस्त के साथ एक लूप था।

4) समस्या चार: सत्यापन गायब है, और यह पूरा खेल है।

सत्यापन परतों के बीच का अनुबंध है। जब एक निचला लूप एक ऊपरी लूप को एक तथ्य के बजाय एक रिपोर्ट सौंपता है, तो ऊपरी लूप एक झूठ पर बंद हो जाता है।

वह एकल अंतर ही कारण है कि एक लूप अपनी रोक की स्थिति तक पहुंच सकता है और फिर भी गलत हो सकता है।

यह वह संस्करण है जिसके खिलाफ मैं निर्माण करता हूं।

साक्ष्य सीढ़ी

छह पायदान, प्रत्येक के दो निकास, और एक नियम: नियंत्रण लक्ष्यों के रूप में नीचे बहता है, साक्ष्य तथ्यों के रूप में ऊपर बहता है, और कोई भी पायदान अपने नीचे के पायदान से रिपोर्ट पर बंद नहीं हो सकता है।

आकार से पांच नियम निकलते हैं।

हर पायदान का एक निरस्त होता है, या यह एक बिल है। यदि आप यह नहीं बता सकते कि एक लूप बुरी तरह कैसे समाप्त होता है, तो आपने एक सब्सक्रिप्शन बनाया है। यही कारण है कि ralph.sh दो कैप रखता है और झुंड एक चक्र कैप रखता है।

साक्ष्य ऊपर बहता है और नियंत्रण नीचे बहता है। एक पायदान अपने नीचे उत्पादित तथ्य पर बंद होता है, अपने नीचे लिखे सारांश पर कभी नहीं।

फैक्ट्री गेट इस नियम का SQL में रूप है। दो समीक्षकों ने हरा कहा। गेट ने फिर भी मना कर दिया, क्योंकि किसी ने पासिंग टेस्ट पंक्ति नहीं बनाई थी।

एक फैसला एक राय है। एक पंक्ति साक्ष्य है।

प्रति मोड़ लागत प्रति पायदान लगभग दस गुना बढ़ जाती है।

एक बग जो पायदान 2 से बच जाता है, उसे पायदान 3 पर पकड़ने में दस गुना अधिक खर्च होता है, और पायदान 4 पर सौ गुना अधिक।

यह अपने सर्वोत्तम सत्यापन को सीढ़ी पर जितना संभव हो उतना नीचे रखने का पूरा तर्क है, यही कारण है कि गेट एक bash स्क्रिप्ट है न कि एक बैठक।

समय-सीमा मॉडल की है, पायदान की नहीं।

पायदान 2 को 2024 में मिनट लगते थे, 2026 में घंटे लगते हैं, और जल्द ही दिन लगेंगे। घड़ी के खिलाफ कभी नहीं, निकास की स्थिति के खिलाफ डिज़ाइन करें। यह वह जगह है जहां पुरानी तस्वीर सबसे तेज़ी से पुरानी होती है।

केवल पायदान 5 का कोई निकास条件 नहीं है, और इसका मतलब है कि मानव क्या है।

आप वहां रहते हैं। सीढ़ी एक वाक्य अर्जित करने के लिए मौजूद है: एक लूप अपनी रोक की स्थिति तक पहुंच सकता है और फिर भी गलत हो सकता है।

टेस्ट पास होते हैं, गेट हरा हो जाता है, दोनों समीक्षक हस्ताक्षर करते हैं, और आखिरी कमिट अभी भी एक गलती है। आपके नीचे हर पायदान उस जांच को छोटा बनाने के लिए मौजूद है। उनमें से कोई भी इसे आपसे नहीं ले सकता है।

पूर्वापेक्षाएँ

bash

1claude CLI (Claude Code) Fable 5 एक्सेस के साथ
2codex CLI GPT-5.6 एक्सेस के साथ        # या Claude Code के अंदर आधिकारिक प्लगइन
3python3, jq, git, gh, make, cron
4एक रेपो जिसमें एक टेस्ट कमांड है जो आज काम करता है
5
6# वैकल्पिक, मिश्रित फ्लीट के लिए (बिल्ड 7):
7openai/codex-plugin-cc               # आधिकारिक: Claude Code के अंदर Codex चलाएं
8claude-model-switch                  # स्थानीय प्रॉक्सी: Claude Code के पीछे कोई भी प्रदाता
9CLIProxyAPI                          # CLI सब्सक्रिप्शन को API एंडपॉइंट के रूप में लपेटें

आप क्या बना रहे हैं

markdown

1your-repo/
2  CLAUDE.md                          # बिल्ड 1: क्लॉड-साइड संविधान
3  AGENTS.md                          # बिल्ड 1: Codex-साइड संविधान
4  .claude/
5    skills/model-bench/SKILL.md      # बिल्ड 0: कीमतें, API आईडी, फॉलबैक। नंबर वाली एकमात्र फ़ाइल
6    skills/model-router/SKILL.md     # बिल्ड 4
7    skills/stuck-protocol/SKILL.md   # बिल्ड 5
8    skills/ship-gate/SKILL.md        # बिल्ड 2
9    agents/fable-expert.md           # बिल्ड 5
10    agents/fresh-eyes-reviewer.md    # बिल्ड 6
11    agents/sol-reviewer.md           # बिल्ड 6
12    agents/scout.md                  # बिल्ड 7
13  loop/
14    ralph.sh                         # बिल्ड 3: दिल की धड़कन
15    two_lane.sh                      # बिल्ड 6: क्रॉस-वेंडर समीक्षा लूप
16    PROMPT.md  TASKS.md              # बिल्ड 3: कार्य प्रोटोकॉल
17  gate/
18    verify.sh                        # बिल्ड 2: नियतात्मक अंतिम वोट
19    eval_gate.py  eval/cases.jsonl   # बिल्ड 2: रूटिंग-परिवर्तन गेट
20  router/
21    router.py                        # बिल्ड 4
22    advisor_loop.py                  # बिल्ड 5
23  ~/.codex/
24    config.toml                      # बिल्ड 0: luna/terra/sol प्रोफाइल
25    prompts/effort.md                # /effort      कार्य को स्कोर करें, सीट का नाम बताएं
26    prompts/plan-stop.md             # /plan-stop   योजना बनाएं, इसकी कीमत लगाएं, फिर रुकें
27    prompts/fable-advice.md          # /fable-advice क्रॉस-वेंडर विशेषज्ञ परामर्श
28    prompts/review-hostile.md        # /review-hostile स्वच्छ-संदर्भ फैसला
29    prompts/compost.md               # /compost     विफलताएं कानून बन जाती हैं, साप्ताहिक
30  factory/
31    factory_gate.py                  # बिल्ड 8: ब्लैकबोर्ड + पूर्णता गेट
32    factory.sh                       # बिल्ड 8: ब्रीफ -> इम्प्लीमेंट -> रिव्यू -> गेट
33    factory.db                       # बिल्ड 8: वे पंक्तियाँ जो निर्णय लेती हैं
34  swarm/
35    swarm.sh                         # बिल्ड 9: योजना -> प्रेषण -> स्कोर -> पुनर्योजना
36    goals.jsonl                      # बिल्ड 9: प्रति पंक्ति एक लक्ष्य, प्रत्येक अपनी जाँच के साथ
37  system/
38    verify_goals.py                  # बिल्ड 10: दैनिक पुनः-सत्यापन, हमेशा के लिए
39    goals/                           # बिल्ड 10: प्रति समाप्त चीज़ एक फ़ाइल
40  ROUTING.md                         # बिल्ड 12: पूर्ण रूटिंग नीति, दोनों हार्नेस
41  progress.log                       # हर बिल्ड यहां जोड़ता है
42  # वैकल्पिक (बिल्ड 7): localhost:4000 पर claude-model-switch प्रॉक्सी,
43  # CLI सब्सक्रिप्शन को API एंडपॉइंट के रूप में लपेटने के लिए CLIProxyAPI

बिल्ड 0: इंजन कॉन्फ़िगर करें

अपनी कोई भी फ़ाइल लिखने से पहले इन्हें सेट करें। प्रकाशन के सप्ताह आधिकारिक मूल्य निर्धारण पृष्ठों से प्रत्येक संख्या की पुष्टि की गई थी।

बेंच: हर सीट, जुलाई 2026

वह रोस्टर जिससे सिस्टम किराया लेता है।

कीमतें एक स्किल फ़ाइल, .claude/skills/model-bench/SKILL.md में रहती हैं, जो किसी भी रूटिंग या लागत प्रश्न से पहले मांग पर लोड की जाती है। कोई अन्य फ़ाइल किसी संख्या को हार्डकोड नहीं करती है।

यह लिखे जाने से पहले के छह हफ्तों में कीमतें तीन बार बदली गईं। एक लेख में कीमत प्रकाशन के समय गलत होती है। एक स्किल फ़ाइल में कीमत एक संपादन है।

वह विभाजन जो डाउनस्ट्रीम सब कुछ तय करता है:

फेबल 5 कठिन सॉफ्टवेयर कार्य में अग्रणी है। SWE-Bench Pro पर 80 प्रतिशत, सोल के 64.6 के मुकाबले, और यह समग्र बुद्धिमत्ता में सोल को पीछे छोड़ देता है।
सोल टर्मिनल और एजेंट कार्य में अग्रणी है। Terminal-Bench 2.1 पर 88.8 प्रतिशत, और यह लगभग फेबल की प्रति कार्य लागत के एक तिहाई पर कोडिंग-एजेंट इंडेक्स में सबसे ऊपर है।

यही विभाजन इस सिस्टम के दो-विक्रेता होने का कारण है। फेबल न्याय करता है और योजना बनाता है, सोल समीक्षा करता है और टर्मिनल चलाता है, और कोई भी बल्क टाइपिंग नहीं करता है।

दो सीटें जिन्हें लोग गलत पढ़ते हैं।

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

परिचयात्मक मूल्य पर Sonnet 5 बोर्ड पर सबसे अच्छा मूल्य है। क्षमता में Opus 4.8 के करीब, फेबल की इनपुट कीमत के एक अंश पर, यही कारण है कि यह इस बिल्ड में हर जगह डिफ़ॉल्ट निष्पादक है। यह दर 31 अगस्त को समाप्त होती है, और स्किल फ़ाइल इसे पहले से जानती है।

वह स्किल फ़ाइल सिस्टम में एकमात्र फ़ाइल है जिसमें कोई संख्या है:

markdown

1---
2name: model-bench
3description: वर्तमान मूल्य सूची, API मॉडल आईडी, और इस सिस्टम द्वारा किराए पर लिए जा सकने वाले प्रत्येक
4  मॉडल के लिए फॉलबैक श्रृंखला। किसी भी रूटिंग निर्णय, लागत अनुमान, बजट प्रश्न, मॉडल तुलना,
5  या जब उपयोगकर्ता पूछता है कि किसी चीज़ की कीमत क्या है, से पहले लोड करें।
6---
7
8# मॉडल बेंच
9
10कीमतों और API पहचानकर्ताओं के लिए एकमात्र स्रोत। इस रेपो में और कुछ भी
11कीमत को हार्डकोड नहीं करता है, इसलिए जब लैब अपनी दरें बदलते हैं तो आप इस फ़ाइल को संपादित करते हैं और
12कुछ और नहीं। 2026-07-13 को सत्यापित। कीमतें बदलती हैं। बजट बनाने से पहले पुनः सत्यापित करें।
13
14## Anthropic (Messages API, /v1/messages)
15
16Effort: output_config {"effort": "low|medium|high|xhigh|max"}। फेबल 5 के लिए
17एडेप्टिव थिंकिंग हमेशा चालू रहती है और इसे अक्षम नहीं किया जा सकता है। max_tokens सोचने के साथ-साथ
18प्रतिक्रिया टेक्स्ट को भी सीमित करता है, इसलिए इसे उच्च और उससे ऊपर बड़ा सेट करें (64k के पास से शुरू करें), अन्यथा मॉडल
19बीच में ही स्थान खत्म कर देता है।
20
21| मॉडल | इन/आउट प्रति Mtok | कैश रीड | सीट |
22|---|---|---|---|
23| claude-fable-5 | $10/$50 | $1.00 | कंडक्टर, प्लानर, एडवाइज़र, जज। स्वचालित रूप से opus-4-8 पर फॉलबैक करता है |
24| claude-opus-4-8 | $5/$25 | $0.50 | प्रतिधारण नियमों के तहत कंडक्टर |
25| claude-sonnet-5 | $2/$10 (31 अगस्त तक, फिर $3/$15) | n/a | डिफ़ॉल्ट कोडिंग निष्पादक |
26| claude-haiku-4-5 | $1/$5 | $0.10 | स्काउट, उप-एजेंट, यांत्रिक कार्य |
27
28फेबल, Opus 4.8, Sonnet 5 पर 1M संदर्भ, लंबे संदर्भ पर FLAT मूल्य, यही कारण है कि
29लंबी रीड यहां रूट होती हैं। अधिकतम आउटपुट 128K।
30
31## OpenAI (Responses API, /v1/responses)
32
33| मॉडल | इन/आउट प्रति Mtok | कैश्ड | सीट |
34|---|---|---|---|
35| gpt-5.6-sol | $5/$30 | $0.50 | क्रॉस-वेंडर समीक्षक, टर्मिनल कार्य |
36| gpt-5.6-terra | $2.50/$15 | $0.25 | Codex दैनिक ड्राइवर (पहले Luna के विरुद्ध परीक्षण करें) |
37| gpt-5.6-luna | $1/$6 | $0.10 | यांत्रिक कार्य, शांत टिक |
38
39सीमा से ऊपर लंबा संदर्भ लगभग इनपुट मूल्य को दोगुना कर देता है, जो Anthropic के
40फ्लैट 1M स्तरों के विपरीत है। स्पष्ट कैश ब्रेकपॉइंट वाला पहला परिवार; लिखने की लागत 1.25x।
41
42## ओपन वेट (बल्क वर्कर)
43
44| मॉडल | इन/आउट प्रति Mtok | कैश हिट |
45|---|---|---|
46| deepseek-v4-flash | $0.14/$0.28 | $0.0028 (लगभग 98 प्रतिशत छूट) |
47| deepseek-v4-pro | $0.435/$0.87 | n/a |
48| kimi-k2.7-code | $0.95/$4.00 | $0.19 |
49
50## छूट जो स्टैक होती हैं
51  - कैश रीड दोनों लैब में ताजा इनपुट की लागत का दसवां हिस्सा है (लगभग 90 प्रतिशत छूट)
52  - कैश राइट एक रीड (5m) या दो (1h) के बाद अपने लिए भुगतान करते हैं
53  - बैच API दोनों दिशाओं में 50 प्रतिशत छूट हैं
54  - बार-बार उपसर्ग पर बैच + कैश रीड लगभग 95 प्रतिशत छूट पर पहुंचता है
55  - Anthropic का नवीनतम टोकनाइज़र समान टेक्स्ट के लिए लगभग 30 प्रतिशत अधिक टोकन बनाता है,
56    इसलिए प्रभावी लागत स्टीकर से ऊपर बैठती है। प्रभावी पर बजट बनाएं।
57
58## लागत प्रश्न का उत्तर कैसे दें
59  1. इनपुट और आउटपुट का अलग-अलग अनुमान लगाएं। एजेंट हर 1 टोकन लिखने के लिए लगभग 100 टोकन पढ़ते हैं
60     जो वे लिखते हैं, इसलिए इनपुट हावी होता है और कैश हिट दर बिल तय करती है।
61  2. बार-बार उपसर्ग पर कैश रीड दर लागू करें, आधार दर नहीं।
62  3. टोकनाइज़र के लिए Anthropic के आंकड़ों को लगभग 1.3 से गुणा करें।
63  4. एक सीमा बताएं, मान्यताओं का नाम बताएं, कहें कि आपने इस फ़ाइल की कौन सी पंक्ति का उपयोग किया।
64  5. यदि संख्या रेपो की दैनिक सीमा से अधिक है, तो कुछ भी चलाने से पहले ऐसा कहें।
65
66कभी भी ऐसी कीमत पेश न करें जो आपने इस फ़ाइल से नहीं पढ़ी हो। यहां सूचीबद्ध नहीं किया गया मॉडल
67बेंच पर नहीं है, और एक को जोड़ना एक रूटिंग परिवर्तन है जो गेट से गुज़रता है।

सात तथ्य जो आपके निर्माण के तरीके को बदलते हैं:

कैश्ड इनपुट दोनों लैब में 90 प्रतिशत छूट है। आपके सिस्टम प्रॉम्प्ट में एक टाइमस्टैम्प इसे हर कॉल पर जला देता है। स्थिर उपसर्ग, केवल-जोड़ें इतिहास, हमेशा। एजेंट हर 1 टोकन लिखने के लिए लगभग 100 टोकन पढ़ते हैं, इसलिए यह छूट आपके अधिकांश बिल के लिए जिम्मेदार है।
कैश राइट अतिरिक्त खर्च करते हैं लेकिन जल्दी भुगतान करते हैं। Anthropic का 5 मिनट का राइट 1.25x बिल करता है और एक एकल रीड के बाद ब्रेक ईवन करता है। GPT-5.6 OpenAI का स्पष्ट कैश ब्रेकपॉइंट और मूल्य वाले राइट वाला पहला परिवार है। कैश के आसपास उसी तरह आर्किटेक्ट करें जैसे एक सिस्टम प्रोग्रामर मेमोरी पदानुक्रम के आसपास आर्किटेक्ट करता है।
नवीनतम Anthropic टोकनाइज़र समान टेक्स्ट के लिए लगभग 30 प्रतिशत अधिक टोकन बनाता है। प्रभावी कीमत स्टीकर से ऊपर बैठती है। प्रभावी पर बजट बनाएं।
फेबल 5 से सुरक्षा इनकार कोई त्रुटि नहीं है। कॉल सफल होता है और कार्य Opus 4.8 पर उतरता है, डिज़ाइन द्वारा, 5 प्रतिशत से कम सत्रों में। केवल निकास कोड नहीं, बल्कि जो हुआ उसे पढ़ें, और इसकी आवश्यकता होने से पहले फॉलबैक श्रृंखला कॉन्फ़िगर करें।
मध्य स्तर पर डिफ़ॉल्ट न करें। स्वतंत्र परीक्षण में पाया गया कि कुछ Luna या Sol सेटिंग ने लागत-गुणवत्ता सीमा पर Terra को हमेशा हराया। इसके लिए भुगतान करने से पहले अपने स्वयं के ट्रैफ़िक पर Terra का Luna के विरुद्ध परीक्षण करें।
बैच API किसी भी चीज़ को आधा कर देते हैं जो रात भर इंतजार कर सकती है, और छूट कैशिंग के साथ स्टैक होती है: बैच किए गए कार्य में बार-बार उपसर्ग लगभग 95 प्रतिशत छूट पर चलते हैं। इसका शोषण करने के लिए बिल्ड 7 में रात भर जलाने वाला उपकरण मौजूद है।
उपलब्धता एक परिचालन जोखिम है, एक काल्पनिक नहीं। फेबल 5 ने जून में 19 दिन खो दिए। यहां प्रत्येक मॉडल संदर्भ का एक फॉलबैक है: fable-5 opus पर फॉलबैक करता है, sol terra पर फॉलबैक करता है, और प्रत्येक फॉलबैक progress.log में लॉग किया जाता है।

दूसरा मीटर: एक सीट एक API कुंजी नहीं है

ऊपर प्रत्येक संख्या डॉलर प्रति मिलियन टोकन में मूल्यांकित है। यदि आप प्रति कॉल भुगतान करते हैं तो यह सही मुद्रा है।

यदि आप इसे $200 Codex Pro सीट या Claude Max सीट पर चलाते हैं तो यह गलत है।

एक सीट पर मीटर पांच घंटे की विंडो और साप्ताहिक विंडो है, जिसका एक साथ मूल्यांकन किया जाता है, और एक अनुरोध दोनों के खिलाफ गिना जाता है।

आप सप्ताह में धनी हो सकते हैं और फिर भी चार घंटे के लिए बंद हो सकते हैं, क्योंकि एक एकल संदेश ने छोटी विंडो को खा लिया।

समान सिद्धांत। अलग मुद्रा। तीन सेटिंग्स तय करती हैं कि एक संदेश एक विंडो का कितना हिस्सा ले सकता है:

फास्ट मोड महंगा है, क्योंकि यह एक संख्या को गुणा करता है जो अभी बड़ी हुई है।

GPT-5.6 प्रति संदेश 5.5 की तुलना में कहीं अधिक लंबा चलता है। अधिकतर एक उपहार। यह बर्न को अप्रत्याशित भी बनाता है।

Theo ने Sol पर $200,000 से अधिक टोकन जलाने की रिपोर्ट की है
उसने देखा है कि एक 5.6 संदेश पांच घंटे की विंडो का 15 प्रतिशत लेता है
गुणक पर, यह एक एकल संदेश में विंडो का 40 प्रतिशत है

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

अल्ट्रा अधिक सूक्ष्म जाल है, क्योंकि इंटरफ़ेस इसे फ़ाइल करता है जहां प्रयास स्तर रहते हैं और यह उनमें से एक नहीं है।

मैक्स गहराई है। एक मॉडल, एक समस्या, तर्क की एकल श्रृंखला पर अधिक समय।
अल्ट्रा चौड़ाई है। कार्य चार एजेंटों तक फैलता है, फिर संश्लेषित किया जाता है।
अलग अक्ष। अल्ट्रा "मैक्स से अधिक" नहीं है।

एक ऐसे कार्य पर इंगित किया गया जो वास्तव में विभाजित नहीं होता है, अल्ट्रा चार एजेंटों को एक जांच की नकल करते हुए खरीदता है।

यह Terminal-Bench 2.1 पर लगभग 3.1 अंक, 88.8 से 91.9, एक फ्लीट के लायक बर्न के लिए मूल्यवान है। तब तक बंद रखें जब तक उप-समस्याओं के बीच की सीमाएं वास्तविक न हों।

सोल और टेरा दोनों सही डिफ़ॉल्ट क्यों हैं

एक फील्ड रिपोर्ट लगभग हर चीज़ के लिए सोल चलाती है। उपरोक्त बेंच टेरा को Codex दैनिक ड्राइवर बनाता है। दोनों सही हैं, और मीटर इसका कारण है।

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

दर लागत नहीं है। लागत दर गुणा हरा-तक-मोड़ है, और दूसरा पद वह है जो चलता है।

जो बिल्ड 4 का नियम दूसरी दिशा से आ रहा है: डायल को छूने से पहले सीट को अपग्रेड करें। एक सीट पर जो $200 टियर पर सोल को उच्च पर पढ़ता है, उसके नीचे सोल को निम्न पर। विश्वास करने से पहले मापें।

अब Codex स्तर सेट करें:

text

1# ~/.codex/config.toml
2model = "gpt-5.6-terra"                 # दैनिक ड्राइवर
3model_reasoning_effort = "medium"
4# service_tier = "fast"                 # टिप्पणी छोड़ दें। फास्ट मोड 2.5x क्रेडिट बिल करता है
5                                        # /fast status चलाकर पुष्टि करें कि आप
6                                        # पहले से इसमें नहीं हैं।
7
8[profiles.fast]                         # यांत्रिक कार्य। "फास्ट मोड" नहीं: यह
9model = "gpt-5.6-luna"                  # प्रोफ़ाइल एक सस्ता मॉडल है, 2.5x
10model_reasoning_effort = "low"          # मीटर नहीं। दो अलग चीजें, एक शब्द।
11
12[profiles.deep]                          # योजना, बुरे बग, समीक्षाएं
13model = "gpt-5.6-sol"
14model_reasoning_effort = "high"

जाँच 0: दोनों CLI प्रमाणित करते हैं, और आपका टेस्ट कमांड वर्तमान रेपो पर 0 निकास कोड देता है।

बिल्ड 1: संविधान

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

CLAUDE.md बनाएं:

markdown

1# CLAUDE.md
2
3## कभी नहीं (अपवादों के लिए पहले पूछना आवश्यक है)
4- सत्र के बीच कभी भी मॉडल न बदलें। रूटिंग केवल सत्र और
5  उप-एजेंट सीमाओं पर होती है। मध्य-कार्य स्वैप कैश को जला देते हैं।
6- अपने स्वयं के डिफ की कभी समीक्षा न करें। समीक्षा एक ताजा संदर्भ या
7  एक अलग वंशावली से आती है। Devin का समीक्षक प्रति एजेंट PR में 2 बग पकड़ता है
8  ठीक इसलिए क्योंकि यह लेखक के साथ कुछ भी साझा नहीं करता है।
9- कभी भी टेस्ट को पास कराने के लिए उसे संपादित, कमजोर या हटाएं नहीं। स्वचालित FAIL।
10- कभी भी आत्म-मूल्यांकन से पूर्ण होने की रिपोर्ट न करें। पूर्ण = gate/verify.sh पास हुआ।
11- कभी भी चौथा एडवाइज़र परामर्श न लें। तीन चूक = BLOCKED, मानव की बारी।
12- कभी भी ऐसे रूटिंग या प्रॉम्प्ट परिवर्तन को मर्ज न करें जिसे eval_gate.py ने BLOCKED किया हो।
13- कभी भी दोनों कैप सेट किए बिना कोई लूप न चलाएं: MAX_ITERS और BUDGET_USD।
14- कभी भी यह न मानें कि एक फ्रंटियर मॉडल चालू है। फॉलबैक: fable-5 -> opus,
15  sol -> terra। प्रत्येक फॉलबैक को progress.log में लॉग करें।
16- कभी भी ऐसा उप-एजेंट न बनाएं जिसके लिए आपसे नहीं कहा गया हो। चिल्ड्रन माता-पिता के
17  मॉडल और प्रयास दोनों को इनहेरिट करते हैं, इसलिए एक उत्सुक फ्लीट महंगी सीट को इनहेरिट करता है।
18
19## प्रेषण (पहला मिलान जीतता है)
20| # | कार्य | सीट |
21|---|---|---|
22| 1 | योजना / आर्किटेक्ट / माइग्रेट | fable-5 योजना बनाता है, sonnet निष्पादित करता है |
23| 2 | निकालें / प्रारूपित करें / परीक्षण / दस्तावेज़ | haiku या luna |
24| 3 | 60k टोकन से अधिक संदर्भ | Anthropic 1M फ्लैट-मूल्य वाला टियर |
25| 4 | एजेंट-लिखित कोड की समीक्षा | sol codex के माध्यम से, मूल हार्नेस |
26| 5 | अस्पष्ट | कठिनाई स्कोर: 0-1 सस्ता, 2 sonnet, 3+ फ्रंटियर |
27| 6 | अभी भी अनिश्चित | सस्ता एक बार चलाएं, सत्यापित करें, विफलता पर एक बार एस्केलेट करें |
28
29## पूर्ण
30- प्रत्येक कार्य काम शुरू होने से पहले एक मशीन-जांच योग्य done_when रखता है।
31- एक ताजा-संदर्भ समीक्षक विनिर्देश के विरुद्ध डिफ का न्याय करता है, और कुछ नहीं।
32- gate/verify.sh अंतिम वोट रखता है। एक आइटम पर दो निर्माता/जांचकर्ता
33  असहमति -> रुकें, मानव के लिए कतारबद्ध करें।

रेपो रूट पर AGENTS.md बनाएं, Codex की बोली में वही कानून। इसे लगभग 100 पंक्तियों के पास रखें, एक विषय-सूची, एक विश्वकोश नहीं:

markdown

1# AGENTS.md
2
3## कमांड
4| उद्देश्य | कमांड |
5|---|---|
6| परीक्षण | make test   (यह कमांड पूर्णता की परिभाषा है) |
7| लिंट | make lint |
8
9## सत्र प्रोटोकॉल
101. पहले progress.log और TASKS.md पढ़ें। 2. एक अनचेक किया गया कार्य।
113. कार्यान्वित करें, पूरा सूट चलाएं, केवल हरा कमिट करें, वर्णनात्मक संदेश।
124. कार्य को टिक करें, progress.log में एक पंक्ति जोड़ें, रुकें।
13परीक्षण पूर्णता को परिभाषित करते हैं। कभी भी कमजोर, छोड़ें या हटाएं नहीं। गलत परीक्षण =
14कार्य को BLOCKED चिह्नित करें और कारण बताएं।
15
16## मॉडल नीति
17डिफ़ॉल्ट: terra, मध्यम प्रयास। यांत्रिक: प्रोफ़ाइल fast (luna, low)।
18योजना और बुरे बग: प्रोफ़ाइल deep (sol, high)।
19प्रयास मॉडल से पहले। प्रोफ़ाइल सत्र की शुरुआत में चुना जाता है, कभी मध्य-कार्य नहीं।
20फास्ट मोड बंद (2.5x क्रेडिट)। अल्ट्रा बंद। दोनों में से कोई भी प्रयास स्तर नहीं है।
21केवल तभी उप-एजेंट बनाएं जब मैं आपसे पूछूं। चिल्ड्रन इस सत्र के मॉडल और
22तर्क स्तर दोनों को इनहेरिट करते हैं, इसलिए उच्च प्रयास पर एक उत्सुक स्पॉन पूरे फ्लीट को उच्च प्रयास पर लाता है।
23
24## अटक गया
25संकेत: एक ही त्रुटि दो बार; दो कोई-प्रगति नहीं कदम; एक परीक्षण दो अलग-अलग
26सुधारों से बच रहा है। फिर /fable-advice। अधिकतम 3 परामर्श, फिर BLOCKED।
27
28## समीक्षा
29किसी भी मर्ज से पहले एक ताजा सत्र में /review-hostile, या क्लॉड पक्ष से क्रॉस-वेंडर
30लेन। अपने स्वयं के असमीक्षित कार्य को कभी मर्ज न करें।

एक सिद्धांत दोनों पक्षों पर रहना चाहिए, या जिस भी हार्नेस के ढीले आदतें होंगी वह हर बार जब आप टूल बदलते हैं तो जीत जाएगा।

जाँच 1: प्रत्येक पंक्ति के लिए, पूछें कि क्या मॉडल 80 प्रतिशत अनुपालन कर सकता है और सफलता का दावा कर सकता है। यदि हाँ, तो इसे एक संख्या या एक कभी नहीं के साथ फिर से लिखें। wc -l CLAUDE.md 60 से कम।

बिल्ड 2: गेट

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

अपने स्टैक के लिए gate/verify.sh बनाएं:

bash

1#!/usr/bin/env bash
2set -e
3npm run typecheck --if-present
4npm test --if-present
5npm run lint --if-present

gate/eval_gate.py बनाएं, प्रत्येक भविष्य के रूटिंग या प्रॉम्प्ट परिवर्तन के लिए सीटबेल्ट। यह वर्तमान कॉन्फ़िगरेशन और प्रस्तावित एक के माध्यम से 50 से 500 रखे गए मामलों को चलाता है, केवल नियतात्मक जाँच के साथ:

python

1for case in cases:   # {prompt, must_include, must_not_include, max_words}
2    hits += passes(case, run_config(case.prompt))
3verdict = "SHIP" if new_score >= old_score - 0.02 else "BLOCKED"

फिर एक कौशल के रूप में गेट को अछोड़ने योग्य बनाएं, .claude/skills/ship-gate/SKILL.md:

markdown

1---
2name: ship-gate
3description: किसी भी रूटिंग, मॉडल या प्रॉम्प्ट बदलाव को शिप करने से पहले eval गेट चलाएँ। तब उपयोग करें जब उपयोगकर्ता रूटिंग नियम बदलने, मॉडल टियर स्वैप करने, सिस्टम प्रॉम्प्ट एडिट करने, एफर्ट लेवल समायोजित करने, या राउटर, प्रॉम्प्ट्स या मॉडल कॉन्फ़िग से जुड़ी कोई चीज़ मर्ज करने के लिए कहे।
4---
5
6# शिप गेट
7
8रूटिंग या प्रॉम्प्ट्स में कोई भी बदलाव तब तक क्वालिटी का जुआ है जब तक गेट कुछ और न कहे। यह स्किल इसलिए मौजूद है ताकि जुआ कभी चुपचाप शिप न हो।
9
10  1. eval/cases.jsonl ढूँढें। अगर यह मौजूद नहीं है, तो रुकें और उपयोगकर्ता को बताएँ कि पहले रियल ट्रैफ़िक से 50 से 500 प्रतिनिधि केस बनाएँ। खुद से केस न बनाएँ।
11  2. चलाएँ: python3 eval_gate.py eval/cases.jsonl, मौजूदा कॉन्फ़िग बनाम प्रस्तावित।
12  3. ब्लॉक्ड: दोनों स्कोर रिपोर्ट करें, सूची बनाएँ कि कौन से केस रिग्रेस हुए, बदलाव लागू न करें, सबसे छोटा रिवर्ट सुझाएँ जो गेट को क्लियर करे।
13  4. शिप: लागू करें, और progress.log में एक पंक्ति जोड़ें जिसमें दोनों स्कोर हों।
14
15सख्त नियम:
16  - कभी भी ब्लॉक्ड वर्डिक्ट को ओवरराइड न करें, भले ही अच्छे से पूछा जाए। फेल होने वाले केस अटैच करके इंसान को एस्केलेट करें।
17  - उसी सेशन में केस फ़ाइल को कभी एडिट न करें जिसमें रूटिंग बदलाव हो। गेट और बदलाव का एक ही लेखक नहीं हो सकता।
18  - कॉस्ट नंबर क्वालिटी ड्रॉप के खिलाफ बचाव नहीं हैं। गेट जीतता है।

गेट केवल डिटरमिनिस्टिक चेक का उपयोग करता है, क्योंकि इसे कभी भी "वेरिफायर को कौन वेरिफाई करे" वाली समस्या विरासत में नहीं लेनी चाहिए। बिना eval गेट के रूटिंग बदलाव एक कॉस्ट एक्सपेरिमेंट है जो आप अपने ग्राहकों पर चला रहे हैं।

चेक 2: ./gate/verify.sh आज 0 कोड के साथ बाहर निकलता है, और eval_gate.py अपने डेमो पर SHIP प्रिंट करता है। अगर verify.sh अब फेल होता है, तो पहले इसे ठीक करें। सिस्टम इस स्क्रिप्ट पर खड़ा है।

बिल्ड 3: द हार्टबीट

मॉडल इंटेलिजेंस लाता है। लूप अनुशासन लाता है।

हर इटरेशन में ताज़ा कॉन्टेक्स्ट कॉन्टेक्स्ट रॉट को रोकता है
रिपोजिटरी सारी मेमोरी लेकर चलती है
दो कैप्स एक भगोड़े एजेंट को दस डॉलर के सबक में बदल देते हैं

यह वही सटीक आकार है जो Anthropic के 16-लूप रन के पीछे था जिसने लगभग $20,000 में 100,000-लाइन का C कंपाइलर बनाया, बिना किसी ऑर्केस्ट्रेटर मॉडल के।

loop/PROMPT.md बनाएँ:

markdown

1progress.log और TASKS.md पढ़ें। बिल्कुल एक अनचेक किया गया टास्क चुनें।
2उसे लागू करें। टेस्ट चलाएँ। अगर ग्रीन: एक वर्णनात्मक संदेश के साथ कमिट करें,
3टास्क को टिक करें, progress.log में एक पंक्ति जोड़ें, रुकें।
4अगर वही टास्क दो बार फेल होता है, तो उसे एरर के साथ ब्लॉक्ड मार्क करें और रुकें।
5DONE नामक फ़ाइल तभी बनाएँ जब हर टास्क टिक हो जाए और पूरा सूट पास हो जाए।
6कभी भी किसी टेस्ट को पास कराने के लिए एडिट न करें।

loop/ralph.sh बनाएँ:

bash

1#!/usr/bin/env bash
2set -u
3MAX_ITERS="${MAX_ITERS:-25}"      # cap one: iterations
4BUDGET_USD="${BUDGET_USD:-10}"    # cap two: dollars
5MAX_FAILS=3; fails=0; spent=0; i=0
6
7while [ ! -f DONE ] && [ "$i" -lt "$MAX_ITERS" ]; do
8  i=$((i + 1))
9  # fresh session every iteration: no memory except the repo itself
10  claude -p "$(cat PROMPT.md)" --max-turns 30 \
11    --output-format json > out.json 2> err.log \
12    && fails=0 || fails=$((fails + 1))
13  [ "$fails" -ge "$MAX_FAILS" ] && exit 2        # circuit breaker
14  cost=$(jq -r '.total_cost_usd // 0' out.json)
15  spent=$(awk -v a="$spent" -v b="$cost" 'BEGIN{printf "%.4f", a+b}')
16  awk -v s="$spent" -v c="$BUDGET_USD" 'BEGIN{exit !(s>c)}' && exit 3  # cap
17  sleep 2
18done
19[ -f DONE ] && echo "done in $i ticks, \$$spent" || echo "cap hit, \$$spent"

claude लाइन को codex exec से बदलें और वही लूप GPT-5.6 को चलाता है।

एग्जिट मैप जानबूझकर है: 0 done or quiet, 2 circuit breaker, 3 budget. बिल्ड 12 में हर अलार्म इन्हीं पर आधारित है।

कॉस्ट लाइन सेशन की अपनी JSON कॉस्ट रिपोर्ट पढ़ती है, इसलिए कैप को हार्नेस द्वारा वास्तविक खर्च के खिलाफ लागू किया जाता है, अनुमान से नहीं।

उस प्रॉम्प्ट में स्टॉप्स गिनें। हर शाखा एक में समाप्त होती है, और यह डिज़ाइन है, कोई बात नहीं।

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

लूप इस समस्या को संरचनात्मक रूप से हल करता है: प्रति टिक एक कार्य, अंत में हार्ड स्टॉप।

इंटरैक्टिव रूप से आपको इसे ज़ोर से कहना होगा। दो प्रॉम्प्ट काम करते हैं:

"योजना लिखें, फिर रुकें और मुझे दिखाएँ इससे पहले कि आप इसमें से कुछ भी बनाएँ"
एक बार योजना अच्छी हो जाए: "इसे बनाएँ, इसका परीक्षण करें, PR खोलें, रिव्यू टिप्पणियों के पहले दौर को संभालें, फिर रुकें"

एक मॉडल जो लंबा चलता है, केवल तभी खतरनाक है जब किसी ने उसे नहीं बताया कि किनारा कहाँ है।

लंबे कार्य उसी तरह विफल होते हैं जैसे कॉन्टेक्स्ट विफल होता है, इसलिए इटरेशन छोटे रहते हैं और वातावरण याद रखने का काम करता है। फेबल 5 और कोडेक्स मॉडल अब अपने कॉन्टेक्स्ट को मिड-रन में कॉम्पैक्ट करते हैं, इसलिए स्मार्ट मेमोरी प्लंबिंग जोड़ने का विरोध करें; सही मात्रा हर तिमाही घटती है।

चेक 3: TASKS.md में दो छोटे रियल टास्क, BUDGET_USD=2 पर एक हाथ से चलाया गया टिक। एक कमिट, एक टिक किया गया टास्क, एक लॉग लाइन, और यह पुष्टि करें कि लूप दूसरा कार्य शुरू करने के बजाय बाहर निकलता है।

बिल्ड 4: द राउटर जो अपनी नौकरी कमाता है (मॉडल, फिर एफर्ट)

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

किसी भी कोड से पहले निर्णय नियम। राउटर तभी जोड़ें जब ये दोनों सत्य हों:

सस्ता और फ्रंटियर टियर आपके ट्रैफ़िक पर लगभग पाँच गुना क्षमता-प्रति-डॉलर का अंतर दिखाते हैं
बिल्ड 2 का eval सेट इसे पुलिस करने के लिए मौजूद है

अगर एक अच्छी तरह से चुना गया मॉडल उन evals पर आपके राउटर को हराता है, तो राउटर को हटा दें और सादगी को बैंक करें।

एक बार जब यह बार को क्लियर कर देता है, तो router/router.py तीन परतें चलाता है, सबसे सस्ता निर्णय पहले। ध्यान दें कि टियर सीटों को नाम देते हैं, कीमतों को नहीं: दरें रनटाइम पर बेंच स्किल से आती हैं, इसलिए कीमत में बदलाव कभी आपके राउटर को नहीं छूता।

python

1TIERS = {                                   # seats, not numbers
2  "cheap":    "gpt-5.6-luna",               # or claude-haiku-4-5
3  "mid":      "claude-sonnet-5",
4  "frontier": "claude-fable-5",             # or gpt-5.6-sol
5}
6PRICES = load_bench(".claude/skills/model-bench/SKILL.md")   # one source of truth
7
8RULES = [
9  (kind in {"extract", "format", "summarize"},  "cheap"),
10  (kind in {"plan", "architect", "migrate"},    "frontier"),
11  (context_length > 60_000,                     "mid"),
12]
13tier = layer1_rules(task) or layer2_classifier(task)
14if tier: return call(TIERS[tier], task)
15return cascade(task)   # cheap first, verify, escalate ONCE on fail

बीच की परत आपके द्वारा पढ़े जा सकने वाले मार्करों पर कठिनाई को स्कोर करती है: क्यों, डीबग, रेस, डेडलॉक, रीफैक्टर, सुरक्षा, साथ ही प्रॉम्प्ट में कोड, पिछला विफल प्रयास, और एक से अधिक सबसिस्टम को छूना।

शून्य या एक अंक सस्ता जाता है। दो मिड जाता है। तीन या अधिक फ्रंटियर जाता है। कैस्केड का वेरिफायर डिटरमिनिस्टिक है और बिल्कुल एक बार एस्केलेट करता है।

उन्हीं निर्णयों को हार्नेस में वायर करें ताकि वे बिना आह्वान के फायर करें, .claude/skills/model-router/SKILL.md। ध्यान दें कि स्किल नियमों को दोहराती नहीं है, वह उन्हें पढ़ती है, वही सिंगल-सोर्स-ऑफ-ट्रुथ ट्रिक जो बेंच कीमतों के लिए उपयोग करती है:

markdown

1---
2name: model-router
3description: प्रत्येक कार्य को काम शुरू करने से पहले सही सीट और एफर्ट पर रूट करें।
4  सेशन शुरू होने पर, सबएजेंट स्पॉन करने से पहले, जब उपयोगकर्ता पूछता है कि किस मॉडल का
5  उपयोग करना है, या जब कोई कार्य प्लानिंग और एक्ज़ीक्यूशन को मिलाता है, तब उपयोग करें।
6---
7
8# मॉडल राउटर
9
10ROUTING.md पढ़ें और इसे लागू करें। कोई नीति स्वयं न बनाएँ, और यहाँ कोई नीति दोबारा न बताएँ:
11यह फ़ाइल सड़ जाएगी, और नीति फ़ाइल वही है जो eval गेट के अंतर्गत है।
12
13तीन चीज़ें जो यह स्किल उस फ़ाइल के शीर्ष पर लागू करती है:
14
15  1. केवल सीमाओं पर रूट करें। सेशन स्टार्ट और सबएजेंट स्पॉन। मिड-टास्क स्वैप
16     कैश को अमान्य करता है और कैश्ड दर के दस गुना पर कॉन्टेक्स्ट को फिर से बिल करता है।
17  2. सेशन के अंत में, progress.log में सस्ते-टियर शेयर जोड़ें। बचत तभी चक्रवृद्धि होती है
18     जब एक बार अधिकांश ट्रैफ़िक सस्ता हो जाता है, इसलिए वह संख्या देखने वाली है।
19  3. ROUTING.md में कोई भी बदलाव शिप-गेट स्किल के माध्यम से शिप होता है। कोई अपवाद नहीं।

निर्णय क्रम लागत को दर्शाता है: पहले एक मुफ्त चेक, दूसरा एक स्कोर किया गया अनुमान, अंतिम एक भुगतान किया गया प्रयोग।

पैसा ट्रैफ़िक स्प्लिट है, चतुराई नहीं।

70 प्रतिशत काम को दसवें मूल्य के टियर पर भेजें और बिल लगभग दो-तिहाई गिर जाता है
प्रोडक्शन रिपोर्ट 40 से 85 प्रतिशत बचत के बीच क्लस्टर होती हैं, और स्प्रेड लगभग पूरी तरह से स्प्लिट है
बचत तभी चक्रवृद्धि होती है जब अधिकांश ट्रैफ़िक सस्ता हो जाता है

यही कारण है कि progress.log में सस्ता शेयर वह एक नंबर है जिसे यह सिस्टम आपको देखने के लिए मजबूर करता है।

एफर्ट दूसरा डायल है

एफर्ट एक स्तर नीचे रूटिंग है: वही स्किल, जो इस बात पर लागू होती है कि मॉडल कितनी देर सोचता है बजाय इसके कि कौन सा मॉडल चलता है।

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

डिफ़ॉल्ट रूप से हाई पर रखें और मैक्स को अंतिम उपाय मानें, दिखावा नहीं।

Anthropic के अपने एफर्ट डॉक्स स्वीट स्पॉट को हाई पर रखते हैं, और चेतावनी देते हैं कि मैक्स ओवरथिंकिंग में बदल जाता है
26 कोडिंग कार्यों के एक सार्वजनिक बेंचमार्क ने पाया कि हाई ने लो की गुणवत्ता को लगभग तिगुना कर दिया
उसी बेंचमार्क ने पाया कि xhigh की लागत दोगुनी से अधिक थी, जो शायद ही कभी वापस मिलती थी

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

दो सेटिंग्स को इस सीढ़ी के उच्च पायदान के रूप में गलत समझा जाता है। कोई भी उस पर नहीं है।

मैक्स गहराई है। एक मॉडल, एक समस्या, अधिक समय।
अल्ट्रा चौड़ाई है। एक कार्य चार समानांतर एजेंटों में फैलाया गया, फिर संश्लेषित किया गया।

अलग-अलग अक्ष। अल्ट्रा "मैक्स से अधिक" नहीं है, और इसे एक ऐसे कार्य पर इंगित करना जो वास्तव में विभाजित नहीं होता है, एक जाँच को दोहराते हुए चार एजेंट खरीदता है।

सीढ़ी संस्करणों के बीच पोर्ट नहीं होती है। एक ही शब्द एक नए मॉडल पर पुराने मॉडल की तुलना में अलग मात्रा में सोच खरीदता है।

एक परिचित कार्य को एक नई सीट पर ले जाना, आपके द्वारा भरोसे जाने वाली सेटिंग से एक पायदान नीचे से शुरू करें। केवल तभी चढ़ें जब आउटपुट पूछे।

एक जाल विशेष रूप से स्वार्म्स का है।

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

उन्हें अपने खुद के फ्रंटमैटर में पिन करें, और जानें कि जब आप ऐसा करते हैं तो आप किस हार्नेस में हैं, क्योंकि पिन केवल उतनी ही अच्छी है जितना स्पॉनर जो इसे पढ़ता है।

Claude साइड। नीचे का फ्रंटमैटर नियंत्रण है।
Codex साइड। 5.6 बच्चों को पैरेंट के अपने मॉडल और रीजनिंग लेवल पर स्पॉन करता है, और यह उत्सुकता से स्पॉन करता है। पैरेंट का डायल बेड़े का डायल है।

Codex साइड पर एकमात्र वास्तविक नियंत्रण वह सेटिंग है जिसके साथ आपने सेशन खोला था, और AGENTS.md में एक पंक्ति जो कहती है कि जब तक न पूछा जाए, स्पॉन न करें। किसी पर भी भरोसा करने से पहले सत्यापित करें कि आपके पास कौन सा है:

yaml

1name: scout
2model: haiku
3effort: low     # subagents inherit the parent. a max-effort swarm
4                # empties a window in one message. pin them down.

इसे प्रति टूल सेट करें: Claude Code और Codex TUI में /effort, codex -e high जैसा फ्लैग, कॉन्फ़िग में एक पंक्ति, या API पर effort फ़ील्ड।

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

सप्ताह में एक बार एक नंबर ट्रैक करें:

bash

1grep '^route' progress.log | awk -F'\t' \
2  '{r++; if($3!="frontier")c++} END{printf "cheap share: %.0f%%\n", c/r*100}'

ROUTING.md, वह नीति जिसे दोनों हार्नेस पढ़ते हैं

ऊपर सब कुछ रिपोजिटरी रूट पर एक फ़ाइल में संघनित होता है।

markdown

1# ROUTING.md
2
3रूटिंग चार निर्णय हैं, और क्रम ही बिंदु है:
4  1. कहाँ: कौन सा हार्नेस काम चलाता है
5  2. कब: किस सीमा पर निर्णय लिया जाता है
6  3. कौन: कौन सा मॉडल सीट लेता है
7  4. कितनी मेहनत: वह मॉडल किस एफर्ट लेवल पर चलता है
8अधिकांश टीमें केवल 3 के बारे में बहस करती हैं। पैसा 2 और 4 में है।
9
10## 1. कहाँ: मॉडल से पहले हार्नेस
11एक हार्नेस के अंदर पोस्ट-ट्रेन किया गया मॉडल कहीं और आउट ऑफ डिस्ट्रीब्यूशन चलता है।
12मापा गया स्प्रेड: 20.2 प्रतिशत नेटिव बनाम 7.7 प्रतिशत विदेशी, समान वेट।
13
14| काम | हार्नेस | क्यों |
15|---|---|---|
16| कोड लिखना | मॉडल का नेटिव हार्नेस | लेखक डिस्ट्रीब्यूशन से बाहर घटते हैं |
17| कोड की समीक्षा करना | समीक्षक का नेटिव हार्नेस | कमजोर समीक्षा बिल्कुल न होने से बदतर है |
18| पढ़ना, स्काउटिंग | कहीं भी | पढ़ना सस्ता और सत्यापन योग्य है |
19| मैकेनिकल ट्रांसफॉर्म | कहीं भी | अगर चेक डिटरमिनिस्टिक है, तो हार्नेस मुश्किल से मायने रखता है |
20
21कानून: रीडर और रिव्यूअर लेन को स्वतंत्र रूप से रीमैप करें। राइटर लेन हार्नेस-नेटिव रहता है
22जब तक आपका अपना eval सेट कुछ और न कहे। वह ओवरराइड एक माप होना चाहिए, प्राथमिकता नहीं।
23
24## 2. कब: सीमाओं पर रूट करें, उनके अंदर कभी नहीं
25मिड-सेशन स्वैप प्रॉम्प्ट कैश को फेंक देता है। कैश्ड इनपुट की लागत ताज़ा इनपुट का दसवां हिस्सा है,
26इसलिए एक अनावश्यक स्वैप पूरे कॉन्टेक्स्ट को दस गुना कीमत पर फिर से बिल करता है और कुछ नहीं खरीदता है।
27
28कानूनी सीमाएँ, एकमात्र स्थान जहाँ रूटिंग निर्णय हो सकता है:
29  - सेशन स्टार्ट
30  - सबएजेंट स्पॉन
31  - स्वार्म में एक नया लक्ष्य
32  - दूसरी वंशावली को समीक्षा का हस्तांतरण
33  - आउटेज या सुरक्षा उपाय द्वारा फायर किया गया फॉलबैक
34
35बाकी सब जगह अवैध। कोई प्रति-टर्न रूटिंग नहीं। कोई मिड-टास्क एडेप्टिव स्वैपिंग नहीं।
36कैस्केड को बिल्कुल एक एस्केलेशन मिलता है, और यह एक ताज़ा सीमा खोलता है।
37
38कानून: जब सीमा खुलती है तो सीट चुनें, फिर अगले तक वहीं रहें।
39
40## 3. कौन: निर्णय प्रक्रिया (पहला मैच जीतता है, परिणाम लॉग करें)
41
42परत 1, नियम। मुफ्त। हमेशा पहले जाँचें।
43
44| संकेत | सीट |
45|---|---|
46| extract / format / summarize / classify / tests | Haiku या Luna, effort low |
47| plan / architect / migrate / root-cause | Fable योजना बनाता है, Sonnet निष्पादित करता है |
48| 60k टोकन से अधिक कॉन्टेक्स्ट | Anthropic 1M टियर (फ्लैट-प्राइस्ड) |
49| एजेंट-लिखित कोड की समीक्षा करना | दूसरी वंशावली, नेटिव हार्नेस |
50| लक्ष्य स्वतंत्र टुकड़ों में विभाजित होता है | स्वार्म: Fable लिखता है और स्कोर करता है |
51
52परत 2, स्कोर। एक अंक प्रत्येक:
53  - contains why / debug / race / deadlock / refactor / security / optimize
54  - एक से अधिक सबसिस्टम को छूता है
55  - पिछला प्रयास पहले ही विफल हो चुका है
56  - परिवर्तन अपरिवर्तनीय या उपयोगकर्ता-सामना करने वाला है
57  0-1 -> cheap tier, low effort. 2 -> Sonnet, medium. 3+ -> frontier, high.
58
59परत 3, कैस्केड। सस्ता चलाएँ, डिटरमिनिस्टिक रूप से सत्यापित करें, बिल्कुल एक बार एस्केलेट करें।
60कभी दो बार नहीं। दूसरी विफलता एक स्पेक समस्या है, और एक बड़ा मॉडल आपके स्पेक को ठीक नहीं करेगा।
61
62सीटें और फॉलबैक .claude/skills/model-bench/SKILL.md में रहते हैं। यहाँ कोई कीमत नहीं।
63
64## 4. कितनी मेहनत: एफर्ट रूटिंग
65एफर्ट एक स्तर नीचे रूटिंग है। इस फ़ाइल में सबसे सस्ता डायल: और कुछ नहीं बदलता है
66और कैश गर्म रहता है।
67
68| एफर्ट | इसका उपयोग किसके लिए करें |
69|---|---|
70| low | टाइपो, रीनेम, सॉर्टिंग, एक्सट्रैक्शन, डिफ़ॉल्ट रूप से हर सबएजेंट |
71| medium | स्पष्ट स्पेक से नियमित कोड, सारांश, मानक लेखन |
72| high | टीयरडाउन, माइग्रेशन, गंभीर बग, सभी कंडक्टर कार्य (डिफ़ॉल्ट) |
73| max | केवल वह समस्या जिसे high पहले ही हल करने में विफल रहा है |
74| ultra | इस सीढ़ी पर नहीं। चौड़ाई, गहराई नहीं: समानांतर में 4 एजेंट। डिफ़ॉल्ट रूप से बंद |
75
76  1. डिफ़ॉल्ट रूप से high करें। स्वीट स्पॉट वहाँ बैठता है; max ओवरथिंकिंग में बदल जाता है।
77  2. बेहतर मॉडल उच्च डायल को हराता है। सेटिंग से पहले सीट को अपग्रेड करें।
78  3. सबएजेंट पैरेंट के मॉडल और एफर्ट को इनहेरिट करते हैं। मैक्स-एफर्ट कंडक्टर से
79     स्पॉन किया गया बेड़ा मैक्स पर चलता है और एक संदेश में एक विंडो खाली करता है। हर
80     सबएजेंट को अपने स्वयं के फ्रंटमैटर में पिन करें: effort: low। जहाँ स्पॉनर
81     पिन को अनदेखा करता है, पैरेंट का डायल बेड़े का डायल है। जाँचें कि आपके पास कौन सा है।
82  4. मैक्स गहराई है। अल्ट्रा चौड़ाई है। अल्ट्रा केवल तब जब उप-समस्याएँ वास्तव में
83     स्वतंत्र हों, कभी डिफ़ॉल्ट के रूप में नहीं, और बिल्कुल नहीं जब हार्नेस ओवर-स्पॉन करता है।
84  5. सीढ़ी संस्करणों के बीच पोर्ट नहीं होती है। एक नए मॉडल पर, पुराने मॉडल पर
85     आपके द्वारा भरोसे जाने वाली सेटिंग से एक पायदान नीचे शुरू करें।
86  6. फास्ट मोड भी कोई एफर्ट लेवल नहीं है। यह टोकन पर 2.5x क्रेडिट पर विलंबता खरीदता है
87     जिन्हें आप वैसे भी जला रहे थे। बंद।
88
89डायल चार स्थानों पर रहता है: Claude Code और Codex TUI में /effort, codex -e high,
90config में model_reasoning_effort, API पर effort फ़ील्ड। Claude Code
91डिफ़ॉल्ट रूप से high, Codex डिफ़ॉल्ट रूप से medium, अधिकांश ऐप्स इसे पूरी तरह से छिपाते हैं, यही कारण है कि
92टीमें गलती से सब कुछ के लिए एक स्तर चलाती हैं।
93
94## 5. फॉलबैक: मान लें कि फ्रंटियर डाउन है
95फ्रंटियर उपलब्धता की गारंटी नहीं है, और एक सुरक्षा उपाय 5 प्रतिशत से कम सेशन में, बिना त्रुटि के,
96मिड-रन में Opus 4.8 पर कॉल को रीरूट कर सकता है।
97  - हर सीट का एक नामित फॉलबैक होता है। कोई अपवाद नहीं।
98  - हर फॉलबैक लॉग किया जाता है। एक मूक रीरूट एक बग है, क्योंकि हो सकता है कि आप
99    किसी ऐसे मॉडल से आउटपुट पढ़ रहे हों जिसे आपने नहीं चुना।
100  - कभी भी उस मॉडल के आउटपुट पर पुनरावृत्ति न करें जिसे आपने नहीं चुना।
101
102## 6. वह संख्या जो तय करती है कि इसमें से कुछ भी काम किया या नहीं
103ब्लेंडेड लागत आपका ट्रैफ़िक स्प्लिट है, और कुछ नहीं। 70 प्रतिशत सस्ता बिल को लगभग दो-तिहाई कम कर देता है।
10410 प्रतिशत पॉकेट चेंज बचाता है। राउटर सटीकता राउटर चतुराई से कहीं अधिक मूल्यवान है।
105
106इसे बिल्ड 4 में एक-लाइनर से ट्रैक करें। 50 प्रतिशत से नीचे, बचत ने चक्रवृद्धि शुरू नहीं की है।
107यहाँ कुछ और छूने से पहले स्प्लिट को ठीक करें।
108
109## 7. इस फ़ाइल पर गेट
110कानून: इस फ़ाइल में कोई भी बदलाव 50 से 500 अलग रखे गए केसों पर eval_gate.py पास किए बिना शिप नहीं होता है।
111BLOCKED वर्डिक्ट अंतिम है और इसे सेशन में ओवरराइड नहीं किया जा सकता है। गेट और बदलाव का एक ही लेखक नहीं हो सकता है।
112
113## 8. इस फ़ाइल को कब हटाएँ
114यदि एक अच्छी तरह से चुना गया एकल मॉडल आपके evals पर इस पूरे स्टैक को हरा देता है, तो राउटर को हटा दें और सादगी रखें। 2026 के सबसे कठोर रूटिंग बेंचमार्क ने पाया कि कई राउटर, जिनमें कमर्शियल वाले भी शामिल हैं, सबसे अच्छे सिंगल मॉडल को चुनने को मात देने में विश्वसनीय रूप से विफल रहते हैं।
115पहले मापें। फिर रूट करें। खुशी-खुशी हटाएँ।

चेक 4: router.py ऑफ़लाइन चलता है और एक निर्णय, एक कारण और स्प्लिट प्रिंट करता है। आपके नोट्स में 5x गैप माप है, या एक दिनांकित नोट है जो कहता है कि राउटर अभी तक उचित नहीं है।

बिल्ड 5: द एडवाइज़र इन्वर्ज़न

क्लासिक पैटर्न स्मार्ट मॉडल को प्रभारी रखता है और बल्क एक्ज़ीक्यूशन पर फ्रंटियर टोकन जलाता है। इसे उल्टा करें।

Anthropic के एडवाइज़र परिणाम: Opus-क्लास एडवाइज़र के साथ Haiku ने एक कठिन ब्राउज़िंग बेंचमार्क पर अपने स्कोर को दोगुना से अधिक कर दिया, 41.2 बनाम 19.7 अकेले, मिड टियर की तुलना में प्रति कार्य 85 प्रतिशत कम लागत पर।

एक्ज़ीक्यूशन बल्क है। सलाह ग्राम है।

हार्नेस तय करता है कि ड्राइवर कब अटका है, ड्राइवर कभी नहीं, .claude/skills/stuck-protocol/SKILL.md:

markdown

1---
2name: stuck-protocol
3description: जब प्रगति रुक जाती है तो fable-expert एडवाइज़र को एस्केलेट करें। तब उपयोग करें
4  जब वही त्रुटि दो बार दिखाई देती है, जब लगातार दो चरण त्रुटियों के बने रहने पर कोई फ़ाइल नहीं बदलते,
5  जब दो अलग-अलग फिक्स प्रयासों के बाद कोई टेस्ट फेल होता है, या जब उपयोगकर्ता कहता है कि एजेंट
6  चक्कर काट रहा है।
7---
8
9# स्टक प्रोटोकॉल (द एडवाइज़र इन्वर्ज़न)
10
11आप सस्ता ड्राइवर हैं और यह एक विशेषता है: एक्ज़ीक्यूशन बल्क है, सलाह ग्राम है।
12लेकिन छोटे मॉडल ओवरकॉन्फिडेंट होते हैं, इसलिए आपको यह तय करने का अधिकार नहीं है कि आप ठीक हैं।
13इसके बजाय डिटरमिनिस्टिक सिग्नल देखें।
14
15स्टक सिग्नल (कोई भी एक प्रोटोकॉल को फायर करता है):
16  1. लगातार दो चरणों पर एक ही त्रुटि स्ट्रिंग।
17  2. लगातार दो चरण जिनमें त्रुटियों के बने रहने पर शून्य फ़ाइलें बदली गईं।
18  3. दो वास्तव में अलग-अलग फिक्स प्रयासों के बाद वही टेस्ट फेल होना।
19
20प्रक्रिया:
21  1. इस सेशन में परामर्श गिनें। 3 पर, रुकें: कार्य को एरर अटैच करके BLOCKED मार्क करें,
22     मानव के लिए सारांश दें, आगे बढ़ें। कभी चौथा परामर्श नहीं।
23  2. ब्रीफ बनाएँ, इसमें और कुछ नहीं जाता:
24       GOAL: एक पंक्ति
25       ATTEMPT x2: पिछले दो प्रयास, प्रत्येक 200 अक्षर
26       ERROR: सटीक त्रुटि, 300 अक्षर
27  3. ब्रीफ के साथ fable-expert स्पॉन करें। यह मार्गदर्शन लौटाता है, कोड नहीं।
28  4. अपने स्वयं के कुछ भी करने से पहले, अगले चरण में मार्गदर्शन लागू करें।
29  5. progress.log में एक पंक्ति जोड़ें: परामर्श #N, उसने क्या कहा, क्या यह काम किया।
30
31सख्त नियम:
32  - विशेषज्ञ से काम करने के लिए कभी न कहें। यदि उत्तर में पूर्ण कार्यान्वयन है,
33    तो विचार लें और कोड को त्याग दें।
34  - ब्रीफ को अपने तर्क इतिहास से कभी न भरें। विशेषज्ञ का मूल्य स्वच्छ कॉन्टेक्स्ट है;
35    एक लंबी ब्रीफ इसे जहरीला बनाती है।
36  - यदि मार्गदर्शन विफल होता है, तो यह अगले परामर्श की ओर आपके दो प्रयासों में से एक के रूप में
37    गिना जाता है। तीन असफल परामर्शों का मतलब है कि कार्य इस सेशन की भुगतान क्षमता से ऊपर है,
38    और ऐसा कहना सही आउटपुट है।

विशेषज्ञ सीट, .claude/agents/fable-expert.md:

markdown

1---
2name: fable-expert
3description: अटके हुए क्षणों के लिए फ्रंटियर एडवाइज़र। stuck-protocol से एक संक्षिप्त ब्रीफ
4  प्राप्त करता है, 600 टोकन से कम मार्गदर्शन लौटाता है, कभी खुद काम नहीं करता है।
5model: claude-fable-5      # swap to opus if retention rules bite
6effort: high
7tools: Read, Grep, Glob    # may read, may never edit
8---
9
10आप विशेषज्ञ सलाहकार हैं, ठेकेदार नहीं। एक सस्ता मॉडल गाड़ी चला रहा है और एक दीवार से टकरा गया है।
11आपका मूल्य ग्राम में निर्णय है, और स्वच्छ कॉन्टेक्स्ट: आपको कुछ नहीं पता कि ड्राइवर यहाँ कैसे पहुँचा,
12यही कारण है कि आपका पढ़ना तेज है।
13
14आपको एक ब्रीफ मिलता है: GOAL, पिछले दो ATTEMPT, और ERROR। यदि ब्रीफ विशिष्ट फ़ाइलों का नाम देती है,
15तो आप उन्हें पढ़ सकते हैं। आप कुछ भी एडिट नहीं कर सकते हैं।
16
17  1. यदि ब्रीफ में कुछ कमी है जिसकी आपको आवश्यकता है, तो एक पंक्ति में उत्तर दें जिसमें बताया गया हो कि
18     क्या कमी है। अंतर के आसपास अनुमान न लगाएँ।
19  2. निर्धारित करने से पहले निदान करें: वास्तव में क्या गलत है, इस पर एक या दो वाक्य।
20  3. फिर इस प्रारूप में उत्तर दें और उसके बाद कुछ नहीं:
21       GUIDANCE:
22       1. (सबसे संभावित फिक्स: क्या प्रयास करें, और यह क्यों काम करना चाहिए)
23       2. (यदि 1 विफल होता है तो फॉलबैक)
24       3. (केवल तभी जब कोई वास्तव में अलग तीसरा रास्ता हो)
25       CONFIDENCE: high | medium | low
26  4. 600 टोकन से कम। 10 पंक्तियों से अधिक के कोई कोड ब्लॉक नहीं। विचार दें, कार्यान्वयन नहीं।
27     यदि आपके उत्तर में पूर्ण समाधान है, तो आप भूमिका में विफल रहे।
28  5. यदि कार्य ही गलत समझा गया है, तो आइटम 1 में ऐसा कहें और सिफारिश करें कि मानव को क्या बताना है।
29
30ऑपरेटर नोट: यदि आपका संगठन Mythos-क्लास प्रतिधारण को स्वीकार नहीं कर सकता है, तो मॉडल लाइन को
31opus में बदलें। भूमिका वैसे ही काम करती है; एडवाइज़र परिणाम पहली बार Opus-क्लास एडवाइज़र के साथ साबित हुआ था।

और Codex सेशन के लिए उल्टा वही लेन, ~/.codex/prompts/fable-advice.md:

bash

1claude --model claude-fable-5 -p "You are an expert advisor.
2  A cheaper model is driving and is stuck. BRIEF: <goal, two
3  attempts, error>. Reply GUIDANCE: up to 3 numbered items,
4  under 600 tokens. Do not do the work."

छोटे मॉडल ओवरकॉन्फिडेंट होते हैं, इसलिए हार्नेस पूछने के बजाय व्यवहार देखता है।

ब्रीफ छोटी रहती है, क्योंकि विशेषज्ञ का मूल्य स्वच्छ कॉन्टेक्स्ट है और एक लंबी ब्रीफ इसे जहरीला बनाती है।

प्रत्येक परामर्श कुछ सौ टोकन मार्गदर्शन चलाता है। यही कारण है कि अर्थशास्त्र ढह जाता है: एक्ज़ीक्यूशन लाखों $1 टियर पर सवार होते हैं, और निर्णय $50 प्रति मिलियन पर ग्राम द्वारा आता है।

Cognition ने पहले विफलता प्रकाशित की। सीमा ड्राइवर द्वारा निर्धारित की जाती है, एडवाइज़र द्वारा नहीं, और पैटर्न ने केवल उनके ड्राइवर के एक पीढ़ी सुधारने के बाद भुगतान किया।

खुली समस्या एक ड्राइवर है जो नोटिस करता है कि वह अटक गया है। यही कारण है कि उपरोक्त सिग्नल व्यवहारिक हैं, और यही कारण है कि वे हार्नेस में रहते हैं।

चेक 5: advisor_loop.py अपने दावों को पास करता है: ड्राइवर एक ही तरह से दो बार विफल होता है, एक परामर्श फायर होता है, कार्य पूरा होता है, परामर्श कैप के नीचे रहते हैं।

बिल्ड 6: द टू-लेन बेंच

कोई भी अपना होमवर्क खुद ग्रेड नहीं करता है एक कानून है, और यह बिल्ड इसे विक्रेताओं में लागू करता है।

एक विदेशी हार्नेस में समान वेट कठोर गिरते हैं। एक 2026 माप ने 20.2 प्रतिशत नेटिव बनाम 7.7 प्रतिशत तृतीय-पक्ष दिखाया।

इसलिए प्रत्येक समीक्षक अपने स्वयं के घर में चलता है। Claude Claude Code में समीक्षा करता है। Sol Codex CLI के माध्यम से समीक्षा करता है।

इन-हाउस जज, .claude/agents/fresh-eyes-reviewer.md:

markdown

1---
2name: fresh-eyes-reviewer
3description: स्वच्छ संदर्भ कोड समीक्षक। किसी एजेंट द्वारा लिखे गए बदलाव के बाद इसे लागू करें।
4  लेखक के साथ कोई इतिहास साझा नहीं करता, खुद डिफ पढ़ता है, संपादन नहीं कर सकता।
5model: haiku               # जब डिफ महत्वपूर्ण हो तो opus पर स्विच करें
6effort: medium
7tools: Read, Grep, Glob, Bash
8---
9
10आपको याद नहीं है कि यह बदलाव कैसे लिखा गया था, और यही बात है। लेखक के तर्क के बारे में न पूछें। किसी भी सारांश पर भरोसा न करें। केवल साक्ष्य।
11
12  1. git diff HEAD~1 (या दी गई सीमा) चलाएँ और हर हंक को पढ़ें।
13  2. प्रभावित प्रत्येक फ़ाइल की पूरी सामग्री पढ़ें, सिर्फ हंक नहीं। बग अक्सर बदलाव के आसपास की अपरिवर्तित पंक्तियों में छिपे होते हैं।
14  3. README या CLAUDE.md में नामित टेस्ट सूट चलाएँ।
15  4. तीन क्लासिक एजेंट विफलताओं की तलाश करें:
16       आलस्य: आंशिक कार्यान्वयन, TODOs, सिर्फ एक मामले के लिए संभाला गया
17       स्व-ग्रेडिंग: कमजोर किए गए टेस्ट, हटाए गए एसर्शन, छोड़े गए सूट
18       बहाव: बताए गए कार्य के दायरे से बाहर के बदलाव
19  5. निर्णय, बिल्कुल इस प्रारूप में:
20       VERDICT: PASS या FAIL
21       BUGS: क्रमांकित, प्रत्येक के साथ file:line और एक वाक्य का कारण
22       RISK: एक वाक्य में इस बदलाव की सबसे जोखिम भरी बात
23
24सख्त नियम: आप फ़ाइलों को संपादित नहीं कर सकते, लेखक का कार्य पुनः नहीं चला सकते, और खाली BUGS सूची के साथ VERDICT: FAIL अमान्य है। यदि टेस्ट नहीं चल सकते, तो यह अपने आप FAIL है, कारण सहित।

क्रॉस-वेंडर जज, .claude/agents/sol-reviewer.md, एक पाइपलाइन है जो एक कमांड चलाती है और निर्णय को शब्दशः रिले करती है। Sol समीक्षक है; यह फ़ाइल इसे अपने हार्नेस में डालती है:

markdown

1---
2name: sol-reviewer
3description: क्रॉस-वेंडर समीक्षक। नवीनतम कमिट को Codex CLI के माध्यम से GPT-5.6 Sol को उसके मूल हार्नेस में भेजता है और निर्णय को अछूता रिले करता है।
4model: haiku               # सिर्फ पाइपलाइन। Sol समीक्षक है।
5effort: low
6tools: Bash, Read
7---
8
9आप पाइपलाइन हैं, समीक्षक नहीं। एक परिवार के मॉडल साझा अंध-धब्बे साझा करते हैं; यह लेन इसलिए मौजूद है क्योंकि Sol Claude के अंध-धब्बों को साझा नहीं करता।
10
11  1. CLI जाँचें: codex --version। यदि अनुपस्थित है, तो VERDICT: FAIL आउटपुट करें जिसमें कारण "codex CLI इंस्टॉल नहीं है" और सेटअप पथ (या आधिकारिक प्लगइन: /plugin marketplace add openai/codex-plugin-cc, /plugin install, /codex:review) शामिल हो।
12  2. उच्च प्रयास में, Sol के अपने हार्नेस में समीक्षा चलाएँ:
13
14     codex --profile deep exec "नवीनतम कमिट (git show HEAD) की समीक्षा एक शत्रुतापूर्ण वरिष्ठ इंजीनियर के रूप में करें जो लेखक से कभी नहीं मिला। प्रभावित प्रत्येक फ़ाइल को पूर्ण रूप से पढ़ें, सिर्फ हंक नहीं। खोजें: आंशिक कार्यान्वयन, कमजोर या हटाए गए टेस्ट, बताए गए कार्य के दायरे से बाहर के बदलाव। अंत में बिल्कुल 'VERDICT: PASS' या 'VERDICT: FAIL' लिखें, उसके बाद क्रमांकित निष्कर्ष, प्रत्येक के साथ file:line और एक वाक्य का कारण।"
15
16  3. पूर्ण आउटपुट को .review_sol_<short-hash>.md में सहेजें।
17  4. ऊपर की ओर रिले करें: पहले VERDICT लाइन, फिर निष्कर्ष शब्दशः। निष्कर्षों को संक्षिप्त न करें, आश्वासन न जोड़ें, Sol से बहस न करें। यदि निर्णय FAIL है, तो मूल तय करता है कि क्या ठीक करना है। आप कुछ भी तय नहीं करते।
18
19सख्त नियम: फ़ाइलों को कभी संपादित न करें, लेखक का कार्य कभी पुनः न चलाएँ, अपनी खुद की समीक्षा कभी प्रतिस्थापित न करें। यदि codex बीच में त्रुटि करता है, तो एक से अधिक बार चुपचाप पुनः प्रयास करने के बजाय इसे stderr के साथ FAIL के रूप में रिपोर्ट करें।

CI के लिए, loop/two_lane.sh पूरे आदान-प्रदान को चलाता है, अधिकतम तीन राउंड:

bash

1claude -p "कार्यान्वित करें: $TASK। टेस्ट चलाएँ। हरे होने पर कमिट करें।"
2review=$(codex exec "HEAD की समीक्षा करें ... VERDICT: PASS या FAIL और निष्कर्ष।")
3grep -q "VERDICT: PASS" <<< "$review" && exit 0
4claude -p "दूसरे मॉडल परिवार के एक समीक्षक ने ये समस्याएँ पाईं।
5  हर एक को ठीक करें, टेस्ट पुनः चलाएँ, कमिट करें: $review"

Claude Code के अंदर आप स्क्रिप्ट को पूरी तरह छोड़ सकते हैं।

OpenAI ने Claude Code के लिए एक आधिकारिक Codex प्लगइन जारी किया है, जो मार्च 2026 से लाइव है और नौ हफ्तों के भीतर लगभग बीस हजार GitHub स्टार्स तक पहुँच गया। यह बाजार आपको बता रहा है कि क्रॉस-वेंडर समीक्षा मुख्यधारा में आ गई है। एक बार इंस्टॉल करें:

text

1/plugin marketplace add openai/codex-plugin-cc
2/plugin install codex@openai-codex
3/codex:setup

किसी भी Claude सत्र में तीन क्रियाएँ:

/codex:review मानक पास के लिए
adversarial मोड, जो जानबूझकर आपके डिज़ाइन निर्णयों पर हमला करता है
बैकग्राउंड हैंडऑफ Codex को

किसी भी महत्वपूर्ण चीज़ पर adversarial का उपयोग करें। जब काम टर्मिनल-भारी हो, जहाँ Sol सबसे मजबूत है, तब हैंडऑफ का उपयोग करें।

अब बढ़ती संख्या में डेवलपर्स Claude Code के अंदर, BUILD 7 के प्रॉक्सी के माध्यम से GPT-5.6 Sol चला रहे हैं, और दैनिक कार्य के लिए इसे Codex से अधिक पसंद करते हैं।

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

पकड़ मूल-हार्नेस का नियम है, क्योंकि Sol Claude Code में अपने घर के बाहर चलता है। अपने खुद के eval सेट पर इसकी पुष्टि करें। यदि आपके eval कहते हैं कि विदेशी हार्नेस जीतता है, तो आपके eval बेंचमार्क से ऊपर हैं।

तीन गुण समीक्षक को रखने लायक बनाते हैं:

स्वच्छ संदर्भ। यह लेखक के किसी भी इतिहास के बिना आता है।
अलग वंशावली। यह लेखक के अंध-धब्बों को साझा नहीं करता।
मूल हार्नेस। यह पूरी ताकत से निर्णय करता है।

नरम निर्णय एक टूटा हुआ सत्यापनकर्ता है, इसलिए रिले शब्दशः होता है। तीसरा FAIL एक इंसान को पेज करता है, चौथा प्रयास नहीं लेता।

CHECK 6: two_lane.sh चलाएँ, या अपने अंतिम कमिट पर /codex:review चलाएँ। एक VERDICT .review फ़ाइल में आता है, और FAIL लेखक लेन पर वापस रूट होता है।

BUILD 7: वैकल्पिक फैन-आउट (शर्त दिखने पर इंस्टॉल करें)

स्काउट स्वार्म। तब इंस्टॉल करें जब शोध या कोडबेस आर्कियोलॉजी आपके दिन के 30 मिनट से अधिक खा जाए। तीन को समानांतर में अलग-अलग स्लाइस पर स्पॉन करें:

markdown

1---
2name: scout
3description: शोध फैन-आउट के लिए सस्ता समानांतर पाठक। कोडबेस सर्वेक्षण, निर्भरता ऑडिट, लॉग आर्कियोलॉजी, दस्तावेज़ शोध के लिए एक साथ कई को स्पॉन करें।
4  सिद्धांत से केवल-पढ़ने; पढ़ना फैन-आउट होता है, लिखना एकल-थ्रेडेड रहता है।
5model: haiku
6effort: low                # विरासत गार्ड (BUILD 4): एक स्वार्म जो अधिकतम प्रयास प्राप्त करता है, एक संदेश में विंडो खाली कर देता है
7tools: Read, Grep, Glob, Bash
8---
9
10आप संभवतः समानांतर में चलने वाले कई पाठकों में से एक हैं। अपने स्लाइस का सर्वेक्षण करें और छोटा और तीखा रिपोर्ट करें। केवल आपका अंतिम संदेश मूल तक पहुँचता है, इसलिए इसे 400 शब्दों से कम रखें और हर शब्द को अपनी जगह कमाए।
11
12  1. अपने असाइनमेंट को स्वयं एक स्लाइस तक सीमित करें (एक निर्देशिका, एक उपप्रणाली, एक प्रश्न), और बताएं कि आपने क्या सीमित किया।
13  2. केवल पढ़ना: Read, Grep, Glob, और केवल-पढ़ने वाला शेल (ls, git log, git show, rg)। कभी संपादित न करें, इंस्टॉल न करें, या हटाएं नहीं। यदि कार्य को लिखने की आवश्यकता है, तो इसे रिपोर्ट करें, करें नहीं।
14  3. पहले चौड़ाई, फिर दो या तीन सबसे गर्म स्थानों पर गहराई।
15
16रिपोर्ट प्रारूप, और कुछ नहीं:
17  FINDINGS: अधिकतम 10 बुलेट, प्रत्येक एक तथ्य अपने साक्ष्य के साथ (file:line, कमिट हैश, या URL)
18  GAPS: आप क्या निर्धारित नहीं कर सके और क्यों, ताकि मूल को पता चले कि अभी क्या अंधकार है
19  HOTSPOT: एकल फ़ाइल या फ़ंक्शन जो गहन नज़र का सबसे अधिक हकदार है, एक पंक्ति में क्यों
20
21संपादकीय न करें, कार्यान्वयन प्रस्तावित न करें, पैडिंग न करें। एक स्काउट जो 300 उपयोगी शब्द लौटाता है, उस स्काउट से बेहतर है जो 3,000 मिश्रित शब्द लौटाता है, क्योंकि आप जो कुछ भी उत्सर्जित करते हैं वह मूल के संदर्भ विंडो में आता है और मूल उसके लिए भुगतान कर रहा है।

पढ़ना फैन-आउट होता है क्योंकि समानांतर पाठक गुणा करते हैं। शब्द सीमा इसलिए मौजूद है क्योंकि हर रिपोर्ट एक संदर्भ विंडो में आती है जिसके लिए मूल भुगतान करता है।

लिखना कभी फैन-आउट नहीं होता। 2026 के एक समान-बजट अध्ययन में पाया गया कि टोकन स्थिर रहने पर एकल एजेंट मल्टी-एजेंट सेटअप से मेल खाते हैं। यह लेन केवल पढ़ने के लिए है।

रात भर बर्नर। तब इंस्टॉल करें जब TASKS.md में दस या अधिक छोटे सत्यापन योग्य आइटम हों। रात-भर-बर्नर कौशल फ़ाइलें सेट करता है, दोनों कैप की पुष्टि करता है, टेस्ट कमांड चलने की पुष्टि करता है, फिर ralph.sh लॉन्च करता है। सुबह का इंटरफ़ेस: git log, progress.log, टिक मार्क।

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

ट्रायो बेंच। तब इंस्टॉल करें जब एक कठिन बदलाव तीन दृष्टिकोणों का हकदार हो। दो भूमिकाएँ पढ़ती हैं और एक लिखता है, और चौथा पैन एक जाल है। पाइपलाइन नीचे बैठती है।

मिश्रित बेड़े के लिए पाइपलाइन

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

claude-model-switch (ओपन सोर्स, Rust, localhost:4000 पर चलता है)। Claude Code और किसी भी Anthropic- या OpenAI-संगत एंडपॉइंट के बीच एक स्थानीय प्रॉक्सी।

Claude Code के तीन आंतरिक स्तरों (haiku, sonnet, opus) को आपके प्रदाता की पेशकश के अनुसार मॉडलों पर रीमैप करता है
कॉन्फ़िग रीलोड के माध्यम से, बिना पुनरारंभ किए प्रदाताओं को स्विच करता है
स्लैश कमांड के साथ Claude Code प्लगइन के रूप में शिप करता है

bash

1claude-model-switch init                 # Claude Code को प्रॉक्सी पर इंगित करता है
2claude-model-switch add openrouter sk-or-xxx
3claude-model-switch add glm \
4  --haiku glm-4.5-air --sonnet glm-4.7 --opus glm-5
5claude-model-switch use glm              # प्रति सत्र, कभी भी कार्य के बीच में नहीं
6claude-model-switch orchestrate start --preset trio   # योजनाकार/कोडर/समीक्षक

ट्रायो प्रीसेट BUILD 7 की बेंच को भौतिक बनाता है: तीन tmux पैन, प्रत्येक भूमिका अलग प्रदाता पर, प्रत्येक पता योग्य (orchestrate send coder "माइलस्टोन 1 लागू करें"), मध्य-सत्र भूमिका पुनर्निर्धारण के साथ यदि कोई प्रदाता खराब हो जाए।

CLIProxyAPI (ओपन सोर्स)। वही ट्रिक, दूसरी दिशा में इंगित।

यह ChatGPT Codex, Claude Code, Gemini, और Grok के OAuth लॉगिन को OpenAI-, Claude-, और Gemini-संगत API एंडपॉइंट के रूप में लपेटता है।

अनुवाद: आप जिन सब्सक्रिप्शन सीटों के लिए पहले से भुगतान कर रहे हैं, वे [ralph.sh](https://ralph.sh/) और two_lane.sh जैसी स्क्रिप्ट के लिए रूटेबल API लक्ष्य बन जाती हैं, बिना अलग API कुंजियों के। समुदाय फोर्क इसे Factory और Amp तक विस्तारित करते हैं, और ccs जैसे रैपर मल्टी-अकाउंट स्विचिंग जोड़ते हैं।

दोनों को नियंत्रित करने वाला नियम, BUILD 6 के डेटा से: एक रीमैप किया गया मॉडल एक विदेशी हार्नेस में चलता है।

पाठक और समीक्षक लेन को स्वतंत्र रूप से रीमैप करें। वे सस्ते और सत्यापन योग्य हैं।

कोड लिखने वाली लेन को उसके हार्नेस के मूल मॉडल पर रखें, जब तक कि आपका खुद का eval सेट अन्यथा साबित न करे।

CHECK 7: प्रत्येक स्थापित फैन-आउट के बगल में उसकी ट्रिगर शर्त लिखी गई है। इनमें से किसी को भी अटकलबाजी में इंस्टॉल करना वही है जो स्टैक को फूलाता है।

BUILD 8: द फैक्ट्री (पूर्णता एक डेटाबेस तथ्य बन जाती है)

अब तक सब कुछ पल में काम साबित करता है। गेट, निर्णय और eval सेट सभी रन के दौरान फायर करते हैं।

एक बार जब एक से अधिक एजेंट किसी प्रोजेक्ट को एक से अधिक सत्रों में छूते हैं, तो आपको ऐसे प्रमाण की आवश्यकता होती है जो रन से बचे: किसने क्या काम किया, किस क्रम में, और क्या अंतिम समीक्षा चक्र साफ हुआ।

पैटर्न pi-factory डेमो (github.com/xpriment626/pi-factory) से आता है। मुख्य विचार एक वाक्य में है

एक थ्रेड एक ट्रेस है। एक पंक्ति साक्ष्य है। गेट पंक्तियों को पढ़ता है।

progress.log एक डायरी है। ब्लैकबोर्ड एक खाता-बही है। SQLite खाता-बही है क्योंकि सभी के बोलना बंद करने के बाद यह क्वेरी करने योग्य है।

factory/factory_gate.py बनाएँ। इसमें चार तालिकाएँ (tickets, briefs, evidence, verdicts), एक रिकॉर्ड कमांड जो प्रत्येक एजेंट काम करते समय कॉल करता है, और पूर्णता गेट होता है। गेट की विफलता की शर्तें स्वयं काम से मैप होती हैं:

python

1checks = [
2  (tickets == 0,                 "कोई टिकट दर्ज नहीं किया गया।"),
3  (done != tickets,              "सभी टिकट पूरे नहीं हुए।"),
4  (first_brief is None,          "कोई आर्किटेक्चर ब्रीफ दर्ज नहीं किया गया।"),
5  (first_brief > first_code,     "कार्यान्वयन साक्ष्य ब्रीफ से पहले का है।"),
6  (code_ev == 0,                 "कोई कार्यान्वयनकर्ता कोड साक्ष्य दर्ज नहीं किया गया।"),
7  (build_ok == 0,                "कोई सफल बिल्ड कमांड साक्ष्य नहीं।"),
8  (test_ok == 0,                 "कोई सफल टेस्ट कमांड साक्ष्य नहीं।"),
9  (latest("architect") != "green",  "नवीनतम आर्किटेक्ट निर्णय हरा नहीं है।"),
10  (latest("reviewer")  != "green",  "नवीनतम समीक्षक निर्णय हरा नहीं है।"),
11]

वह सूची पूरे सिद्धांत को एनकोड करती है।

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

factory/factory.sh बनाएँ, जो आपके द्वारा पहले से बनाई गई सीटों को रन ऑर्डर में जोड़ता है और प्रत्येक चरण के बीच पंक्तियों को रिकॉर्ड करता है:

bash

1G ticket "कानबान बोर्ड" "कॉलम रेंडर, ड्रैग पर्सिस्ट"    # योजनाकार पंक्तियाँ
2G brief  "$BRIEF"                                          # किसी भी कोड से पहले
3../loop/ralph.sh && G evidence code pass "लूप पूरा हुआ"  # BUILD 3 काम करता है
4npm test          && G evidence test pass "npm test हरा"
5G verdict 1 architect green "लेआउट ब्रीफ से मेल खाता है"         # Claude सीट
6G verdict 1 reviewer  green "टेस्ट पास, दायरा साफ"      # Sol सीट, codex के माध्यम से
7python3 factory_gate.py gate factory.db                    # पंक्तियाँ तय करती हैं

कुछ भी नया नियुक्त नहीं किया गया।

Fable टिकट काटता है और ब्रीफ लिखता है, केवल-पढ़ने के लिए। BUILD 3 लूप कार्यान्वित करता है। Claude और Sol प्रत्येक अपने हार्नेस से एक निर्णय लौटाते हैं। चक्र तीन बार तक दोहराता है जब तक दोनों हरे न हो जाएँ।

फैक्ट्री उन कर्मचारियों के लिए ऑर्ग चार्ट है जो आपके पास पहले से हैं।

एक वास्तविक रन, नकली नहीं। दूसरी गेट कॉल इस बिल्ड का पूरा तर्क है:

text

1$ factory_gate.py record demo.db ticket "kanban-board" "कॉलम रेंडर, ड्रैग पर्सिस्ट"
2
3$ factory_gate.py gate demo.db
4GATE: REFUSED
5  - सभी टिकट पूरे नहीं हुए।
6  - कोई आर्किटेक्चर ब्रीफ दर्ज नहीं किया गया।
7  - कोई कार्यान्वयनकर्ता कोड साक्ष्य दर्ज नहीं किया गया।
8  - कोई सफल बिल्ड कमांड साक्ष्य नहीं।
9  - कोई सफल टेस्ट कमांड साक्ष्य नहीं।
10  - कोई समीक्षा चक्र दर्ज नहीं किया गया।
11  exit: 1
12
13... एजेंट काम करते हैं। हर कदम एक पंक्ति लिखता है ...
14
15$ factory_gate.py record demo.db brief    "स्टैक: node+sqlite। /tasks CRUD।"
16$ factory_gate.py record demo.db evidence code  pass "src/board.js लिखा गया"
17$ factory_gate.py record demo.db evidence build pass "npm run build exit 0"
18$ factory_gate.py record demo.db done     "kanban-board"
19$ factory_gate.py record demo.db verdict 1 architect green "लेआउट ब्रीफ से मेल खाता है"
20$ factory_gate.py record demo.db verdict 1 reviewer  green "दायरा साफ"
21
22$ factory_gate.py gate demo.db
23GATE: REFUSED
24  - कोई सफल टेस्ट कमांड साक्ष्य नहीं।
25  exit: 1
26
27$ factory_gate.py record demo.db evidence test pass "npm test 33/33"
28
29$ factory_gate.py gate demo.db
30GATE: COMPLETE (1/1 टिकट, चक्र 1 हरा x2)
31  exit: 0

दोनों समीक्षकों ने हरा कहा। आर्किटेक्ट ने पुष्टि की कि लेआउट ब्रीफ से मेल खाता है। समीक्षक ने पुष्टि की कि दायरा साफ है।

और गेट ने फिर भी मना कर दिया, एक पंक्ति के साथ: कोई सफल टेस्ट कमांड साक्ष्य नहीं। किसी ने टेस्ट नहीं चलाए थे।

एक निर्णय एक राय है। दो राय अभी भी एक तथ्य नहीं हैं। एक साक्ष्य टेस्ट पास पंक्ति के बाद, वही गेट COMPLETE लौटाता है और 0 से बाहर निकलता है।

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

जब गेट मना करता है, तो वह गायब कलाकृति का नाम बताता है। यह "रन विफल हुआ" को "एक सफल टेस्ट पंक्ति उत्पन्न करें" में बदल देता है। एक कार्य, कोई रहस्य नहीं।

स्थापना शर्त: प्रति दिन एक से अधिक लेखक सत्र, समीक्षा चक्र जो दिनों तक चलते हैं, या बाद में यह साबित करने की आवश्यकता कि क्या हुआ। एकल रेपो के लिए एक रात्रि लूप के साथ, BUILD 3 पर्याप्त है और यह फूलापन है।

CHECK 8: स्क्रीनशॉट को पुन: उत्पन्न करें। एक टेस्ट पंक्ति को छोड़कर सब कुछ रिकॉर्ड करें, और गेट को ठीक एक कारण के साथ मना करना चाहिए। पंक्ति जोड़ें और यह COMPLETE लौटता है। एक गेट जो इसके बिना पास होता है, एक ट्रांसक्रिप्ट पाठक है।

BUILD 9: द स्वार्म (Fable योजना बनाता है, बेड़ा निष्पादित करता है, Fable स्कोर करता है)

एक ड्राइवर एक सलाहकार के साथ एक कार्य को कवर करता है। एक लक्ष्य जो चार स्वतंत्र टुकड़ों में विभाजित होता है, चार श्रमिकों की मांग करता है।

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

रंग 3 शाब्दिक बनाया गया। Fable लक्ष्य लिखता है, बेड़ा उन्हें निष्पादित करता है, Fable प्रत्येक परिणाम को अपनी जाँच के विरुद्ध स्कोर करता है, और अगला चक्र केवल छूटे हुए लक्ष्यों की पुनः योजना बनाता है।

इसका एबॉर्ट चक्र सीमा है। जब सीमा छूटे हुए लक्ष्यों के साथ ट्रिप करती है, तो यह एक इंसान के पास जाने वाली स्पेक समस्या है, चौथा चक्र चलाने का कारण नहीं।

swarm/swarm.sh बनाएँ। तीन सेटिंग्स सिद्धांत को वहन करती हैं:

bash

1FLEET=4                              # लिखना कभी नहीं टकराता: प्रत्येक का अपना वर्कट्री
2WORKER_MODEL=claude-sonnet-5         # या haiku / luna / kimi शुद्ध निष्पादन के लिए
3WORKER_EFFORT=low                    # कंडक्टर के प्रयास को कभी इनहेरिट न करें
4CONDUCTOR=claude-fable-5             # या opus-4-8 यदि प्रतिधारण नियम काटते हैं

वे तीन पंक्तियाँ स्पष्ट हैं क्योंकि डिफ़ॉल्ट ऐसा नहीं है।

एक बेड़ा जो इनहेरिट करता है, कंडक्टर का मॉडल और कंडक्टर का प्रयास दोनों उठाता है। एक Fable-एट-हाई कंडक्टर जो यांत्रिक काम करने के लिए चार Fable-एट-हाई श्रमिकों को स्पॉन करता है, सबसे सस्ती चीज़ करने का सबसे महंगा संभव तरीका है।

उन्हें सेट करें। उन्हें कभी डिफ़ॉल्ट न होने दें।

क्रॉस-हार्नेस फैन-आउट कानूनी है, और यह ROUTING.md के पहले नियम का अपवाद नहीं है जैसा दिखता है।

एक Fable कंडक्टर जो codex exec को शेल आउट करता है, Sol को Codex के अंदर, मूल रूप से चलाता है। यह नियम का पालन है, मोड़ नहीं।
जो नियम तोड़ता है वह एक Claude-पक्षीय उप-एजेंट है जो GPT मॉडल स्ट्रिंग पहनता है, या इसका उलटा।

हार्नेस श्रमिक के साथ यात्रा करता है, कंडक्टर के साथ नहीं।

कंडक्टर लक्ष्य लिखता है, कभी कोड नहीं, और प्रत्येक लक्ष्य अपना स्वयं का चेक कमांड वहन करता है, इसलिए किया गया एक तथ्य बना रहता है:

json

1{"id":"strip-legacy-auth","spec":"routes/ से v1 प्रमाणीकरण पथ हटाएँ","check":"npm test -- tests/auth"}
2{"id":"migrate-sessions","spec":"सत्र स्टोर को नए एडाप्टर में ले जाएँ","check":"npm test -- tests/session"}

फिर डिस्पैच, स्कोर, और पुनः योजना:

bash

1# डिस्पैच: प्रति लक्ष्य एक git वर्कट्री, FLEET तक समानांतर में
2claude --model "$WORKER_MODEL" --effort "$WORKER_EFFORT" -p "इस स्पेक को ठीक वैसे ही निष्पादित करें
3  जैसा है। दायरे का विस्तार न करें। टेस्ट चलाएँ। हरे होने पर ही कमिट करें।"
4
5# स्कोर: कंडक्टर प्रत्येक लक्ष्य को उसके अपने चेक कमांड के विरुद्ध ग्रेड करता है।
6# कार्यकर्ता का आत्मविश्वास साक्ष्य नहीं है। एग्जिट कोड साक्ष्य है।
7bash -c "$chk" && echo "$id" >> passed.txt || misses=$((misses+1))
8
9# पुनः योजना: अगला चक्र passed.txt देखता है और केवल छूटे हुए लक्ष्यों की पुनः योजना बनाता है

सीट दर सीट:

Sonnet 5 कोडिंग निष्पादन के लिए
Haiku या Luna शुद्ध यांत्रिक कार्य के लिए
Kimi जैसा ओपन-वेट वर्कर जब काम दोहराव वाला हो और वेट मुफ्त हों
Sol जब काम टर्मिनल-भारी हो
Opus 4.8 कार्यकर्ता सीट में, केवल जब एक उप-एजेंट को तर्क करने की आवश्यकता हो

Fable को केवल उन दो कार्यों के लिए आरक्षित रखें जो कोई सस्ता मॉडल नहीं कर सकता: लक्ष्य लिखना, और उन्हें ग्रेड करना।

एक बेड़ा एक लागत रणनीति है, बुद्धिमत्ता रणनीति कभी नहीं।

मल्टी-एजेंट रन समतुल्य कार्य के लिए 3 से 10 गुना टोकन जलाते हैं, और 2026 के एक समान-बजट अध्ययन में पाया गया कि टोकन स्थिर रहने पर एकल एजेंट उनसे मेल खाते हैं।

एक झुंड अपना रखरखाव तभी कमाता है जब लक्ष्य स्वतंत्र और अधिकतर यांत्रिक हों। लिखना प्रति वर्कट्री एकल-थ्रेडेड रहता है, मर्ज क्रमिक रूप से होते हैं, और एक इंसान अंतिम कमिट लेता है।

CHECK 9: एक लक्ष्य पर झुंड चलाएँ जो तीन तरह से विभाजित होता है। एक टूटा हुआ लक्ष्य results.tsv में FAIL के रूप में वापस आना चाहिए और चक्र 2 में पुनः योजना बनाई जानी चाहिए, कभी पूरा घोषित नहीं किया जाना चाहिए।

BUILD 10: रंग 4 (जो एक बार पास हुआ, वह कभी अनदेखा नहीं रहता)

अब तक सब कुछ काम को बनाते समय सत्यापित करता है। अब तक कुछ भी तब नहीं देखता जब तैयार काम छह हफ्ते बाद सच होना बंद हो जाता है। एक लक्ष्य जिसे आप एक बार सत्यापित करते हैं, वह एक टाइमस्टैम्प वाली धारणा है।

रंग 4 के दो हिस्से हैं, और इसका एबॉर्ट उतना ही मायने रखता है जितना इसका एग्जिट: यदि इस सप्ताह कोई प्रस्ताव गेट को साफ नहीं करता है, तो सिस्टम नहीं बदलता है, और यह एक सफलता है।

आधा एक, स्थायी लक्ष्य। प्रत्येक तैयार चीज़ एक इन्वेरिएंट में एक विधेय के साथ स्नातक होती है, प्रतिदिन पुनः सत्यापित, हमेशा के लिए। goals/ में प्रति तैयार चीज़ एक फ़ाइल बनाएँ:

text

1predicate: npm test -- tests/auth 2>&1 | tail -1 | grep -q passing
2born: 2026-07-13
3status: satisfied
4last-pass: 2026-07-13
5on-violation: मुझे जगाओ। अपने आप ठीक मत करो।

फिर system/verify_goals.py पूरे को चलाता है और 1 से बाहर निकलता है यदि कोई इन्वेरिएंट टूटा है, लक्ष्य, वह तारीख जब उसने आखिरी बार पकड़ा था, और आपके द्वारा निर्धारित नीति का नाम बताता है:

python

1held = subprocess.run(["bash","-c",predicate], timeout=60).returncode == 0
2g["status"] = "satisfied" if held else "VIOLATED"
3# टाइमआउट एक उल्लंघन है, पास नहीं: एक महंगा विधेय एक टूटा हुआ है

विधेय नियम जानबूझकर सख्त हैं: एक शेल कमांड, एग्जिट 0 का मतलब है कि इन्वेरिएंट मान्य है, सस्ता और केवल-पढ़ने के लिए।

विशेषण प्रतिबंधित हैं। यदि एक शेल इसे जाँच नहीं सकता, तो एक मॉडल भी नहीं कर सकता।

गैर-कोड लक्ष्य उसी तरह काम करते हैं। test -s reports/$(date +%Y-%m)-review.md मासिक रिपोर्ट के लिए एक अच्छा स्थायी लक्ष्य है।

आधा दो, खाद। सप्ताह में एक बार, सिस्टम द्वारा पहले से उत्पादित निकास को पढ़ें: BLOCKED कार्य, विफल गेट रन, अस्वीकृत फैक्ट्री गेट, वापस लिए गए PR, उल्लंघन किए गए लक्ष्य।

फिर अधिकतम तीन बदलाव प्रस्तावित करें। संविधान के लिए एक नया कानून। एक कौशल का सुधार जो उसी तरह विफल होता रहता है। या एक स्थायी लक्ष्य जो आपसे छूट गया था।

केवल प्रस्तावित करें। आप हस्ताक्षर करते हैं।

bash

1claude --model claude-fable-5 --effort high --allowedTools "Read,Grep,Glob" \
2  -p "इस सप्ताह का निकास पढ़ें: progress.log में BLOCKED लाइनें, GATE REFUSED प्रविष्टियाँ, VIOLATED लक्ष्य, बिना मर्ज किए बंद PR। अधिकतम 3 प्रस्ताव निकालें: एक नया कानून (घटनाओं को उद्धृत करें), एक कौशल सुधार (वही विफलता दोहरा रही है), या एक स्थायी लक्ष्य जिसकी हमें कमी थी। केवल प्रस्तावित करें, कुछ भी संपादित न करें। साफ सप्ताह एक वैध उत्तर है, ऐसा कहें और रुक जाएँ।"

यह रंग तभी बंद होता है जब eval और जज कहते हैं कि सिस्टम बेहतर हुआ है। जिसका मतलब है कि सिस्टम को सुधार के लिए अपनी खुद की विफलताओं की स्मृति की आवश्यकता है।

खाद रन वह है जो एक स्क्रिप्ट को एक संस्था में बदल देता है।

स्थायी लक्ष्य वह हैं जो समाप्त करना सुरक्षित बनाते हैं। संतरी पता लगाता है, सामान्य पाइपलाइन ठीक करती है, और चुपचाप कुछ भी सड़ता नहीं है।

CHECK 10: verify_goals.py डेमो टूटे हुए इन्वेरिएंट का नाम उसकी अंतिम-पास तिथि के साथ बताता है और स्वस्थ को अकेला छोड़ देता है। फिर अपने द्वारा पूरी की गई अंतिम चीज़ के लिए एक वास्तविक स्थायी लक्ष्य लिखें।

BUILD 11: रंग 5 (आपकी सीट, और यह कभी खाली क्यों नहीं होती)

रंग 5 आपका नाम एक यांत्रिक कारण से रखता है, भावनात्मक नहीं।

एक लूप अपनी रुकने की शर्त को हिट कर सकता है और फिर भी गलत हो सकता है। टेस्ट पास होते हैं, गेट हरा हो जाता है, दोनों समीक्षक हस्ताक्षर करते हैं, और अंतिम कमिट फिर भी एक गलती है।

इसके नीचे हर बिल्ड उस जोखिम को कम करने के लिए मौजूद है। उनमें से कोई भी इसे मिटाता नहीं है।

आपके स्थायी कर्तव्य, सभी सस्ते:

कतार को कॉफी के साथ पढ़ें: BLOCKED कार्य, GATE REFUSED लाइनें, VIOLATED लक्ष्य, सस्ता-स्तर हिस्सा। दस मिनट।
मर्ज करने से पहले अंतिम कमिट की जाँच करें। हर डिफ नहीं, आखिरी वाला, वह जिसके बारे में सिस्टम सबसे अधिक आश्वस्त था।
तीन खाद प्रस्तावों पर हस्ताक्षर करें या अस्वीकार करें। यही एकमात्र तरीका है जिससे कानून संविधान में प्रवेश करते हैं।

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

नाटक एक, परियोजना फीडबैक लूप, मासिक।

Fable को उस चीज़ पर इंगित करें जो आपने पहले ही शिप की है, केवल-पढ़ने के लिए, और उसे एक विस्तृत सुधार योजना लिखने दें। फिर उस योजना का निष्पादन Opus 4.8 या Sol को सौंपें।

महंगा मॉडल वह हिस्सा करता है जो चक्रवृद्धि करता है, यह निर्णय कि क्या बदलना है, और कभी वह हिस्सा नहीं करता जो नहीं करता, टाइपिंग।

bash

1claude --model claude-fable-5 --effort high --allowedTools "Read,Grep,Glob" \
2  -p "इस परियोजना की सिरे से सिरे तक समीक्षा करें। लीवरेज के अनुसार रैंक की गई सुधार योजना लिखें: क्या नाजुक है, क्या अति-निर्मित है, क्या गायब है, क्या हटाया जाना चाहिए। कोड न लिखें। स्वीकार्यता मानदंड के साथ कार्य आउटपुट करें।" \
3  > plans/$(date +%F)-improvement.md

प्ले दो, व्यवहार विश्लेषण, मासिक।

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

यह सिस्टम की एकमात्र रिपोर्ट है जिसका विषय आप हैं। यह आमतौर पर वह होती है जो सबसे अधिक बदलती है।

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

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

चेक 11: अपने खुद के रेपो पर प्ले वन चलाएं। यदि योजना उन चीज़ों का नाम नहीं लेती है जिन्हें आप पहले से जानते थे कि वे कमज़ोर हैं, तो आपकी संदर्भ फ़ाइलें बहुत पतली हैं, जो एक बिल्ड 1 की समस्या है।

बिल्ड 12: ऑप्स

एजेंट चैट कॉल के टोकन की तुलना में 10 से 100 गुना अधिक टोकन जलाते हैं, और इनपुट लगभग 100 से 1 के अनुपात में हावी होता है।

बिल्ड 0 के चार लीवरों (स्प्लिट, कैश, बैच, कॉम्पैक्शन) को स्टैक करें और टीमें अपने अनऑप्टिमाइज़्ड बेसलाइन से 70 से 90 प्रतिशत नीचे आने की रिपोर्ट करती हैं।

सामान्य जानकारी के लिए: $13 प्रति डेवलपर प्रति सक्रिय दिन क्लॉड कोड एंटरप्राइज़ औसत है, और 90 प्रतिशत उपयोगकर्ता $30 से नीचे रहते हैं।

एक नए सबसिस्टम के बजाय एक पंक्ति का अनुशासन: एक टास्क क्लास 20 लॉग किए गए रन के बाद 95 प्रतिशत पास दर पर ही ऑटो-मर्ज हो सकता है, और 90 प्रतिशत से नीचे एक भी गिरावट इसे जोरदार तरीके से रद्द कर देती है।

bash

1awk -F'\t' '$2=="fix-lint"{r++; if($3=="pass")p++}
2  END{printf "%d runs, %.0f%%\n", r, (r?p/r*100:0)}' progress.log

साप्ताहिक खर्च, प्रति-टिक लागतों से जो ralph.sh पहले से लॉग करता है:

bash

1grep '^cost' progress.log | awk -F'\t' \
2  -v d="$(date -d '7 days ago' +%F)" \
3  '$2>=d{s+=$3} END{printf "week: $%.2f\n", s}'

क्रॉन करने से पहले मेटाबोलिज़्म की गणना करें। दैनिक लागत टिक्स गुना औसत टिक लागत है।

वह सीट जो शांत नो-वर्क टिक को संभालती है, बिल तय करती है। सस्ते टियर पर सेंट, एक फ्रंटियर मॉडल पर उच्च प्रयास पर डॉलर, समान "कुछ नहीं करने" के उत्तर के लिए।

अपनी सीमाओं के भीतर चलना

ये मॉडल तेज़ी से टोकन जलाते हैं, और आप उन्हें कैसे चलाते हैं, यह तय करता है कि दीवार से टकराने से पहले एक दिन का कितना काम पूरा होता है।

पहले, जानें कि कौन सी दीवार है।

API कुंजी पर, दीवार बिल है। progress.log पहले से ही इस पर नज़र रखता है।
सब्सक्रिप्शन सीट पर, दीवार पांच घंटे की खिड़की और एक साप्ताहिक खिड़की है जिसका एक साथ मूल्यांकन किया जाता है। उपरोक्त लॉग में इनमें से कोई भी दिखाई नहीं देता है।

उस मीटर पर नज़र रखें जिस पर आप वास्तव में हैं: कोडेक्स सेटिंग्स में उपयोग पैनल, क्लॉड साइड पर /usage, या स्क्रीन के कोने में रखा एक मॉनिटर जैसे ccusage या codexbar।

एक सीमा जिसे आप कभी नहीं पढ़ते, वह एक सीमा है जिसे आप टकराकर खोजते हैं, घड़ी पर चार घंटे शेष और चलाने के लिए कुछ नहीं के साथ।

छह लीवर, पहले सबसे सस्ता। अधिकांश सोपान 0 से 2 पर कार्य करते हैं, जहाँ टोकन जलते हैं:

CLAUDE.md और AGENTS.md को आवश्यकताओं तक छाँटें। प्रत्येक एकल प्रॉम्प्ट उन्हें पढ़ता है, साथ ही आपके द्वारा सक्षम प्रत्येक कौशल और उपकरण। जो उपयोग नहीं कर रहे हैं उसे बंद कर दें; एक अप्रयुक्त MCP सर्वर हर संदेश पर कर है।
जब आपको सीढ़ी के शीर्ष की आवश्यकता नहीं हो तो प्रयास कम करें। डिफ़ॉल्ट मध्यम या उच्च। उन समस्याओं के लिए अधिकतम बचाएं जिन्हें इसकी आवश्यकता है। और पुष्टि करें कि फास्ट मोड बंद है, जबकि आप वहाँ हैं, क्योंकि यह आप जो भी चुनते हैं उसे कई गुना बढ़ा देता है।
मॉडल को स्पष्ट रुकने के बिंदु दें। ये मॉडल डिज़ाइन के अनुसार लंबे समय तक चलते हैं। उन्हें निष्पादित करने से पहले योजना समाप्त करने और जाँच करने के लिए कहें, जो प्लान मोड का वास्तविक काम है।
उप-एजेंटों को कम प्रयास पर रखें। वे माता-पिता के मॉडल और उसके डायल दोनों को प्राप्त करते हैं, और अधिकतम पर एक झुंड एक संदेश में एक खिड़की खाली कर देता है। सस्ता फिक्स दोनों संविधानों में एक कानून है: पूछे बिना प्रजनन न करें।
महंगे मॉडल को थोक से दूर रखें। चाहे Fable एक कम-टोकन कंडक्टर के रूप में शीर्ष पर बैठे या एक सलाहकार के रूप में कॉल पर, यह निर्णय बिंदुओं पर अपनी कीमत कमाता है, कभी भी हज़ारवीं पंक्ति टाइप करते समय नहीं।
पढ़ें कि एक संदेश की लागत क्या है, फिर उपरोक्त पांच को उस संख्या के विरुद्ध ट्यून करें। यह एकमात्र लीवर है जो बताता है कि अन्य पांच में से कौन सी आपकी समस्या है।

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

क्रॉन, जब सप्ताह 2 शुरू होता है:

bash

1# task loop: the daily tick, both caps set
20 7 * * 1-5   cd /path/to/repo/loop && BUDGET_USD=5 ./ralph.sh >> ../progress.log 2>&1
3
4# system loop: nothing that passed once goes unwatched
530 7 * * *    cd /path/to/repo && python3 system/verify_goals.py goals/ >> progress.log 2>&1
6
7# system loop: failures become laws, once a week, proposals only
80 9 * * 1     cd /path/to/repo && codex --profile deep exec \
9              "$(cat ~/.codex/prompts/compost.md)" >> proposals/$(date +\%F).md 2>&1

रनबुक। प्रत्येक अलार्म, और इसके बारे में क्या करना है:

30-दिन का शेड्यूल। ग्रेजुएशन को न छोड़ें; प्रत्येक अगले को अनलॉक करता है।

द कमांड डेक

यहाँ का हर लूप एक कीस्ट्रोक से पहुँच योग्य है। स्लैश कमांड कोडेक्स साइड पर ~/.codex/prompts/ में रहते हैं, जहाँ फ़ाइल का नाम कमांड बन जाता है, और क्लॉड साइड पर .claude/skills/ में। CLI क्लिप्स हेडलेस वर्शन हैं जिन्हें क्रॉन और CI चलाते हैं।

कोडेक्स स्लैश कमांड

/plan-stop और /effort सबसे तेज़ भुगतान करते हैं। दोनों कुछ सौ टोकन खर्च करके आपको कुछ सौ हज़ार खर्च करने से रोकते हैं।

ये मॉडल लंबे समय तक चलते हैं, इसलिए आपको जो चेकपॉइंट चाहिए वह खर्च से पहले आता है। /plan-stop योजना, डन-व्हेन कमांड, ब्लास्ट रेडियस, लागत और एक प्रश्न लौटाता है जो वह मानव से पूछेगा। फिर यह रुक जाता है।

दोनों फ़ाइलों को ~/.codex/prompts/ में डालें, जहाँ फ़ाइल का नाम कमांड बन जाता है।

effort.md /effort बन जाता है, रूटिंग डायल स्पष्ट किया गया:

markdown

1# /effort - खर्च करने से पहले प्रयास स्तर चुनें
2
3अभी तक कार्य का उत्तर न दें। पहले इसे रूट करें।
4
5इसे स्कोर करें। प्रत्येक के लिए एक अंक:
6  - इसमें एक क्यों, एक डीबग, एक रेस, एक डेडलॉक, एक रीफैक्टर, एक सुरक्षा चिंता,
7    या एक ऑप्टिमाइज़ शामिल है
8  - एक से अधिक सबसिस्टम को छूता है
9  - पिछला प्रयास पहले ही विफल हो चुका है
10  - परिवर्तन अपरिवर्तनीय है या उपयोगकर्ताओं के सामने आता है
11
12फिर मैप करें:
13
14| स्कोर | प्रयास | सीट |
15|---|---|---|
16| 0-1 | कम | codex -e low, या प्रोफ़ाइल तेज़ (Luna)। इस पर कभी फ्रंटियर सीट न लगाएं। |
17| 2 | मध्यम | Terra मध्यम पर सीट है। |
18| 3+ | उच्च | वास्तविक काम के लिए डिफ़ॉल्ट, और जहाँ स्वीट स्पॉट बैठता है। |
19
20केवल अगर उच्च पहले ही आज़माया जा चुका है और विफल रहा है: अधिकतम की सिफारिश करें, और स्पष्ट रूप से बताएं कि अतिरिक्त सोच से क्या खरीदने की उम्मीद है। आप जिस आधार दर के खिलाफ बहस कर रहे हैं वह लगभग दोगुनी लागत है जो आमतौर पर भुगतान नहीं करती है।
21
22अपग्रेड की सिफारिश करने से पहले दो अनुस्मारक:
23  1. कम प्रयास पर एक बेहतर मॉडल आमतौर पर अधिकतम पर एक कमजोर मॉडल को हरा देता है। डायल से पहले सीट बदलें।
24  2. यदि यह कार्य उप-एजेंटों को जन्म देता है, तो उनके प्रयास को स्पष्ट रूप से बताएं (जब तक अन्यथा साबित न हो, कम)। उप-एजेंट माता-पिता को प्राप्त करते हैं, और अधिकतम पर एक बेड़ा एक संदेश में संदर्भ विंडो खाली कर देता है।
25
26बिल्कुल आउटपुट:
27  EFFORT: कम | मध्यम | उच्च | अधिकतम
28  SEAT: <model>
29  WHY: <एक पंक्ति, उन बिंदुओं का नामकरण जिन्होंने स्कोर किया>
30  SUBAGENTS: <पिन करने के लिए प्रयास, या कोई नहीं>
31फिर रुकें। मानव आपके द्वारा नामित स्तर पर कार्य चलाता है।

एक लाइव उत्तर इस तरह दिखता है, और कुछ सौ हज़ार से बचने के लिए इसकी लागत कुछ सौ टोकन है:

text

1EFFORT: उच्च
2SEAT: gpt-5.6-sol
3WHY: इसमें "क्यों" शामिल है, auth और सत्रों को छूता है, पिछला प्रयास विफल रहा
4SUBAGENTS: कम

plan-stop.md /plan-stop बन जाता है, खर्च से पहले चेकपॉइंट:

markdown

1# /plan-stop - काम की योजना बनाएं, फिर रुकें
2
3ये मॉडल लंबे समय तक चलते हैं। जब योजना सही होती है तो यह एक विशेषता है और जब यह नहीं होती है तो गलत होने का एक महंगा तरीका है। यह कमांड खर्च से पहले चेकपॉइंट खरीदता है।
4
5कार्य की योजना बनाएं। एक भी फ़ाइल संपादित न करें। एक भी बिल्ड न चलाएं। शुरू न करें।
6
7उत्पादन करें:
8  GOAL: <एक पंक्ति>
9  ASSUMPTIONS: <आप क्या मान लेते हैं; यदि ये गलत हैं, तो योजना भी गलत है>
10  STEPS: <क्रमांकित, प्रत्येक एक कमिट के काम के बराबर>
11  DONE_WHEN: <सटीक शेल कमांड जो साबित करता है कि प्रत्येक चरण उतरा>
12  BLAST RADIUS: <छुई गई फ़ाइलें और सिस्टम; auth, भुगतान, माइग्रेशन, प्रोड कॉन्फ़िग का स्पष्ट रूप से नाम बताएं>
13  COST: <मोटे तौर पर टोकन या डॉलर, और प्रत्येक चरण कौन सी सीट चलाती है>
14  UNKNOWNS: <आप मानव से क्या पूछेंगे यदि आप केवल एक प्रश्न पूछ सकते हैं>
15
16फिर रुकें और प्रतीक्षा करें।
17
18योजना बनाते समय नियम:
19  - अस्पष्टता UNKNOWNS में जाती है। अनुमान लगाकर और आगे बढ़कर इसे हल न करें। एक अनुमान जो निष्पादन में जीवित रहता है, एक प्रश्न से सौ गुना अधिक खर्च करता है।
20  - यदि योजना को एक क्रेडेंशियल, एंडपॉइंट, या सम्मेलन की आवश्यकता है जो इस रेपो में नहीं लिखा गया है, तो रुकें और कहें। कभी आविष्कार न करें।
21  - यदि कोई DONE_WHEN शेल कमांड नहीं है, तो उस चरण को फिर से लिखें जब तक वह न हो जाए। यदि शेल इसे जांच नहीं सकता, तो समीक्षक भी नहीं कर सकता।
22  - यदि ब्लास्ट रेडियस AGENTS.md में नेवर-लिस्ट को छूता है, तो शीर्ष पर ऐसा कहें और मानव के लिए कतारबद्ध करने की सिफारिश करें।
23
24आपको यहाँ योजना के लिए भुगतान किया जाता है, डिफ के लिए नहीं। वास्तविक अज्ञात के साथ एक छोटी ईमानदार योजना, एक आत्मविश्वासी योजना से बेहतर है जिसने चुपचाप गलत चीज़ मान ली।

fable-advice.md और review-hostile.md /fable-advice और /review-hostile बन जाते हैं। दोनों उन फ़ाइलों के कोडेक्स-साइड मिरर हैं जिन्हें आपने पहले ही लिखा है: बिल्ड 5 से सलाहकार ब्रीफ, और बिल्ड 6 से शत्रुतापूर्ण-समीक्षक अनुबंध। समान नियम, समान सीमाएं, विक्रेता लाइन के पार दूसरी दिशा में इंगित।

compost.md /compost बन जाता है, सोपान 4 का साप्ताहिक संस्थान-निर्माता:

markdown

1# /compost - इस सप्ताह की विफलताओं को अगले सप्ताह के कानूनों में बदलें
2
3इस सप्ताह का निकास पढ़ें, सब कुछ, और कुछ नहीं:
4  - progress.log में BLOCKED पंक्तियाँ (ऐसे कार्य जिन्होंने तीन सलाहकार परामर्शों को हराया)
5  - GATE: REFUSED प्रविष्टियाँ (एक रन जो साबित नहीं कर सका कि वह पूरा हो गया था)
6  - VIOLATED स्थायी लक्ष्य (कुछ समाप्त हो गया सच होना बंद हो गया)
7  - सर्किट-ब्रेकर और बजट निकास (कोड 2 और 3)
8  - लूप द्वारा खोले गए और बिना मर्ज किए बंद किए गए PR (मानव ने चुपचाप असहमति जताई)
9  - कोई भी टास्क क्लास जिसकी पास दर 90 प्रतिशत से नीचे गिर गई
10
11अधिकतम तीन प्रस्ताव निकालें। तीन एक कठोर सीमा है, लक्ष्य नहीं। एक साफ सप्ताह एक वैध निष्कर्ष है, और ऐसा कहना काम गढ़ने से अधिक उपयोगी है।
12
13प्रत्येक प्रस्ताव बिल्कुल इनमें से एक है:
14  1. CLAUDE.md या AGENTS.md के लिए एक नया कानून। उन घटनाओं को उद्धृत करें जिन्हें इसने रोका होता। एक घटना के पीछे एक कानून एक संयोग है; दूसरे की प्रतीक्षा करें।
15  2. एक कौशल फिक्स, जब एक ही विफलता एक ही स्थान पर दोहराई जाती है। कौशल, पैटर्न और सबसे छोटे संपादन का नाम बताएं जो इसे तोड़ता है।
16  3. एक स्थायी लक्ष्य जो आपको याद आ रहा था, जब कुछ चुपचाप सड़ गया। विधेय को शेल कमांड के रूप में लिखें, या प्रस्ताव न करें।
17
18आउटपुट:
19  WEEK: <तारीखें>
20  EXHAUST: <गणना: अवरुद्ध, अस्वीकृत, उल्लंघन, वापस लिया गया>
21  PROPOSAL n: <कानून | कौशल फिक्स | स्थायी लक्ष्य>
22    EVIDENCE: <घटनाएँ, उद्धृत>
23    CHANGE: <जोड़ने के लिए सटीक पाठ या विधेय>
24    COST OF NOT DOING IT: <एक पंक्ति>
25  VERDICT: <यदि आप केवल एक ही कर सकते तो आप पहले क्या करेंगे>
26
27कठोर नियम:
28  - केवल प्रस्ताव करें। CLAUDE.md, AGENTS.md, किसी भी कौशल या किसी भी लक्ष्य फ़ाइल को संपादित न करें। मानव हस्ताक्षर करता है, या यह नहीं होता है।
29  - ऐसा कानून प्रस्तावित न करें जो गेट को नरम करता हो, बजट बढ़ाता हो, या नेवर को आराम देता हो। वे सिस्टम हैं जो अधिक आराम से विफल होने की अनुमति मांग रहे हैं।
30  - खाली निकास: "साफ सप्ताह" कहें और रुकें। रन को सही ठहराने के लिए काम की तलाश में न जाएं।

CLI क्लिप्स

इन्हें एक स्क्रैच फ़ाइल में रखें। ये पूरा सिस्टम हैं जो एक टर्मिनल से पहुँच योग्य है:

bash

1# the daily tick, capped in both dimensions
2BUDGET_USD=5 MAX_ITERS=20 ./loop/ralph.sh
3
4# plan first, spend later (the single highest-leverage habit here)
5codex -e high exec "$(cat ~/.codex/prompts/plan-stop.md)
6
7TASK: migrate the session store off the legacy adapter"
8
9# cross-vendor review of the last commit, in Sol's native harness
10codex --profile deep exec "$(cat ~/.codex/prompts/review-hostile.md)"
11
12# the mirrored lane: Codex stuck, Claude advises
13claude --model claude-fable-5 --effort high -p "$(cat ~/.codex/prompts/fable-advice.md)"
14
15# the goal loop: Fable plans, the fleet runs, Fable scores
16CYCLES=3 FLEET=4 WORKER_EFFORT=low ./swarm/swarm.sh "split the auth migration"
17
18# the system loop: nothing that passed once goes unwatched
19python3 system/verify_goals.py goals/          # exit 1 names what rotted
20python3 gate/eval_gate.py eval/cases.jsonl     # exit 1 blocks the routing change
21
22# rung 3, the factory: rows decide, not transcripts
23./factory/factory.sh "build the kanban and notes app per PRD.md"
24python3 factory/factory_gate.py gate factory.db
25
26# the weekly institution-building run
27codex --profile deep exec "$(cat ~/.codex/prompts/compost.md)"
28
29# the one number that says whether any of this worked
30grep '^route' progress.log | awk -F'\t' \
31  '{n++; if($3!="frontier") c++} END{printf "cheap share: %.0f%%\n", c/n*100}'

पूर्ण नीति बिल्ड 4 से ROUTING.md में रहती है, जिसे दोनों हार्नेस पढ़ते हैं।

नियम (इसे प्रिंट करें)

कानून, सुझाव नहीं: एक संख्या, एक नेवर, या एक कमांड जो इसे जांचता है।
मॉडल किराए पर है। लूप आपका है। आप सोपान 5 पर रहते हैं।
बिना रद्दीकरण वाला लूप एक बिल है। प्रत्येक पर दो सीमाएं: पुनरावृत्तियाँ और डॉलर।
साक्ष्य ऊपर बहता है, नियंत्रण नीचे बहता है। कोई सोपान अपने नीचे की रिपोर्ट पर बंद नहीं होता है।
एक लूप रुक सकता है और फिर भी गलत हो सकता है। मर्ज करने से पहले अंतिम कमिट जांचें।
सीमाओं पर रूट करें। मॉडल से पहले प्रयास। कैश स्विच करने के खिलाफ वोट करता है।
डिफ़ॉल्ट उच्च। अधिकतम गहराई है, अल्ट्रा चौड़ाई है, फास्ट मोड 2.5x कर है, और उप-एजेंट माता-पिता की सीट और डायल दोनों प्राप्त करते हैं।
राउटर तब तक दोषी है जब तक वह आपके मूल्यांकन पर सर्वश्रेष्ठ एकल मॉडल को नहीं हरा देता।
बचत ट्रैफिक स्प्लिट है। दर कार्ड नहीं, सस्ता हिस्सा देखें।
निष्पादन थोक है, सलाह ग्राम है। परामर्श को तीन पर सीमित करें।
कोई भी अपना होमवर्क ग्रेड नहीं करता है। ताजा संदर्भ, अन्य वंशावली, देशी हार्नेस।
एक थ्रेड एक ट्रेस है। एक पंक्ति साक्ष्य है। गेट पंक्तियाँ पढ़ता है।
इसे पास करने के लिए कभी भी परीक्षण संपादित न करें। कभी भी अवरुद्ध गेट को पार करके मर्ज न करें।
एक लक्ष्य जिसे आप एक बार सत्यापित करते हैं, वह एक टाइमस्टैम्प वाली धारणा है।
एक बार में एक ग्रेजुएशन। हर महीने, कुछ हटाएं।

समापन

अब से तीस दिन बाद, यदि आपने जाँच की:

एक लूप एक नियतात्मक गेट के पीछे, बिना निगरानी के उबाऊ काम भेजता है
एक सस्ता ड्राइवर केवल तभी फ्रंटियर विशेषज्ञ को फोन करता है जब वह अटक जाता है
प्रत्येक सार्थक डिफ का मूल्यांकन एक ऐसे मॉडल द्वारा किया जाता है जिसने इसे नहीं लिखा
progress.log में एक संख्या बताती है कि क्या अर्थशास्त्र चक्रवृद्धि हो रहा है

मॉडल कभी कठिन हिस्सा नहीं थे। एक सिस्टम जो ईमानदार रहता है जब आप देखना बंद कर देते हैं, कठिन हिस्सा है, और यही कारण है कि सोपान 5 पर अभी भी आपका नाम है।

आज रात उन बीस मिनट से शुरू करें जो इसे साबित करते हैं। बिल्ड 2 का verify.sh। बिल्ड 3 का एक हाथ से चलाया गया टिक। आपकी अंतिम कमिट पर दूसरी वंशावली से एक समीक्षा।

पहली बार जब एक समीक्षक जो लेखक के साथ कोई संदर्भ साझा नहीं करता है, उस काम में एक वास्तविक बग पाता है जिसे आप सुनिश्चित थे कि पूरा हो गया था, आपको बाकी के बारे में समझाने की आवश्यकता नहीं होगी।

आज रात गेट बनाएं। उत्तर दें कि इसने पहले रन पर क्या पकड़ा।

अस्वीकरण

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

यह लेख लेखक के नोट्स से लिखा गया था जैसा कि पूर्वोक्त पैराग्राफ में उल्लेख किया गया है और क्लॉड ओपस 4.7 के साथ संपादित किया गया है।

यदि आप कोई अन्य सुधार जोड़ना चाहते हैं, तो कृपया टिप्पणियों में जोड़ें।

AI एजेंट स्टैक जिसे हर किसी को GPT 5.6 + Fable 5 के साथ इस्तेमाल करना चाहिए (बिल्डर्स गाइड)

परिचय

मानचित्र, और सामान्य वाला गलत क्यों है

साक्ष्य सीढ़ी

पूर्वापेक्षाएँ

आप क्या बना रहे हैं

बिल्ड 0: इंजन कॉन्फ़िगर करें

बेंच: हर सीट, जुलाई 2026

दूसरा मीटर: एक सीट एक API कुंजी नहीं है

सोल और टेरा दोनों सही डिफ़ॉल्ट क्यों हैं

बिल्ड 1: संविधान

बिल्ड 2: गेट

बिल्ड 3: द हार्टबीट

बिल्ड 4: द राउटर जो अपनी नौकरी कमाता है (मॉडल, फिर एफर्ट)

एफर्ट दूसरा डायल है

ROUTING.md, वह नीति जिसे दोनों हार्नेस पढ़ते हैं

बिल्ड 5: द एडवाइज़र इन्वर्ज़न

बिल्ड 6: द टू-लेन बेंच

BUILD 7: वैकल्पिक फैन-आउट (शर्त दिखने पर इंस्टॉल करें)

मिश्रित बेड़े के लिए पाइपलाइन

BUILD 8: द फैक्ट्री (पूर्णता एक डेटाबेस तथ्य बन जाती है)

BUILD 9: द स्वार्म (Fable योजना बनाता है, बेड़ा निष्पादित करता है, Fable स्कोर करता है)

BUILD 10: रंग 4 (जो एक बार पास हुआ, वह कभी अनदेखा नहीं रहता)

BUILD 11: रंग 5 (आपकी सीट, और यह कभी खाली क्यों नहीं होती)

बिल्ड 12: ऑप्स

अपनी सीमाओं के भीतर चलना

द कमांड डेक

कोडेक्स स्लैश कमांड

CLI क्लिप्स

नियम (इसे प्रिंट करें)

समापन

अस्वीकरण

Turn one viral article into a full content workflow

हाल के वायरल लेख

निष्पक्ष खेल: बूस्टिंग और स्मर्फिंग के खिलाफ अन्य उपाय

दोहरी AI मुद्रीकरण रणनीति: विदेशी गीक्स ChatGPT और Claude का एक साथ उपयोग कैसे करते हैं

AI के युग में आउटलायर इन्वेस्टिंग

Yusuke Narita की जीनियस AI उपयोग तकनीकें [प्रिजर्वेशन एडिशन]

प्रिय Robinhood, कृपया मेमकोइन चेन न बनाएं।

CleanSpark ने हाई-इन्वेस्टमेंट ग्रेड ग्लोबल टेक्नोलॉजी कंपनी के साथ बीस साल का लीज समझौता किया

AI एजेंट स्टैक जिसे हर किसी को GPT 5.6 + Fable 5 के साथ इस्तेमाल करना चाहिए (बिल्डर्स गाइड)

परिचय

मानचित्र, और सामान्य वाला गलत क्यों है

साक्ष्य सीढ़ी

पूर्वापेक्षाएँ

आप क्या बना रहे हैं

बिल्ड 0: इंजन कॉन्फ़िगर करें

बेंच: हर सीट, जुलाई 2026

दूसरा मीटर: एक सीट एक API कुंजी नहीं है

सोल और टेरा दोनों सही डिफ़ॉल्ट क्यों हैं

बिल्ड 1: संविधान

बिल्ड 2: गेट

बिल्ड 3: द हार्टबीट

बिल्ड 4: द राउटर जो अपनी नौकरी कमाता है (मॉडल, फिर एफर्ट)

एफर्ट दूसरा डायल है

ROUTING.md, वह नीति जिसे दोनों हार्नेस पढ़ते हैं

बिल्ड 5: द एडवाइज़र इन्वर्ज़न

बिल्ड 6: द टू-लेन बेंच

BUILD 7: वैकल्पिक फैन-आउट (शर्त दिखने पर इंस्टॉल करें)

मिश्रित बेड़े के लिए पाइपलाइन

BUILD 8: द फैक्ट्री (पूर्णता एक डेटाबेस तथ्य बन जाती है)

BUILD 9: द स्वार्म (Fable योजना बनाता है, बेड़ा निष्पादित करता है, Fable स्कोर करता है)

BUILD 10: रंग 4 (जो एक बार पास हुआ, वह कभी अनदेखा नहीं रहता)

BUILD 11: रंग 5 (आपकी सीट, और यह कभी खाली क्यों नहीं होती)

बिल्ड 12: ऑप्स

अपनी सीमाओं के भीतर चलना

द कमांड डेक

कोडेक्स स्लैश कमांड

CLI क्लिप्स

नियम (इसे प्रिंट करें)

समापन

अस्वीकरण

Turn one viral article into a full content workflow

अपने Markdown को एक साफ़-सुथरे 𝕏 आर्टिकल में बदलें

हाल के वायरल लेख

निष्पक्ष खेल: बूस्टिंग और स्मर्फिंग के खिलाफ अन्य उपाय

दोहरी AI मुद्रीकरण रणनीति: विदेशी गीक्स ChatGPT और Claude का एक साथ उपयोग कैसे करते हैं

AI के युग में आउटलायर इन्वेस्टिंग

Yusuke Narita की जीनियस AI उपयोग तकनीकें [प्रिजर्वेशन एडिशन]

प्रिय Robinhood, कृपया मेमकोइन चेन न बनाएं।

CleanSpark ने हाई-इन्वेस्टमेंट ग्रेड ग्लोबल टेक्नोलॉजी कंपनी के साथ बीस साल का लीज समझौता किया