Skip to main content

कहाँ से शुरू करें: महीनों में नहीं, दिनों में Agentic AI Engineer बनें

AI सीखने के लिए आपके पास महीनों का समय नहीं है। अच्छी बात यह है कि आपको महीनों की ज़रूरत भी नहीं है। हर कोई एक ही तरह शुरू करता है: browser में छह Foundations courses, कुछ भी install किए बिना, चाहे आप code कर सकते हों या नहीं। फिर आप एक decision लेते हैं, AI से अपना काम करवाना है या ऐसा AI बनाना है जो आपके लिए काम करे, और वहीं से courses आगे बढ़ते हैं। Engineer destination है, prerequisite नहीं।

यह section beginner से production में काम पहुँचा सकने वाले Agentic AI Engineer तक जाने का सबसे छोटा रास्ता है: semesters में नहीं, दिनों में मापा गया। कुछ hours में AI के साथ productive होना, एक weekend में पहला Digital FTE, और focused evenings के एक महीने में पूरा Agent Factory stack।

दिन क्यों, महीने क्यों नहीं​

यह promise impossible लगता है, जब तक आप उसके पीछे का method नहीं देखते। यह वही method है जिसे कोई भी कम background के साथ नई job में survive करने के लिए इस्तेमाल करता है। पहले, आपको काम की बड़ी तस्वीर मिलती है। दूसरे, आप उन थोड़े से topics को identify करते हैं जो सच में काम करने के लिए critical हैं। तीसरे, आप हर topic का वह 80% सीखते हैं जो routine में इस्तेमाल होता है, काम शुरू करते हैं, और बाकी रास्ते में सीखते जाते हैं: reference material आपके पास खुला रहता है।

तीन-step pedagogy: बड़ी तस्वीर, क्या सच में matter करता है उसे पहचानना, फिर critical 80% cover करना और वास्तविक इस्तेमाल से बाकी सीखते हुए काम पूरा करना

हर topic की हर detail पहले ही सीखने की कोशिश करने में महीनों लगते हैं। कुछ भी ship करने से पहले ही आप थक जाएँगे। हमारी pedagogy उलटी philosophy पर बनी है: critical 80% cover करें, आपको काम में लगाएँ, और बाकी real use से भरने दें। इस section का हर crash course बिल्कुल इसी तरह बनाया गया है।

note

इस book पर एक note। इस section के crash courses आपको जल्दी काम शुरू करवाते हैं। Book के chapters course के बाद वाला reference हैं: real work में जब भी gap दिखे, वापस आने के लिए लिखे गए।

यह कैसे organized है (यहाँ से शुरू करें)​

आप इसे सब कुछ पढ़कर नहीं सीखते; आप इसे एक clear path चलकर सीखते हैं। इसलिए यही path है, सिर्फ़ यही map आपको याद रखना है। यही वही map है जो sidebar पहले से दिखाता है: पहले Foundations, फिर General Agents, फिर Personal Agent Harnesses, जहाँ हर कोई अपना persistent agent हासिल करता है, फिर दो tracks में से एक, Mode 1 या Mode 2, और अंत में References & Companions। बीच में सिर्फ़ एक decision है, कौन सा mode, और उस decision से पहले की हर चीज़ हर reader के लिए common है।

Curriculum को map की तरह देखें। ऊपर से नीचे एक shared trunk चलता है: Foundations, फिर General Agents, फिर Personal Agent Harnesses (persistent agent own करना)। Personal Agent Harnesses से path "mode चुनें" fork तक पहुँचता है जो दो tracks में split होता है: Mode 1, Problem-Solving (एक problem को एक बार solve करना), और Mode 2, Manufacturing (ऐसा worker बनाना जो वही काम करे), और दोनों tracks नीचे References & Companions में मिलते हैं। Fork से पहले की हर चीज़ हर reader के लिए shared है; mode ही एक बड़ा decision है।

पहले thesis पढ़ें। इसके दो versions हैं, एक technical और business professionals के लिए, और एक absolute beginners के लिए, ताकि background कुछ भी हो, हर कोई follow कर सके। Thesis के बाद Foundations आते हैं: language model सच में क्या है, prompting, agentic work की दो document languages, वह code commission करना जो आप कभी नहीं लिखते, AI को task एक बार सिखाना और उसे अपने apps से connect करना, और AI era में सोचना सीखना। Mode चुनने से पहले हर reader ये courses लेता है।

आप कहाँ से शुरू करते हैं? Browser में। आपके पहले छह courses, Foundations, chat tab में चलते हैं: Claude.ai, ChatGPT या Gemini, कुछ भी install किए बिना, चाहे आप पहले से code कर सकते हों या नहीं। वही browser tab वह जगह है जहाँ everyday AI value का बड़ा हिस्सा पहले से मौजूद है। जब काम को आपकी real files चाहिए होती हैं, तब आप अपनी machine पर चलने वाले general agent तक आगे बढ़ते हैं, और agentic work की तीन layers शुरू होती हैं।

