GPT-6 Astra: Codex, एजेंट्स और लागत को अधिकतम करने के लिए व्यावहारिक मैनुअल

उद्देश्य:

Luna, Terra, Sol और Astra को बुद्धिमानी से वितरित करना सीखें ताकि प्रदर्शन को अधिकतम किया जा सके, लागत कम की जा सके, और एजेंट वर्कफ़्लो को लंबे समय तक चलने दिया जा सके।

OpenAI का GPT-6 Astra, जिसकी घोषणा 3 सितंबर, 2026 को की गई थी, एजेंटों की जटिल कंप्यूटिंग कार्यों को करने की क्षमता में एक बड़ी छलांग का प्रतिनिधित्व करता है, जिसके लिए पहले काफी मानवीय हस्तक्षेप की आवश्यकता होती थी।

लेकिन असली चुनौती अब केवल यह पूछना नहीं रह गई है कि "क्या Astra यह कार्य कर सकता है?"।

अब महत्वपूर्ण प्रश्न यह है:

Astra वास्तव में कहाँ मूल्य जोड़ता है, हमें अपने संसाधनों का आवंटन कैसे करना चाहिए, हम एजेंटों को अधिक समय तक कैसे काम करवा सकते हैं, और हम यह सब सबसे कम संभव लागत पर कैसे प्राप्त कर सकते हैं?

यह लेख मुख्य रूप से उन लोगों के लिए है जो नियमित रूप से Codex और प्रोग्रामिंग एजेंटों का उपयोग करते हैं, विशेष रूप से लगभग-उत्पादन वातावरण में।

लक्षित दर्शक

यह मैनुअल उन लोगों के लिए डिज़ाइन किया गया है जो:

• लगभग-उत्पादन वातावरण में Codex या OpenAI API के माध्यम से एजेंटों का उपयोग करते हैं।
• मासिक API या बुनियादी ढांचे की लागत को कम करने के लिए Luna, Terra, Sol और Astra के बीच वैकल्पिक रूप से उपयोग करना चाहते हैं।
• लंबे समय तक चलने वाले वर्कफ़्लो बनाना चाहते हैं: व्यापक डिबगिंग, बड़े पैमाने पर रिफैक्टरिंग, कंप्यूटर टूल उपयोग, गणितीय सत्यापन, स्वचालित परीक्षण, और ऐसे कार्य जिनमें लंबे समय तक संदर्भ बनाए रखने की आवश्यकता होती है।

0. पूर्वापेक्षाएँ

तैनाती, एंटरप्राइज़, डेब्रेक और उपलब्धता

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

घोषणा की तिथि

3 सितंबर, 2026 — आधिकारिक घोषणा

OpenAI — GPT-6 Astra

तैनाती

आधिकारिक घोषणाओं के अनुसार, Trusted Access/Daybreak पहले तैनाती चैनलों में से एक होगा।

Plus, Pro, Business और Enterprise योजनाओं के साथ-साथ API और AWS को बाद में तैनात किया जाएगा।

एंटरप्राइज़ वातावरण में, व्यवस्थापक को स्पष्ट रूप से एक्सेस सक्षम करने की आवश्यकता हो सकती है।

महत्वपूर्ण बिंदु

• एंटरप्राइज़: जहाँ लागू हो, व्यवस्थापक को इसे सक्षम करना होगा।
• फ्री टियर: Astra को फ्री मॉडल के रूप में योजनाबद्ध नहीं किया गया है।
• क्रेडिट: भुगतान योजनाओं के उपयोगकर्ताओं के पास उत्पाद के आधार पर अतिरिक्त क्रेडिट विकल्प हो सकते हैं।
• साइबर सुरक्षा: कुछ उन्नत क्षमताएँ Daybreak जैसे विशिष्ट एक्सेस पथों पर निर्भर हो सकती हैं।
• API मॉडल ID: gpt-6-astra।

मानक API मूल्य

इस दस्तावेज़ में बताई गई दरों के अनुसार:

• इनपुट: $10 / मिलियन टोकन।
• आउटपुट: $50 / मिलियन टोकन।

कुछ मोड, लंबे संदर्भ, कैशिंग और प्राथमिकता प्रसंस्करण के लिए अलग-अलग दरें और शर्तें हैं।

मूलभूत नियम:

सिर्फ इसलिए कि Astra इंटरफ़ेस में दिखाई नहीं देता है, इसका मतलब यह नहीं है कि मॉडल आपके संगठन के लिए मौजूद नहीं है। पहले उपलब्धता, अनुमतियाँ और तैनाती की जाँच करें।

एक्सेस सत्यापित करते समय, Sol को आधार मॉडल के रूप में उपयोग करके रणनीति बनाई जा सकती है।

1. Astra कहाँ उत्कृष्ट है और Sol कब पर्याप्त है?

Astra को पेशेवर कार्यों के लिए एक उच्च-स्तरीय मॉडल के रूप में डिज़ाइन किया गया है, विशेष रूप से उन कार्यों के लिए जो इससे संबंधित हैं:

• कंप्यूटर उपयोग,
• ब्राउज़िंग,
• सॉफ़्टवेयर इंजीनियरिंग,
• एजेंट,
• विज्ञान,
• गणित,
• जटिल एंड-टू-एंड कार्य।

आधिकारिक दस्तावेज़ीकरण सबसे कठिन एंड-टू-एंड कार्यों के लिए उच्च-स्तरीय मॉडल रखता है।

हालाँकि, सही रणनीति हर चीज़ के लिए Astra का उपयोग करना नहीं है।

