Fable 5 का उपयोग करके Agentic OS कैसे बनाएं (बिल्डर्स गाइड)

यह Claude Fable 5 का एक पूर्ण A–Z विश्लेषण है कि यह क्या है और इसे 100x इंजीनियर की तरह कैसे उपयोग करें

यह आपके Claude के साथ काम करने के तरीके को पूरी तरह से बदल देगा

इन 8 बिल्ड को भूलने से पहले बुकमार्क कर लें

परिचय

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

जुलाई 2026 तक की स्थिति यह है। Fable 5 बिना निगरानी के घंटों तक चल सकता है, अपने स्वयं के उप-एजेंट भेज सकता है, और एक रात में एक सप्ताह का काम कर सकता है। यह मीटर्ड भी है ($10/M इनपुट, $50/M आउटपुट उपयोग क्रेडिट के माध्यम से), जब दायरा सीमित नहीं होता है तो यह अतिरिक्त देता है, और यह अपनी गलतियों के लिए अधिकांश लोगों की तुलना में अधिक प्रभावी ढंग से बहस करता है।

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

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

अंत में आपके पास क्या होगा:

• एक CLAUDE.md जिससे मॉडल समझौता नहीं कर सकता (बिल्ड 1)
• एक दैनिक लूप जहां Fable 5 हर निर्णय लेता है लेकिन लगभग कोई टोकन नहीं लिखता, सस्ते मॉडल काम करते हैं, एक स्वतंत्र सत्यापनकर्ता इसे ग्रेड करता है, और एक bash स्क्रिप्ट अंतिम वोट रखती है (बिल्ड 2-3)
• एक विश्वास खाता बही जो प्रति कौशल स्वायत्तता प्रदान और रद्द करता है, स्वचालित रूप से, मापी गई पास दरों के आधार पर (बिल्ड 4)
• एक लक्ष्य निर्देशिका जहां आपके द्वारा कभी भी पूरी की गई हर चीज़ प्रतिदिन फिर से सत्यापित होती रहती है, हमेशा के लिए, ताकि कुछ भी चुपचाप खराब न हो (बिल्ड 5)
• एक बजट जो आपको आश्चर्यचकित करने के बजाय स्वयं को लागू करता है (बिल्ड 6)
• चार वैकल्पिक लूप (कोरम, रैचेट, स्पैरिंग, कम्पोस्ट) प्रत्येक में वह शर्त होती है जो आपको बताती है कि इसे कब स्थापित करना है (बिल्ड 7)
• एक क्रॉन शेड्यूल, प्रत्येक अलार्म के लिए एक रनबुक जो सिस्टम उठा सकता है, और एक 30-दिवसीय विश्वास शेड्यूल जो इसे पर्यवेक्षित से स्व-विस्तारित में ले जाता है।

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

इसे कैसे पढ़ें। क्रम में, चेक करते हुए। बिल्ड 0 आधिकारिक Anthropic सेटिंग्स और प्रॉम्प्ट भाषा है; इसके बाद सब कुछ उस पर बनाया गया सिस्टम है। प्रत्येक बिल्ड 10 से 20 मिनट का है। अंत में 30 दिन पढ़ने का समय नहीं हैं; वे क्रमिक-विश्वास शेड्यूल हैं जिसके दौरान सिस्टम आपके बिना चलने का अधिकार अर्जित करता है। कुल व्यावहारिक समय: लगभग 2 घंटे।

तीन सिद्धांत जो सब कुछ रेखांकित करते हैं, ताकि आप इसे पढ़ने से पहले किसी भी डिज़ाइन निर्णय की भविष्यवाणी कर सकें:

1. नियम, सुझाव नहीं। हर नियम में एक संख्या, एक कभी नहीं, या एक कमांड होता है जो इसे जांचता है। इससे नरम कुछ भी अनुकूलित हो जाता है।
2. कोई भी अपना होमवर्क खुद ग्रेड नहीं करता। योजनाकार, कार्यकर्ता, सत्यापनकर्ता और गेट चार अलग-अलग पक्ष हैं, और अंतिम नियतात्मक है।
3. एक बार पास हुआ कुछ भी बिना देखे नहीं छोड़ा जाता। पूरा काम एक पुन: सत्यापित अपरिवर्तनीय में स्नातक होता है। एक लक्ष्य जिसे आप केवल एक बार सत्यापित करते हैं, वह एक टाइमस्टैम्प वाली धारणा है।

यहां से कोई निबंध नहीं। आठ बिल्ड, प्रत्येक में फ़ाइलें, कमांड और एक चेकपॉइंट।

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

1claude CLI (Claude Code) Fable 5 एक्सेस के साथ     # उपयोग क्रेडिट सक्षम, /usage-credits कैप सेट
2llm CLI + OpenRouter कुंजी                          # llm install llm-openrouter
3jq, gh, git, make, cron
4एक टेस्ट कमांड वाला रेपो

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

1your-repo/
2  CLAUDE.md                    # बिल्ड 1: संविधान
3  loop/
4    loop.sh                    # बिल्ड 3: दिल की धड़कन
5    conductor.md               # बिल्ड 3: रूटिंग प्रॉम्प्ट
6    triage.md                  # बिल्ड 3: सस्ता रीडर प्रॉम्प्ट
7    contract.md                # बिल्ड 2: तीन सूचियाँ
8    workers/implement.md       # बिल्ड 3
9    workers/verify.md          # बिल्ड 3
10    guardrails/verify.sh       # बिल्ड 2: नियतात्मक गेट
11    scripts/trust-log.sh       # बिल्ड 4
12    scripts/log-cost.sh        # बिल्ड 6
13    scripts/cost-check.sh      # बिल्ड 6
14    quorum.sh                  # बिल्ड 7 (वैकल्पिक)
15    verify-goals.sh            # बिल्ड 5
16    goals/                     # बिल्ड 5: स्थायी लक्ष्य
17    skills/                    # बिल्ड 4: प्रति कर्मचारी एक फ़ाइल
18    memory/
19      STATE.md  trust.tsv  goal-ledger.tsv  dispatch.tsv  usage.log
20  Makefile                     # बिल्ड 8: tick / queue / trust / audit / dream

