AI एजेंट को अपना बनाने का तरीका
(monet.team-monet.com)अगर आप ऐसे डेवलपर हैं जो हर दिन AI coding agent के साथ काम करते हैं, तो यह एहसास आप जानते होंगे.
कल ही हमने मिलकर यह convention तय किया था, लेकिन नया session खुलते ही सब कुछ फिर से blank हो जाता है. मैं TypeScript में हमेशा interface की जगह type इस्तेमाल करता हूँ, PR review में मैंने कहा था कि वह pattern मुझे पसंद नहीं, पिछले हफ्ते बड़ी मुश्किल से पकड़े गए उस bug का root cause — हर चीज़ ऐसे पेश आती है जैसे पहली बार सुन रहे हों.
इसे बार-बार दोहराने के बाद आखिरकार मन में आता है, "छोड़ो, मैं खुद ही कर लेता हूँ."
इसी समस्या को हल करने के लिए मैंने Monet बनाया. ऐसा सिस्टम जो एक general-purpose AI agent को मेरे agent की तरह काम करने लायक बना दे. जो मेरे conventions सीखे, मेरी पसंदीदा working style याद रखे, और project की history को अपने आप संभाले.
यह कैसे काम करता है
इसका core idea सरल है.
लिखना — agent खुद तय करता है. आपको अलग से "इसे याद रखो" कहने की ज़रूरत नहीं. काम के दौरान लिए गए decisions, मिले हुए patterns, और सामने आए issues को वह खुद रिकॉर्ड करता है. noise को छाँटकर सिर्फ signal रखता है.
पढ़ना — जो उपयोगी रहा, वही पहले आता है. यह साधारण keyword search नहीं है. जिन यादों का वास्तव में ज़्यादा reference हुआ है और जिन्होंने समस्या हल करने में मदद की है, वे पहले दिखाई देती हैं. जिन zombie memories को कोई नहीं ढूँढ़ता, वे स्वाभाविक रूप से पीछे चली जाती हैं.
विकास — जितना ज़्यादा जमा होगा, उतना smarter बनेगा. पहला काम धीमा होता है. क्योंकि उसे codebase नहीं पता, conventions नहीं पता, और बार-बार आने वाले bugs भी नहीं पता. लेकिन जैसे-जैसे memory जमा होती है, अगला काम तेज़ हो जाता है. कल मिला pattern, पिछले हफ्ते लिया गया decision, उस bug का root cause — इन्हें फिर से खोजने की ज़रूरत नहीं रहती. करीब एक महीने बाद यह agent सिर्फ एक general-purpose tool नहीं रहता, बल्कि इस project को गहराई से जानने वाले मेरे dedicated engineer की तरह काम करने लगता है.
यहाँ तक कैसे पहुँचा
शुरुआत में मैं बस एक file में notes जमा करता था. agent काम करते हुए जो सीखता, उसे Markdown में लिख देता, और नया session शुरू होने पर उसे include कर लेता. यह सरल था, लेकिन सामग्री बढ़ने के साथ noise भी बढ़ने लगा.
इसलिए 4 महीने पहले मैंने एक proper memory system बनाया. पुराना Monet. इसे MCP आधारित बनाया गया था ताकि agent पढ़ और लिख सके, और team sharing भी ध्यान में रखी गई थी. लेकिन team sharing पर ज़्यादा ध्यान देने की वजह से, अकेले इस्तेमाल करने का अनुभव थोड़ा अस्पष्ट हो गया. चीज़ें चल तो रही थीं, लेकिन मेरे workflow से पूरी तरह मेल नहीं खा रही थीं.
इसलिए मैंने इसे पूरी तरह दोबारा बनाया. कुछ हफ्ते पहले मैंने team sharing के लक्ष्य को थोड़ी देर के लिए अलग रखा और सिर्फ एक बात पर ध्यान दिया: "क्या मैं इसे सच में हर दिन इस्तेमाल कर सकता हूँ?" इसी एक सवाल पर केंद्रित होकर मैंने Monet को शुरुआत से फिर बनाया. यह लिखते समय 12 agents नए Monet पर पढ़ और लिख रहे हैं. अभी monitoring feature नहीं है, इसलिए सटीक आँकड़े नहीं दे सकता, लेकिन पहले की तुलना में search कम हुआ है और read/write काफ़ी बढ़े हैं. इसका मतलब है कि agent अपने आप महत्वपूर्ण चीज़ों को चुनकर जमा कर रहे हैं.
सच कहूँ तो
vibe coding वाले चरण में memory उतनी महत्वपूर्ण नहीं लगती. ज़्यादातर नई features बन रही होती हैं और bugs भी सरल होते हैं. आप agent से कहते हैं, "इसे ठीक कर दो," और मामला context window के भीतर ही निपट जाता है.
लेकिन जैसे-जैसे वह app जटिल होती जाती है, कहानी बदल जाती है. code की एक line बदलने के लिए 10 जुड़े हुए logic देखने पड़ते हैं, और side effects खोजते-खोजते agent इस file से उस file तक भटकता रहता है. गलतियाँ भी बढ़ती हैं. 1M tokens दे दो, फिर भी context को तीन बार compress करने के बाद आप वहीं के वहीं रह जाते हैं.
घर पर मैं agents के साथ नए code में मज़ेदार चीज़ें बनाता हूँ, और कंपनी में हर दिन 20 साल पुराने code से जूझता हूँ. कंपनी में agent memory अनिवार्य है. इसके बिना काम आगे बढ़ता ही नहीं.
इसीलिए मैंने file-based indexed memory खुद बनाकर इस्तेमाल करना शुरू किया. वहीं से Monet की शुरुआत हुई. आजकल कंपनी में मैं जानबूझकर agents को चक्कर लगवाता हूँ — ताकि वे context इकट्ठा करें. ज़्यादातर tickets सिर्फ 20% context में ही निपट जाती हैं. समय की बचत तो होती ही है, stress भी कम हुआ है.
सबसे बढ़कर, पहले मैं यह सोचकर दिमाग पर ज़ोर डालता था कि "वह bug मैंने कैसे ठीक किया था?" अब मैं बस Kiro (कंपनी का coding agent) से पूछता हूँ. ज़्यादातर बार उसे पता होता है.
जब agents दर्जनों में हों और code लाखों lines का हो, तब context अब bytes की समस्या नहीं रहता, बल्कि infrastructure की समस्या बन जाता है. और उसी बिंदु पर memory सिर्फ nice-to-have नहीं रहती, बल्कि यह तय करती है कि काम संभव भी है या नहीं.
अगर आप इसे आज़माना चाहते हैं
- होमपेज: monet.team-monet.com
- GitHub: github.com/team-monet/with-monet — installation harness (Apache-2.0)
- 100% local: code आपकी device से बाहर नहीं जाता. On-device embeddings, कोई network या telemetry नहीं. memory सिर्फ
~/.monetमें एक SQLite file है — आप इसे खुद खोलकर देख सकते हैं, backup ले सकते हैं, और export कर सकते हैं. - मुफ़्त इस्तेमाल. engine एक private compiled binary है, लेकिन integration interface standard MCP है. Claude Code, Cursor, Codex जैसे MCP-supported agents के साथ सीधे integrate किया जा सकता है.
खास तौर पर, मैं चाहता हूँ कि ये लोग इसे एक बार ज़रूर आज़माएँ:
- वे डेवलपर्स जो AI agents के साथ गंभीरता से हर दिन काम करते हैं
- वे लोग जिन्हें यह थकान महसूस हुई है कि "कल वाली बात फिर से समझानी पड़ेगी…"
- वे लोग जो सोचते हैं, "agent memory? उसकी ज़रूरत क्यों है?" (सच में — मैं अलग राय भी सुनना चाहता हूँ)
इस लेख में दिए गए उदाहरण और परिदृश्य सभी वास्तविक अनुभवों पर आधारित हैं.
अभी कोई टिप्पणी नहीं है.