सही रणनीति यह है:

Astra का उपयोग केवल तभी करें जब इसकी उच्च क्षमता का परिणाम पर वास्तविक प्रभाव पड़ता हो।

1.1. अंतर वास्तव में कहाँ दिखाई देता है?

सबसे महत्वपूर्ण अंतर उन कार्यों में दिखाई देते हैं जहाँ कई कारक संयुक्त होते हैं:

• एकाधिक फ़ाइलें या मॉड्यूल,
• कई लगातार चरण,
• उपकरणों का गहन उपयोग,
• ग्राफ़िकल इंटरफ़ेस के साथ बातचीत,
• कठिन-से-पुनरुत्पादित समस्याएँ,
• गणितीय तर्क,
• लंबे समय तक डिबगिंग,
• गलती करने की उच्च लागत,
• संदर्भ का नुकसान,
• लंबे समय तक रणनीति बनाए रखने की आवश्यकता।

रोज़मर्रा और सरल कार्यों में, अंतर बहुत छोटा हो सकता है।

इसलिए, एक अच्छा नियम है:

यह न पूछें कि कौन सा मॉडल "बेहतर" है। पूछें कि इस कार्य को सही ढंग से पूरा करने के लिए कौन सा मॉडल सस्ता है।

1.2. OSWorld, Mind2Web और गति का प्रश्न

OSWorld और Mind2Web जैसे बेंचमार्क मॉडलों के बीच अंतर को समझने के लिए उपयोगी हैं, लेकिन उनकी सही व्याख्या की जानी चाहिए।

आधिकारिक दस्तावेज़ीकरण में उल्लिखित OSWorld 2.0 विलंबता सिमुलेशन में, Astra ने Sol की तुलना में अधिक प्रोसेसर उपयोग प्राप्त किया और संकेतित तुलना में प्रति कार्य लगभग 47% कम समय दिखाया।

उदाहरण के लिए:

• Astra: लगभग 40 मिनट।
• Sol: लगभग 75 मिनट।

संकेतित स्कोर लगभग था:

• Astra: 72.6%
• Sol: 65.7%

इसी तरह, दस्तावेज़ीकरण इंगित करता है कि Astra + नया Codex हार्नेस कुछ Mind2Web परीक्षणों में वर्तमान Sol अनुभव से लगभग 1.9× तेज़ हो सकता है।

लेकिन दो बातें याद रखें

1. यह एक बेंचमार्क है।

Mind2Web पर 1.9× परिणाम का मतलब यह नहीं है कि कंपनी का हर आंतरिक कार्य 1.9× तेज़ होगा।

2. यह एक उपयोगी संकेत प्रदान करता है।

कोई कार्य जितना अधिक इस पर निर्भर करता है:

• स्क्रीन,
• उपकरण,
• नेविगेशन,
• एकाधिक क्रियाएँ,
• मध्यवर्ती निर्णय,

उतना ही अधिक मॉडल + एजेंट सिस्टम के संयोजन का मूल्यांकन करना समझ में आता है, न कि केवल प्रति सेकंड टोकन की तुलना करना।

1.3. Sol कब पर्याप्त है?

पहले Sol, Terra या Luna का उपयोग करें जब:

• उत्तर एक ही आदान-प्रदान में पूरा किया जा सकता है;
• आपको केवल एक या दो फ़ाइलों को संशोधित करने की आवश्यकता है;
• परीक्षण छोटे हैं;
• कार्य मुख्य रूप से पढ़ना है;
• किसी GUI की आवश्यकता नहीं है;
• किसी जटिल उपकरण की आवश्यकता नहीं है;
• काम को दोहराने की लागत कम है;
• एक विफलता बड़े परिणाम उत्पन्न नहीं करती है।

Astra तब समझ में आने लगता है जब विपरीत होता है

उदाहरण के लिए:

• कई फ़ाइलें;
• एकाधिक मॉड्यूल;
• लंबी टूल चेन;
• कंप्यूटर उपयोग;
• जटिल डिबगिंग;
• गणितीय सत्यापन;
• ऐसे कार्य जहाँ विफलता का अर्थ है बहुत अधिक पुन: कार्य;
• लंबे सत्र के दौरान संदर्भ का नुकसान।

2. ChatGPT, API और Codex कॉन्फ़िगरेशन

2.1. ChatGPT: Astra चुनें

जब Astra उपलब्ध हो जाए:

1. वेब या डेस्कटॉप पर ChatGPT खोलें।
2. मॉडल चयनकर्ता की जाँच करें।
3. Astra / GPT-6 Astra चुनें।
4. यदि आप Codex का उपयोग करते हैं, तो जाँच करें कि वही मॉडल वहाँ उपलब्ध है या नहीं।
5. यदि Astra दिखाई नहीं देता है: अपनी योजना की जाँच करें; एंटरप्राइज़ अनुमतियाँ जाँचें; तैनाती सत्यापित करें; अस्थायी कॉन्फ़िगरेशन के रूप में Sol का उपयोग करें।

Pro, Business और Enterprise योजनाओं में Astra के विशिष्ट वेरिएंट शामिल हो सकते हैं। आपको केवल इंटरफ़ेस में प्रदर्शित नाम से निष्कर्ष नहीं निकालना चाहिए: हमेशा योजना के अनुरूप विवरण की समीक्षा करें।

2.2. API: model = "gpt-6-astra"

मूल कॉन्फ़िगरेशन में Responses API में मॉडल निर्दिष्ट करना शामिल है।

