स्वयं को बेहतर बनाने वाले क्वांट ट्रेडिंग सिस्टम के निर्माण के लिए लूप इंजीनियरिंग का उपयोग कैसे करें

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

चलिए सीधे मुद्दे पर आते हैं।

इसे बुकमार्क करें

- मैं रोन हूँ, एक बैकएंड डेवलपर जो सिस्टम डिज़ाइन, HFT-शैली निष्पादन और क्वांटिटेटिव ट्रेडिंग सिस्टम पर काम करता है। मेरा काम इस बात पर केंद्रित है कि प्रेडिक्शन मार्केट्स लोड के तहत वास्तव में कैसे व्यवहार करते हैं। किसी भी सुझाव, विचारशील सहयोग, साझेदारी के लिए DM खुले हैं।

एक बात जो मैं आज से शुरू कर रहा हूँ।

अगर आप एक क्वांट सिस्टम बना रहे हैं, शुरू करने वाले हैं या बस इसके बारे में सोच रहे हैं, तो मुझे DM करें कि आप किस पर काम कर रहे हैं या बस इस लेख के नीचे जवाब दें और मैं आपसे संपर्क करूंगा (आप मुझे अपने मौजूदा आर्किटेक्चर का स्क्रीनशॉट भी भेज सकते हैं)।

मैं पहले 20 सेटअप में व्यक्तिगत रूप से आपको दिखाऊंगा कि आपके पास जो है और एक ऐसी सिस्टम जो वास्तव में अल्फा प्रिंट करती है, उसके बीच का अंतर क्या है।

ज़्यादातर क्वांट्स अब भी क्लॉड को प्रॉम्प्ट करते हैं। वे टाइप करते हैं। वे इंतज़ार करते हैं। वे आउटपुट पढ़ते हैं। वे फिर से टाइप करते हैं।

ग्रह पर सबसे बुद्धिमान बिल्डर्स ने ऐसा करना बंद कर दिया है।

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

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

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

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

वॉल स्ट्रीट का हर फंड इसी चक्र को चलाता है। 1988 से रेनेसां इसे चला रहा है। सिटाडेल इसे इंजीनियरों की टीमों के साथ हर चरण की निगरानी करते हुए चलाता है। टू सिग्मा, जेन स्ट्रीट, वे सभी।

फर्क सिर्फ इतना है कि उन्हें लूप के अंदर बैठने के लिए सैकड़ों मनुष्यों की आवश्यकता है। आपको नहीं।

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

यह लेख वह सब कुछ है जो मैंने लूप इंजीनियरिंग और इसे एक पूर्ण ऑटोनॉमस ट्रेडिंग सिस्टम में कैसे वायर किया जाए, इसके बारे में सीखा है।

इस लेख के अंत तक आपको पता चल जाएगा:

एक एजेंट को प्रॉम्प्ट करने और लूप को इंजीनियर करने के बीच सटीक अंतर।

वे छह टुकड़े जो प्रोडक्शन में हर काम करने वाले लूप को चलाते हैं।

उन छह टुकड़ों को स्क्रैच से एक सेल्फ-इम्प्रूविंग क्वांट ट्रेडिंग सिस्टम में कैसे वायर करें।

चलिए इसमें गोता लगाते हैं।

भाग 1: प्रॉम्प्टिंग और लूप इंजीनियरिंग के बीच का अंतर

पिछले दो वर्षों में, AI के साथ काम करना इस तरह दिखता था।

आपने एक प्रॉम्प्ट टाइप किया। आपने पढ़ा कि क्या वापस आया। आपने देखा जो आपने देखा, उसके आधार पर अगला प्रॉम्प्ट टाइप किया।

आप लूप थे।

एजेंट एक उपकरण था। आपने इसे हर समय पकड़े रखा। हर कदम आप अपने कीबोर्ड पर बैठकर तय कर रहे थे कि आगे क्या करना है।

लूप इंजीनियरिंग उसे समाप्त करती है।

आप लूप के अंदर की चीज़ बनना बंद कर देते हैं। आप वास्तुकार बन जाते हैं जो इसे डिज़ाइन करता है।

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

एजेंट रनों के बीच भूल जाता है। लूप नहीं भूलता।

