मैंने अपने OpenClaw एजेंट की मेमोरी को डीबग करने में 5 दिन बिताए। यहाँ वह सब कुछ है जो मैंने सीखा।

मेरे एजेंट का नाम चिटी है। यह टेलीग्राम पर चलता है, दो SaaS उत्पादों के लिए ग्राहक सहायता संभालता है, ट्वीट का मसौदा तैयार करता है, चालान प्रबंधित करता है, और मेरे सह-संस्थापक के साथ समय क्षेत्रों में समन्वय करता है। यह मेरे पास एक जूनियर कर्मचारी के सबसे करीबी चीज़ है।

और हफ्तों तक, यह चीज़ें भूलता रहा।

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

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

दिन 1: लंबी बातचीत के बाद एजेंट सब कुछ भूल जाता है

पहली समस्या का वर्णन करना सरल था और निदान करना दर्दनाक।

लंबी बातचीत के बाद, चिटी पहले का संदर्भ खोने लगता। धीरे-धीरे नहीं, बस गायब हो जाता। 20 संदेश पहले जो बताया था वह चला गया। सत्र की शुरुआत में लिए गए निर्णय? कभी हुए ही नहीं।

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

यह डिज़ाइन द्वारा है। कॉन्टेक्स्ट विंडो सीमित है। लेकिन डिफ़ॉल्ट व्यवहार सब कुछ समान रूप से मानता है, जिसका अर्थ है कि संदेश #3 से आपका सावधानीपूर्वक तैयार निर्देश संदेश #7 से आकस्मिक छोटी बात के समान व्यवहार प्राप्त करता है।

मैंने क्या किया:

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

1{
2  "compaction": {
3    "memoryFlush": {
4      "enabled": true,
5      "softThresholdTokens": 4000
6    }
7  }
8}

जब सत्र संदर्भ सीमा के करीब पहुंचता है, OpenClaw एक मूक मोड़ शुरू करता है जो एजेंट को याद दिलाता है कि कॉम्पैक्शन उन्हें मिटाने से पहले memory/YYYY-MM-DD.md में टिकाऊ तथ्यों को सहेज ले। एजेंट जो मायने रखता है लिखता है, कॉम्पैक्शन चलता है, और महत्वपूर्ण चीज़ें डिस्क पर बच जाती हैं भले ही संदर्भ सारांश उन्हें खो दे।

मैंने क्या सीखा:

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

दिन 2: खोज कचरा लौटाती है

दैनिक लॉग जमा होने और MEMORY.md बढ़ने के साथ, मुझे एजेंट को वास्तव में चीज़ें खोजने की आवश्यकता थी। बिल्ट-इन मेमोरी खोज अप्रासंगिक परिणाम लौटा रही थी या स्पष्ट मिलानों को याद कर रही थी।

समस्या खोज बैकएंड थी। OpenClaw का डिफ़ॉल्ट SQLite-आधारित खोज प्रासंगिक चंक खोजने के लिए वेक्टर एम्बेडिंग (सिमैंटिक समानता) का उपयोग करता है। यह व्यापक प्रश्नों के लिए काम करता है लेकिन सटीक मिलानों के लिए संघर्ष करता है। मैं एक विशिष्ट ग्राहक नाम खोजता और पूरी तरह से अलग विषय के परिणाम मिलते जो समान भाषा का उपयोग करता था।

मैंने क्या किया:

मैंने मेमोरी खोज बैकएंड के रूप में QMD पर स्विच किया। QMD BM25 (कीवर्ड मिलान) को वेक्टर एम्बेडिंग और एक रीरैंकर के साथ जोड़ता है। इसलिए जब मैं "Charles payment failure" खोजता हूं, तो यह उन सटीक शब्दों वाले परिणाम और सिमैंटिक रूप से संबंधित परिणाम दोनों ढूंढता है, फिर उन्हें प्रासंगिकता के अनुसार पुनः क्रमबद्ध करता है।