महत्वपूर्ण विचार

• टूल कॉल के लिए, अधिमानतः Responses API का उपयोग करें।
• Astra reasoning.effort = "none" का समर्थन नहीं करता है।
• यदि आप तर्क के निम्न स्तर का उपयोग करते हैं, तो एक छोटे कॉन्फ़िगरेशन से शुरू करें और केवल आवश्यक होने पर ही बढ़ाएँ।
• कुछ पारंपरिक पैरामीटर, जैसे temperature या top_p, उपलब्ध नहीं हो सकते हैं।
• EU में डेटा निवास Fast/Priority पर प्रतिबंध लगा सकता है।
• कैश कॉन्फ़िगरेशन को prompt_cache_options.ttl में माइग्रेट किया जा सकता है।

2.3. Codex: प्रायोगिक संदर्भ प्रबंधन

लंबे सत्रों के लिए, Codex संदर्भ प्रबंधन तंत्र का उपयोग कर सकता है जो सरल इतिहास संपीड़न से परे जाता है।

विचार महत्वपूर्ण जानकारी को बनाए रखना है जैसे:

• जाँच की गई परिकल्पनाएँ;
• खारिज की गई परिकल्पनाएँ;
• निरीक्षण की गई फ़ाइलें;
• निष्पादित परीक्षण;
• प्राप्त परिणाम;
• लिए गए निर्णय।

एक अवधारणात्मक कॉन्फ़िगरेशन हो सकता है:

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

यह क्यों मायने रखता है?

कई घंटों तक चलने वाले डिबगिंग सत्र में, संदर्भ खोने से एजेंट को फिर से जाँच करने के लिए मजबूर होना पड़ सकता है:

• कौन सी परिकल्पनाएँ पहले ही खारिज की जा चुकी थीं;
• कौन सी फ़ाइलों की पहले ही समीक्षा की जा चुकी थी;
• कौन से कमांड पहले ही काम कर चुके थे;
• कौन से परीक्षण पहले ही निष्पादित किए जा चुके थे।

नोट लेने से उस पुनरावृत्ति को कम किया जा सकता है।

महत्वपूर्ण:

लगातार एजेंट नोट्स में कभी भी गोपनीय जानकारी, रहस्य, API कुंजी या संवेदनशील डेटा संग्रहीत न करें।

2.4. अनुमोदन और सैंडबॉक्स

ऑटोमेशन का लक्ष्य यह नहीं होना चाहिए:

"कि एजेंट बिल्कुल सब कुछ कर सके।"

लक्ष्य यह होना चाहिए:

हर उस चीज़ को स्वचालित करें जो प्रतिवर्ती है और मानवीय हस्तक्षेप को केवल अपरिवर्तनीय या उच्च जोखिम वाले बिंदुओं पर बनाए रखें।

एक प्रारंभिक बिंदु के रूप में अनुशंसित इंटरैक्टिव कॉन्फ़िगरेशन:

एजेंट ध्यान रख सकता है:

• फ़ाइलें पढ़ना;
• परीक्षण चलाना;
• लॉग का विश्लेषण करना;
• स्थानीय परिवर्तन करना;
• कमिट बनाना;
• पुल रिक्वेस्ट तैयार करना;
• अपने स्वयं के काम की समीक्षा करना;
• त्रुटियों को सुधारना।

मानव को नियंत्रण बनाए रखना चाहिए:

• उत्पादन;
• तैनाती;
• अंतिम मर्ज;
• प्रकाशन;
• बाहरी जानकारी भेजना;
• अनुमतियाँ संशोधित करना;
• अपरिवर्तनीय संचालन;
• गोपनीय जानकारी।

अनुमोदन अंतिम चेकपॉइंट बनना चाहिए, न कि पूरी प्रक्रिया में लगातार रुकावट।

2.5. AGENTS.md और Skills

Codex के साथ कोई महत्वपूर्ण कार्य शुरू करने से पहले, एजेंट को प्रोजेक्ट नियमों को जानना होगा।

एक उपयोगी आर्किटेक्चर है:

AGENTS.md

इसमें शामिल है:

• स्थायी नियम;
• अनुमत दायरा;
• प्रतिबंध;
• पूर्णता की शर्तें;
• अनिवार्य परीक्षण;
• मानव अनुमोदन बिंदु।

Skills

इसमें शामिल है:

• दोहराई जाने वाली प्रक्रियाएँ;
• वर्कफ़्लो;
• परिचालन जाँच सूची;
• विशिष्ट प्रक्रियाएँ।

MCP

इसके लिए उपयोग किया जाता है:

• बाहरी कनेक्शन;
• सेवाएँ;
• उपकरण;
• डेटा स्रोत।

एक सरल विभाजन होगा:

AGENTS.md = नियम

Skills = प्रक्रियाएँ

MCP = कनेक्शन

AGENTS.md का न्यूनतम उदाहरण

3. Astra का लाभ उठाने वाले निर्देश कैसे लिखें

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

Astra इसके प्रति बहुत संवेदनशील हो सकता है:

• अस्पष्टताएँ;
• विरोधाभास;
• अप्रचलित निर्देश;
• असंगत Skills;
• डुप्लिकेट नियम।

इसलिए, एक अच्छा कॉन्फ़िगरेशन मॉडल बदलने जितना ही प्रदर्शन में सुधार कर सकता है।

3.1. स्वायत्तता बढ़ाएँ