आपको यह mental model चाहिए: AI era में काम तीन layers में होता है। आप problems solve करने के लिए general agents इस्तेमाल करते हैं। आप specialized jobs करने के लिए AI Workers बनाते हैं। आप उन Workers को जोड़कर AI-Native Companies assemble करते हैं। हर professional engagement एक ही तरह शुरू होता है: एक इंसान general agent को direction देता है। बस सवाल यह है कि कौन सा agent, और यह इस पर depend करता है कि आप क्या हासिल करना चाहते हैं।

note

नामों पर छोटी note। इस book में AI Worker, Digital FTE, और AI Employee एक ही idea को बताते हैं: human-defined policy के तहत real job करने वाला specialized agentic system। Business value पर ज़ोर देते समय हम Digital FTE इस्तेमाल करते हैं, implementation पर ज़ोर देते समय AI Worker, और company के अंदर role पर ज़ोर देते समय AI Employee। किसी भी दूसरे unfamiliar term के लिए glossary आपकी मदद करेगा।

यही तीन layers वह arc हैं जिस पर यह section आपको अभी की जगह से आगे ले जाता है:

Beginner से AI-Native Company Architect तक seven-stage journey, तीन layers के हिसाब से color-coded। Layer 1, general agent use करना: Stage 1 Beginner, prompting से thinking तक छह Foundations, सब browser में (आप यहाँ हैं); Stage 2 Agent User, Claude Code या Cowork जैसे general agent को real work पर direct करना; Stage 3 Personal Agent Harnesses, persistent agent own करना (OpenClaw या Hermes), जो हर कोई mode pick करने से पहले करता है। Layer 2, AI Workers बनाना: Stage 4 Agent Builder, OpenAI Agents SDK से अपना पहला agent बनाना; Stage 5 Worker Builder, उस agent को durable Digital FTE में बदलना। Layer 3, AI-Native Company बनाना: Stage 6 Workforce Builder, control plane, hiring, और delegate के साथ workforce govern करना; Stage 7 AI-Native Company Architect, हर Worker को evals से prove करना और cloud पर deploy करना। ज़्यादातर readers stage 4 या 5 पर रुकते हैं।

आपको पूरा path चलना ज़रूरी नहीं है। ज़्यादातर readers stage 4 या 5 पर रुकते हैं, और serious career या first startup के लिए इतना काफी है। Full path तब है जब आप उसे चाहते हैं।

अपना Mode चुनें​

यही decision पास से देखें: AI इस्तेमाल करने और ऐसा AI बनाने के बीच fork जो आपके लिए काम करे। पहले इसे abstract रूप में लें, फिर अपनी row ढूँढें।

Thesis का section general agents इस्तेमाल करने के दो modes उन दो तरीकों को बताता है जिनसे लोग सच में general-purpose agents इस्तेमाल करते हैं। Mode 1 तब, जब आप AI से अपना काम करवाना चाहते हैं। Mode 2 तब, जब आप ऐसा AI बनाना चाहते हैं जो आपके लिए काम करे। "Manufacturing" नाम industrial लगता है, और है भी: Workers बनाना उन्हें इस्तेमाल करने से अलग discipline है।

एक चीज़ decision नहीं बदलता: Foundations के ठीक बाद हर कोई general agent चुनता है, Course 7 या Course 8। Mode decision आपको track पर route करता है; यह decide नहीं करता कि आप general agent इस्तेमाल करेंगे या नहीं। आप हमेशा करते हैं।

Mode 1 बनाम Mode 2: Mode 1 में agent काम करता है; Mode 2 में agent ऐसा Worker बनाता है जो काम करता है

Mode 1: Problem-SolvingMode 2: Manufacturing
इसे चुनें अगर आप...चाहते हैं कि AI आपको काम तेज़ करने में मदद करेऐसे AI Workers बनाना चाहते हैं जो आपके लिए काम करें
किसके लिए हैकोई भी: engineers या knowledge workersEngineers, या engineer के साथ paired knowledge worker
आपका toolClaude Code/OpenCode या Claude Cowork/OpenWorkबनाने के लिए Claude Code/OpenCode; course pages वे concepts सिखाते हैं जिन्हें आप पहले खुद पढ़ते हैं, फिर agent से बनवाते हैं
यहाँ से शुरू करेंCourse 7 (engineers) या Course 8 (knowledge workers)Course 20: AI Agents बनाएँ
आप क्या बनाते हैंपूरा हुआ कामऐसा Worker जो अपने आप काम निकालता है
किससे governed हैProblem Solving के सात principlesAgent Factory के सात invariants