मैंने QMD पथों में अपना लर्निंग्स फ़ोल्डर भी शामिल किया:

1{
2  "memory": {
3    "qmd": {
4      "paths": "paths": [
5        {
6          "path": "/Users/ramya/clawd",
7          "name": "memory-root",
8          "pattern": "MEMORY.md"
9        },
10        {
11          "path": "/Users/ramya/clawd",
12          "name": "memory-alt",
13          "pattern": "memory_alt.md"
14        },
15        {
16          "path": "/Users/ramya/clawd/memory",
17          "name": "memory-dir",
18          "pattern": "**/*.md"
19        },
20        {
21          "path": "/Users/ramya/clawd/learnings",
22          "name": "learnings",
23          "pattern": "**/*.md"
24        }
25      ]
26    }
27  }
28}

मैंने क्या सीखा:

शुद्ध सिमैंटिक खोज सिद्धांत में अच्छी लगती है लेकिन उचित संज्ञाओं, विशिष्ट संख्याओं और सटीक वाक्यांशों पर विफल होती है। हाइब्रिड खोज (कीवर्ड + वेक्टर + रीरैंकिंग) वास्तविक दुनिया के एजेंट मेमोरी के लिए काफी बेहतर है। यदि आपका एजेंट कुछ नहीं ढूंढ पाता जो आप जानते हैं कि उसकी फाइलों में है, तो संभवतः खोज बैकएंड बाधा है, फाइलें नहीं।

दिन 3: एजेंट ढूंढता है लेकिन उपयोग नहीं करता

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

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

मैंने क्या किया:

मैंने बूट सीक्वेंस में स्पष्ट पुनर्प्राप्ति निर्देश जोड़े। यह उम्मीद करने के बजाय कि एजेंट ज़रूरत पड़ने पर खोज करेगा, मैंने उसे बताया कि कब खोजना है:

markdown

कोई भी कार्य शुरू करने से पहले:

• संबंधित संदर्भ के लिए दैनिक लॉग खोजें
• इस प्रकार के कार्य के नियमों के लिए LEARNINGS.md जांचें
• यदि कोई ग्राहक उल्लिखित है, तो उसका इतिहास खोजें

मैंने एक पुनर्प्राप्ति परीक्षण भी बनाया। मैं दैनिक लॉग में एक विशिष्ट मार्कर लगाता — जैसे "MARKER: 2026-02-20 — Remember to always check git status before claiming code is pushed." फिर मैं प्रतीक्षा करता, एक नया सत्र शुरू करता, और पूछता: "कल का मार्कर क्या था?" यदि एजेंट उसे ढूंढ लेता, तो पुनर्प्राप्ति काम कर रही थी। यदि नहीं, तो कुछ टूटा हुआ था।

मैंने क्या सीखा:

"जानकारी मौजूद है" और "एजेंट जानकारी का उपयोग करता है" में अंतर है। आपको दोनों की आवश्यकता है। खोज बुनियादी ढांचा पहले भाग को संभालता है। बूट निर्देश और पुनर्प्राप्ति की आदतें दूसरे को संभालती हैं। दोनों का अलग-अलग परीक्षण करें।

दिन 4: इसे कॉम्पैक्शन-सुरक्षित बनाना

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

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

मैंने क्या किया:

मैंने कॉम्पैक्शन के साथ काम करने के लिए कॉन्टेक्स्ट प्रूनिंग कॉन्फ़िगर किया:

1{
2  "contextPruning": {
3    "mode": "cache-ttl",
4    "ttl": "6h",
5    "keepLastAssistants": 3
6  }
7}

यह 6 घंटे के बाद पुराने संदर्भ को आक्रामक रूप से काटता है जबकि पिछले 3 असिस्टेंट उत्तरों को रखता है। मेमोरी फ्लश के साथ संयुक्त, इसका मतलब है कि एजेंट महत्वपूर्ण चीज़ों को जल्दी डिस्क पर लिखता है, और पुराना संदर्भ ओवरफ्लो होने से पहले साफ हो जाता है।

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