ऐसे निर्देश बनाने के बजाय जो एजेंट को लगातार पुष्टि माँगने पर मजबूर करते हैं, स्पष्ट रूप से उस स्थान को परिभाषित करें जिसके भीतर वह अपने आप कार्य कर सकता है।

3.2. समीक्षा योग्य परिणामों के बाद अनुमोदन

स्वायत्त एजेंटों के लिए सबसे अच्छे नियमों में से एक है:

पहले एक समीक्षा योग्य परिणाम तैयार करें; फिर अपरिवर्तनीय चरण के लिए अनुमोदन माँगें।

यह पैटर्न से बचाता है:

एजेंट → प्रश्न → मानव → एजेंट → प्रश्न → मानव

और इसे इससे बदल देता है:

एजेंट → जाँच करता है → कार्यान्वित करता है → परीक्षण करता है → परिणाम तैयार करता है → मानव अनुमोदन करता है → अंतिम कार्रवाई

3.3. ऐसे प्रश्न जो मुख्य कार्य को अवरुद्ध नहीं करते हैं

लंबे सत्रों में मुख्य प्रवाह को रोके बिना स्वतंत्र प्रश्नों की अनुमति देना उपयोगी हो सकता है।

एक अच्छा नियम है:

मुख्य कार्य की एक निश्चित एक-वाक्य पूर्णता शर्त होती है। यदि निष्पादन के दौरान कोई स्वतंत्र प्रश्न आता है, तो मुख्य कार्य को बाधित किए बिना संक्षेप में उत्तर दें। मुख्य वर्कफ़्लो को तभी रोकें जब प्रश्न कार्य की दिशा, दायरा, अनुमतियाँ या आवश्यक आउटपुट बदल देता है।

API निष्पादन के दौरान अतिरिक्त निर्देश भेजने के लिए तंत्र और लंबे समय तक काम के लिए अतुल्यकालिक उपकरणों का भी उपयोग कर सकता है।

3.4. उप-एजेंटों को प्रतिनिधिमंडल

जब किसी कार्य को समानांतर किया जा सकता है, तो स्पष्ट रूप से करें।

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

समानांतरीकरण के उदाहरण:

• एजेंट A → प्रमाणीकरण मॉड्यूल की जाँच करें।
• एजेंट B → परीक्षणों का विश्लेषण करें।
• एजेंट C → प्रकारों की समीक्षा करें।
• एजेंट D → दस्तावेज़ीकरण की समीक्षा करें।

फिर, मुख्य एजेंट परिणामों को एकीकृत करता है।

3.5. परीक्षण की मात्रा को नियंत्रित करें

अधिक परीक्षणों का हमेशा बेहतर परिणाम नहीं होता है।

छोटे बदलावों के लिए:

लक्ष्य एक तुच्छ संशोधन को अनावश्यक परीक्षणों की एक बड़ी बैटरी को ट्रिगर करने से रोकना है।

3.6. लंबे समय तक डिबगिंग के लिए टेम्पलेट

3.7. कंप्यूटर और ब्राउज़र कार्यों के लिए टेम्पलेट

4. मूल्य को अधिकतम करें, टोकन गणना को नहीं

सही प्रश्न यह नहीं है:

"मैं Astra के सभी टोकन कैसे खर्च कर सकता हूँ?"

सही प्रश्न यह है:

"मैं प्रत्येक खर्च किए गए डॉलर के लिए अधिक काम कैसे पूरा करवा सकता हूँ?"

संकेतित दरों के अनुसार:

Astra प्रति टोकन स्पष्ट रूप से अधिक महंगा है।

लेकिन प्रति टोकन मूल्य आवश्यक रूप से किसी कार्य को पूरा करने की वास्तविक लागत का प्रतिनिधित्व नहीं करता है।

यदि Astra प्राप्त करता है:

• कम त्रुटियाँ;
• कम पुनरावृत्तियाँ;
• कम पुन: कार्य;
• कम टूल कॉल;
• कम कुल समय;
• उच्च सफलता दर;

तो प्रति पूर्ण कार्य की लागत प्रतिस्पर्धी या कम भी हो सकती है।

4.1. व्यावहारिक रूटिंग तालिका

सामान्य नियम:

Luna/Terra वॉल्यूम के लिए → Sol मानक कार्य के लिए → Astra उन कार्यों के लिए जो वास्तव में उनकी लागत को उचित ठहराते हैं।

4.2. लागत कम करने वाली आदतें

1. पहले पूर्णता की शर्त लिखें

यह अनावश्यक अन्वेषण को कम करता है।

1. मध्यवर्ती एकालाप से बचें

प्राथमिकता दें:

स्थिति → अगली कार्रवाई → परिणाम

अंतहीन स्पष्टीकरण के बजाय।

1. सरल सत्यापन किफायती मॉडलों को भेजें

Astra को इस पर बर्बाद न करें:

• प्रारूप की जाँच करना;
• छोटे लॉग का सारांश देना;
• फ़ाइलों को वर्गीकृत करना;
• दोहराए जाने वाले कार्य करना।

1. निर्देश उपसर्ग को स्थिर करें

सिस्टम/डेवलपर निर्देशों को सुसंगत रखने से कुशल कैश उपयोग को बढ़ावा मिल सकता है।

1. फास्ट मोड का उपयोग केवल तभी करें जब वे मूल्य जोड़ते हों

यदि कोई मोड अधिक महंगा है, तो इसे निष्पादन समय में वास्तविक कमी से उचित ठहराया जाना चाहिए।

4.3. साप्ताहिक लागत ऑडिट

प्रत्येक सप्ताह समीक्षा करें:

• Astra के साथ निष्पादित कार्य;
• इसके उपयोग का कारण;
• परिणाम;
• अनुमानित लागत;
• क्या Sol पर्याप्त होता;
• क्या Terra पर्याप्त होता;
• पुनरावृत्तियों की संख्या;
• विफलताएँ;
• पुन: कार्य।

सरल नियम

यदि आप लिखित रूप में स्पष्ट नहीं कर सकते:

"Astra आवश्यक था क्योंकि..."

उस श्रेणी के कार्यों को निचले मॉडल में स्थानांतरित करने पर विचार करें।

5. अनुशंसित वर्कफ़्लो

5.1. लंबी डिबगिंग

चरण 1 — वर्गीकरण

यदि कई फ़ाइलें, जटिल पुनरुत्पादन या कई उपकरण हैं:

Astra.

यदि यह सरल है:

Sol/Terra.

चरण 2 — सीमाएँ

AGENTS.md में परिभाषित करें:

• अनुमत फ़ाइलें;
• निषिद्ध फ़ाइलें;
• अनुमत कमांड;
• अनिवार्य परीक्षण;
• अनुमोदन बिंदु।

चरण 3 — कॉन्फ़िगरेशन

model = "gpt-6-astra" approval_policy = "on-request" sandbox_mode = "workspace-write" [features.context_management] experimental_mode = true

चरण 4 — प्रारंभ

हमेशा एक स्पष्ट पूर्णता शर्त के साथ शुरू करें।

चरण 5 — लॉग

बनाए रखें:

• परिकल्पनाएँ;
• परीक्षण;
• परिणाम;
• जाँच की गई फ़ाइलें;
• निर्णय।

चरण 6 — रुकावटें

स्वतंत्र प्रश्नों को मुख्य कार्य के संदर्भ को नष्ट नहीं करना चाहिए।

चरण 7 — प्रदेय

एजेंट तक जा सकता है:

पुल रिक्वेस्ट समीक्षा के लिए तैयार है।

अंतिम मर्ज मानव नियंत्रण में रहता है।

चरण 8 — सीखना

यदि वही समस्या बार-बार आती है:

इसे एक

Skill

में बदल दें।

5.2. बड़े पैमाने पर रिफैक्टरिंग

दो-चरणीय रणनीति अच्छी तरह से काम करती है:

चरण 1 — सस्ती जाँच

इसका उपयोग करें:

Luna → Terra → Sol

निर्माण करने के लिए:

• निर्भरता मानचित्र;
• प्रभाव;
• प्रभावित मॉड्यूल;
• जोखिम;
• निष्पादन योजना।

चरण 2 — कार्यान्वयन

इसका उपयोग करें:

Astra

उन मॉड्यूल के लिए जिन्हें वास्तव में उच्च क्षमता की आवश्यकता है।

चरण 3 — समानांतरीकरण

उप-एजेंटों के लिए:

• परीक्षण;
• प्रकार की जाँच;
• समीक्षा;
• स्वतंत्र मॉड्यूल।

चरण 4 — मानव समीक्षा

मानव इस पर ध्यान केंद्रित करता है:

• आर्किटेक्चर;
• सार्वजनिक API;
• संगतता;
• अपरिवर्तनीय निर्णय।

5.3. कंप्यूटर उपयोग

ब्राउज़र या GUI कार्यों के लिए:

1. लक्ष्य स्क्रीन को स्पष्ट रूप से परिभाषित करें।
2. निषिद्ध संचालन को परिभाषित करें।
3. Astra का उपयोग करें जब कार्य लंबा या दृष्टिगत रूप से जटिल हो।
4. जहाँ लागू हो, नवीनतम Codex हार्नेस का उपयोग करें।
5. राज्यों और प्रक्रियाओं को लॉग करें।
6. परिणाम को एक समीक्षा योग्य प्रदेय में बदलें।

Mind2Web में 1.9× आंकड़े को केवल एक बेंचमार्क के रूप में व्याख्यायित किया जाना चाहिए, न कि आंतरिक प्रदर्शन की गारंटी के रूप में।

5.4. API-आधारित एजेंट

अवधारणात्मक कॉन्फ़िगरेशन:

Model: gpt-6-astra API: Responses Reasoning: low → high जब आवश्यक हो Tools: enabled Long-running tools: asynchronous जब उपयुक्त हो Human gate: अंतिम अपरिवर्तनीय कार्रवाई

लंबे समय तक चलने वाले उपकरणों के लिए:

जब टूल रनटाइम इतना लंबा हो कि ब्लॉकिंग सिंक्रोनस निष्पादन थ्रूपुट को कम कर दे, तो अतुल्यकालिक टूल निष्पादन का उपयोग करें।

यदि निष्पादन के दौरान कठिनाई का स्तर बदलता है:

तर्क प्रयास तभी बढ़ाएँ जब कार्य वास्तव में कठिन हो जाए। जब उपयुक्त हो, नियमित निष्पादन के लिए तर्क के निचले स्तर पर लौटें।

विचार सबसे महंगे संसाधनों को उन क्षणों के लिए आरक्षित करना है जिन्हें वास्तव में उनकी आवश्यकता है।

6. करें और न करें

करें

