2026 में AI इंजीनियर कैसे बनें (CS डिग्री के बिना)

2026 में AI इंजीनियर कैसे बनें

CS डिग्री के बिना।

बूटकैंप के बिना।

यह जाने बिना कि आज ट्रांसफॉर्मर क्या है।

यहाँ वह बात है जो कोई नहीं बताता:

जो कंपनियाँ अभी हायर कर रही हैं, उन्हें ऐसे लोग नहीं चाहिए जो मैथ समझते हों।

उन्हें ऐसे लोग चाहिए जो ऐसे सिस्टम बना सकें जो प्रोडक्शन में टिके।

इन दोनों में फर्क है।

चैटबॉट रैपर कोई सिस्टम नहीं है।

टूल कॉल कोई एजेंट नहीं है।

LangChain जानना हार्नेस इंजीनियरिंग जानना नहीं है।

इन दो चीज़ों के बीच का अंतर लगभग $150,000 सैलरी का है।

यह वही सटीक रोडमैप है जो यह गैप पाटता है।

इसे सेव करें। आप इसे दो बार पढ़ेंगे।

पहले कड़वा सच

इस वक्त ज़्यादातर डेवलपर AI बना रहे हैं, वे खिलौने बना रहे हैं।

वे GPT को कुछ प्रॉम्प्ट के साथ रैप करते हैं। इसे "AI प्रोडक्ट" कहते हैं। फिर सोचते हैं कि कोई इसके लिए पैसे क्यों नहीं दे रहा।

बाज़ार LLMs के ऊपर पतली परतों से भरा हुआ है।

ये बिज़नेस नहीं हैं। ये ऐसी फीचर्स हैं जिन्हें बड़ी टेक कंपनियाँ कभी भी कॉपी कर सकती हैं।

यहाँ वो चीज़ें हैं जिनके लिए कंपनियाँ 2026 में वास्तव में पैसे देती हैं:

→ ऐसे एजेंट जो शुक्रवार रात 2 बजे नहीं टूटते

→ ऐसे सिस्टम जिन्हें आप माप सकें और साबित कर सकें कि वे बिगड़ नहीं रहे

→ ऐसे हार्नेस जो एक ही मॉडल को 86% बेहतर प्रदर्शन कराएँ

आखिरी वाला काल्पनिक नहीं है।

Anthropic ने एक ही मॉडल (Opus 4.5) को दो अलग-अलग हार्नेस पर चलाया:

→ Claude Code हार्नेस: CORE बेंचमार्क पर 78%

→ Smolagents हार्नेस: CORE बेंचमार्क पर 42%

एक ही मॉडल। अलग हार्नेस। 36 अंकों का अंतर।

हार्नेस ही काम है।

2026 में AI इंजीनियर वास्तव में क्या करता है

प्रॉम्प्ट लिखना नहीं। मॉडल चुनना नहीं।

AI इंजीनियर मॉडल के चारों ओर सिस्टम बनाता और संचालित करता है।

इसका मतलब है:

→ एजेंट लूप और टूल डिस्पैच डिज़ाइन करना

→ कॉन्टेक्स्ट इंजीनियरिंग — हर स्टेप पर मॉडल के सामने कौन से टोकन जाते हैं

→ ऐसे टूल लिखना जिन्हें मॉडल वास्तव में सही तरीके से चुनता है

→ प्रोडक्शन ट्रैफिक के लिए मेमोरी, ड्यूरेबिलिटी, और सैंडबॉक्सिंग जोड़ना

→ इवल्स और CI रिग्रेशन गेट्स वायर करना ताकि "बेहतर" मापने योग्य बने

→ ऐसे एजेंट शिप करना जो असली यूज़र्स और असली कॉस्ट को झेलें

चार कॉन्टेक्स्ट प्रिमिटिव जो हर एजेंट इंजीनियर को चाहिए:

Write — स्क्रैचपैड, मेमोरी फ़ाइलें जिन्हें एजेंट पढ़ता और अपडेट करता है

Select — उपयोग के बिंदु पर रिट्रीवल, शुरू में सब कुछ डंप करना नहीं

Compress — कॉन्टेक्स्ट विंडो के 85-95% पर समरीकरण

Isolate — अपने अलग कॉन्टेक्स्ट विंडो वाले सब-एजेंट

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

6-चरणीय रोडमैप

अगर फुल-टाइम हो तो 17 हफ्ते। अगर पार्ट-टाइम हो तो 40 हफ्ते।