मैंने क्या सीखा:

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

दिन 5: सिस्टम प्रॉम्प्ट 28% फूला हुआ था

यह वह दिन था जब सब कुछ जुड़ गया। मैंने /context detail चलाया और संख्याओं को घूरता रहा।

मेरा एजेंट मेरा संदेश पढ़ने से पहले ही 11,887 टोकन का सिस्टम प्रॉम्प्ट लोड कर रहा था। 51 कौशल, जिनमें से 20 मैंने कभी उपयोग नहीं किए थे। MEMORY.md कंपनी विकी की 200 पंक्तियाँ थी जो हर सत्र पर लोड होती थीं। और मेरे पास दो प्रतिस्पर्धी बूट सीक्वेंस थे - एक BOOT.md में (जिसे OpenClaw पहचानता भी नहीं) और एक AGENTS.md में 200 पंक्तियाँ गहरी दबी हुई।

सबसे बुरी बात, हर बार जब मैं मॉडल बदलता, चिटी सब कुछ भूल जाता। कोई हैंडओवर प्रोटोकॉल नहीं। वर्तमान संदर्भ का कोई लिख-बैक नहीं। बस गायब।

मूल कारण:

OpenClaw इन फाइलों को हर नए सत्र पर ऑटो-रीड करता है: AGENTS.md, SOUL.md, TOOLS.md, IDENTITY.md, HEARTBEAT.md, MEMORY.md।

बाकी सब कुछ — LEARNINGS.md, दैनिक लॉग, डॉक्स, संदर्भ फाइलें — एजेंट को उन्हें स्वयं टूल का उपयोग करके पढ़ना होता है। यदि उन फाइलों को पढ़ने का निर्देश ऑटो-लोडेड फाइलों (विशेष रूप से AGENTS.md) में से एक में नहीं है, तो एजेंट उन्हें कभी नहीं देखेगा।

मेरे BOOT.md में पूरा बूट सीक्वेंस था। लेकिन OpenClaw BOOT.md को ऑटो-लोड नहीं करता। तो निर्देश वहीं पड़े रहे, अपढ़, कुछ नहीं कर रहे थे।

मैंने क्या किया:

मैंने पूर्ण ऑडिट और सफाई की:

1. बूट सीक्वेंस को AGENTS.md के शीर्ष पर ले जाया (स्टार्टअप निर्देशों के लिए एकमात्र विश्वसनीय स्थान)
2. BOOT.md हटाया (OpenClaw द्वारा मान्यता प्राप्त नहीं)
3. BOOTSTRAP.md हटाया (एक बार का ऑनबोर्डिंग फ़ाइल, पहले से पूर्ण, हर सत्र में 361 टोकन बर्बाद कर रहा था)
4. MEMORY.md को 200 पंक्तियों से घटाकर 90 कर दिया, संदर्भ डॉक्स को docs/ फ़ोल्डर में ले जाकर
5. 20 अप्रयुक्त मार्केटिंग कौशल हटाए जो प्रति सत्र 3,000 टोकन खा रहे थे
6. लिखित अनुशासन जोड़ा: हर कार्य अपने परिणाम को लॉग करता है, हर गलती एक नियम बन जाती है
7. एक हैंडओवर प्रोटोकॉल जोड़ा: किसी भी मॉडल स्विच या सत्र समाप्ति से पहले, एजेंट वर्तमान संदर्भ को दैनिक लॉग में लिखता है

बूट सीक्वेंस अब इस तरह दिखता है:

markdown

कुछ भी करने से पहले:

1. USER.md पढ़ें
2. learnings/LEARNINGS.md पढ़ें
3. memory/YYYY-MM-DD.md पढ़ें (आज + कल)
4. MEMORY.md पढ़ें (केवल मुख्य सत्र, समूहों में कभी नहीं)
5. PROTOCOL_COST_EFFICIENCY.md पढ़ें
6. प्रिंट करें: LOADED: USER | LEARNINGS | DAILY | MEMORY | PROTOCOL