बिल्ड 0: इंजन कॉन्फ़िगर करें (आधिकारिक Fable 5 दस्तावेज़ से)

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

स्पेक शीट:

सेटिंग

मान

स्रोत

मॉडल स्ट्रिंग

claude-fable-5

मॉडल अवलोकन

संदर्भ / आउटपुट

1M टोकन / प्रति अनुरोध 128k तक आउटपुट

परिचय दस्तावेज़

मूल्य

$10/M इनपुट, $50/M आउटपुट

परिचय दस्तावेज़

सोच

अनुकूली, हमेशा चालू;

thinking: {type:"disabled"}

अस्वीकार किया गया है; सोच आउटपुट केवल सारांशित है

परिचय + प्रयास दस्तावेज़

प्रयास

low

medium

high

xhigh

max

;

high

= डिफ़ॉल्ट = पैरामीटर छोड़ना

प्रयास दस्तावेज़

API आकार

output_config: {"effort": "..."}

Messages API पर

प्रयास दस्तावेज़

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

1. max_tokens सोच प्लस प्रतिक्रिया टेक्स्ट के लिए एक हार्ड कैप है। high और xhigh पर, इसे बड़ा सेट करें (64k से शुरू करें) या Fable के पास सोच के बीच में जगह खत्म हो जाती है। इस गाइड में प्रत्येक claude -p कॉल पर लागू होता है।
2. xhigh आधिकारिक तौर पर "लंबे समय तक चलने वाले एजेंटिक कार्यों (30 मिनट से अधिक) के लिए है जिसमें टोकन बजट लाखों में होते हैं।" यह कंडक्टर सीट है और इस सिस्टम में और कुछ नहीं। दस्तावेज़ यह भी कहते हैं कि Fable 5 पर कम प्रयास "अक्सर पिछले मॉडलों पर xhigh प्रदर्शन से अधिक होता है," इसलिए वर्कर्स को अपग्रेड करने का विरोध करें।
3. अस्वीकृति HTTP 200 है। Fable 5 सुरक्षा क्लासिफायर (आपत्तिजनक साइबर, जीवविज्ञान/जीवन-विज्ञान, तर्क-निष्कर्षण) चलाता है। एक अस्वीकृत अनुरोध stop_reason: "refusal" को एक सफल प्रतिक्रिया के रूप में लौटाता है। आपकी स्क्रिप्ट को निकास कोड नहीं, बल्कि स्टॉप कारण की जांच करनी चाहिए। आधिकारिक उपाय: Opus 4.8 पर पुन: रूट करने के लिए सर्वर-साइड फ़ॉलबैक या SDK मिडलवेयर कॉन्फ़िगर करें।
4. Fable को कभी भी अपने तर्क को प्रतिध्वनित करने के लिए न कहें। प्रॉम्प्ट या कौशल जो "अपनी सोच दिखाएं" या "प्रतिक्रिया में अपने तर्क की व्याख्या करें" कहते हैं, reasoning_extraction अस्वीकृति श्रेणी को ट्रिगर करते हैं और फ़ॉलबैक बढ़ाते हैं। माइग्रेट करते समय प्रत्येक पुराने कौशल का इसके लिए ऑडिट करें। इसके बजाय संरचित सोच ब्लॉक पढ़ें।
5. बारी डिज़ाइन द्वारा लंबी होती है। कठिन कार्य उच्च प्रयास पर प्रति अनुरोध कई मिनट चलते हैं; स्वायत्त रन घंटों तक विस्तारित होते हैं। क्लाइंट टाइमआउट समायोजित करें और रन को अतुल्यकालिक रूप से जांचें (शेड्यूल किए गए कार्य, ब्लॉकिंग प्रतीक्षा नहीं)। यही कारण है कि दिल की धड़कन क्रॉन है, ब्लॉकिंग लूप नहीं।

आधिकारिक प्रॉम्प्ट पैक। Anthropic Fable 5 के ज्ञात व्यवहारों के लिए परीक्षण किए गए प्रॉम्प्ट भाषा भेजता है। ये आपके प्रॉम्प्ट में शब्दशः जाते हैं; उन्हें पतला करके व्याख्या न करें:

1. अति-योजना विरोधी (कंडक्टर और किसी भी इंटरैक्टिव सत्र के लिए):

1जब आपके पास कार्य करने के लिए पर्याप्त जानकारी हो, तो कार्य करें। बातचीत में पहले से स्थापित तथ्यों को पुनः प्राप्त न करें, उस निर्णय पर पुनः बहस न करें जो उपयोगकर्ता पहले ही कर चुका है, या उन विकल्पों का वर्णन न करें जिन्हें आप आगे नहीं बढ़ाएंगे। यदि आप किसी विकल्प का वजन कर रहे हैं, तो एक सिफारिश दें, एक विस्तृत सर्वेक्षण नहीं।

1. गोल्ड-प्लेटिंग विरोधी (प्रत्येक वर्कर प्रॉम्प्ट के लिए; यह अतिरिक्त वितरण के आसपास आधिकारिक बाड़ है):

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

1. ग्राउंडेड प्रगति दावे (किसी भी लंबे रन के लिए; Anthropic के परीक्षण में इसने लगभग निर्मित स्थिति रिपोर्ट को समाप्त कर दिया):

1प्रगति की रिपोर्ट करने से पहले, इस सत्र के एक टूल परिणाम के विरुद्ध प्रत्येक दावे का ऑडिट करें। केवल उस काम की रिपोर्ट करें जिसके लिए आप साक्ष्य इंगित कर सकते हैं; यदि कुछ अभी तक सत्यापित नहीं है, तो स्पष्ट रूप से कहें। यदि परीक्षण विफल होते हैं, तो आउटपुट के साथ कहें; यदि कोई चरण छोड़ दिया गया था, तो वह कहें।

1. स्वायत्त-पाइपलाइन अनुस्मारक (प्रत्येक क्रॉन-संचालित प्रॉम्प्ट के लिए; "मैं अब X चलाऊंगा" प्रारंभिक स्टॉप को मारता है):

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

1. आधिकारिक मेमोरी प्रारूप (ड्रीमर और memory/learnings/ के लिए):

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