यह एक तथ्य पूरी वास्तुकला है।

बोरिस का यही मतलब था जब उन्होंने कहा कि उनका काम लूप्स लिखना है। उन्होंने एक-एक करके निर्देश टाइप करना बंद कर दिया। उन्होंने ऐसी सिस्टम बनाईं जो उनके लिए निर्देश भेजती हैं, परिणाम पढ़ती हैं और तय करती हैं कि आगे क्या होगा।

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

ट्रेडिंग के लिए, यह सब कुछ बदल देता है।

क्योंकि किसी भी क्वांट ने कभी एक प्रॉम्प्ट टाइप करके और चले जाने से पैसा नहीं कमाया है। एज उसी चक्र को हज़ारों बार चलाने, हर पुनरावृत्ति में एक प्रतिशत बेहतर होने और कभी न सोने से आता है।

लूप बिल्कुल यही करता है।

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

प्रॉम्प्टिंग और लूप इंजीनियरिंग के बीच का अंतर

भाग 2: वे छह टुकड़े जो हर काम करने वाले लूप को चलाते हैं

एक काम करने वाला लूप छह भागों से बना होता है। एक को छोड़ दें और लूप चुपचाप टूट जाता है।

1. ऑटोमेशन।

यह दिल की धड़कन है। एक क्रॉन शेड्यूल, एक वेबहुक, एक /loop कमांड, या क्लॉड कोड के अंदर एक हुक जो आपके टाइप किए बिना फायर करता है।

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

ट्रेडिंग में, /loop हर मिनट आपका डेटा पुल है। /goal "इस सिग्नल पर तब तक दोहराते रहें जब तक कि बैकटेस्ट शार्प 1.5 से ऊपर न हो जाए।"

2. स्किल।

एक स्किल एक प्रक्रिया मैनुअल है जिसे एजेंट हर सत्र में स्क्रैच से बताए जाने के बजाय पढ़ता है।

यह एक SKILL.md फ़ाइल में रहता है। इसमें आपके कन्वेंशन, आपके नियम, आपका "हम ऐसा इसलिए नहीं करते क्योंकि वह एक घटना थी" शामिल है।

स्किल्स के बिना, हर लूप रन शून्य से शुरू होता है। स्किल्स के साथ, इरादा संचित होता है।

3. स्टेट फ़ाइल।

एक मार्कडाउन फ़ाइल। आमतौर पर STATE.md या PROGRESS.md कहा जाता है।

यह रनों के बीच जीवित रहता है। एजेंट भूल जाता है। फ़ाइल नहीं भूलती।

एजेंट हर रन की शुरुआत में इसे पढ़ता है। यह अंत में वापस लिखता है कि क्या हुआ।

यह इतना बेवकूफी भरा लगता है कि इससे कोई फर्क नहीं पड़ता। यह वास्तव में हर काम करने वाले लूप की रीढ़ है।

4. वेरिफायर।

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

इसे ट्रेडिंग पर लागू करें। जिस एजेंट ने सिग्नल जनरेट किया, वह यह तय करने के लिए सबसे खराब संभव जज है कि सिग्नल वास्तविक अल्फा है या शोर।

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

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

5. वर्कट्रीज़।

जिस क्षण आप एक ही फ़ाइलों के विरुद्ध एक से अधिक एजेंट चलाते हैं, वे टकराना शुरू कर देते हैं।

Git वर्कट्रीज़ प्रत्येक एजेंट को अपनी शाखा पर इंगित अपनी स्वयं की पृथक कार्य निर्देशिका देते हैं।

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

6. कनेक्टर्स।

एक लूप जो केवल फ़ाइलें पढ़ सकता है, एक छोटा लूप है।

मॉडल कॉन्टेक्स्ट प्रोटोकॉल पर बने कनेक्टर्स लूप को ब्रोकर API हिट करने, डेटाबेस क्वेरी करने, स्लैक पर पोस्ट करने, एक्सचेंज को ऑर्डर भेजने देते हैं।

यह एक लूप के बीच का अंतर है जो ट्रेडों का सुझाव देता है और एक लूप जो वास्तव में उन्हें रखता है।