हर चरण में एक ठोस प्रोजेक्ट है। कोई भी चरण कुछ शिप किए बिना खत्म नहीं होता।

चरण 0: सही मानसिक मॉडल बनाएं

(हफ्ते 1-2)

अभी एजेंट कोड की एक लाइन भी न लिखें।

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

तीन चीज़ें जिन्हें कुछ और करने से पहले अच्छी तरह समझ लें:

1. वर्कफ़्लो बनाम एजेंट

वर्कफ़्लो का एक निश्चित कंट्रोल फ़्लो होता है जो आपने लिखा है। एजेंट एक लूप के अंदर अपने स्वयं के कंट्रोल-फ़्लो निर्णय लेता है।

जब आपको वर्कफ़्लो चाहिए तो एजेंट बनाना 10x अधिक खर्चीला और दोगुना बार-बार टूटता है।

2. 5 वर्कफ़्लो पैटर्न (Anthropic से)

→ प्रॉम्प्ट चेनिंग: एक कॉल का आउटपुट दूसरे को पास करें

→ रूटिंग: अलग-अलग कार्यों के लिए अलग-अलग मॉडल

→ पैरेललाइज़ेशन: एक ही समय में कई कार्य चलाएं

→ ऑर्केस्ट्रेटर-वर्कर: एक दिमाग, कई हाथ

→ इवैलुएटर-ऑप्टिमाइज़र: जनरेट करें → जज करें → सुधारें

3. हार्नेस

हार्नेस वह चीज़ है जो आपके और मॉडल API के बीच रहता है।

इसे ऑपरेटिंग सिस्टम की तरह समझें:

→ मॉडल = CPU (कच्ची कंप्यूटेशन)

→ RAM = कॉन्टेक्स्ट विंडो

→ OS = हार्नेस

→ ऐप्स = आपके एजेंट की स्किल्स

OS तय करता है कि CPU वास्तव में क्या कर सकता है। हार्नेस तय करता है कि मॉडल वास्तव में क्या कर सकता है।

चरण 0 प्रोजेक्ट: अपने शब्दों में 2-पेज का एक डॉक्यूमेंट लिखें — जिसमें परिभाषित करें: वर्कफ़्लो बनाम एजेंट, 5 वर्कफ़्लो पैटर्न, 4 कॉन्टेक्स्ट प्रिमिटिव, ऑर्केस्ट्रेटर-वर्कर पैटर्न।

अगर आप बिना देखे यह नहीं लिख सकते, तो आपने पर्याप्त ध्यान से नहीं पढ़ा।

चरण 1: अपना पहला एजेंट स्क्रैच से बनाएं

(हफ्ते 3-5)

एक एजेंट दो बार लिखें।

पहले: रॉ Anthropic SDK के साथ। लगभग 100 लाइनें Python।

दूसरे: Claude Agent SDK के साथ।

फिर फर्क महसूस करें।

बिल्ड #1 — रॉ लूप

एजेंट लूप कोई जादू नहीं है।

मॉडल को मैसेज और टूल के साथ कॉल करें
tool_use ब्लॉक्स को पार्स करें
टूल को एक्ज़ीक्यूट करें
tool_result जोड़ें
stop_reason = end_turn होने तक लूप करें

इसे खुद 100 लाइनों के अंदर लिखें।

एक बार जब आप यह कर लेंगे, हर फ्रेमवर्क पढ़ने लायक हो जाएगा।

इसे 3 टूल दें:

→ web_search

→ read_file

→ write_file

इसे एक रिसर्च टास्क पर चलाएं। ट्रेस का हर स्टेप पढ़ें।

बिल्ड #2 — Claude Agent SDK पर वही एजेंट

Claude Agent SDK वही हार्नेस है जो Claude Code को पावर देता है।

जोड़ें:

→ CLAUDE.md प्रोजेक्ट कन्वेंशन के साथ

→ एक स्किल (एक फ़ोल्डर जो "research-summary" आउटपुट फ़ॉर्मेट को परिभाषित करता है)

→ एक PostToolUse हुक जो एजेंट द्वारा लिखी गई हर फ़ाइल को ऑटो-फ़ॉर्मेट करता है

→ Task टूल के ज़रिए एक सब-एजेंट स्पॉन करें

फिर 200 शब्दों में लिखें: "हार्नेस ने मुझे कौन सी चीज़ें मुफ़्त दीं जो मैंने बिल्ड #1 में खुद लिखी थीं?"