1. आधिकारिक सत्यापनकर्ता निर्देश (दस्तावेज़ इसे सीधे कहते हैं: "अलग, ताज़ा-संदर्भ सत्यापनकर्ता उप-एजेंट आत्म-आलोचना से बेहतर प्रदर्शन करते हैं"):

1अपने स्वयं के काम की जाँच करने के लिए [X] के अंतराल पर एक विधि स्थापित करें जैसा कि आप बनाते हैं। इसे हर [X अंतराल] पर चलाएं, विनिर्देश के विरुद्ध उप-एजेंटों के साथ अपने काम को सत्यापित करें।

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

चेक 0: आपकी स्क्रिप्ट में प्रत्येक claude -p कॉल में एक स्पष्ट बड़ा max_tokens है जहां समर्थित है; आपकी स्क्रिप्ट stop_reason: "refusal" की जाँच करती है; कहीं भी कोई प्रॉम्प्ट या कौशल "अपनी सोच दिखाएं" नहीं कहता है।

बिल्ड 1: संविधान (CLAUDE.md)

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

फ़ाइल के लिए नियम: चार ब्लॉक, 150 पंक्तियों से कम, कोई "चरण दर चरण सोचें" नहीं (तर्क हमेशा चालू है; वे भुगतान किए गए टोकन हैं), कोई पूर्वनिर्धारित एजेंट व्यक्तित्व नहीं (Fable आपके द्वारा पूर्वनिर्धारित की जा सकने वाली टीमों से बेहतर टीमें डिज़ाइन करता है), अधिकतर स्टॉप संकेत।

CLAUDE.md बनाएं:

1# CLAUDE.md
2
3## कभी नहीं (कानून; अपवादों के लिए पहले पूछना आवश्यक है)
4- बिना पूछे एक कमिट में 200 से अधिक बदली हुई पंक्तियाँ कभी न करें।
5- बिना निगरानी के src/auth/, src/billing/, migrations/, या prod config को कभी न छुएं।
6- अपने स्वयं के आकलन से काम को पूर्ण के रूप में कभी रिपोर्ट न करें। पूर्ण = चेक पास हुआ।
7- कभी भी कोई रहस्य, एंडपॉइंट या परंपरा का आविष्कार न करें। रुकें और पूछें।
8- कभी भी कोई निर्भरता न जोड़ें। इसे STATE.md में प्रस्तावित करें और रुकें।
9- किसी भी लूप के अंदर कभी भी effort high से अधिक न करें। xhigh केवल एक-शॉट समीक्षाओं के लिए है।
10- कभी भी किसी परीक्षण को पास करने के लिए उसे संपादित या हटाएं नहीं। यह हमेशा एक विफलता है।
11- कभी भी प्रतिक्रिया टेक्स्ट में अपने आंतरिक तर्क को प्रतिध्वनित, लिपिबद्ध या समझाएं नहीं।
12  (आधिकारिक: Fable 5 पर reasoning_extraction अस्वीकृतियों को ट्रिगर करता है।)
13- जब कोई /goal शर्त पास होती है, तो सफलता की रिपोर्ट करने से पहले goals/<name>.md को उसकी शर्त को विधेय के रूप में लिखें।
14
15## डिस्पैच (प्रत्येक कार्य को रूट करें; पहला मैच जीतता है; memory/dispatch.tsv में लॉग करें)
16| मॉडल           | सीमांत | भूख | बुद्धिमत्ता | स्वाद |
17|-----------------|----------|----------|--------------|-------|
18| claude-fable-5  | 2 (क्रेडिट) | 3     | 10           | 10    |
19| claude-opus-4-8 | 7 (सब)  | 6        | 8            | 9     |
20| claude-sonnet-5 | 9 (सब)  | 8        | 7            | 7     |
21| codex (2nd सब) | 9        | 10       | 9            | 5     |
221. निर्णय (योजना/समीक्षा/रूट/गतिरोध) -> fable-5, effort high, केवल-पढ़ने के लिए।
232. >50k टोकन पढ़ता है (लॉग/पीडीएफ/स्क्रीनशॉट) -> codex। कभी fable नहीं।
243. उपयोगकर्ताओं को भेजता है (UI/API/कॉपी) -> स्वाद >= 8 को अंतिम पास मिलता है।
254. विनिर्देश पूर्ण -> sonnet-5, effort medium।
265. अन्यथा sonnet-5; बिना पूछे एक पायदान ऊपर बढ़ाएं।
27
28## शब्द
29- "बुद्धिमत्ता" = सबसे कठिन समस्या जिसे बिना निगरानी के संभाला गया
30- "स्वाद" = UI/UX, कोड गुणवत्ता, API डिज़ाइन, कॉपी
31- "पूर्ण" = विधेय पास होता है; और कुछ नहीं
32- "छोटा" = 50 बदली हुई पंक्तियों से कम; "त्वरित" = आपके समय के 10 मिनट से कम
33- "सफाई" = व्यवहार समान, पहले और बाद में verify.sh हरा
34
35## पूर्ण
36- प्रत्येक कार्य में काम शुरू होने से पहले एक मशीन-जांचने योग्य done_when होता है।
37- एक ताज़ा-संदर्भ एजेंट जिसने न तो योजना और न ही मसौदा देखा, इसके विरुद्ध सत्यापित करता है।
38- guardrails/verify.sh के पास अंतिम वोट है।
39- विचलन: रूढ़िवादी विकल्प, IMPLEMENTATION.md में लॉग करें, जारी रखें।
40- निर्माता और जांचकर्ता दो बार असहमत -> रुकें, मानव के लिए कतारबद्ध करें।

अपने अनुसार संख्याएँ और पथ संपादित करें। कार्यप्रवाह-विशिष्ट सामग्री (PR प्रक्रिया, रिलीज़ चेकलिस्ट) skills/ में जाती है, यहाँ नहीं।

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

बिल्ड 2: दीवारें और गेट

क्यों: पहले टिक से पहले विस्फोट त्रिज्या घोषित की जानी चाहिए, और एक bash स्क्रिप्ट के पास अंतिम वोट होना चाहिए।

loop/contract.md बनाएं:

1## अकेले कार्य करता है
2शाखाओं पर ड्राफ्ट PR; लिंट/टेस्ट ऋण ठीक करें; STATE.md अपडेट करें; मुद्दों को लेबल करें
3
4## मेरे लिए कतारबद्ध करता है
5auth, भुगतान, माइग्रेशन; "auto" स्तर से नीचे कोई भी कौशल; कोई भी अंतर > 400 पंक्तियाँ
6
7## मुझे जगाता है
8एक ही आइटम पर दो बार सत्यापन विफल होता है
9सुरक्षा राउटर ने मॉडल को रन के बीच बदल दिया
10दैनिक बजट का उल्लंघन हुआ
11कुछ भी एक रहस्य का अनुरोध करता है
12एक स्थायी लक्ष्य का उल्लंघन हुआ है

loop/guardrails/verify.sh बनाएं (अपने स्टैक के लिए संपादित करें):

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

चेक 2: ./loop/guardrails/verify.sh चलता है और आपके वर्तमान रेपो पर 0 से बाहर निकलता है। यदि यह अब विफल होता है, तो पहले इसे ठीक करें; पूरा सिस्टम इस स्क्रिप्ट पर खड़ा है।

बिल्ड 3: दिल की धड़कन

तीन पंक्तियों में क्यों: Fable एक कार्यकर्ता के रूप में चार-अंकीय बिल है (500k-1M टोकन सत्र $50/M आउटपुट पर); Fable एक कंडक्टर के रूप में 10-20% टोकन उत्सर्जित करता है जबकि 100% निर्णय लेता है। एक $0.01 मॉडल शांत टिक पढ़ता है। एजेंट एक JSON स्कीमा के माध्यम से हैंडऑफ करते हैं ताकि कोई भी मॉडल किसी भी सीट में फिट हो सके।

loop/triage.md बनाएं:

1आपको हाल के कमिट, खुले मुद्दे और CI रन प्राप्त होते हैं। केवल निष्कर्ष आउटपुट करें:
2- finding: <एक पंक्ति>
3  evidence: <कमिट/मुद्दा/रन आईडी>
4  status: actionable | informational
5कोई फिक्स नहीं, कोई राय नहीं। रिपोर्ट करने के लिए कुछ नहीं = बिल्कुल "status: quiet" आउटपुट करें।
6auth, भुगतान, माइग्रेशन, रहस्यों को छूने वाली कोई भी चीज़ = हमेशा actionable,
7"contract-sensitive" के रूप में नोट किया गया।

loop/conductor.md बनाएं:

1आप कंडक्टर हैं। आप कोड नहीं लिखते हैं। आप फ़ाइलों को संपादित नहीं करते हैं।
21. STATE, TRUST LEDGER, CONTRACT नीचे पढ़ें। उनकी स्मृति पर भरोसा न करें।
32. एक सबसे उच्च-मूल्य वाली actionable वस्तु चुनें।
4   contract-sensitive, अस्पष्ट, या संभावित >400-पंक्ति अंतर -> action: queue
5   करने लायक कुछ नहीं -> action: stop
63. अन्यथा action: execute, एक विनिर्देश के साथ जिसका एक औसत मॉडल पालन कर सकता है।
7केवल यह JSON आउटपुट करें:
8{ "action": "execute|queue|stop", "item": "...", "skill": "<kebab-case,
9रनों में स्थिर>", "spec": "...", "done_when": ["<सत्यापन योग्य>", ...] }
10आप महंगे हैं। संक्षिप्त रहें। आपका आउटपुट एक निर्णय है, एक निबंध नहीं।

loop/workers/implement.md बनाएं:

1आपको एक कार्य आदेश (JSON) प्राप्त होता है। विनिर्देश को बिल्कुल निष्पादित करें।
2done_when की ओर एक अगला कदम करें। छोटे अंतर जीतते हैं।
3लापता क्रेडेंशियल या अप्रलेखित निर्णय -> रुकें, प्रश्न को IMPLEMENTATION.md में लिखें।
4कभी भी रहस्य या परंपराओं का आविष्कार न करें।
5आपने क्या किया और क्यों किया, इसे IMPLEMENTATION.md में रिकॉर्ड करें (अधिकतम 3 पंक्तियाँ)।

loop/workers/verify.md बनाएं:

1आपको एक SPEC और एक DIFF प्राप्त होता है, और कुछ नहीं। केवल अपने सामने जो है उसका न्याय करें।
21. क्या अंतर प्रत्येक done_when को संतुष्ट करता है? पंक्तियों का हवाला दें।
32. विनिर्देश के दायरे से बाहर कुछ भी? तत्काल विफल। हटाए गए/छोड़े गए परीक्षण? तत्काल विफल।
4बिल्कुल एक पंक्ति आउटपुट करें: "PASS: <कारण>" या "FAIL: <कारण>"।
5निर्माता आश्वस्त था। वह साक्ष्य नहीं है।

loop/loop.sh बनाएं:

1#!/usr/bin/env bash
2set -euo pipefail
3cd "$(dirname "$0")"
4MAX_ITERS="${MAX_ITERS:-10}"
5DAILY_BUDGET_USD="${DAILY_BUDGET_USD:-5}"
6CHEAP="${CHEAP:-openrouter/deepseek/deepseek-v4-flash}"
7WORKER="${WORKER:-openrouter/moonshotai/kimi-k2.6}"
8
9./scripts/cost-check.sh --budget "$DAILY_BUDGET_USD" || exit 3
10
11for ((i=1; i<=MAX_ITERS; i++)); do
12  # 1 ट्राइएज: शांत-टिक गेट, ~$0.01
13  { git log --oneline -20; gh issue list --limit 20 2>/dev/null || true; \
14    gh run list --limit 10 2>/dev/null || true; } \
15    | llm -m "$CHEAP" -s "$(cat triage.md)" >> memory/STATE.md
16  ./scripts/log-cost.sh triage 0.01
17  grep -q "status: actionable" memory/STATE.md || { echo quiet; exit 0; }
18
19  # 2 कंडक्ट: Fable, xhigh, ताज़ा संदर्भ, केवल-पढ़ने के लिए, JSON आउट
20  claude -p "$(cat conductor.md)
21STATE: $(cat memory/STATE.md)
22TRUST: $(./scripts/trust-log.sh --render)
23CONTRACT: $(cat contract.md)" \
24    --model claude-fable-5 --effort xhigh --allowedTools "Read" \
25    --output-format json > /tmp/c.json
26  ./scripts/log-cost.sh conductor 0.35
27
28  # 2a रूट-सहनशीलता: कभी भी उस मॉडल पर पुनरावृति न करें जिसे आपने नहीं चुना
29  SERVED=$(jq -r '.modelUsage | keys[0] // "claude-fable-5"' /tmp/c.json)
30  [[ "$SERVED" != *fable* ]] && { echo "rerouted" >> memory/STATE.md; exit 2; }
31
32  jq -r '.result' /tmp/c.json > work-order.json
33  SKILL=$(jq -r .skill work-order.json); ACTION=$(jq -r .action work-order.json)
34  [[ "$ACTION" == stop  ]] && exit 0
35  [[ "$ACTION" == queue ]] && { echo "queued: $SKILL" >> memory/STATE.md; continue; }
36
37  # 3 निष्पादित करें: सस्ता कार्यकर्ता, पृथक कार्य वृक्ष
38  WT="../wt-$i"; git worktree add "$WT" -b "loop/$SKILL-$i" >/dev/null
39  ( cd "$WT" && llm -m "$WORKER" -s "$(cat "$OLDPWD/workers/implement.md")" \
40      "$(cat "$OLDPWD/work-order.json")" > IMPLEMENTATION.md )
41  ./scripts/log-cost.sh worker 0.10
42
43  # 4 सत्यापित करें: ताज़ा Fable, कोई उपकरण नहीं, केवल spec + diff देखता है
44  V=$(claude -p "$(cat workers/verify.md)
45SPEC: $(jq -r .spec work-order.json)
46DIFF: $(cd "$WT" && git diff)" \
47    --model claude-fable-5 --effort high --allowedTools "" \
48    --output-format json | jq -r .result)
49  ./scripts/log-cost.sh verifier 0.40
50
51  # 5 गेट: नियतात्मक; फिर खाता बही; केवल auto स्तर पर भेजें
52  if [[ "$V" == PASS* ]] && ( cd "$WT" && "$OLDPWD/guardrails/verify.sh" ); then
53    ./scripts/trust-log.sh "$SKILL" pass
54    if [[ "$(./scripts/trust-log.sh --tier "$SKILL")" == auto ]]; then
55      ( cd "$WT" && git add -A && git commit -qm "loop: $SKILL" && gh pr create --fill || true )
56      echo "- shipped: $SKILL" >> memory/STATE.md
57    else
58      echo "- review: $SKILL in $WT" >> memory/STATE.md
59    fi
60  else
61    ./scripts/trust-log.sh "$SKILL" fail
62    echo "- FAILED: $SKILL in $WT" >> memory/STATE.md
63  fi
64  ./scripts/cost-check.sh --budget "$DAILY_BUDGET_USD" || exit 3
65done
66exit 1   # बिना स्टॉप के पुनरावृति सीमा: STATE.md जांचें

निकास मानचित्र: 0 शांत/पूर्ण, 1 सीमा, 2 पुन: रूट, 3 बजट। सभी लेबल किए गए, उद्देश्य पर।

चेक 3: chmod +x loop.sh guardrails/verify.sh फिर एक बार हाथ से ./loop.sh चलाएं। पुष्टि करें: एक शांत रेपो लगभग एक पैसे के लिए 0 से बाहर निकलता है; एक actionable रेपो सभी पाँच फ़ील्ड और STATE.md में एक फैसला पंक्ति के साथ work-order.json उत्पन्न करता है।

बिल्ड 4: विश्वास खाता बही

क्यों: "जैसे-जैसे विश्वास बढ़ता है, स्वायत्तता बढ़ाएं" एक तंत्र नहीं है; स्तर नियमों वाला एक TSV है। स्वायत्तता प्रति लूप नहीं, प्रति कौशल है।

loop/scripts/trust-log.sh बनाएं:

1#!/usr/bin/env bash
2# उपयोग: trust-log.sh <skill> <pass|fail> | --render | --tier <skill>
3set -euo pipefail
4F="$(dirname "$0")/../memory/trust.tsv"; touch "$F"
5tier_of() { awk -v r="$1" -v p="$2" 'BEGIN{
6  rate=(r>0)?p/r:0
7  if (r>=20 && rate>=0.95) print "auto"
8  else if (r<10 || rate<0.90) print "watch"
9  else print "queue"}'; }
10case "${1:-}" in
11  --render)
12    printf "%-20s %5s %5s %6s %s\n" skill runs pass rate tier
13    while IFS=$'\t' read -r s r p; do [ -z "$s" ] && continue
14      printf "%-20s %5s %5s %5s%% %s\n" "$s" "$r" "$p" \
15        "$(awk -v r="$r" -v p="$p" 'BEGIN{printf "%.0f",(r>0)?p/r*100:0}')" \
16        "$(tier_of "$r" "$p")"; done < "$F";;
17  --tier)
18    line=$(grep -P "^${2}\t" "$F" || echo -e "${2}\t0\t0")
19    tier_of "$(cut -f2 <<<"$line")" "$(cut -f3 <<<"$line")";;
20  *)
21    awk -v s="$1" -v r="$2" -F'\t' 'BEGIN{OFS="\t"; f=0}
22      $1==s {f=1; print s,$2+1,$3+(r=="pass"); next} {print}
23      END{if(!f) print s,1,(r=="pass")?1:0}' "$F" > "$F.t" && mv "$F.t" "$F"
24    if [ "$2" = fail ]; then
25      runs=$(grep -P "^${1}\t" "$F" | cut -f2)
26      [ "$("$0" --tier "$1")" = watch ] && [ "$runs" -ge 10 ] \
27        && echo "ALERT: $1 को $runs रन के बाद watch पर पदावनत किया गया" >&2 || true
28    fi;;
29esac