Fork से पहले एक note। Mode pick करने से पहले हर कोई एक shared step लेता है: खुद को अपना persistent personal agent देना। यही Personal Agent Harnesses section है (OpenClaw with General Agents, Course 11, और Hermes with General Agents, Course 12)। यह shared path का step है, mode नहीं: आप यहाँ अपना agent बनाते हैं, फिर Mode 1 या Mode 2 choose करते हैं।

Mode 2 पर ध्यान दें। General agent का output अंतिम नतीजा नहीं है; वह Worker है जो नतीजा देता है। Developer Claude Code से code-reviewing Worker को spec करता, बनाता और deploy करता है। Finance analyst, engineer के साथ मिलकर, Claude Code से ऐसा close-process Worker spec करता है जो हर month-end run करता है। Tool वही, discipline वही, domain अलग।

आपका शुरुआती path​

अगर Mode picker अभी भी abstract लग रहा है, तो वही फैसला पूरी तरह concrete terms में यहाँ है: जो row आपसे match करे उसे चुनें और सबसे बाएँ वाले course से शुरू करें। हर path universal Foundations (Courses 1-6) से शुरू होता है।

आप हैं...आपका शुरुआती pathपहला पड़ाव
बिल्कुल नए readerThesis → Course 1 (AI क्या है) → Course 2 (Prompting) → Course 3 (Markdown & HTML) → Course 4 (Code जो आप कभी नहीं लिखते) → Course 5 (Skills & Connectors) → Course 6 (Thinking)Foundations तैयार; नीचे किसी mode के साथ आगे बढ़ें
Knowledge workerFoundations (Courses 1-6) → Course 8 (Cowork) → Course 11 या 12 (coding agent के ज़रिए अपना harness own करें) → Course 13 (क्या यह Agent Problem है?) → Course 14 (Principles)AI के साथ असली knowledge work पूरा करें
EngineerFoundations (Courses 1-6) → Course 7 (Claude Code) → Course 11 या 12 (अपना harness own करें) → Course 20 → Course 22 (FTE)अपना पहला Digital FTE तैयार करें
Workforce builderEngineer path, फिर Course 25 (Paperclip) → Course 28 (Evals) → Course 29 (Deploy)Governed AI workforce, cloud पर deploy

Courses​

आपने call कर ली है, इसलिए यहाँ हर course है, ठीक उसी grouping में जो sidebar दिखाता है, साथ में सबसे तेज़ route और पूरी list से पहले हर depth का time।

tip

कई courses में Reader track है: एक conceptual, no-build pass जिसे आप काम समझने और direct करने के लिए लेते हैं, हर line implement करने के लिए नहीं। जहाँ यह offered है वहाँ इसे use करके, Digital FTE ship करने का सबसे तेज़ path है Foundations (Courses 1-6) → Course 7 → Course 20 → Course 22 → Course 28 (Reader track): लगभग 15 hours का focused काम। बाकी courses उस Digital FTE को governed workforce में बदलते हैं, लेकिन पहला ship करने के लिए वे ज़रूरी नहीं हैं।

गहराई के हिसाब से कुल समय: Mode 1 (AI के साथ productive) ~8h · Mode 2 minimum (पहला Digital FTE) ~15h · Mode 2 full (governed workforce) ~28h · Full Agent Factory mastery ~48h (cloud deployment course के साथ)।

नीचे दिए गए छह Foundations सबके लिए common हैं; उसके बाद path mode के हिसाब से split होता है।