चरण 1 प्रोजेक्ट: एक डेली ब्रीफिंग एजेंट। आपके Markdown नोट्स + RSS फीड पढ़ता है। हर सुबह एक समरीकृत ब्रीफिंग डिस्क पर लिखता है। इसे एक हफ़्ते तक चलाएं। इसे असफल होते देखें। इसे ठीक करें।

चरण 2: सही आर्किटेक्चर के साथ एक असली एजेंट बनाएं

(हफ्ते 6-9)

अब आप LangGraph + Deep Agents पर बनाते हैं।

यह प्रोडक्शन स्टैक है।

LangGraph आपको देता है:

→ स्टेट मशीन (नोड्स + एजेस)

→ PostgresSaver चेकपॉइंटिंग (किसी भी प्रोसेस किल से बचे)

→ टाइम-ट्रैवल डीबगिंग (किसी भी स्टेप पर रिवाइंड करें)

→ ह्यूमन-इन-द-लूप इंटरप्ट्स

→ LangSmith के ज़रिए फ़र्स्ट-क्लास ऑब्ज़र्वेबिलिटी

Deep Agents (LangChain का पैकेज्ड हार्नेस) आपको देता है:

→ प्लानिंग मिडलवेयर

→ वर्चुअल फ़ाइलसिस्टम

→ सब-एजेंट स्पॉनिंग

→ ऑटोमैटिक कॉन्टेक्स्ट कंप्रेशन

→ स्किल्स

मुख्य अवधारणा: मिडलवेयर

मिडलवेयर वह तरीका है जिससे आप पैकेज्ड एजेंट को फोर्क किए बिना कस्टमाइज़ करते हैं।

चार हुक जो मायने रखते हैं:

→ before_agent — लूप शुरू होने से पहले चलता है

→ wrap_model_call — हर LLM कॉल को रैप करता है

→ before_tools — किसी भी टूल के एक्ज़ीक्यूट होने से पहले चलता है

→ after_tools — किसी भी टूल के एक्ज़ीक्यूट होने के बाद चलता है

चरण 2 प्रोजेक्ट: रिसर्च एनालिस्ट एजेंट

इनपुट: एक रिसर्च प्रश्न

आर्किटेक्चर:

→ लीड एजेंट योजना बनाता है, वर्चुअल फ़ाइलसिस्टम पर TODO लिस्ट लिखता है

→ 3 सर्च सब-एजेंट्स को पैरेलल में स्पॉन करता है (आइसोलेटेड कॉन्टेक्स्ट)

→ सब-एजेंट परिणाम फ़ाइलों में लिखते हैं, पैरेंट को छोटी समरी लौटाते हैं

→ साइटेशन सब-एजेंट दावों को सत्यापित करता है

→ राइटर एजेंट इनलाइन साइटेशन के साथ अंतिम Markdown बनाता है

→ स्टेट PostgresSaver के ज़रिए बनी रहती है — प्रोसेस को मारें, जहाँ छोड़ा था वहाँ से फिर से शुरू करें

→ ह्यूमन-इन-द-लूप इंटरप्ट: टोकन में $1 से अधिक होने से पहले पुष्टि मांगें

अपने README के साथ LangSmith ट्रेस URL शिप करें।

चरण 3: हार्नेस लेयर खुद बनाएं

(हफ्ते 10-13)

यह पूरे रोडमैप का सबसे अधिक लाभकारी चरण है।

पैकेज्ड हार्नेस का उपयोग बंद करें। खुद एक पतला हार्नेस बनाएं।

जब तक आप एक बार हार्नेस नहीं बना लेते, आप प्रोडक्शन में सही हार्नेस ट्रेड-ऑफ़ कभी नहीं कर पाएंगे।

आधुनिक हार्नेस के 10 घटक:

लूप कंट्रोल — while-लूप जो मॉडल → टूल → मॉडल चलाता है
टूल डिस्पैच — रजिस्ट्री, स्कीमा वैलिडेशन, पैरेलल कॉल, रीट्राइज़
कॉन्टेक्स्ट मैनेजमेंट — सिस्टम-प्रॉम्प्ट असेंबली, विंडो के 85% पर कॉम्पैक्शन
पर्सिस्टेंस — हर नोड पर चेकपॉइंट स्टेट रिज़्यूम, रिवाइंड, फोर्क के लिए
सब-एजेंट ऑर्केस्ट्रेशन — आइसोलेटेड-कॉन्टेक्स्ट चाइल्ड, संकुचित समरी वापस
स्किल्स और प्रोग्रेसिव डिस्क्लोज़र — क्षमताएँ केवल प्रासंगिक होने पर लोड करें
हुक — PreToolUse, PostToolUse, PreCompact, Stop
ऑब्ज़र्वेबिलिटी — हर मॉडल कॉल, टूल कॉल, सब-एजेंट इनवोकेशन के लिए OTEL स्पैन
सैंडबॉक्सिंग — एक कंटेनर में कोड एक्ज़ीक्यूशन जहाँ मॉडल के पास क्रेडेंशियल न हों
ऑथ ब्रोकरिंग — क्रेडेंशियल कभी मॉडल के कॉन्टेक्स्ट में प्रवेश न करें

