31 AI Coding Agent Terms जो आपको पता होने चाहिए, पांच Pillars में

हर हफ्ते कोई नया term feed में आ जाता है। Context engineering। Harness engineering। RLM। Progressive disclosure। AI coding agents रोज़ use करता हूं, और vocabulary उस रफ्तार से बढ़ रही थी जो समझ से तेज़ थी।

तो मैंने रुककर अपने इकट्ठे किए सभी 31 terms को groups में sort किया। पांच pillars सामने आए, और जैसे ही ये दिखे, Claude Code और Codex जैसे tools की पूरी architecture एक नई clarity के साथ समझ में आई।

पांच pillars एक logical sequence follow करते हैं: आप design करते हैं कि agent क्या देखता है, काम को agents में divide करते हैं, execute कैसे होगा उसे control करते हैं, sessions के पार memory बनाते हैं, और बाहरी दुनिया से connect करते हैं।

Design. Divide. Control. Remember. Connect.

Agent क्या देखता है, उसे Design करना

AI model सिर्फ एक चीज़ process करता है: उसकी context window। हर system prompt, user instruction, attached file, conversation history entry, memory block, और loaded skill एक single stream of tokens में concatenate हो जाते हैं। वो stream ही model की पूरी दुनिया है। AGENTS.md, जिसे बहुत सी teams agent behavior configure करने के लिए use करती हैं, उस stream का बस एक और हिस्सा है।

Prompt वो direct instruction है जो आप model को देते हैं। Prompt engineering उन instructions को design करने की practice है, जिसमें examples और output formats शामिल होते हैं, ताकि reliable results मिलें। ये दोनों terms establish हो चुके हैं, लेकिन ये model में जो actually जाता है उसका सिर्फ एक छोटा हिस्सा cover करते हैं।

Context वो सब कुछ है जो model reference कर सकता है: system prompts, conversation history, attached files, memory, skills, और tool outputs मिलाकर। Context engineering वो discipline है जो decide करती है कि क्या जाएगा, क्या नहीं जाएगा, और किस order में। फर्क मायने रखता है। मैंने देखा है कि identical prompts बिल्कुल अलग results देते हैं, बस इस बात पर निर्भर करते हुए कि 2,000-line की file instruction से पहले थी या बाद में। Order cosmetic नहीं होता।

Intent user का actual goal होता है, जो उन्होंने literally टाइप किया उससे अलग हो सकता है। जब आप लिखते हैं “fix the tests,” तो intent हो सकता है “CI green करो” या “test suite को नए API से match करने के लिए refactor करो।” Agent routing यहीं से शुरू होती है, और intent गलत समझना downstream सब कुछ affect करता है।

Skill expert instructions का एक reusable bundle होता है जो invoke करने पर context में load हो जाता है। इसे prompts के लिए एक function की तरह समझें। हर बार same 200-line instruction paste करने की जगह, आप /refactor-clean call करते हैं और skill का content on demand context window में आ जाता है।

Progressive disclosure वो design pattern है जहां आप सभी skills को एक साथ context में load नहीं करते। बल्कि, agent सिर्फ वही skill load करता है जो उस moment चाहिए। Anthropic ने इस approach को अपने skills blog post में publish किया। यह इसलिए मायने रखता है क्योंकि context window space finite है। 40 skills upfront load करने से model के काम शुरू करने से पहले ही tokens जल जाते हैं। Progressive disclosure window को lean और model को focused रखती है।

शुरुआत में बार-बार मैं यही गलती करता था: context में बहुत ज़्यादा ठूंस देता और सोचता रहता कि model का output quality क्यों खराब हो गई। 200K context window एक theoretical maximum है। Reality में, system prompts, MCP server definitions, और conversation history के बाद usable space 70K या उससे कम हो सकती है। Context engineering उस constraint को respect करने के बारे में है।

Agents में काम Divide करना

एक अकेला agent सब कुछ handle करे, यह simple लगता है जब तक context window भर न जाए और output quality गिर न जाए। इसीलिए multi-agent architectures exist करते हैं।

Subagent एक child process होता है जिसे main agent काम delegate करता है। Main agent अपनी context clean रखता है specialized tasks offload करके। Claude Code में जब आप background research task launch करते हैं, तो वो एक subagent होता है जो अपनी context window में operate करता है और सिर्फ result वापस करता है।

Swarm एक pattern है जहां multiple agents एक ही problem के अलग-अलग हिस्सों पर parallel में काम करते हैं। अगर आपको एक साथ पांच files analyze करनी हैं, तो swarm पांच agents को एक-एक file handle करने देता है बजाय एक agent के sequentially करने के।