ये छह टुकड़े सार्वभौमिक हैं। वे क्लॉड कोड में दिखाई देते हैं। वे कोडेक्स में दिखाई देते हैं। वे ग्रह पर हर काम करने वाली एजेंटिक सिस्टम में दिखाई देते हैं।

अब मैं आपको दिखाता हूँ कि उन्हें एक साथ एक पूर्ण ट्रेडिंग सिस्टम में कैसे वायर किया जाए।

भाग 3: एक सेल्फ-इम्प्रूविंग क्वांट ट्रेडिंग लूप कैसे बनाएं

क्वांट ट्रेडिंग लूप के पाँच चरण हैं। प्रत्येक चरण अपना स्वयं का उप-लूप है, अपने स्वयं के कौशल, अपनी स्वयं की स्टेट फ़ाइल और अपने स्वयं के वेरिफायर के साथ।

चरण एक। डेटा इन्जेशन।

एक ऑटोमेशन हर मिनट, हर घंटे या हर दिन एसेट क्लास के आधार पर फायर करता है।

1@loop(interval="1h")
2def ingest_data():
3    data = fetch_market_data(symbols=universe, lookback="30d")
4    state.write("latest_data.parquet", data)

डेटा एक साझा स्टेट फ़ाइल में जाता है जिसे अगला चरण पढ़ता है।

चरण दो। सिग्नल जनरेशन।

यह वह जगह है जहाँ अल्फा रिसर्च होती है।

1@loop(trigger="data_updated")
2def generate_signal():
3    data = state.read("latest_data.parquet")
4    signal = claude.run_skill("alpha_research", data)
5    state.write("pending_signal.json", signal)

सिग्नल जनरेशन एजेंट एक SKILL.md फ़ाइल से पढ़ता है जिसमें आपके अल्फा रिसर्च नियम होते हैं।

1# alpha_research_skill.md
2
3## Goal
4पिछले 30 दिनों के मूल्य और वॉल्यूम डेटा पर
5लीनियर रिग्रेशन का उपयोग करके सिग्नल जनरेट करें।
6
7## Rules
8- शार्प अनुपात पिछले 5 बैकटेस्ट में से 3 में 1.5 से ऊपर होना चाहिए
9- पोजीशन का आकार प्रति सिग्नल पूंजी के 2 प्रतिशत तक सीमित
10- FOMC घोषणा के दिनों में सिग्नल छोड़ें
11- आय रिलीज़ से 48 घंटे पहले सिग्नल छोड़ें
12
13## Lessons learned
14- 2026-02-14: कमाई सप्ताह के दौरान 4.2 प्रतिशत खोया।
15  नया नियम: आय से 48 घंटे पहले किसी भी सिग्नल को छोड़ें।
16- 2026-03-08: सेक्टर एक्सपोजर उल्लंघन के कारण 6 प्रतिशत ड्रॉडाउन हुआ।
17  नया नियम: सेक्टर एक्सपोजर को 30 प्रतिशत पर सीमित करें।
18- 2026-04-22: FOMC दिन पर मोमेंटम सिग्नल खराब हो गया।
19  नया नियम: FOMC दिनों पर सभी मोमेंटम सिग्नल को मार दें।

कौशल समय के साथ बढ़ता है। हर नुकसान एक नया सबक वापस लिखता है। हर सबक अगले रन के लिए एक नया नियम बन जाता है।

यही सिस्टम को सेल्फ-इम्प्रूविंग बनाता है।

चरण तीन। सत्यापन।

सिग्नल एक पूरी तरह से अलग एजेंट के पास जाता है। अलग मॉडल। अलग निर्देश। मूल सिग्नल के तर्क के लिए कोई एक्सपोजर नहीं।

1@checker
2def verify_signal(signal):
3    result = claude.invoke(
4        skill="backtest_verification_skill.md",
5        signal=signal,
6        rules=[
7            "शार्प अनुपात 1.5 से ऊपर",
8            "अधिकतम ड्रॉडाउन 10 प्रतिशत से नीचे",
9            "न्यूवे-वेस्ट टी-स्टैट 2.0 से ऊपर",
10            "आउट ऑफ सैंपल अवधि कम से कम 2 वर्ष"
11        ]
12    )
13    return result.verdict