चरण 3 प्रोजेक्ट: ~1,500 लाइनों Python में एक मिनी-हार्नेस लिखें।

इसमें शामिल होना चाहिए:

→ @tool डेकोरेटर से JSON-स्कीमा जनरेशन के साथ टूल रजिस्ट्री

→ CLAUDE.md-शैली सिस्टम-प्रॉम्प्ट लोडर

→ SKILL.md प्रोग्रेसिव-डिस्क्लोज़र लोडर

→ आइसोलेटेड कॉन्टेक्स्ट के साथ सब-एजेंट स्पॉन प्रिमिटिव

→ फ़ाइलसिस्टम ऑफ़लोड: 20K टोकन से अधिक का कोई भी टूल परिणाम → डिस्क पर लिखें, कॉन्टेक्स्ट में पथ + 10-लाइन पूर्वावलोकन से बदलें

→ कॉन्टेक्स्ट विंडो के 85% पर ऑटो-कॉम्पैक्शन

→ प्लगेबल हुक सिस्टम (pre_tool, post_tool, stop)

→ OpenTelemetry ट्रेसिंग

→ ड्यूरेबल रिज़्यूम: प्रत्येक स्टेप के बाद SQLite पर पर्सिस्ट करें, रन ID द्वारा रीलोड करें

असली डिलीवरेबल: 1,000-शब्द का पोस्ट-मॉर्टम जो आपके मिनी-हार्नेस की तुलना Claude Agent SDK और Deep Agents से करता है। आपने क्या सही किया। आपने क्या काटा। आप अलग क्या करते।

चरण 4: Eval और Regression हार्नेस बनाएं

(हफ्ते 14-17)

इसके बिना, हर "सुधार" सिर्फ अनुमान है।

यहीं पर ज़्यादातर इंजीनियर अटक जाते हैं।

वे एक बढ़िया एजेंट बना सकते हैं। वे नहीं बता सकते कि उनका अगला बदलाव इसे बेहतर या बदतर बनाता है या नहीं।

4 eval प्रकार जिन्हें आपको लागू करना ही होगा:

1. सिंगल-टर्न evals

दिए गए इनपुट पर, क्या आउटपुट सही है? सबसे सस्ता। जहाँ संभव हो डिटरमिनिस्टिक ग्रेडर। लगातार चलाएं।

2. ट्रैजेक्ट्री evals

क्या एजेंट ने सही टूल्स को सही आर्गुमेंट्स के साथ सही क्रम में कॉल किया? सिंगल-स्टेप, फुल-टर्न, और मल्टी-टर्न वेरिएंट का परीक्षण करें।

3. LLM-as-judge

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

4. एंड-स्टेट evals

स्टेटफुल एजेंट के लिए: क्या डेटाबेस सही तरीके से लिखा गया? क्या सही फ़ाइलें बदलीं? अंतिम वातावरण की स्थिति की तुलना ग्राउंड ट्रुथ से करें।

evals के बारे में असहज सच:

मॉडल पता लगा सकते हैं कि उनका मूल्यांकन किया जा रहा है। वे eval इनपुट पर अलग व्यवहार करते हैं।

अपने eval सूट को इसे रोकने के लिए डिज़ाइन करें। सिंथेटिक नहीं, बल्कि असली प्रोडक्शन क्वेरी का उपयोग करें।

चरण 4 प्रोजेक्ट: आपके चरण 2 एजेंट के आसपास रिग्रेशन हार्नेस।

→ गोल्डन डेटासेट: 30-50 हैंड-ग्रेडेड रिसर्च प्रश्न (3 कठिनाई स्तर)

→ तथ्यात्मक प्रश्नों के लिए डिटरमिनिस्टिक ग्रेडर

→ ओपन-एंडेड के लिए 5-मानदंड रूब्रिक के साथ LLM-as-judge