Fleet आपके running agents का operational view है। यह एक management term है, architecture term नहीं। जब आपके तीन subagents और दो background agents active हों, तो वो collection आपकी fleet है।

Handoff एक agent (या person) से दूसरे को काम का transfer होता है। Sequential workflows में, Agent A अपना phase complete करता है और Agent B को handoff करता है। ज़रूरी detail यह है कि transfer क्या होता है: सिर्फ output, या पूरा context? ज़्यादातर handoffs एक summary transfer करते हैं, जिसका मतलब है कि information loss possible है और उसे account में रखना चाहिए।

Background agent asynchronously run होता है, user interaction के बिना। GitHub का Copilot Workspace और Anthropic का Claude Code दोनों इस pattern को support करते हैं। आप एक task describe करते हैं, laptop बंद करते हैं, और agent independently काम करता रहता है। Results लौटने पर मिलते हैं।

जो trap मुझे लगा: बहुत जल्दी काम को बहुत ज़्यादा agents में split करना। एक single agent जिसका context well-designed हो, 80% tasks को एक poorly coordinated multi-agent setup से बेहतर handle करता है। Split तभी करें जब evidence हो कि single agent context limits या quality degradation hit कर रहा है।

Agents Execute कैसे करें, उसे Control करना

एक agent जो correct code generate करे, बेकार है अगर वो चुपचाप dangerous tools भी call करे या जो files उसे नहीं छूनी चाहिए उन्हें modify करे। Control तीसरा pillar है, और यही वो pillar है जिसमें ज़्यादातर teams कम निवेश करती हैं।

Harness वो operational frame है जो agent के execution, verification, और lifecycle को wrap करती है। इसमें permission checks से लेकर output validation और retry logic तक सब आता है। Harness engineering उस frame के भीतर constraints और feedback loops design करना है। OpenAI ने इस term को mainstream में लाया जब उन्होंने publish किया कि Codex ने structured harness patterns से एक million से ज़्यादा lines of code generate किए।

Trace हर उस step और decision का execution log होता है जो agent ने लिया। मैंने traces को seriously लेना तब शुरू किया जब पता चला कि एक agent एक task पर web search tool 14 बार call कर रहा था जबकि information एक बार में मिल जाती। Trace के बिना मैं assume करता रहता कि agent efficiently काम कर रहा है। Traces AI agents के लिए debugging के सबसे करीब की चीज़ हैं।

Diff code का comparison होता है agent के changes से पहले और बाद का। Traces के साथ मिलकर, diffs verification की backbone बनाते हैं। आप वो review नहीं कर सकते जो आपको दिखे ही न, और diffs agent changes को उसी तरह reviewable बनाते हैं जैसे pull requests human changes को।

Guardrails वो rules और validation checks हैं जो dangerous outputs को रोकते हैं। ये उतने simple हो सकते हैं जितना “कभी rm -rf वाले shell commands execute मत करो,” या उतने sophisticated जितने content classifiers जो sensitive data को outputs में आने से रोकें।

Sandbox एक isolated execution environment होता है restricted permissions के साथ। Codex एक Docker sandbox के अंदर run होता है जहां agent code लिख सकता है और tests run कर सकता है लेकिन network access नहीं है और host system modify नहीं कर सकता। यही फर्क है “agent ने mistake की” और “agent ने ऐसी mistake की जिसने production affect किया” के बीच।

CLI (command-line interface) agent era में वापस आ रहा है। Terminal के ज़रिए tools run करना protocol layers के through routing से ज़्यादा token-efficient निकलता है। जब हर token का पैसा लगता है और context space लेता है, तो CLI की directness मायने रखती है।

REPL (read-eval-print loop) code तुरंत execute करने का interactive environment है। Agents REPLs का use hypotheses test करने, intermediate results validate करने, और पहले files disk पर लिखे बिना solutions पर iterate करने के लिए करते हैं।

Sessions के पार याद रखना

Large language models की एक hard boundary होती है: context window। जब वो भर जाती है, तो पुराना content evict हो जाता है। जो tasks घंटों या दिनों तक चलती हैं, उनके लिए यह एक real problem है।

Memory कोई भी system है जो conversation history और task state को एक single context window से आगे store करता है। Memory hierarchy इन stores को layers में organize करती है, आमतौर पर short-term (current conversation), medium-term (recent sessions), और long-term (persistent knowledge)। यह design CPU cache hierarchies को parallel करता है उसी reason से: अलग-अलग access patterns को अलग-अलग storage strategies चाहिए।