Foundations (सबके लिए)​

  1. AI सच में क्या है: बिना math और बिना code का mental model, उस machine का जो हर दूसरे course के नीचे बैठी है। नौ ideas जो बताते हैं कि language model चीज़ें look up करने के बजाय predict क्यों करता है, गलत होने पर भी confident क्यों लगता है, "strawberry" में letters गलत क्यों गिनता है, और उसकी skill jagged क्यों होती है। इसे पहले पढ़ें, और नीचे के courses में हर "इसने ऐसा क्यों किया?" का जवाब पहले से तैयार मिलेगा। लगभग 45 minutes।

  2. 2026 में AI Prompting: 2026 में ChatGPT, Claude और Gemini को अच्छे से इस्तेमाल करने पर 45-minute, 13-concept परिचय: context, reasoning modes, deep research, multimodal और AI desktop apps। वे mechanics जिन्हें इस book का हर chapter मानता है कि आप पहले से जानते हैं।

  3. Markdown In, HTML Out: Agentic काम की दो document languages पर 13-concept परिचय: machine के लिए काफ़ी precise Markdown specs लिखना, headings, lists, fences, links, और grade-to-9 validation loop वाला spec skeleton, और इंसान के लिए काफ़ी rich HTML output माँगना, साथ में वह publishing ladder जो artifact को share करने लायक link में बदल देती है। Closing prompts समेत लगभग 90 minutes। पहले करें: Course 2.

  4. Code जो आप कभी नहीं लिखते: AI से ऐसा code लिखवाने, run करवाने और verify करवाने पर 13-concept परिचय जिसे आप कभी नहीं पढ़ते। कौन से tasks code problems हैं (Volume, Precision, Repetition, Files), बिना technical words के five-section brief कैसे लिखना है, estimation की जगह computation कैसे force करनी है, ऐसा result कैसे verify करना है जिसे आप पढ़ नहीं सकते, और वे पाँच surfaces जहाँ AI आपके लिए code run करता है: Claude.ai, Claude Code, OpenCode, Cowork और OpenWork। लगभग 1 hour, plus closing prompts और चार projects के लिए 40 minutes। पहले करें: Courses 2 और 3.

  5. Skills और Connectors: दो upgrades पर no-code primer जो chat box को coworker में बदल देते हैं। एक Skill AI को task एक बार सिखाती है, एक SKILL.md जिसे वह तभी load करता है जब request match होती है, ताकि वह हर बार आपके तरीके से काम करे; एक Connector AI को आपके real apps, Drive, Gmail, Slack या tracker, तक safe, permission-scoped access देता है, MCP standard पर। किसे कब use करना है, built-in वाले कैसे use करने हैं, AI से अपना कैसे बनवाना है, वह file आपके लिए लिखता है, और वही पाँच surfaces पर सब safely कैसे करना है, ChatGPT और Gemini equivalents की notes के साथ। Accountants, doctors, marketers, engineers और students के लिए बनाया गया। Closing prompts और projects समेत लगभग 75 minutes। पहले करें: Courses 2-4.

  6. AI युग में कैसे सोचें: वह cognitive discipline जो AI से वास्तविक लाभ लेने वालों को उन लोगों से अलग करती है जो लाभ नहीं ले पाते: agent कब इस्तेमाल करना है, कब नहीं, और problems को कैसे frame करना है ताकि agent सच में मदद कर सके।

General Agents (अपना co-worker चुनें)​

ये general-purpose agents हैं जिन्हें आप आगे आने वाले हर mode में direction देंगे। Engineers coding agent चुनते हैं; knowledge workers desktop co-working agent चुनते हैं। दोनों Mode 2 में भी reuse होते हैं: ये Mode 1-specific नहीं, बल्कि हर mode के नीचे वाला tool layer हैं। यहाँ के आख़िरी दो courses, Spec-Driven Development और Loop Engineering, वे disciplines हैं जिन्हें आप अपने चुने हुए co-worker पर चलाते हैं: क्या बनाना है यह specify करें, फिर वह loop design करें जो उसे आपके लिए बनाता है।

  1. Agentic Coding Crash Course: Claude Code और OpenCode: Claude Code और OpenCode का 90-minute, 15-concept परिचय। Vocabulary वही, keybindings थोड़ी अलग; skills दोनों tools के बीच साफ़ transfer होती हैं। Engineers के लिए general-agent starting point.

  2. Cowork Crash Course: Claude Cowork पर 90-minute, 15-concept परिचय: असली desktop knowledge work delegate करना, autonomy ladder, prompt-injection defenses, और plan-review habit जो ज़्यादातर पछतावे रोकती है। Knowledge workers के लिए general-agent starting point.

  3. Spec-Driven Development: कुछ generate करने से पहले क्या बनाना है इस पर सहमत होने पर 13-concept परिचय: project constitution, चार phases (Research, Specify, Clarify, Build), और वही discipline तीन तरीकों से चलाई गई, claude.ai, Claude Code, और OpenCode में। यह coding skill नहीं बल्कि सोचने की discipline है, इसलिए non-programmers भी इसे चलाते हैं। लगभग 90 minutes, plus दो बार बनाया गया worked example और छह hands-on projects। वह discipline जो आपके चुने हुए co-worker को भरोसेमंद बनाती है।

  4. Loop Engineering: agent को turn-by-turn prompt करने से उस loop को design करने की ओर shift पर 15-concept परिचय जो आपके लिए उसे prompt करता है। आप loop के छह हिस्से सीखते हैं, एक heartbeat, worktree isolation, एक skill, maker-checker sub-agent split, एक connector, और वह state spine जो runs के बीच बची रहती है, दोनों Claude Code और OpenCode में एक बार बनाए गए, फिर एक ही morning-triage-to-PR loop में composed। एक beat के codified body के रूप में dynamic workflows, loop को affordable रखने वाली cost-by-cadence discipline, और क्यों durable skill उन दो छोरों पर रहती है जिन्हें कोई loop कभी automate नहीं कर सकता: intent और accountability। पढ़ने में लगभग दो घंटे, बनाने में ज़्यादा। पहले करें: Course 7; सीधे Course 9 (Spec-Driven Development) पर बनता है।