→ ट्रैजेक्ट्री eval: क्या एजेंट ने योजना बनाई, 2+ सब-एजेंट स्पॉन किए, स्रोतों का हवाला दिया, बजट के अंदर खत्म किया?

→ GitHub Actions में वायर करें: गोल्डन सेट पास रेट 3+ अंक गिरने पर मर्ज ब्लॉक करें

→ प्रोडक्शन सैंपलिंग: 1% लाइव ट्रेस रात्रि में ऑटो-ग्रेड किए जाएं

चरण 5: प्रोडक्शन हार्डनिंग

(हमेशा के लिए)

यह चरण खत्म नहीं होता।

पाँच चीज़ें जो हमेशा मायने रखती हैं:

1. कॉस्ट डिसिप्लिन

→ अपने CLAUDE.md, सिस्टम प्रॉम्प्ट, और टूल डेफ़िनिशन को कैश करें — 90% तक बचत

→ कठिनाई के अनुसार रूट करें: सरल टर्न के लिए Haiku, अधिकांश कार्यों के लिए Sonnet, कठिन रीज़निंग के लिए Opus

→ नॉन-रियल-टाइम काम के लिए Batch API: 50% छूट

→ मल्टी-एजेंट सिंगल-एजेंट की तुलना में ~15x टोकन खर्च करता है — केवल तभी चलाएं जब मूल्य उस बार को पार करे

2. लेटेंसी

→ हमेशा पैरेलल टूल कॉल — Anthropic के अपने रिसर्च एजेंट के सिस्टम प्रॉम्प्ट में सचमुच लिखा है "आपको पैरेलल टूल कॉल का उपयोग करना चाहिए"

→ UI पर पार्शियल आउटपुट स्ट्रीम करें

→ सब-एजेंट फैन-आउट: 60-स्टेप सीक्वेंशियल एजेंट → 10-स्टेप लीड + 5 पैरेलल 10-स्टेप सब-एजेंट

3. सुरक्षा और सैंडबॉक्सिंग

→ सभी कोड एक्ज़ीक्यूशन सैंडबॉक्स में (Modal, E2B): अपने मेन प्रोसेस में कभी भी मॉडल आउटपुट पर exec() न करें

→ मॉडल कॉन्टेक्स्ट के बाहर क्रेडेंशियल ब्रोकर किए गए: मॉडल कभी भी वह API key नहीं देखता जिसका वह उपयोग करता है

→ किसी भी अपरिवर्तनीय कार्रवाई पर ह्यूमन-इन-द-लूप इंटरप्ट

4. मॉनिटरिंग और ड्रिफ्ट

→ अलर्ट करें: प्रति अनुरोध टोकन लागत, टूल-कॉल विफलता दर, LLM-as-judge स्कोर, p95 लेटेंसी

→ हर मॉडल अपग्रेड के बाद evals को फिर से बेसलाइन करें — हार्नेस इस बारे में धारणाएँ एनकोड करते हैं कि मॉडल क्या नहीं कर सकता, और वे धारणाएँ पुरानी हो जाती हैं

5. रेज़िलिएंस

→ किसी भी एजेंट के लिए ड्यूरेबल एक्ज़ीक्यूशन (Inngest, Temporal, PostgresSaver) जो 60 सेकंड से अधिक चलता है

→ हर नोड के बाद चेकपॉइंट

→ रिवाइंड और फोर्क हमेशा संभव होना चाहिए

5 प्रोडक्शन-ग्रेड प्रोजेक्ट (एक चुनें और इस वीकेंड बनाएं)

ये जटिलता के क्रम में हैं।

ये साबित करते हैं कि कंपनियों को वास्तव में क्या देखना चाहिए।

प्रोजेक्ट 1: SLM के साथ AI-संचालित मोबाइल ऐप

छोटे भाषा मॉडल का उपयोग करके एक ऑफ़लाइन-फ़र्स्ट मोबाइल ऐप बनाएं। शून्य API लागत। पूर्ण गोपनीयता।

इसे गैर-तुच्छ क्या बनाता है:

→ मॉडल को डिमांड पर लेज़ी-लोड करें, मेमोरी प्रेशर पर अनलोड करें

→ स्लाइडिंग कॉन्टेक्स्ट विंडो सीमैंटिक चंकिंग के साथ

→ पुराने उपकरणों के लिए 4-बिट क्वांटाइज़ेशन, नए के लिए 8-बिट

→ बैटरी वेक साइकिल कम करने के लिए बैच इन्फ्रेंस