लिखित अनुशासन:

markdown

प्रत्येक कार्य के बाद:

1. निर्णय + परिणाम लॉग करें → memory/YYYY-MM-DD.md
2. यदि गलती → learnings/LEARNINGS.md में जोड़ें
3. यदि महत्वपूर्ण संदर्भ → MEMORY.md अपडेट करें (केवल हार्टबीट समीक्षा के दौरान, कार्यों के दौरान कभी सीधे नहीं)

हैंडओवर प्रोटोकॉल:

markdown

सत्र समाप्ति या मॉडल स्विच से पहले:

memory/YYYY-MM-DD.md में HANDOVER अनुभाग लिखें:

• क्या चर्चा हुई
• क्या निर्णय लिया गया
• सटीक विवरण के साथ लंबित कार्य
• शेष अगले कदम

परिणाम:

• सिस्टम प्रॉम्प्ट: 11,887 → 8,529 टोकन
• कौशल: 51 → 32
• सत्र टोकन: 18,280 → 14,627
• 28% हल्का। वही एजेंट। वही मॉडल। बस कम शोर।

मैंने क्या सीखा:

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

वे नियम जो मैं दिन 1 पर जानना चाहता था

5 दिन चीज़ें तोड़ने और ठीक करने के बाद, ये वे नियम हैं जो मैं OpenClaw मेमोरी सेट करने वाले किसी भी व्यक्ति को दूंगा:

1. केवल ये फाइलें ऑटो-लोड होती हैं: AGENTS.md, SOUL.md, TOOLS.md, IDENTITY.md, USER.md, HEARTBEAT.md, MEMORY.md।

बाकी सब कुछ को AGENTS.md में एक स्पष्ट पढ़ने के निर्देश की आवश्यकता है। यदि यह बूट सीक्वेंस में नहीं है, तो एजेंट इसे नहीं देखेगा। BOOT.md OpenClaw में एक वास्तविक चीज़ नहीं है। मेरे पास हफ्तों तक था। इसने कुछ नहीं किया।

2. बूट सीक्वेंस AGENTS.md के शीर्ष पर जाता है।

बीच में नहीं। नीचे नहीं। बिल्कुल शीर्ष पर। ऑटो-लोडेड फाइलें सिस्टम प्रॉम्प्ट में इंजेक्ट हो जाती हैं, इसलिए बूट निर्देशों को एजेंट द्वारा संसाधित की जाने वाली पहली चीज़ होनी चाहिए।

3. लिखित अनुशासन पढ़ने के अनुशासन से अधिक महत्वपूर्ण है।

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

4. कार्यों के दौरान कभी सीधे MEMORY.md में न लिखें।

दैनिक लॉग कच्चे और केवल-जोड़े जाने वाले होते हैं। MEMORY.md क्यूरेटेड दीर्घकालिक मेमोरी है। यदि आप एजेंट को MEMORY.md में कुछ भी डालने देते हैं, तो यह हफ्तों के भीतर 200-पंक्ति की गड़बड़ी में बदल जाता है। समय-समय पर समीक्षा (हार्टबीट या क्रॉन) के दौरान हाल के दैनिक लॉग से अंतर्दृष्टि निकालकर MEMORY.md को क्यूरेट करें। मैंने यह एक साथी OpenClaw उपयोगकर्ता से सीखा जिसने अपने एजेंट को ठीक यही करते पकड़ा — अक्यूरेटेड शोर के साथ MEMORY.md को फुलाकर बेकार कर दिया।

5. LEARNINGS.md सबसे कम आंका गया फ़ाइल है।

एजेंट द्वारा की गई प्रत्येक गलती एक-पंक्ति का नियम बन जानी चाहिए। "कोड पुश होने का दावा करने से पहले git स्थिति जांचना कभी न भूलें।" "समूह चैट में पूर्ण MEMORY.md न पढ़ें।" "शेड्यूल करने से पहले हमेशा उपयोगकर्ता के समय क्षेत्र की पुष्टि करें।" ये नियम संयोजित होते हैं। कुछ हफ्तों के बाद, आपके एजेंट के पास अपनी विफलताओं से निर्मित एक व्यक्तिगत संचालन मैनुअल होता है।