• Astra को उन कार्यों के लिए आरक्षित रखें जहाँ इसका वास्तविक अंतर हो।
• AGENTS.md और Skills के बीच विसंगतियों की समीक्षा करें।
• अनुमोदन को अंतिम चेकपॉइंट के रूप में रखें।
• प्राधिकरण का अनुरोध करने से पहले समीक्षा योग्य परिणाम उत्पन्न करें।
• जहाँ लागू हो, लंबे कार्यों के लिए संदर्भ प्रबंधन सक्रिय करें।
• परिकल्पनाओं, परीक्षणों और परिणामों को लॉग करें।
• बेंचमार्क को मार्गदर्शन के रूप में मानें, आंतरिक KPI के रूप में नहीं।
• सफलता दर और प्रति कार्य समय मापें।
• शुरू से जाँच करें कि क्या किसी कार्य के लिए Daybreak की आवश्यकता है।
• गोपनीय जानकारी को लगातार नोट्स से बाहर रखें।

न करें

• हर छोटे प्रश्न के लिए Astra का उपयोग करें।
• प्रचार वाक्यांशों को तकनीकी विशिष्टताओं के रूप में व्याख्यायित करें।
• व्यक्तिगत X या Reddit अनुभवों को आधिकारिक दस्तावेज़ीकरण के रूप में मानें।
• व्यवस्थापक द्वारा सक्षम किए जाने से पहले एंटरप्राइज़ तैनाती की घोषणा करें।
• अपरिवर्तनीय संचालनों तक स्वचालित पहुँच दें।
• संदर्भ फ़ाइलों में रहस्य या गोपनीय जानकारी संग्रहीत करें।
• तुच्छ परिवर्तनों के लिए विशाल परीक्षण बैटरी चलाएँ।
• आंतरिक मेट्रिक्स के विकल्प के रूप में बाहरी बेंचमार्क का उपयोग करें।

7. 60-मिनट कार्यान्वयन योजना

0–5 मिनट

जाँच करें कि gpt-6-astra उपलब्ध है या नहीं:

• मॉडल चयनकर्ता;
• API;
• Codex.

यदि यह एंटरप्राइज़ है, तो व्यवस्थापक अनुमतियाँ सत्यापित करें।

5–15 मिनट

जाँच करें:

model = "gpt-6-astra" approval_policy = "on-request" sandbox_mode = "workspace-write"

और, संदर्भ प्रयोगों के लिए:

[features.context_management] experimental_mode = true

यदि आवश्यक हो तो Codex को पुनरारंभ करें।

15–25 मिनट

AGENTS.md अपडेट करें:

• दायरा;
• प्रतिबंध;
• परीक्षण;
• पूर्णता की शर्तें;
• अनुमोदन बिंदु।

25–35 मिनट

एक रूटिंग तालिका बनाएँ:

Luna → Terra → Sol → Astra

35–55 मिनट

Astra के साथ सीमित दायरे का एक वास्तविक डिबगिंग कार्य निष्पादित करें।

एक स्पष्ट पूर्णता शर्त का उपयोग करें।

55–60 मिनट

लॉग करें:

• क्या Astra वास्तव में आवश्यक था?
• क्या Sol पर्याप्त होता?
• इसने कितना पुन: कार्य रोका?
• कौन सा कॉन्फ़िगरेशन काम कर गया?
• क्या एक Skill बनना चाहिए?

बस इतना ही काफी है।

आपको हर उपलब्ध सुविधा का परीक्षण करने की आवश्यकता नहीं है।

वितरण + सीमाएँ + लंबे सत्र = Astra का लाभ उठाने का आधार।

8. आवर्ती व्यावहारिक पैटर्न

1. दो-चरणीय रॉकेट

किफायती मॉडल → Astra

पहले:

• जाँच;
• दायरा परिभाषा;
• विश्लेषण।

फिर:

• जटिल कार्यान्वयन;
• एकीकरण;
• सत्यापन।

2. शुरू से पूर्णता की शर्त

लंबे एजेंटों में, निर्देश के पहले भाग में लिखें:

"कार्य तब समाप्त होगा जब..."

यह लक्ष्यहीन अन्वेषण को रोकता है।

3. संदर्भ और नोट लेना

लंबे कार्यों के लिए, बनाए रखें:

• परिकल्पनाएँ;
• परिणाम;
• निर्णय;
• परीक्षण;
• महत्वपूर्ण फ़ाइलें।

विशेष रूप से एजेंट की संपीड़ित मेमोरी पर निर्भर न रहें।

4. अनुमोदन अंतिम चरण होना चाहिए

लगातार बाधित न करें।

बेहतर:

जाँच करें → कार्यान्वित करें → परीक्षण करें → परिणाम तैयार करें → समीक्षा करें → अनुमोदन करें → अपरिवर्तनीय कार्रवाई निष्पादित करें

5. बेंचमार्क मार्गदर्शन के रूप में

Mind2Web और OSWorld आपको यह तय करने में मदद कर सकते हैं कि क्या परीक्षण करना है।

लेकिन वास्तविक KPI आंतरिक होने चाहिए:

• सफलता दर;
• निष्पादन समय;
• प्रति कार्य लागत;
• पुनरावृत्तियों की संख्या;
• पुन: कार्य;
• मानवीय हस्तक्षेप।

9. सामान्य त्रुटियाँ

निष्कर्ष निकालने से पहले:

"Astra कमजोर है।"

पहले इस क्रम में जाँच करें:

1. दृश्यता

क्या मॉडल वास्तव में उपलब्ध है?

1. ढाँचा

क्या Codex अपडेटेड और सही ढंग से कॉन्फ़िगर किया गया है?

1. प्रॉम्प्ट

क्या निर्देश स्पष्ट हैं?

1. AGENTS.md

क्या कोई विरोधाभासी नियम हैं?

1. Skills