यह क्यों मायने रखता है: आप साबित करते हैं कि आप संसाधन बाधाओं और डिवाइस-स्तरीय AI को समझते हैं। आप सिर्फ एक API कॉल नहीं कर रहे हैं — आप मेमोरी प्रेशर और क्वांटाइज़ेशन का प्रबंधन कर रहे हैं।

प्रोजेक्ट 2: स्व-सुधारशील कोडिंग एजेंट

एक एजेंट बनाएं जो कोड लिखता है, टेस्ट चलाता है, और असफलताओं से सीखता है। यह तब तक नहीं रुकता जब तक कोड कार्यात्मक न हो जाए।

इसे गैर-तुच्छ क्या बनाता है:

→ योजना → निष्पादित करें → परीक्षण → अधिकतम पुनरावृत्ति सीमा के साथ प्रतिबिंब लूप

→ प्रति कार्य संसाधन सीमाओं के साथ आइसोलेटेड एक्ज़ीक्यूशन वातावरण

→ मेमोरी पदानुक्रम: शॉर्ट-टर्म (पिछले 5 पुनरावृत्तियाँ), लॉन्ग-टर्म (सफल पैटर्न), विफलता मेमोरी (त्रुटि हस्ताक्षर + समाधान)

→ निष्पादन से पहले स्थैतिक विश्लेषण — खतरनाक संचालन का पता लगाएं

यह क्यों मायने रखता है: एजेंटिक लूप का परिचय देता है। दिखाता है कि आप प्रोडक्शन डीबगिंग और पुनरावृत्तीय शोधन समझते हैं।

प्रोजेक्ट 3: वीडियो एडिटर्स के लिए कर्सर

एक ओपन-सोर्स एडिटर (Shotcut) को फोर्क करें और एक AI एजेंट बनाएं जो एडिटिंग इरादे को समझता है।

उपयोगकर्ता कहता है "इसे सिनेमैटिक बनाओ।" एजेंट कट्स, ट्रांज़िशन और कलर ग्रेडिंग संभालता है।

इसे गैर-तुच्छ क्या बनाता है:

→ विज़न मॉडल हर फ्रेम का विश्लेषण करता है + ऑडियो मॉडल डायलॉग का विश्लेषण करता है

→ इरादा अनुवाद: "सिनेमैटिक" → ठोस पैरामीटर (पेसिंग, LUT, फोकस सिमुलेशन)

→ फ्रेम-अंतर विश्लेषण के माध्यम से सीन डिटेक्शन

→ इंक्रीमेंटल प्रीव्यू — केवल प्रभावित अनुभागों को फिर से रेंडर करें

यह क्यों मायने रखता है: मल्टीमॉडल AI + जटिल टूल एकीकरण। आपको चैटबॉट बिल्डर्स के 99% से अलग बनाता है।

प्रोजेक्ट 4: पर्सनल लाइफ OS एजेंट

एक एजेंट बनाएं जो आपके कैलेंडर, वित्त और स्वास्थ्य का प्रबंधन करता है। महीनों पहले योजना बनाता है। नींद के पैटर्न और मीटिंग डेंसिटी का विश्लेषण करके बर्नआउट का पता लगाता है।

इसे गैर-तुच्छ क्या बनाता है:

→ कैलेंडर, वित्त, स्वास्थ्य, संचार से रियल-टाइम इन्जेशन

→ संस्थाओं और संबंधों का पर्सनल नॉलेज ग्राफ़

→ हर 6 घंटे में असामान्यताओं की जाँच करने वाला बैकग्राउंड थ्रेड

→ वैल्यू अलाइनमेंट: उपयोगकर्ता प्राथमिकताएँ बताता है (परिवार > काम) — हर सिफारिश उनके खिलाफ मान्य की जाती है

→ उपयोगकर्ता-नियंत्रित कुंजियों के साथ सभी डेटा रेस्ट पर एन्क्रिप्टेड

यह क्यों मायने रखता है: परिष्कृत कॉन्टेक्स्ट प्रबंधन और नैतिक AI डिज़ाइन की आवश्यकता है। गोपनीयता-प्रथम प्रोडक्शन आर्किटेक्चर प्रदर्शित करता है।

प्रोजेक्ट 5: स्वायत्त एंटरप्राइज़ वर्कफ़्लो एजेंट

एक एजेंट जो बिज़नेस वर्कफ़्लो को एंड-टू-एंड चलाता है।