6. पुनर्प्राप्ति का परीक्षण करें, न कि केवल भंडारण का।

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

7. हैंडओवर प्रोटोकॉल मॉडल-स्विच का समाधान है।

जब आप मॉडल बदलते हैं तो OpenClaw एजेंट सभी संदर्भ खो देते हैं। नया मॉडल एक ताजा कॉन्टेक्स्ट विंडो से शुरू होता है — यह केवल ऑटो-लोडेड फाइलों को देखता है। एक हैंडओवर प्रोटोकॉल के बिना जो स्विच से पहले वर्तमान स्थिति को दैनिक लॉग में डंप करता है, नए मॉडल को पता नहीं होता कि क्या हो रहा था। हफ्तों तक यह मेरा सबसे बड़ा दर्द बिंदु था।

8. नियमित रूप से /context detail चलाएं।

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

9. हाइब्रिड खोज शुद्ध सिमैंटिक खोज से बेहतर है।

BM25 (कीवर्ड) + वेक्टर (अर्थ) + रीरैंकिंग अकेले वेक्टर की तुलना में काफी बेहतर परिणाम देता है। ग्राहक नाम, विशिष्ट संख्याएं, सटीक वाक्यांश — सिमैंटिक खोज इन्हें याद करती है। कीवर्ड खोज इन्हें पकड़ती है। दोनों का उपयोग करें।

10. कॉम्पैक्शन दुश्मन नहीं है। अलिखित संदर्भ है।

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

मेरा वर्तमान सेटअप

संदर्भ के लिए, मेरा वर्कस्पेस अब इस तरह दिखता है:

workspace/

├── AGENTS.md (बूट सीक्वेंस + लिखित अनुशासन + हैंडओवर प्रोटोकॉल)

├── SOUL.md (व्यक्तित्व और व्यवहार)

├── IDENTITY.md (नाम, भूमिका)

├── USER.md (मालिक की जानकारी)

├── TOOLS.md (टूल उपयोग दिशानिर्देश)

├── HEARTBEAT.md (स्वायत्त चेक-इन व्यवहार)

├── MEMORY.md (क्यूरेटेड दीर्घकालिक मेमोरी, ~90 पंक्तियाँ)

├── PROTOCOL_COST_EFFICIENCY.md

├── learnings/

│ └── LEARNINGS.md (गलतियों से नियम)

├── memory/ (दैनिक लॉग: YYYY-MM-DD.md)

├── docs/ (MEMORY.md से बाहर ले जाए गए संदर्भ डॉक्स)

│ ├── tweetsmash-arch.md

│ ├── knowledge-transfer.md

│ ├── infrastructure.md

│ └── group-chat-rules.md

└── skills/ (32 कौशल, 51 से नीचे)

सिस्टम प्रॉम्प्ट: 8,529 टोकन। सत्र टोकन: 200,000 कॉन्टेक्स्ट विंडो में से 14,627 (7.3%)। एजेंट बूट होता है, जो चाहिए पढ़ता है, जो सीखता है लिखता है, और मॉडल स्विच से पहले संदर्भ सौंपता है।

यहां तक पहुंचने में 5 दिन लगे। अधिकांश समय इस धारणा को अनसीखने में बीता कि अधिक फाइलें बेहतर मेमोरी के बराबर होती हैं। ऐसा नहीं है। अनुशासन करता है। मेरा प्रयोग अभी भी जारी है।

मैं TweetSmash और LinkedMash बना रहा हूं — अपने सह-संस्थापक के साथ सोशल मीडिया बुकमार्क टूल। मैं X पर प्रोडक्शन में OpenClaw एजेंट चलाने के बारे में जो सीखता हूं वह साझा करता हूं: @code_rams