Kimi K3 के साथ अपना पहला AI एजेंट लूप कैसे बनाएं (पूरा सेटअप अंदर)

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

अंदर: एक डायग्राम में लूप पैटर्न समझाया गया, दो सटीक सेटअप (Claude Code और raw API), और कैश गणित जो K3 को लूप मशीन बनाता है।

आपका पहला लूप आज रात लगभग $0.39 प्रति टर्न पर चलेगा।

यहाँ पूरा सेटअप है 👇

गोता लगाने से पहले, मैं अपने Telegram चैनल में AI और वाइब कोडिंग पर रोज़ाना नोट्स शेयर करता हूँ: https://t.me/zodchixquant 🧠

लूप वास्तव में क्या है

हाइप को हटा दें और एक लूप चार चरणों की पुनरावृत्ति है:

1लक्ष्य → प्रयास → जाँच → (बेहतर? : जारी रखें : पुनः प्रयास करें)
2        ↑__________________________|

• लक्ष्य: एक मापने योग्य फिनिश लाइन, न कि कोई एहसास। "सभी टेस्ट पास हों", "पेज 1 सेकंड से कम में लोड हो", "स्कोर 90 से ऊपर"
• प्रयास: मॉडल उस दिशा में काम की एक इकाई करता है
• जाँच: कोई चीज़ लक्ष्य के विरुद्ध परिणाम को सत्यापित करती है। एक टेस्ट सूट, एक लिंटर, एक दूसरा मॉडल
• दोहराएँ: जाँच के परिणाम को वापस फीड करें, फिर से जाएँ, जब लक्ष्य पूरा हो जाए या बजट खत्म हो जाए तो रुकें

बस इतना ही। बाकी सब कुछ (मेमोरी, सब-एजेंट, रात भर चलने वाले रन) इस चक्र पर सजावट है।

K3 विशेष रूप से क्यों: लूप अर्थशास्त्र

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

1टर्न लागत = fresh_tokens × $3/M + cached_tokens × $0.30/M
2
3वास्तविक आकार (800K स्थिर संदर्भ + 50K ताज़ा प्रति टर्न):
4K3:       $0.24 + $0.15 = $0.39/टर्न
5Fable 5:  850K × $10/M  = $8.50/टर्न

एक 50-टर्न वाला रात भर का लूप: K3 पर लगभग $20, Fable 5 पर लगभग $425। यह कोई छूट नहीं है, यह "इसे चलने दो" और "इसे बाज़ की तरह देखो" के बीच का अंतर है।

एक नियम: अपने स्थिर संदर्भ को हर टर्न पर एक समान उपसर्ग के रूप में रखें, कार्य अंत में, ताकि कैश वास्तव में हिट हो।

सेटअप A: Claude Code (5 मिनट का रास्ता)

यदि आप Claude Code में रहते हैं, तो लूप बिल्ट-इन हैं और K3 Moonshot के आधिकारिक कॉन्फ़िग के माध्यम से नीचे स्लॉट हो जाता है:

1export ANTHROPIC_BASE_URL=https://api.moonshot.ai/anthropic
2export ANTHROPIC_AUTH_TOKEN=${YOUR_MOONSHOT_API_KEY}
3export ANTHROPIC_MODEL=kimi-k3
4export ANTHROPIC_DEFAULT_OPUS_MODEL=kimi-k3
5export ANTHROPIC_DEFAULT_SONNET_MODEL=kimi-k3
6export ANTHROPIC_DEFAULT_HAIKU_MODEL=kimi-k3
7export CLAUDE_CODE_SUBAGENT_MODEL=kimi-k3
8export ENABLE_TOOL_SEARCH=false
9export CLAUDE_CODE_AUTO_COMPACT_WINDOW=1048576
10claude

फिर लूप दो कमांड है:

• /goal फिनिश लाइन सेट करता है: "tests/ में सभी टेस्ट पास हों और कवरेज 80% से ऊपर रहे"। Claude Code पहले उत्तर पर रुकने के बजाय इसकी दिशा में काम करता रहता है
• /loop इसे आवर्ती बनाता है: सत्र एक शेड्यूल पर या लक्ष्य पूरा होने तक फिर से चलता है

/status के माध्यम से पुष्टि करें कि आप K3 पर हैं (/model मेनू यह नहीं दिखाएगा)। कॉन्फ़िग में 1M ऑटो-कॉम्पैक्ट विंडो का मतलब है कि लंबे लूप शायद ही कभी कॉम्पैक्ट होते हैं, जो पुनरावृत्ति इतिहास को जीवित रखता है।

सेटअप B: raw API लूप (पूर्ण नियंत्रण)

Claude Code के बाहर लूप के लिए, यहाँ एक पूर्ण न्यूनतम लूप है, OpenAI-संगत:

1from openai import OpenAI
2
3client = OpenAI(
4    api_key=MOONSHOT_API_KEY,
5    base_url="https://api.moonshot.ai/v1",
6)
7
8# स्थिर उपसर्ग: हर टर्न पर समान = $0.30/M पर कैश हिट
9STABLE = f"""आप एक लूप में कोडिंग एजेंट हैं।
10लक्ष्य: नीचे दिए गए प्रोजेक्ट में सभी टेस्ट पास कराएँ।
11प्रोजेक्ट:
12{project_dump}
13नियम:
14- प्रति टर्न एक केंद्रित बदलाव
15- आपने क्या बदला और क्यों, 2 लाइनों में समझाएँ
16- यदि टेस्ट पास होते हैं, तो ठीक इस प्रकार उत्तर दें: GOAL_REACHED
17"""
18
19history = []
20MAX_TURNS = 30
21
22for turn in range(MAX_TURNS):
23    result = run_tests()          # आपकी जाँच: pytest, npm test, आदि।
24    if result.passed:
25        print(f"{turn} टर्न में हो गया")
26        break
27
28    response = client.chat.completions.create(
29        model="kimi-k3",
30        messages=[
31            {"role": "system", "content": STABLE},
32            *history[-6:],        # पिछले 3 आदान-प्रदान, सीमित
33            {"role": "user", "content":
34                f"टर्न {turn}. टेस्ट आउटपुट:\n{result.output}\n"
35                f"अगली विफलता को ठीक करें।"},
36        ],
37    )
38    change = response.choices[0].message.content
39    apply_change(change)          # संपादन लिखें, एक ब्रांच में कमिट करें
40    history += [
41        {"role": "user", "content": f"टर्न {turn} टेस्ट आउटपुट दिया गया"},
42        {"role": "assistant", "content": change},
43    ]

तीन महत्वपूर्ण विवरण:

• जाँच कोड है, एहसास नहीं। run_tests() प्रगति तय करता है, मॉडल कभी खुद को ग्रेड नहीं करता
• इतिहास सीमित है। केवल पिछले 3 आदान-प्रदान; स्थिर उपसर्ग स्थायी संदर्भ वहन करता है और कैश-अनुकूल रहता है
• हर बदलाव एक ब्रांच में जाता है। लूप 10 बार गलत हो सकता है जब तक main इसे कभी नहीं देखता

दूर जाने से पहले सुरक्षा उपाय

• बजट स्टॉप: प्रति टर्न टोकन गिनें, एक डॉलर सीमा पर लूप को मार दें। MAX_TURNS पर्याप्त नहीं है, एक फूला हुआ टर्न दस सामान्य टर्न से अधिक खा सकता है
• प्रगति स्टॉप: यदि एक ही टेस्ट लगातार 3 टर्न में विफल होता है, तो रुकें और फ़्लैग करें। लूप जो अभिसरण नहीं कर सकते, विनम्रता से पैसा जलाते हैं
• एक K3 कैच: रीज़निंग फिलहाल केवल max-only पर चलती है, इसलिए हर टर्न $15/M पर पूर्ण थिंकिंग आउटपुट वहन करता है। टर्न को केंद्रित रखें, प्रति टर्न एक विफलता, और आउटपुट पक्ष समझदार रहता है

सामान्य गलतियाँ

• अस्पष्ट लक्ष्य। "कोड में सुधार करें" हमेशा के लिए लूप करता है। एक लूप उतना ही अच्छा है जितनी उसकी फिनिश लाइन जाँच योग्य है
• मॉडल को स्वयं ग्रेड करने देना। "मुझे सही लग रहा है" वह तरीका है जिससे लूप कचरा भेजते हैं। जाँचकर्ता बाहरी होना चाहिए: टेस्ट, लिंटर, या एक रूब्रिक वाला दूसरा मॉडल
• कैश को तोड़ना। आपके उपसर्ग में टाइमस्टैम्प, रैंडम आईडी, या पुनः क्रमित फ़ाइलों का मतलब है कि हर टर्न $0.30/M के बजाय $3/M पर बिल होता है। समान का मतलब समान है
• कोई ब्रांच अनुशासन नहीं। main तक राइट एक्सेस वाला एक पर्यवेक्षण रहित लूप अतिरिक्त कदमों वाली एक डरावनी कहानी है
• रात भर के रन से शुरुआत करना। अपने पहले लूप देखते हुए चलाएँ, 10-15 टर्न। उस पर सोने से पहले विश्वास अर्जित करें

15 मिनट का सेटअप

1. Moonshot API कुंजी लें, 10-30% बोनस विंडो के अंदर टॉप अप करें, 11 अगस्त तक लाइव (3 मिनट)
2. सेटअप A या B चुनें और इसे वायर करें (5 मिनट)
3. एक वास्तविक छोटे कार्य के लिए एक जाँच योग्य लक्ष्य लिखें: एक विफल टेस्ट, एक लिंट पास (2 मिनट)
4. 10 पर्यवेक्षित टर्न चलाएँ, देखें कि जाँच काम को कैसे चलाती है (4 मिनट)
5. लागत नोट करें। फिर तय करें कि अगला लूप कितना बड़ा होगा (1 मिनट)

लूप प्रोग्रामिंग का सबसे पुराना विचार है जिसे नवीनतम टूल पर लागू किया गया है। K3 ने इसे वास्तव में उपयोग करने के लिए पर्याप्त सस्ता बना दिया है।

पढ़ने के लिए धन्यवाद!

मैं अपने Telegram चैनल में AI और वाइब कोडिंग पर रोज़ाना नोट्स शेयर करता हूँ: https://t.me/zodchixquant 🧠