Slack/Jira मॉनिटर करता है → निष्पादन की योजना बनाता है → कार्यों को सौंपता है → पूर्ण ऑडिट लॉग के साथ परिणाम रिपोर्ट करता है।

इसे गैर-तुच्छ क्या बनाता है:

→ इवेंट-ड्रिवन: Slack, Jira, ईमेल, मॉनिटरिंग सिस्टम को सुनें

→ मल्टी-एजेंट डेलिगेशन: ऑर्केस्ट्रेटर → कम्युनिकेशन एजेंट, डेटा एजेंट, एनालिसिस एजेंट, डॉक्यूमेंटेशन एजेंट

→ सेल्फ-हीलिंग: एक्सपोनेंशियल बैकऑफ़, सर्किट ब्रेकर, स्वचालित रीट्राय निर्णय

→ इम्यूटेबल ऑडिट लॉग: हर कार्रवाई, किसने अधिकृत किया, क्या परिणाम था

→ ह्यूमन-इन-द-लूप: महत्वपूर्ण वर्कफ़्लो पर निष्पादन से पहले एजेंट योजना प्रस्तावित करता है

यह क्यों मायने रखता है: ऑर्केस्ट्रेशन, सुरक्षा और ऑब्ज़र्वेबिलिटी को एक स्केलेबल सिस्टम में जोड़ता है। यह पोर्टफोलियो क्लोज़र है।

स्टैक (वास्तव में क्या सीखें)

फ्रेमवर्क: LangGraph 1.0 + Deep Agents

क्यों CrewAI, AutoGen, या OpenAI Swarm नहीं?

→ CrewAI: सबसे तेज़ डेमो, प्रोडक्शन में नाज़ुक। हैकाथॉन के लिए उपयोग करें।

→ AutoGen: Microsoft Agent Framework में विलय। अनिश्चित भविष्य।

→ OpenAI Swarm: OpenAI के अपने README के अनुसार स्पष्ट रूप से "प्रोडक्शन-रेडी नहीं"।

LangGraph आपको देता है: स्टेट मशीन + PostgresSaver ड्यूरेबिलिटी + टाइम-ट्रैवल डीबगिंग + OTEL-फ्रेंडली ऑब्ज़र्वेबिलिटी + मॉडल-अज्ञेयवादी।

हार्नेस रेफरेंस: Claude Agent SDK

इसका अध्ययन करें। इसका उपयोग करें। यह वही हार्नेस है जो Claude Code में है।

CLAUDE.md + स्किल्स + सब-एजेंट + हुक + फ़ाइलसिस्टम-एज़-मेमोरी।

2026 में हर दूसरा हार्नेस इन प्रिमिटिव पर कन्वर्ज कर रहा है।

ऑब्ज़र्वेबिलिटी: एक चुनें

→ LangSmith: अगर आप LangGraph में रहते हैं

→ Braintrust: अगर आप फ्रेमवर्क-अज्ञेयवादी CI गेटिंग चाहते हैं ($249/mo फ्लैट)

→ Arize Phoenix: अगर आप ओपन-सोर्स + OTEL-नेटिव चाहते हैं

2026 में छोड़ दें:

→ OpenAI Swarm — प्रोडक्शन-रेडी नहीं (Kimi Agent Swarm उपयोग कर सकते हैं)

→ OpenAI Assistants API — मध्य-2026 में सनसेट हो रहा है

→ अपना खुद का वेक्टर स्टोर बनाना इससे पहले कि आप एक वास्तविक रिकॉल समस्या को मापें

→ नो-कोड एजेंट प्लेटफ़ॉर्म जब तक कि यह डिस्पोजेबल न हो

बेंचमार्क नंबर (मई 2026)

SWE-bench Verified (कोडिंग कार्य):

→ Claude Opus 4.7: ~87.6%

→ GPT-5.5: ~88.7%

GAIA (सामान्य एजेंट कार्य):

→ Claude Sonnet 4.5 74.6% पर आगे है

τ-bench (ग्राहक सेवा एजेंट):

→ Claude Mythos Preview: 89.2%

मुख्य अंतर्दृष्टि: एक ही बेंचमार्क, अलग हार्नेस = 10-36 अंकों का अंतर।

मॉडल से कम हार्नेस मायने रखता है।

17-हफ़्ते की टाइमलाइन

हफ़्ता 2 → चरण 0 पूरा। आप सादे अंग्रेज़ी में हार्नेस समझा सकते हैं।