Personal Agent Harnesses​

एक agent इस्तेमाल करने और एक mode चुनने के बीच का shared step। यहाँ हर कोई खुद को एक persistent personal agent देता है, ऐसा agent जो sessions के पार याद रखता है और आपकी अपनी infrastructure पर चलता है, बजाय हर chat में नए सिरे से शुरू करने के। आप इसे coding agent (Claude Code या OpenCode) को direct करके बनाते हैं; वही install करता है, इसलिए अगर Cowork आपका daily driver भी हो तो इस एक step के लिए coding agent लगाते हैं। यहाँ अपना agent own करें, फिर Mode 1 या Mode 2 pick करें।

  1. OpenClaw with General Agents: 90-minute, 6-scenario hands-on course जहाँ आपका general agent OpenClaw पर Personal AI Employee install और configure करता है: शून्य से फ़ोन पर AI Employee तक, एक custom skill, एक MCP tool, एक heartbeat task, और अंत का ACP-spawn demo जिसमें AI Employee अपना coding agent बुलाता है। Karpathy की "little skill", expanded। पहले करें: Course 7.

  2. Hermes with General Agents: 90-minute, 6-scenario hands-on course जहाँ आपका general agent Hermes (Nous Research) install और run करता है, वह memory-first, self-improving harness: persistent cross-session memory ताकि वह जो सीखे उसे runs के बीच साथ ले जाए, एक learning loop जो हल किए गए कठिन tasks से अपनी skills खुद लिखता है, model-agnostic ताकि आप vendor lock-in से बचें, यह सब आपकी अपनी infrastructure पर चलता है। वही Personal AI Employee idea जो Course 11 में है, लेकिन ऐसे harness पर बना जो जो सीखता है उसे compound करने के लिए design किया गया है। पहले करें: Course 7; Course 11 (OpenClaw) के साथ pair होता है।

Mode 1: Problem-Solving track​

Mode 1 तीन-course arc है: diagnose, solve, cross. आप पहले तय करते हैं कि task सच में agent का काम है या नहीं और कौन-सा mode fit है (Course 13), फिर एक session के अंदर उसे अच्छे से solve करते हैं (Course 14), और जब कोई solve रखने लायक साबित हो जाए, उसे permanent worker में promote करते हैं (Course 15, Mode 2 का bridge).

  1. क्या यह Agent Problem है?: किसी भी agent को खोलने से पहले चलाया जाने वाला दस-minute triage। तीन gates: क्या यह सच में agent job है, या regular tool/chatbot काफी है; क्या आप इसे एक बार करेंगे या हर week करेंगे, यानी Mode 1 या Mode 2; और "finished" दिखता कैसा है? तीन gates, तीन गलत मोड़, एक clear path। अंत में reference card है जो हर answer को 2026 के सही tool से map करता है। यह course आपको ऐसे task पर पूरी session जलाने से बचाता है जो agent का काम था ही नहीं। Beginners और international audience के लिए लिखा गया। Mode 1 का on-ramp और पहला page.

  2. General Agents के साथ समस्या सुलझाना: काम करने की discipline पर 90-minute, 7-principle crash course, जो किसी भी general agent, Claude Code, OpenCode, Cowork या OpenWork, को clever toy से ऐसे tool में बदलता है जिस पर आप असली काम पूरा कर सकते हैं। सात principles चारों tools पर apply होते हैं: Bash को key मानना, code को universal interface मानना, verification को core step बनाना, small reversible decomposition, files में state persist करना, constraints और safety, और observability। इसमें four-phase workflow शामिल है: explore, plan, implement, commit, और capstone exercise।

  3. One-Off से Worker तक: Manufacturing को handoff: यह bridge Mode 1 को बंद करता है और Mode 2 खोलता है। जब कोई task जिसे आप बार-बार हाथ से solve कर रहे हैं, permanent worker बनने लायक proven हो चुका हो, तो उसे promote कैसे करें: एक signal (method अब बदल नहीं रहा), चार promotions (आपका brief → spec, आपकी eyeball check → eval, you-in-the-loop → escalation rule, आपकी session → runtime), और एक fork (personal harness own करें या Digital FTE manufacture करें)। यह Mode 1 से Mode 2 की crossing को cliff से चलने लायक step बनाता है और दिखाता है कि worker ज़्यादातर promotion है, invention नहीं। Mode 1 का आखिरी page; Mode 2 track (Course 16 onward) में handoff.

Mode 2: Manufacturing track​