Embeddings text को numerical vectors में convert करते हैं जो semantic meaning capture करते हैं। ये RAG (retrieval-augmented generation) की foundation हैं, जहां एक agent vector database search करता है relevant information अपनी context window में pull करने के लिए। जब आपका agent पिछले session की कुछ “याद” करता है, तो वो usually एक embedding-based similarity search perform कर रहा होता है।

Long-running agent multiple context windows के पार state maintain करता है, उन tasks पर काम करते हुए जो एक single session से लंबी हों। इसके लिए external state management चाहिए क्योंकि model के पास खुद persistent memory नहीं होती।

Ralph Loop, Geoffrey Huntley का बनाया हुआ, एक autonomous coding loop है जो memory problem को practically solve करता है। हर iteration एक fresh agent instance से शुरू होती है, लेकिन progress git commits और progress files के ज़रिए persist होती है। नया instance git history और progress notes पढ़ता है यह समझने के लिए कि क्या हो चुका है, फिर वहीं से आगे बढ़ता है। यह test-time scaling को maximize करता है बार-बार iterate करके, हर loop repository में accumulated context से benefit लेते हुए।

RLM (Recursive Language Model) एक fundamentally अलग approach लेता है। लंबा input directly model में feed करने की जगह (जहां वो context window exceed कर देता), RLM original data को REPL variables में store करता है और model को उसे explore करने के लिए code लिखने देता है। Model recursive function calls के ज़रिए stored data पर targeted queries issue करता है। चूंकि original data कभी context window में enter नहीं करती, information truncation से कभी lose नहीं होती। Authors का claim है कि यह approach normal context window के 100x के equivalent inputs handle करती है।

दोनों approaches एक ही constraint को acknowledge करते हैं लेकिन अलग तरह से solve करते हैं। Ralph Loop context window की limitations के साथ काम करता है external persistence use करके। RLM context window को entirely bypass करता है data को बाहर रखकर। कोई universally better नहीं है; सही choice इस पर depend करती है कि आपका bottleneck task continuity है (Ralph Loop) या input size (RLM)।

Agents को बाहरी दुनिया से Connect करना

एक agent जो external tools, APIs, या services तक नहीं पहुंच सकता, सिर्फ text generation तक सीमित रह जाता है। Protocols integration problem solve करते हैं।

MCP (Model Context Protocol) standardize करता है कि models external tools से कैसे connect होते हैं। MCP के बिना, N models को M tools के साथ integrate करने के लिए N x M custom implementations चाहिए। MCP के साथ, हर model और हर tool एक बार protocol implement करते हैं, integration cost N + M तक घट जाती है। यही principle USB को successful बनाता था: एक interface पर agree करो, और सब कुछ connect हो जाता है।

ACP (Agent Communication Protocol) editors और coding agents के बीच communication standardize करता है। Zed और JetBrains इसके development में lead कर रहे हैं। यह MCP जैसी ही problem solve करता है लेकिन एक different layer पर: model-to-tool की जगह, यह editor-to-agent है।

LSP (Language Server Protocol) editor-to-code-analysis-server communication के लिए established standard है। यह original proof है कि developer tools में protocol standardization काम करती है। एक reference search जो grep को 30 seconds लगते, LSP के ज़रिए 50ms में complete होती है। Token usage 2,000+ से घटकर लगभग 500 हो जाता है क्योंकि LSP raw file contents की जगह structured, precise results return करता है। LSP ACP के design के लिए reference model भी है, जो sense बनाता है: problem shapes लगभग identical हैं।

ये तीनों protocols अलग-अलग layers पर operate करते हैं लेकिन एक ही architectural insight share करते हैं। Custom point-to-point integrations scale नहीं होते। Standard interfaces होते हैं।

नक्शा, इलाका नहीं

इनमें से ज़्यादातर terms छह महीने पहले exist नहीं करते थे। अगर ये unfamiliar लगें, तो यह expected है। Vocabulary इसलिए बढ़ रही है क्योंकि field बढ़ रही है, और नए concepts को नाम चाहिए।

इन पांच pillars का value definitions memorize करने में नहीं है। यह उस mental framework में है जो बताता है कि कोई नया term encounter होते ही वो कहां fit होगा। जब कोई “agent memory” mention करे, आप जानते हैं यह चौथे pillar में आता है। जब कोई नया protocol launch हो, आप जानते हैं यह पांचवें में है। Framework नई vocabulary को absorb करता है बिना टूटे।

मैं अभी भी regularly terms search करता हूं। फर्क बस यह है कि अब मुझे पता है वो किस shelf पर जाएंगे।