हफ़्ता 5 → चरण 1 पूरा। Claude Agent SDK एजेंट एक स्किल, एक हुक, एक सब-एजेंट के साथ शिप किया गया।

हफ़्ता 9 → चरण 2 पूरा। PostgresSaver ड्यूरेबिलिटी और LangSmith ट्रेस के साथ LangGraph डीप-एजेंट चल रहा है।

हफ़्ता 13 → चरण 3 पूरा। 1,500-लाइन मिनी-हार्नेस लिखा और दस्तावेज़ित किया गया।

हफ़्ता 17 → चरण 4 पूरा। गोल्डन डेटासेट, CI गेट्स, Inspect के माध्यम से एक प्रकाशित-बेंचमार्क रन।

हफ़्ता 17+ → चरण 5। हमेशा के लिए।

प्रति सप्ताह 10-15 घंटे पार्ट-टाइम: सब कुछ 2.5x से गुणा करें।

असहज सच

ज़्यादातर लोग इसे पढ़ेंगे और कुछ नहीं करेंगे।

वे इसे बुकमार्क करेंगे। "शानदार लेख" कहेंगे। रैपर बनाने पर वापस जाएंगे।

2026 के लिए कड़वा सच:

→ जो बदले जा सकते हैं: पतले GPT रैपर बनाना

→ जिन्हें निकालना असंभव: evals और ड्यूरेबिलिटी के साथ स्वायत्त सिस्टम शिप करना

उनके बीच का अंतर 5 प्रोजेक्ट और 17 हफ़्ते का केंद्रित काम है।

57% टीमों के पास अब प्रोडक्शन में एजेंट हैं।

उनमें से 89% के पास ऑब्ज़र्वेबिलिटी जुड़ी है।

गुणवत्ता #1 बाधा है (32% टीमें इसे उद्धृत करती हैं)।

इसका मतलब है कि पूरा क्षेत्र उन इंजीनियरों पर अटका हुआ है जो evals और हार्नेस बना सकते हैं।

उन इंजीनियरों पर नहीं जो LLM API कॉल कर सकते हैं।

यही नौकरी का अवसर है।

समापन

यह रोडमैप आपको 17 हफ़्तों में प्रिंसिपल AI इंजीनियर नहीं बनाएगा।

यह आपको ऐसा व्यक्ति बनाएगा जो एजेंट सिस्टम बना और शिप कर सकता है जो प्रोडक्शन ट्रैफिक को झेलते हैं।

यह संयोगवश वह चीज़ है जिसके लिए कंपनियाँ अभी भुगतान कर रही हैं।

यहाँ बताया गया है कि मैं आपको आगे क्या करने के लिए कहता हूँ:

1. एक प्रोजेक्ट चुनें। अगर आप नए हैं तो प्रोजेक्ट 1 से शुरू करें। अगर आप पहले से कोड शिप कर रहे हैं तो प्रोजेक्ट 5 से शुरू करें। बस शुरू करें।

2. इसे इस वीकेंड बनाएं। बाज़ार शिपिंग को पुरस्कृत करता है, पढ़ाई को नहीं।

3. सब कुछ दस्तावेज़ित करें: आपके आर्किटेक्चर निर्णय, आपकी असफलताएँ और सुधार, आपके स्व-सुधार लूप।

4. सार्वजनिक रूप से बनाएं। जब आप शिप करें तो मुझे टैग करें — मैं इसे एम्प्लीफाई करूँगा।

अगले महीने तक, 90% लोगों ने कुछ नहीं किया होगा। वे अभी भी वही रैपर बना रहे होंगे।

बाकी 10% ने कुछ वास्तविक शिप किया होगा। उनके पास इंटरव्यू, ऑफ़र और करियर लीवरेज होगा।

चुनाव सरल है:

उस आर्किटेक्ट बनें जिसे कंपनियाँ हायर करने के लिए बेताब हैं। या अप्रासंगिक हो जाएँ।

विशेषज्ञता ही एकमात्र नौकरी सुरक्षा बची है। प्रोडक्शन सिस्टम ही एकमात्र पोर्टफोलियो है जो मायने रखता है।

अब कुछ ऐसा बनाएँ जो वास्तविकता को झेले।

उत्तर दें कि आप कौन सा प्रोजेक्ट शुरू कर रहे हैं। मैं हर प्रतिक्रिया पढ़ता हूँ।

→ अपने नेटवर्क के साथ साझा करने के लिए रिपोस्ट करें

→ @sairahul1 को फॉलो करें इस तरह के और विश्लेषण के लिए