पहले gateway है। नीचे हर course मानकर चलता है कि आप अपने agent का लिखा Python पढ़ सकते हैं, इसलिए अगर आपने कभी code नहीं किया, तो build courses से पहले AI era में Python से शुरू करें। आपकी पहली build loop से पहले आती है: connector-native app, यानी ऐसा server जिसे आप ship करते हैं और जिसे host का model call करता है, अभी आपकी अपनी agent loop के बिना। वहाँ से manufacturing path सात moves में end-to-end चलता है: Agent बनाएँ, उसे Employee में promote करें, Employees को nervous system से जोड़ें, management add करें, hiring dynamic बनाएँ, founder को free करें, और evals से साबित करें कि पूरी workforce मापने योग्य भरोसेमंद है। उस आखिरी move के बिना manufacturing साबित नहीं की जा सकती: जिन्हें आप measure नहीं कर सकते, वे Workers सच में production में नहीं जा सकते।

  1. AI era में Python: उन लोगों के लिए read-before-you-write primer जिन्होंने कभी code नहीं किया। आप blank page से Python नहीं लिखते; आप अपने agent द्वारा generate किए गए Python को पढ़ना, predict करना, test करना और verify करना सीखते हैं, PRIMM-AI+ method और Test-Driven Generation (TDG) loop के साथ। 17 concepts और छह छोटे projects, एक companion base के साथ जो आपके agent को disciplined tutor में बदल देता है। हर Mode 2 build course जिस literacy gateway को assume करता है, और Part 4 की on-ramp। पहले करें: Course 7.

  2. Connector-Native Apps: pre-loop build course: एक remote MCP server ship करें जिसे free-tier Claude user एक pasted URL और एक Authorize click से add करता है, कभी agent loop लिखने से पहले। Connector-native app के four invariants पर 14 concepts: one gateway, tools only, verified sign-in से identity prove करना, fail closed, जिन्हें OAuth 2.1, two-table Postgres memory, session-init gate और real deploy वाले Reading Room worked example में बनाया गया है। Host model और loop लाता है; आपका server tools, state और identity लाता है। पढ़ने में लगभग 90-120 minutes, build के लिए एक focused day। पहले करें: Courses 7 और 16; path में आगे आने वाला Build AI Agents आपको loop देता है.

  3. AI Agents के लिए Plugins: एक असली plugin बनाएँ और ship करें जो ऐसे AI agent को extend करता है जो आपका अपना नहीं है (Claude Code या OpenCode), और वही bundle claude.ai तक जाते देखें। Agent plugin के four invariants और उसके चार levers (एक skill, एक subagent, एक MCP server, एक hook) पर तेरह concepts, साथ में वह deterministic exit-2 guard जो सलाह को guarantee में बदल देता है। एक tested starter आपको खाली folder से ऐसे plugin तक ले जाता है जिसे teammate एक ही command से install करता है। यह Connector-Native Apps का आईना है: वहाँ आपने chat app extend किया था; यहाँ आप coding agent extend करते हैं। पहले करें: Course 17.

  4. AI Identity: Human Sign-In और Agent Access: identity और access layer, दो हिस्सों में: पहले अपना sign-in own करें (email और social login, sessions, two-factor, और एक OAuth/OIDC server जो असली tokens issue करता है, Better Auth पर बना), फिर एक AI worker को उसका अपना credential दें और किसी व्यक्ति की ओर से काम करने का एक scoped, time-boxed, revocable, human-approved तरीका दें। मुख्य सूत्र: यह identity किसकी है, और authority इंसान से agent तक कैसे pass होती है? Human sign-in आज production-grade है; agent identity अभी settle हो रही है, इसलिए course durable primitives पर टिका है। पहले करें: Course 17.

  5. AI Agents बनाने का crash course: OpenAI Agents SDK पर 90-minute, 16-concept परिचय: agent loop, tools, sessions, streaming, handoffs, guardrails, tracing, day-1 evals, human approval, Cloudflare पर sandboxed deployment, और cost discipline के लिए DeepSeek V4 Flash। पहले करें: Course 7.

  6. अपने AI को searchable context दें: Postgres और pgvector पर RAG: अपने AI को searchable context देने पर 15-concept परिचय: आप अपने agent को direction देते हैं कि वह Neon + pgvector को working RAG system में बदले: schema, embedding worker, chunking, semantic और hybrid search, eval-driven retrieval, और ऐसा read-only RAG MCP server जिसे कोई भी agent call कर सकता है। वह retrieval foundation जिस पर Digital FTE बनता है, उसी Manufacturing base से। पढ़ने में ~90 minutes plus एक build। पहले करें: Course 7.

  7. Agent से Digital FTE तक: Basic agent को durable Worker में बदलने पर 4-hour workshop: portable Skills, system of record के रूप में pgvector वाला Neon Postgres, उनके बीच wire के रूप में Model Context Protocol, audit-trail discipline, authority model के रूप में approval, और end-to-end बनाया गया customer-support Worker। 15 concepts, 8 build decisions। पहली Quick Win 15 minutes में; cheat-sheet skim 90 में; पूरा build लगभग 3 और hours में। पहले करें: Course 20.

  8. Digital FTE से nervous system वाले production Worker तक: आपके Digital FTE को Inngest operational envelope में wrap करने पर 90-minute, 15-concept course: durable execution, event-driven triggers, step memoization, concurrency और throttling, replay, और HITL gates। Customer-support Worker को extend करता है ताकि वह network की छोटी failures, restarts और लंबे समय तक pending approvals झेल सके। पहले करें: Course 22.

  9. Human-Agent Teams: आपकी Workforce का Operating Model: इंसानों और Digital FTEs को एक ही team की तरह चलाने का operating model: खुले में काम, clear roles वाला एक roster, एक north star, और ऐसा भरोसा जो verified reliability के साथ बढ़ता है। कोई code नहीं; आप अपने agent को direction देते हैं कि वह आठ operating documents draft करे (roster, role cards, north star, verification rubric, doer-verifier, weekly report, attention budget) और आप एक असली team का operating manual लेकर निकलते हैं। पहला worker बनने से पहले planning mode में किया जा सकता है। पहले करें: planning mode के लिए Course 7; live mode एक Digital FTE (Course 22) मानकर चलता है।

  10. Paperclip के साथ Workforce बनाना: 90-minute, 6-scenario hands-on course जहाँ आपका coding agent Paperclip (open-source, MIT-licensed AI-native company control plane) set up करता है, keyless local Worker hire करता है, permanent audited decision record के रूप में board approval file करता है, वास्तविक Gemini-backed Worker लगाता है ताकि budget के पास आखिरकार billable काम meter करने को हो, और activity log के against एक SQL query से पूरी company history दोबारा बना देता है। Scenarios 1-4 और 6 को API key नहीं चाहिए; सिर्फ़ budget scenario को मुफ़्त Gemini key चाहिए। पहले करें: Course 22 या Course 11.

  11. Fixed से Dynamic Workforce तक: Half-day, 15-concept और 7-decision workshop जहाँ Course 22 की workforce capability gap detect करती है, hire proposal draft करती है, उसे उसी approval primitive से पास करवाती है जो $500 refund gate करता है, और Claude Managed Agents पर Legal Specialist provision करती है। Hiring as a callable function। Invariant 6 पूरा करता है: workforce policy के तहत expandable है। पहले करें: Course 25.

  12. Founder Bottleneck से Owner Delegate तक: Half-day, 15-concept और 7-decision workshop जहाँ workforce owner OpenClaw पर Owner Identic AI configure करता है: यह routine Paperclip approval requests पढ़ता है, signed delegated envelope के अंदर वाले requests clear करता है, और सिर्फ़ वे decisions सामने लाता है जिन्हें सच में इंसान चाहिए। Owner आखिरी bottleneck है; यह course उसे हटाता है। Invariant 2 पूरा करता है: हर इंसान को delegate चाहिए। Mock endpoints, rules templates और sample judgment context के साथ downloadable शुरुआती lab zip देता है। पहले करें: Course 26.

  13. AI Employees के लिए Eval-Driven Development: वह discipline जो manufacturing arc पूरा करती है और Courses 7 से 27 तक बनी हर चीज़ को wrap करती है। सीखने के चार रास्ते: Reader (~3-4 hours, conceptual), Beginner (~1 day), Intermediate (~2 days), Advanced (~3 days for full implementation)। 15 concepts plus a 7-decision lab। Nine-layer evaluation pyramid सिखाता है: unit, integration, output, tool-use, trace, RAG, safety, regression, production, और उसे भरने वाला four-tool stack: trace grading के साथ OpenAI Agent Evals, DeepEval, Ragas, Phoenix। अंतिम स्थिति: ऐसी workforce जहाँ हर member measurably trustworthy है, weekly trace-to-regression-test promotion ritual के साथ जो eval suite को महीनों तक चलाए रखता है। Reader track leaders के लिए; Advanced track shipping teams के लिए। OpenAI Agents SDK या Claude Managed Agents runtime में से किसी एक को assume करता है.

  14. अपना Agent Harness cloud पर deploy करें: वह course जो manufacturing track में बनी हर चीज़ ship करता है। यह harness/sandbox split सिखाता है: control plane, यानी harness जो secrets hold करता है, agent loop run करता है और state रखता है, execution plane से अलग security boundary में रहता है, यानी sandbox जहाँ agent का generated code सच में run होता है। आप एक complete production path deploy करते हैं: harness के लिए Azure Container Apps पर FastAPI, durable state के लिए Neon Postgres, files के लिए Cloudflare R2, code-execution sandbox, four-surface observability, और CI gate के रूप में wired Course 28 eval suite। सीखने के चार रास्ते: leaders और architects के लिए Reader; shipping teams के लिए Beginner से Advanced तक; 17 concepts और 9-decision agent-driven lab जहाँ आपका coding agent companion AGENTS.md पढ़कर harness बनाता है जबकि आप उसे direction देते हैं। पहले करें: Course 28; Decision 8 उसका eval suite wire करता है। Reader track को cloud accounts नहीं चाहिए.

  15. Agentic Architectures चुनना: Pattern selection पर conceptual crash course: आपके task के बारे में पाँच सवाल चार core patterns में से एक तक map करते हैं (sequential workflow; single agent + ReAct + tools; planning + ReAct execution; multi-agent specialist), plus additive layer के रूप में reflection। Discipline यह है कि impressive दिखने वाली चीज़ से नहीं, architectural fit से चुनना है: हर pattern task के बारे में एक bet है, और सही bet वही है जिसकी assumptions reality से match करती हैं। पाँच-सवाल decision tree, दो बराबर common failure modes, overshooting और undershooting, mismatch दिखाने वाले runtime signals, और हर pattern आपकी deployment topology और eval suite के साथ कैसे compose होता है, यह सिखाता है। सीखने के चार रास्ते: Reader ~2-3 hours conceptual; Beginner ~1 day; Intermediate ~2-3 days; Advanced ~4-5 days, five-case decision lab, और design reviews के लिए printable classify-this-task worksheet। पहले करें: आप agents बना और evaluate कर सकते हैं; agent-building, operational-envelope और eval courses को cross-reference करता है.

  16. Payment-Enabled Agents: ACP, AP2, x402 और MPP: Agents को money move करने देने वाले चार protocols पर multi-track crash course: consumer shopping के लिए ACP, authorization mandates के लिए AP2, HTTP-native machine payments के लिए x402, और session-based settlement के लिए MPP। मुख्य बात: ये चार layers हैं, rivals नहीं। आप use case पढ़ते हैं, हर layer (discovery, authorization, commerce, settlement) के लिए एक protocol चुनते हैं, और उन्हें OpenAI Agents SDK code के रूप में compose करते हैं, tool-input guardrail के साथ जो payment होने से पहले रोक देता है। सीखने के चार रास्ते: Reader ~2-3 hours conceptual; shipping teams के लिए Beginner से Advanced तक; 19 concepts, five-decision lab, और three-level spend-limit discipline जो runaway agent को wallet खाली करने से रोकती है। पहले करें: Course 20 (OpenAI Agents SDK); Course 23 (Inngest) और Course 29 (cloud deployment) के साथ pair होता है.