• स्तर नियम: auto = 20+ रन और 95%+ पास, बिना निगरानी के भेजता है। queue = सत्यापित ड्राफ्ट आपकी प्रतीक्षा करते हैं। watch = 10 रन से कम या 90% से कम, केवल-ड्राफ्ट। पदावनति स्वचालित है और stderr पर प्रिंट होती है, जिसे क्रॉन आपको मेल करता है।
• रोस्टर को सीड करें: प्रत्येक आवर्ती कार्य के लिए loop/skills/<name>/SKILL.md बनाएं (fix-lint-debt, fix-flaky-test, bump-deps, triage-issues चार मानक हैं)। प्रत्येक फ़ाइल: फ्रंटमैटर (नाम, विवरण, कब), चरण, एक "कभी नहीं" सूची, एक सत्यापन योग्य done-when। प्रत्येक कौशल watch से शुरू होता है।

चेक 4: ./scripts/trust-log.sh demo pass 21 बार चलाएं, फिर --tier demo auto प्रिंट करता है। 10+ रन कौशल पर एक fail लॉग करें और stderr पर ALERT देखें। रीसेट करें: > memory/trust.tsv।

बिल्ड 5: स्थायी लक्ष्य + लक्ष्य खाता बही

एक पंक्ति में क्यों: एक लक्ष्य जिसे आप केवल एक बार सत्यापित करते हैं, वह एक टाइमस्टैम्प वाली धारणा है, इसलिए पूर्ण लक्ष्य अपरिवर्तनीय में स्नातक होते हैं जो प्रतिदिन पुन: सत्यापित और लॉग किए जाते हैं।

प्रति पूर्ण वस्तु एक फ़ाइल बनाएं, goals/<name>.md:

1predicate: cd $REPO && npm test -- tests/auth 2>&1 | tail -1 | grep -q passing
2born: 2026-07-06
3source: /goal session 2026-07-06 (fix auth flake)
4status: satisfied
5last-pass: 2026-07-06
6on-violation: मुझे जगाएं। स्वचालित रूप से ठीक न करें।
7retire-when: auth मॉड्यूल हटा दिया गया। सेवानिवृत्ति एक मानवीय निर्णय है, लॉग किया गया।

loop/verify-goals.sh बनाएं:

1#!/usr/bin/env bash
2set -uo pipefail
3LEDGER="memory/goal-ledger.tsv"; VIOLATIONS=0
4for g in goals/*.md; do
5  [ -e "$g" ] || continue
6  grep -q '^status: retired' "$g" && continue
7  pred=$(grep '^predicate:' "$g" | cut -d' ' -f2-); name=$(basename "$g" .md)
8  start=$(date +%s%3N)
9  if timeout 60 bash -c "$pred" >/dev/null 2>&1; then r=pass
10    sed -i "s/^status:.*/status: satisfied/; s/^last-pass:.*/last-pass: $(date +%F)/" "$g"
11  else r=FAIL; VIOLATIONS=$((VIOLATIONS+1)); sed -i "s/^status:.*/status: VIOLATED/" "$g"; fi
12  echo -e "$(date -Is)\t$name\t$r\t$(( $(date +%s%3N) - start ))" >> "$LEDGER"
13done
14[ "$VIOLATIONS" -gt 0 ] && { grep -l '^status: VIOLATED' goals/*.md; exit 1; }
15echo "सभी स्थायी लक्ष्य कायम हैं"

प्रहरी शुरू करें (केवल पहचान; फिक्स सामान्य पाइपलाइन के माध्यम से जाते हैं):

1/loop 1d ./verify-goals.sh चलाएं। यदि गैर-शून्य: प्रत्येक उल्लंघन किए गए लक्ष्य के लिए, इसकी
2अंतिम-पास तिथि पढ़ें और सूचीबद्ध करें कि तब से क्या मर्ज हुआ (git log --oneline --since=<date>)।
3लक्ष्य, संदिग्ध, on-violation नीति की रिपोर्ट करें। कुछ भी ठीक न करें।

स्नातक कानून पहले से ही CLAUDE.md (बिल्ड 1) में है: प्रत्येक पास किया गया /goal अपना स्वयं का स्थायी लक्ष्य लिखता है। पूरा करना ही नामांकन है।

खाता बही प्रश्न जिनका आप वास्तव में उपयोग करेंगे:

1awk -F'\t' '$3=="FAIL"{n[$2]++} END{for(g in n) print n[g],g}' memory/goal-ledger.tsv | sort -rn | head -5   # सबसे अस्थिर
2grep <goal> memory/goal-ledger.tsv | awk -F'\t' '$3=="FAIL"' | head -1                                      # जब यह टूटा

अस्थिर विधेय: क्वारंटाइन (स्थिति: सेवानिवृत्त, नोट "बेहतर विधेय की आवश्यकता है"), कभी हटाएँ नहीं।

जाँच 5: एक लक्ष्य जोड़ें जिसका विधेय true हो और एक जिसका विधेय false हो। ./verify-goals.sh बाहर निकलता है 1, दूसरे को VIOLATED में बदल देता है, और दोनों लेज़र में दिखाई देते हैं। डमी को हटा दें।

निर्माण 6: बजट

क्यों: दैनिक लागत = टिक × ट्राइएज + हिट्स × (कंडक्टर + वर्कर + वेरिफ़ायर)। वास्तविक कीमतों पर (ट्राइएज $0.01, कंडक्टर $0.35, वर्कर $0.10, वेरिफ़ायर $0.40): एक दैनिक जैनिटर ~$2.56/दिन है; Fable के साथ ट्राइएज सीट पर 15 मिनट का बेबीसिटर समान परिणाम के लिए $34/दिन है। जो मॉडल शांत टिक पढ़ता है, वह बिल तय करता है।

loop/scripts/log-cost.sh बनाएँ:

1#!/usr/bin/env bash
2echo -e "$(date -Is)\t$1\t$2" >> "$(dirname "$0")/../memory/usage.log"

loop/scripts/cost-check.sh बनाएँ:

1#!/usr/bin/env bash
2set -euo pipefail
3F="$(dirname "$0")/../memory/usage.log"; touch "$F"; TODAY=$(date +%F)
4case "${1:-}" in
5  --budget)
6    spent=$(awk -F'\t' -v d="$TODAY" '$1 ~ d {s+=$3} END{printf "%.2f",s}' "$F")
7    awk -v s="$spent" -v b="$2" 'BEGIN{exit (s>=b)?1:0}' \
8      || { echo "spent \$$spent of \$$2" >&2; exit 1; };;
9  --report)
10    awk -F'\t' -v since="$(date -d '7 days ago' +%F)" \
11      '$1>=since{s[$2]+=$3;t+=$3} END{for(k in s) printf "  %-10s $%.2f\n",k,s[k]; printf "  TOTAL      $%.2f\n",t}' "$F";;
12esac

नियम जो इसे सपाट रखते हैं: कैडेंस एक लागत निर्णय है (अंतराल को आधा करने से फ़्लोर दोगुना हो जाता है); शांत टिक की लागत सेंट में होनी चाहिए; लूप में प्रयास कभी high से ऊपर नहीं (xhigh एक बार की समीक्षाओं के लिए है; प्रयास प्रति चरण है, प्रति रन नहीं)।

जाँच 6: एक सप्ताह के टिक के बाद, ./scripts/cost-check.sh --report फ़ॉर्मूले से मेल खाता है शोर के भीतर। DAILY_BUDGET_USD को एक ऐसी संख्या पर सेट करें जिसे बर्बाद करने में आपको कोई आपत्ति न हो।

निर्माण 7: वैकल्पिक लूप (उनकी शर्त दिखने पर इंस्टॉल करें)

• कोरम (इंस्टॉल करें जब डिस्पैच Fable वेक-अप दिखाए जिसने कार्रवाई उत्पन्न की: रुकें)। तीन सस्ते मॉडल वोट करते हैं; Fable 2 में से 3 पर जागता है। वोटर कभी एक-दूसरे के उत्तर नहीं देखते।

1V=0
2for m in deepseek/deepseek-v4-flash qwen/qwen-3.6 moonshotai/kimi-k2.6; do
3  llm -m "openrouter/$m" -s "$(cat triage.md)" < /tmp/signals.txt \
4    | grep -q "status: actionable" && V=$((V+1))
5done
6[ "$V" -ge 2 ] && exec ./conduct.sh || echo "quorum: quiet ($V/3)"

• रैचेट (इंस्टॉल करें जब एक संख्या मायने रखती है)। एकदिशीय सुधार या स्व-वापसी; मीट्रिक को धोखा नहीं दिया जा सकता; तैयार फ़्लोर एक स्थायी लक्ष्य बन जाता है।

1/goal `npm run lint 2>&1 | grep -c warning` को 0 तक कम करें।
2अनुमतियाँ: src/ संपादित करें; प्रति सुधार कमिट करें; प्रत्येक बदलाव के बाद पुनः मापें।
3सीमाएँ: संख्या कभी नहीं बढ़ती; किसी भी बदलाव को वापस लें जो इसे बढ़ाता है या परीक्षण तोड़ता है;
4लिंट कॉन्फ़िग को कभी संपादित न करें इसे कम करने के लिए।
5समय सीमा: बिना किसी प्रगति के 3 प्रयासों के बाद रुकें; बचे हुए की रिपोर्ट करें।

• स्पैरिंग (इंस्टॉल करें जब आप प्रतिदिन कोड शिप करते हैं)। निर्माता और तोड़ने वाला, विरोधी; कोई दूसरे के आउटपुट को नहीं छूता; विवाद आपके पास जाते हैं।

1/loop 1d [breaker] कल के मर्ज किए गए डिफ़ पढ़ें। एक असफल परीक्षण लिखें जो
2एक वास्तविक कमज़ोरी को उजागर करता है। tests/sparring/ के तहत @sparring टैग के साथ कमिट करें।
3कुछ भी ठीक न करें। ठोस कोड = यह कहें, कुछ न लिखें।
4/loop 1d [builder] यदि कोई @sparring परीक्षण विफल होता है, तो CODE को तब तक ठीक करें जब तक वह पास न हो जाए।
5स्पैरिंग परीक्षण को कभी संपादित, कमज़ोर या हटाएँ नहीं; विवाद मेरे लिए कतारबद्ध हों।

• कम्पोस्ट (हमेशा इंस्टॉल करें, साप्ताहिक)। विफलताएँ कानून बन जाती हैं; अधिकतम तीन प्रस्ताव; मानव हस्ताक्षर आवश्यक।

1/loop 7d इस सप्ताह का अपशिष्ट पढ़ें: STATE.md में FAILED, trust.tsv में विफलताएँ,
2goal-ledger.tsv में FAILs, बिना मर्ज किए बंद PRs। अधिकतम 3 प्रस्ताव निकालें:
3एक नया CLAUDE.md कानून (घटनाओं को उद्धृत करें), एक कौशल सुधार (वही विफलता दोहराते हुए),
4या एक स्थायी लक्ष्य जिसकी हममें कमी थी। केवल प्रस्ताव दें। साफ़ सप्ताह = यह कहें।

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

निर्माण 8: संचालन

Makefile बनाएँ:

1tick:            ; ./loop/loop.sh
2queue:           ; @grep -E "review:|queued:|FAILED:|rerouted" loop/memory/STATE.md || echo empty
3trust:           ; @./loop/scripts/trust-log.sh --render
4audit:           ; @./loop/scripts/cost-check.sh --report
5goals:           ; @./loop/verify-goals.sh
6clean-worktrees: ; @git worktree list | awk '/wt-/{print $$1}' | xargs -rn1 git worktree remove --force

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

10 7 * * 1-5  cd /path/to/repo/loop && ./loop.sh >> memory/cron.log 2>&1
230 7 * * *   cd /path/to/repo/loop && ./verify-goals.sh >> memory/cron.log 2>&1

30-दिवसीय विश्वास अनुसूची

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

सप्ताह

स्तर

आप करें

ग्रेजुएट कब

1

L1 रिपोर्ट

निर्माण 1-6;

make tick

प्रतिदिन हाथ से; सब कुछ पढ़ें

3 लगातार रन बिल्कुल वैसे रूट करें जैसे आप करते

2

L2 ड्राफ़्ट

cron चालू;

make queue

कॉफ़ी के साथ; समीक्षाएँ लेज़र को फ़ीड करती हैं

2 कौशल 20 लॉग किए गए रन पार करें

3

L3 शिप

make audit

फ़ॉर्मूले के मुकाबले; सबसे अच्छा कौशल बिना निगरानी के जाता है

1 सप्ताह, शून्य हस्तक्षेप

4

L4 विकास

कम्पोस्ट हस्ताक्षर-बंद; 1 प्रस्तावित कौशल स्वीकृत करें; डिलीट पास चलाएँ

आपने कुछ हटाया और कुछ नहीं टूटा

रनबुक। प्रत्येक अलार्म का अर्थ और क्या करना है:

सिग्नल

अर्थ

कार्रवाई

exit 2 (रीरूट)

सुरक्षा राउटर ने मिड-रन मॉडल बदल दिए

चेकपॉइंट पढ़ें; आइटम को कल पुनः चलाएँ; स्वैप किए गए आउटपुट पर कभी पुनरावृत्ति न करें

stop_reason: refusal

सुरक्षा क्लासिफ़ायर ने अस्वीकार किया (HTTP 200, कोई त्रुटि नहीं)

आधिकारिक पथ: Opus 4.8 पर फ़ॉलबैक करें

फ़ॉलबैक

या मिडलवेयर के माध्यम से; यदि यह एक कौशल पर दोहराता है, तो उस कौशल का तर्क-प्रतिध्वनि या साइबर/बायो-आसन्न वाक्यांश के लिए ऑडिट करें

exit 3 (बजट)

दैनिक खर्च सीमा पर पहुँच गया

make audit

; पता लगाएँ कि कौन सा चरण बढ़ा; बजट नहीं, प्रयास मानचित्र को ठीक करें

ALERT पदावनत

एक स्थापित कौशल 90% से नीचे गिर गया

इसके अंतिम 3 विफलताएँ पढ़ें; आमतौर पर वर्कर नहीं, स्पेक पैटर्न

goal VIOLATED

कुछ समाप्त होना सच होना बंद हो गया

सेंटिनेल संदिग्ध देता है; सुधार सामान्य पाइपलाइन से होकर जाता है

maker/checker गतिरोध x2

कोई भी सही नहीं माना जाता

आप तय करें, या गतिरोध-तोड़ने वाला चलाएँ (तीसरा ताज़ा समीक्षक, साक्ष्य का न्याय करता है, अंतर को विभाजित नहीं कर सकता)

verify-goals टाइमआउट

विधेय बहुत महँगा

यह एक उल्लंघन है; विधेय को सस्ता करें

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

1. कानून, सुझाव नहीं: एक संख्या, एक कभी नहीं, या एक आदेश जो इसे जाँचता है।
2. कंडक्टर योजना बनाता है, वर्कर निष्पादित करते हैं, कोई सत्यापन नहीं करता। --allowedTools इसे लागू करता है।
3. एजेंट कार्य आदेशों में बात करते हैं। done_when = स्पेक + रुकने की शर्त + भविष्य का अपरिवर्तनीय।
4. प्रयास वहाँ खर्च करें जहाँ लूप शाखाएँ बनाता है। लूप में कभी high से ऊपर नहीं।
5. शांत टिक की लागत एक पैनी है या लूप की लागत एक हज़ार है।
6. यदि कोई शेल स्क्रिप्ट इसे जाँच नहीं सकती, तो इसे लक्ष्य के रूप में न लिखें।
7. लक्ष्य ग्रेजुएट होते हैं; वे बंद नहीं होते। verify-goals.sh प्रतिदिन, हमेशा चलता है।
8. प्रति कौशल स्वायत्तता: 20 रन, 95%, स्वचालित। पदावनति स्वचालित और ज़ोरदार।
9. दो लेज़र: विश्वास (वर्कर) और लक्ष्य (कार्य)। दोनों को कॉफ़ी के साथ पढ़ें।
10. क्रॉन से पहले मेटाबॉलिज़्म की गणना करें।
11. रिपॉजिटरी में अनुबंध: अकेला कार्य करता है / कतारबद्ध करता है / मुझे जगाता है।
12. कभी भी उस मॉडल के आउटपुट पर पुनरावृत्ति न करें जिसे आपने नहीं चुना।
13. सेंटिनेल पता लगाता है; पाइपलाइन ठीक करती है।
14. Fable को जगाने से पहले कोरम। रैचेट फिर वेल्ड। प्रतिदिन स्पैर। साप्ताहिक कम्पोस्ट।
15. एक बार में एक ग्रेजुएशन मानदंड। हर महीने, कुछ हटाएँ।
16. आधिकारिक दस्तावेज़ से: max_tokens सोच और टेक्स्ट को सीमित करता है, अस्वीकार HTTP 200 हैं, कभी प्रतिध्वनित तर्क न माँगें, पुराने कौशल Fable को ख़राब करते हैं, और ताज़ा-संदर्भ सत्यापनकर्ता आत्म-आलोचना से बेहतर हैं। Anthropic ऐसा कहता है; सिस्टम इसे लागू करता है।

समापन

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

• मॉडल कभी कठिन हिस्सा नहीं था। कठिन हिस्सा इसके चारों ओर कुछ ऐसा बनाना था जो ईमानदार रहे जब आप देखना बंद कर दें। यही वह है जो आपने अभी बनाया।
• आज रात उन बीस मिनटों से शुरू करें जो इसे साबित करते हैं: निर्माण 2 का verify.sh, निर्माण 3 का पहला टिक हाथ से, और आपके द्वारा पूरी की गई अंतिम चीज़ के लिए एक स्थायी लक्ष्य।
• पहली बार जब verify-goals.sh किसी ऐसी चीज़ पर एक मूक प्रतिगमन पकड़ता है जिसके बारे में आपको यकीन था कि वह हो गई है, तो आपको बाकी के बारे में समझाने की आवश्यकता नहीं होगी।

अस्वीकरण

यह लेख उपयोगकर्ता के नोट्स का उपयोग करके लिखा गया था और Claude Opus 4.8 max द्वारा संपादित किया गया था।