क्या कोई पुरानी या असंगत प्रक्रियाएँ हैं?

1. रूटिंग

क्या आप कार्य के लिए सही मॉडल का उपयोग कर रहे हैं?

अक्सर समस्या मॉडल की क्षमता की नहीं होती है।

यह वह वातावरण है जिसमें मॉडल काम कर रहा है।

10. टीमों के लिए कार्यान्वयन चेकलिस्ट

• परिभाषित करें कि Astra का उपयोग कौन करेगा।
• आवश्यक प्रशासनिक अनुमतियाँ सक्रिय करें।
• एक स्वामी और एक समय सीमा स्थापित करें।
• Luna/Terra/Sol/Astra रूटिंग तालिका बनाएँ।
• एक न्यूनतम AGENTS.md बनाएँ।
• approval_policy परिभाषित करें।
• sandbox_mode परिभाषित करें।
• मानव हस्तक्षेप बिंदु परिभाषित करें।
• गोपनीय संचालन का दस्तावेज़ीकरण करें।
• साप्ताहिक लागत समीक्षा स्थापित करें।
• लॉग करें कि किन कार्यों के लिए वास्तव में Astra की आवश्यकता है।
• बार-बार होने वाली त्रुटियों को Skills में बदलें।

प्राथमिकता टीम की त्रुटियों और पुन: कार्य को कम करना होनी चाहिए, न कि केवल एक व्यक्तिगत एजेंट की गति को अधिकतम करना।

11. निर्णय वृक्ष: Sol बनाम Astra

किसी कार्य की शुरुआत में इस अनुक्रम का उपयोग करें:

1. क्या इसे एक ही आदान-प्रदान में पूरा किया जा सकता है?

हाँ → Luna / Terra / Sol

नहीं → जारी रखें।

1. क्या इसे GUI, उपकरणों या कई चरणों की आवश्यकता है?

हाँ → Astra

नहीं → जारी रखें।

1. क्या विफलता की लागत अधिक है?

हाँ → Astra

नहीं → Sol/Terra

1. क्या निष्पादन के दौरान कार्य की कठिनाई बदल सकती है?

हाँ → Astra + गतिशील तर्क समायोजन पर विचार करें।

1. क्या Astra अभी भी अनुपलब्ध है?

Sol के साथ वही वर्कफ़्लो निष्पादित करें।

जब Astra दिखाई दे, तो केवल मॉडल बदलें और संरचना बनाए रखें।

12. Astra में API माइग्रेशन

अनुशंसित क्रम है:

1. मॉडल बदलें

model = "gpt-6-astra"

1. Responses API का उपयोग करें

विशेष रूप से यदि टूल कॉल हैं।

1. तर्क की समीक्षा करें

Astra इसका उपयोग नहीं करता है:

reasoning.effort = "none"

जब पर्याप्त हो तो निम्न स्तर से शुरू करें।

1. अनावश्यक पैरामीटर हटाएँ

जैसे पैरामीटर की समीक्षा करें:

temperature top_p

यदि मॉडल या एंडपॉइंट अब उनका समर्थन नहीं करता है।

1. कैश की समीक्षा करें

माइग्रेट करें:

prompt_cache_options.ttl

जहाँ लागू हो।

1. डेटा निवास की समीक्षा करें

यदि आप EU में बुनियादी ढाँचे या निवास आवश्यकताओं का उपयोग करते हैं, तो संबंधित प्रतिबंधों को सत्यापित करें।

1. तर्क को गतिशील रूप से समायोजित करें

एक कठिन कार्य के दौरान:

जब कार्य वास्तव में कठिन हो जाए तो तर्क प्रयास बढ़ाएँ।

नियमित संचालन के दौरान:

जब अतिरिक्त तर्क अब उपयोगी न हो तो तर्क के निचले स्तर पर लौटें।

1. लंबे उपकरण

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

13. न्यूनतम Codex कॉन्फ़िगरेशन

एक प्रारंभिक कॉन्फ़िगरेशन हो सकता है:

model = "gpt-6-astra" model_reasoning_effort = "high" approval_policy = "on-request" sandbox_mode = "workspace-write" [features.context_management] experimental_mode = true

और रिपॉजिटरी में एक AGENTS.md होना चाहिए जो परिभाषित करता है:

AGENTS.md

लक्ष्य

• परिवर्तनों को न्यूनतम रखें।
• पूर्णता के लिए सभी आवश्यक परीक्षण पास होने चाहिए।

अनुमत दायरा

• src/
• tests/

अनुमोदन प्रवेशद्वार

• उत्पादन परिनियोजन
• बाहरी डेटा संचरण
• अनुमति परिवर्तन
• अंतिम विलय

संचालन व्यवहार

• अनुमत दायरे के भीतर स्वायत्त रूप से कार्य करें।
• प्रतिवर्ती कार्रवाइयों को प्राथमिकता दें।
• अनुमोदन मांगने से पहले समीक्षा योग्य परिणाम तैयार करें।
• अनावश्यक पुष्टिकरण प्रश्न न पूछें।

कॉन्फ़िगरेशन संशोधित करने के बाद:

1. Codex को पुनरारंभ करें;
2. एक छोटा पढ़ने का कार्य निष्पादित करें;
3. सत्यापित करें कि वातावरण काम करता है;
4. मुख्य कार्य शुरू करें।

14. एक वाक्य में "अधिकतम उपयोग" को परिभाषित करें

इस दस्तावेज़ में, अधिकतम उपयोग का अर्थ अधिकतम टोकन का उपभोग करना नहीं है।