References & Companions​

  1. 2026 में कौन से AI Employees इस्तेमाल करें?: पाँच tools, आपकी identity और need से matched। एक minute से कम में अपनी शुरुआती जगह find करें।

  2. Cheatsheets: इस book के key tools के लिए interactive जल्दी देखने वाले reference cards: Claude Code, Claude collaborative workspace, और OpenClaw।

  3. Agentic Engineering की बुनियाद: उस engineering discipline पर 45-minute परिचय जो इस section की हर चीज़ को सहारा देता है: agent-based systems को उसी rigor के साथ कैसे design, release और operate करें जो आप किसी भी दूसरे production software पर apply करेंगे। Course 22 से आगे जाने वाले किसी भी reader के लिए वैकल्पिक companion read।

Glossary आपका दूसरा लगातार साथ रहने वाला reference है। दोनों tabs में खुले रखें।

पूरा करने पर आपके पास क्या होगा​

जब आप इस section के अंत तक पहुँचेंगे, तो आप सिर्फ़ Agent Factory thesis नहीं समझेंगे; आपने उसके अनुसार बनाया होगा। आपने general agents का इस्तेमाल करके असली काम पूरा किया होगा। आपने कम से कम एक Digital FTE deploy किया होगा जो आपके बिना run करता है। आपने उसे nervous system से जोड़ा होगा, Paperclip-governed workforce के अंदर रखा होगा, उस workforce को अपने colleagues hire करते देखा होगा, और Identic AI के ज़रिए खुद को उसका bottleneck होने से मुक्त किया होगा। आपने पूरी चीज़ को अपने लिखे evals में wrap किया होगा, ताकि आप साबित कर सकें, सिर्फ़ उम्मीद न करें, कि हर Worker trustworthy है।

यही इस book और हर दूसरे AI course के बीच अंतर है: आप notes के साथ finish नहीं करते। आप काम करती AI workforce के साथ finish करते हैं।

और book काम की रहती है: chapters वही reference हैं जिसे आप अटकने पर खोलते हैं।

इस section के बाद सब कुछ वही निखारता है जो आप पहले ही बना चुके हैं। अब अपना mode चुनें और शुरू करें।