यदि सत्यापन विफल होता है, तो सिग्नल मार दिया जाता है। यदि यह पास होता है, तो यह निष्पादन की ओर बढ़ता है।

वेरिफायर कभी नहीं देखता कि मेकर ने क्या तर्क दिया। यह अलगाव पूरा एज है।

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

मेकर चेकर स्प्लिट

चरण चार। निष्पादन।

केवल सत्यापित सिग्नल ही इस चरण तक पहुँचते हैं।

1@auto_mode
2def execute(signal):
3    if verify_signal(signal):
4        broker.send_orders(signal, max_position=0.02)
5        state.write("active_trades", signal)

MCP कनेक्टर ब्रोकर API को संभालता है। लूप कभी अनुमति नहीं मांगता। ऑटो मोड इसे हाथों से मुक्त चलने देता है।

चरण पाँच। जोखिम निगरानी।

पूरे समय एक समानांतर वर्कट्री में चल रहा है।

1@loop(interval="1m")
2def monitor_risk():
3    positions = broker.get_positions()
4    if drawdown(positions) > 0.05:
5        broker.close_all()
6        state.append("STATE.md", "ड्रॉडाउन ट्रिगर हिट हुआ। सभी पोजीशन बंद कर दी गईं।")

यह किल स्विच है। यह बिना बातचीत के नियमों को लागू करता है।

एक साथ ये पाँच उप-लूप एक सेल्फ-रनिंग सिस्टम बनाते हैं।

डेटा अंदर आता है। सिग्नल जनरेट होते हैं। सिग्नल सत्यापित होते हैं। सत्यापित सिग्नल निष्पादित होते हैं। जोखिम की निगरानी की जाती है। सबक वापस मेमोरी में लिखे जाते हैं।

फिर यह फिर से शुरू होता है।

लूप कैसे संचित होता है

मैंने इसे एक बार डिज़ाइन किया। मैंने तब से इनमें से किसी भी चरण को प्रॉम्प्ट नहीं किया है।

वह लूप इंजीनियरिंग है। बोरिस का यही मतलब था जब उन्होंने कहा कि उनका काम लूप्स लिखना है।

एक चेतावनी। एक वास्तविक रोकने की शर्त के बिना एक लूप चुपचाप विफल हो जाता है। एजेंट एक पूर्णता संकेत उत्सर्जित करता है, यह मानते हुए कि आधा किया गया काम समाप्त हो गया है। लूप बाहर निकलता है। बुरा ट्रेड खुला रहता है।

आपकी रोकने की शर्तें एजेंट के अपने दावे के अलावा किसी और चीज़ द्वारा जाँची जाने योग्य होनी चाहिए। "पिछले 30 ट्रेडों में शार्प 1.5 से ऊपर।" "ड्रॉडाउन 5 प्रतिशत से नीचे।" "टेस्ट सूट पास होता है।" कभी नहीं "एजेंट कहता है कि यह हो गया है।"

अपने गेम थ्योरी लेख में मैंने समझाया कि क्यों हर ट्रेड अपूर्ण जानकारी वाले बहु-खिलाड़ी खेल में एक रणनीतिक कदम है। यदि आप इसे चूक गए, तो आप इसे इसके तुरंत बाद पढ़ना चाहेंगे:

https://x.com/RohOnChain/status/2066178991892119820

लूप वह है जो आपको बिना थके हमेशा के लिए उस टेबल पर बैठने देता है।

सारांश

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

लूप इंजीनियरिंग मनुष्यों को हटा देती है।

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

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

सिस्टम हर चक्र में होशियार होता जाता है। हर नुकसान एक नया सबक लिखता है। हर सबक एक नया नियम बन जाता है। सौ ट्रेडों के बाद, स्किल फ़ाइल एक जीवित दस्तावेज है। एक हज़ार के बाद, यह संस्थागत ज्ञान के करीब है, जितना एक भी इंसान याद रख सकता है।

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

तो यहाँ सोचने का सवाल है।

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

कोई गलत जवाब नहीं है, लेकिन बहुत ही प्रकट करने वाले हैं।