इसका अर्थ है:

Astra को उन कार्यों पर केंद्रित करना जहां यह वास्तव में अंतर ला सकता है, बाकी सब कुछ किफायती रूप से निष्पादित करना, और निर्देशों, सीमाओं, अनुमोदनों और संदर्भ प्रबंधन की एक ठोस नींव बनाना जो लंबे कार्यों को अनावश्यक रुकावटों के बिना पूरा करने की अनुमति देता है।

इस परिभाषा से कई निर्णय अनुसरण करते हैं:

• मॉडल को मनमाने ढंग से बदलने की तुलना में रूटिंग तालिका को साप्ताहिक रूप से अपडेट करना बेहतर है।
• हर नई सुविधा को आज़माने की तुलना में वास्तविक डिबगिंग परीक्षण करना बेहतर है।
• बेंचमार्क का पीछा करने की तुलना में प्रति कार्य सफलता और समय को मापना बेहतर है।
• हमें प्रचार वाक्यांशों को आंतरिक विशिष्टताओं में नहीं बदलना चाहिए।
• यदि Astra उपलब्ध नहीं है, तो Sol का उपयोग अस्थायी विकल्प के रूप में किया जा सकता है।

15. तीन मौलिक वितरणीय वस्तुएं

अंततः, यह संपूर्ण प्रणाली तीन तत्वों का उत्पादन करेगी:

1. गतिशील आवंटन तालिका

परिभाषित करती है कि कब उपयोग करना है:

Luna / Terra / Sol / Astra

2. AGENTS.md

परिभाषित करता है:

• नियम;
• दायरा;
• प्रतिबंध;
• परीक्षण;
• पूर्णता की शर्तें;
• मानव जांच बिंदु।

3. लंबा संचालन प्रॉम्प्ट

परिभाषित करना चाहिए:

• भूमिका;
• उद्देश्य;
• पूर्णता की शर्तें;
• प्रक्रिया;
• सीमाएं;
• उपकरण;
• सत्यापन;
• आउटपुट प्रारूप।

ये तीन तत्व पूरी सुविधा सूची को याद करने से अधिक महत्वपूर्ण हैं।

16. वर्गीकरण कार्ड कॉपी करने के लिए

प्रत्येक महत्वपूर्ण सत्र की शुरुआत में इस कार्ड का उपयोग करें:

कार्ड को पूर्ण होने की आवश्यकता नहीं है।

इसका लक्ष्य एक वर्गीकरण की आदत बनाना है।

यदि आप Astra की सिफारिश करते हैं लेकिन कार्य के लिए केवल छोटे उत्तरों की आवश्यकता है, तो आप शायद मॉडल को ओवरसाइज़ कर रहे हैं।

यदि Sol संदर्भ खोने या कार्रवाइयों की लंबी श्रृंखला को पूरा करने में असमर्थता के कारण बार-बार विफल होता है, तो शायद Astra पर स्विच करने का समय आ गया है।

17. मूल्य के बारे में वास्तव में कैसे सोचें

प्रति मिलियन टोकन दरें केवल समीकरण का एक हिस्सा हैं।

उदाहरण के लिए:

Astra

• इनपुट: $10
• आउटपुट: $50

Sol

• इनपुट: $4
• आउटपुट: $20

Astra अधिक महंगा है।

लेकिन कल्पना करें:

Sol

$5 टोकन + 4 प्रयास + 2 विफलताएं + मानव पुनर्कार्य = उच्च वास्तविक लागत

Astra

$12 टोकन + 1 प्रयास + सही परिणाम = प्रति कार्य कम कुल लागत

इसलिए, छोटे कार्यों के लिए:

प्रति टोकन मूल्य बहुत मायने रखता है।

लंबे कार्यों के लिए:

प्रति पूर्ण कार्य लागत बहुत अधिक मायने रखती है।

अंतिम मीट्रिक होनी चाहिए:

लागत × सफलता दर × समय × मानव हस्तक्षेप

और केवल यह नहीं:

$/1M टोकन

निष्कर्ष

Astra का लक्ष्य इसे हर चीज़ के लिए डिफ़ॉल्ट मॉडल बनाना नहीं होना चाहिए।

लक्ष्य एक ऐसी प्रणाली बनाना होना चाहिए जहां प्रत्येक मॉडल वह कार्य करे जिसके लिए वह सबसे अधिक कुशल है।

Luna

वॉल्यूम और सरल कार्य।

Terra

लागत और क्षमता के बीच संतुलन।

Sol

मानक कार्य और सामान्य प्रोग्रामिंग।

Astra

जटिल, लंबे, एजेंटिक, GUI, गणित, डिबगिंग कार्य, और वे कार्य जहां विफलता महंगी है।

सबसे शक्तिशाली पैटर्न है:

सस्ते में जांच करें → योजना बनाएं → आवश्यकता पड़ने पर Astra के साथ निष्पादित करें → सत्यापित करें → समीक्षा योग्य परिणाम तैयार करें → केवल अंतिम जांच बिंदु पर मानव हस्तक्षेप।

सच्चा अनुकूलन Astra का अधिक उपयोग करने के बारे में नहीं है।

यह यह जानने के बारे में है कि Astra कब वास्तव में इसके लायक है।

और एजेंट जितने अधिक जटिल होंगे, उनके आसपास का बुनियादी ढांचा उतना ही महत्वपूर्ण होगा: AGENTS.md, Skills, सैंडबॉक्स, अनुमोदन, संदर्भ प्रबंधन।