पिछले महीने, मैं जो कोडिंग एजेंट बना रहा हूँ, उन्होंने इनपुट और आउटपुट के बीच 13 बिलियन टोकन प्रोसेस किए, जिसमें 97.24% कैश हिट रेट और लगभग R$ 0.04 प्रति मिलियन टोकन की प्रभावी लागत रही।
जब मैं ये आंकड़े बताता हूँ, तो पहली प्रतिक्रिया आमतौर पर अविश्वास होती है—और यह स्वस्थ है। कंपनियों के ऑटोनॉमस एजेंट छोड़ने का नंबर एक कारण लागत है: पायलट काम करता है, बिल आता है, प्रोजेक्ट मर जाता है। तो यह लेख इस बारे में है कि ये आंकड़े कैसे आते हैं। कोई एक ट्रिक नहीं है; एक आर्किटेक्चर है जहाँ हर टोकन जो अंदर और बाहर जाता है, कंप्रेस, रूट और मापा जाता है।
यह है Velua Code, वह एजेंट जिसे हम एक नए स्टार्टअप पर बना रहे हैं जिसे मैंने शुरू करने का फैसला किया है, Velua AI (https://velua.aihttps://velua.ai/))। आर्किटेक्चर से पहले, थीसिस।
थीसिस: तीन समस्याएँ, एक साथ हल
कोडिंग एजेंट तीन जगहों पर टूटते हैं, और केवल एक को हल करना काफी नहीं है।
लागत। एक ऑटोनॉमस एजेंट टोकन को ऐसे पैमाने पर खपत करता है जो किसी भी CFO को डरा देता है। यदि प्रत्येक पुनरावृत्ति महँगी है, तो कोई भी एजेंट को पुनरावृत्ति करने नहीं देता—और एक एजेंट जो पुनरावृत्ति नहीं करता, वास्तव में कुछ भी हल नहीं करता।
संदर्भ। संदर्भ विंडो सीमित और महँगी है। विशिष्ट कार्यान्वयन प्रॉम्प्ट को पूरी फाइलों और grep परिणामों से भर देता है, हर कॉल में हजारों अप्रासंगिक टोकन के लिए भुगतान करता है।
मेमोरी। हर सत्र खरोंच से शुरू होता है। एजेंट मंगलवार को वही फिर से खोजता है जो उसने सोमवार को पहले ही सीख लिया था—और इसे फिर से खोजने के लिए (टोकन और त्रुटियों में) भुगतान करता है।
ये तीनों एक दूसरे को खिलाते हैं: फुलाया हुआ संदर्भ लागत बढ़ाता है, मेमोरी की कमी संदर्भ को फुलाती है। यही कारण है कि Velua Code एक साथ तीनों पर हमला करता है।
लागत: स्रोत संपीड़न + सक्रिय रूटिंग
पहला आर्किटेक्चरल निर्णय: संदर्भ को स्रोत पर संपीड़ित करें, अंत में नहीं। हर टूल आउटपुट—फ़ाइल पढ़ना, खोज परिणाम, बिल्ड लॉग—सत्र इतिहास में प्रवेश करने से पहले एक संपीड़न पाइपलाइन से गुज़रता है। मूल एक मालिकाना संपीड़न मॉडल है जो डेव की मशीन पर या एजेंट के कंटेनर में ONNX में स्थानीय रूप से चलता है। संपीड़ित करने के लिए कोई नेटवर्क कॉल नहीं है: बचत में टोकन खर्च नहीं होते।
इसके चारों ओर, सरल परतें भारी काम करती हैं: रीड का डिडुप्लीकेशन (क्या एजेंट ने एक ही फाइल को फिर से पढ़ा? पुराना संस्करण संदर्भ से बाहर चला जाता है), संरचनात्मक JSON संपीड़न, सिग्नेचर बनाए रखते हुए कोड बॉडी का लोप, और एक अनुकूली सीमा जो संदर्भ बढ़ने पर संपीड़न को कसती है। सब कुछ लक्ष्य मॉडल के वास्तविक टोकनाइज़र से मापा जाता है—बचत वास्तविक टोकन में गिनी जाती है, अनुमानों में नहीं।
और एक निर्णय है कि क्या नहीं करना है: हम रनटाइम पर सिस्टम प्रॉम्प्ट को कभी नहीं छूते हैं। एक स्थिर प्रॉम्प्ट वह है जो 97.24% कैश हिट रेट को बनाए रखता है—और कैश हिट सबसे सस्ता लागत लीवर है जो मौजूद है, क्योंकि एक कैश्ड टोकन की लागत पूर्ण टोकन के एक अंश के बराबर होती है।
दूसरा निर्णय: एजेंट मॉडल नहीं चुनता। एक स्थानीय क्लासिफ़ायर प्रत्येक कार्य को श्रेणी और जटिलता के अनुसार पूर्व-वर्गीकृत करता है, और Velua Gateway—जो रीयल-टाइम मूल्य और प्रदर्शन के साथ 50+ मॉडल देखता है—आवश्यकता के अनुसार सबसे सक्षम मॉडल पर रूट करता है, इसके अलावा गार्डरेल लागू करता है और RAG से समृद्ध करता है। एक वेरिएबल का नाम बदलने के लिए फ्रंटियर मॉडल की आवश्यकता नहीं है; स्कीमा माइग्रेशन डिज़ाइन करने के लिए होती है। सक्रिय रूटिंग के साथ, अधिकांश कॉल छोटे मॉडलों पर जाती हैं, और महँगा मॉडल तभी आता है जब जटिलता इसकी माँग करती है।
गेटवे प्रत्येक अनुरोध की वास्तविक लागत भी मापता है। यह कुछ ऐसा सक्षम बनाता है जिसे मैं उत्पादन में एजेंटों के लिए अनिवार्य मानता हूँ: एक रोकने की शर्त के रूप में बजट। ऑटोनॉमस लूप मुद्रा में एक लागत सीमा के साथ चलता है, उम्मीद से नहीं।
यह संयोजन है—स्रोत संपीड़न, उच्च कैश, छोटे मॉडलों के बीच रूटिंग—जो R$ 0.04 प्रति मिलियन उत्पन्न करता है। तीनों में से कोई भी टुकड़ा अकेला इसके करीब नहीं आता।
संदर्भ: Grep के बजाय एक ग्राफ़
एजेंट के लिए कोडबेस को "समझने" का मानक तरीका grep और फ़ाइल पढ़ना है—महँगा और अंधा। Velua Code एक कोड नॉलेज ग्राफ़ बनाए रखता है: फ़ंक्शन, क्लास, रूट और उनके बीच संबंध (कौन किसे कॉल करता है, कौन क्या लागू करता है)।
यह लूप के दोनों सिरों को बदलता है। इनपुट पर, एजेंट ग्राफ़ से परामर्श करके एक पतला संदर्भ पैकेज इकट्ठा करता है—प्रोजेक्ट का आर्किटेक्चरल दृश्य और कार्य के लिए प्रासंगिक नोड्स—प्रॉम्प्ट में फ़ाइलें डंप करने के बजाय। आउटपुट पर, यह सत्यापन बदलता है: जब एजेंट किसी फ़ंक्शन को संशोधित करता है, तो ग्राफ़ प्रभावित कॉल पॉइंट्स को सूचीबद्ध करता है, और एक समीक्षक एजेंट—स्वच्छ संदर्भ के साथ, कोड लिखने वाले के पूर्वाग्रह के बिना—उनमें से प्रत्येक की जाँच करता है, इसके अलावा टेस्ट, लिंट और बिल्ड चलाता है। "आपने processOrder का सिग्नेचर बदल दिया; सात जगहें इसे कॉल करती हैं" एक प्रकार का सत्यापन है जो grep प्रदान नहीं करता।
मेमोरी: वह लूप जो सीखता है
वह टुकड़ा जो सिस्टम को बंद करता है। प्रत्येक सत्यापित पुनरावृत्ति के अंत में, एजेंट इंजीनियरिंग निर्णय रिकॉर्ड करता है: क्या तय किया गया, क्यों, क्या विकल्पों पर विचार किया गया, क्या विफल हुआ। और प्रत्येक निर्णय ग्राफ़ के भीतर, उन कोड नोड्स से लिंक किया जाता है जिन्हें वह समझाता है।
अगली पुनरावृत्ति में, संदर्भ संग्रह चरण इन निर्णयों को पुनर्प्राप्त करता है—उन दृष्टिकोणों सहित जो पहले ही विफल हो चुके हैं, ताकि उन्हें दोहराया न जाए। लूप एक निष्पादक बनना बंद कर देता है जो कार्यों को दोहराता है और एक ऐसी प्रणाली बन जाता है जो कोडबेस के बारे में ज्ञान संचित करता है। यह सबसे अच्छा लागत परिशोधक भी है जो मौजूद है: सस्ती मेमोरी महँगी पुनर्खोज को बदल देती है।
पूरा लूप, तब: संदर्भ इकट्ठा करें (ग्राफ़ + मेमोरी + RAG), समस्या के आकार के लिए सही मॉडल के साथ योजना बनाएं, उप-एजेंटों के साथ कार्य करें, स्वच्छ-संदर्भ समीक्षक और ग्राफ़ जागरूकता के साथ सत्यापित करें, निर्णय रिकॉर्ड करके सीखें—और दोहराएं, एक लागत सीमा के साथ। यह विहित एजेंट लूप है, जिसमें प्रत्येक सामान्य चरण को अपनी क्षमता से बदल दिया गया है।
पहला क्लाइंट हम क्यों हैं
उत्पाद रणनीति जानबूझकर प्रति-सहज है: किसी भी क्लाइंट को बेचने से पहले, Velua Code SIGE Cloud पर आंतरिक रूप से चलता है। वास्तविक डॉगफूडिंग—एक ERP उत्पादन में, वास्तविक कोड पर एजेंट संचालित करने वाली वास्तविक टीमों के साथ, हर दिन।
यह वह आंतरिक उपयोग था जिसने 13 बिलियन टोकन उत्पन्न किए, और यही उत्पाद को आकार दे रहा है। उत्पादन में ऑटोनॉमस एजेंट उन समस्याओं को उजागर करते हैं जो कोई भी बेंचमार्क उजागर नहीं करता: अनुमतियाँ, संचित लागत, रुके हुए कार्य, सड़ता हुआ संदर्भ। मैं इसे वहाँ परिपक्व होने देना पसंद करता हूँ जहाँ दर्द हमारा अपना है।
आगे क्या: कंपनियों के लिए एकीकृत मेमोरी
आज, निर्णय मेमोरी प्रति प्रोजेक्ट रहती है। अगला कदम वह है जो मुझे सबसे अधिक उत्साहित करता है: इसे कंपनियों के लिए एक एकीकृत इंजीनियरिंग मेमोरी लेयर तक ऊपर उठाना।
कल्पना करें कि टीम A के एजेंट द्वारा रिकॉर्ड किया गया निर्णय—"हम Y के कारण X में माइग्रेट हुए; हमने Z से परहेज किया क्योंकि इसने W को तोड़ दिया"—टीम B के एजेंट द्वारा, और उन मानव डेवलपर्स द्वारा जो इन एजेंटों को संचालित करते हैं, पुनर्प्राप्त करने योग्य, एक्सेस कंट्रोल, प्रोवेनेंस और ऑडिटिंग के साथ। प्रश्न "यह कोड ऐसा क्यों है?" मूल निर्णय के साथ उत्तर दिया गया, कोड से जुड़ा हुआ, संगठन में किसी के लिए या किसी भी एजेंट के लिए। तेज़ ऑनबोर्डिंग, टीमों के बीच स्थिरता, और कंपनी का इंजीनियरिंग ज्ञान अब केवल लोगों के दिमाग में नहीं रहता।
गेटवे द्वारा परोसा गया, यह मेमोरी बुनियादी ढाँचा बन जाती है: कंपनी में कोई भी एजेंट, किसी भी उपकरण में, संचित सीख को प्राप्त करता है।
ऑटोनॉमस एजेंट एक कमोडिटी होंगे। जो ज्ञान वे आपके
सिस्टम के बारे में संचित करते हैं, वह कमोडिटी नहीं होगा।
यही दांव है।
यदि आप उत्पादन में एजेंटों के साथ निर्माण कर रहे हैं—या संदर्भ लागतों पर अपना सिर पीट रहे हैं—मेरा DM खुला है।
