🌍 धडा 08 — Agent patterns: teams, critics, आणि कधी नाही

📍 तुम्ही इथे आहात: 8 पैकी धडा 08 — शेवटचा धडा!

📦 या ब्रँचमध्ये काय आहे

संपूर्ण course, आणि प्रत्यक्ष deployments वापरतात ते पाच patterns — प्रत्येक दोनदा काढलेला (क्रमांकित flow + sequence diagram) 🌐 patterns page वर ← हे शेजारी उघडून ठेवा.

🧒 पाच patterns, शाळेच्या भाषेत

1. 🧍 एकटा कर्ता (single agent + tools) — आपला agent.py: एक विद्यार्थी, एक पट्टा, एक loop. इथून सुरुवात करा, आणि जितके दिवस जमेल तितके इथेच राहा — प्रत्यक्षातले बहुतेक मोल याच रूपात ship होते.

2. 🗺️ Planner + executor — एक विद्यार्थी project चे तुकडे पाडतो ("अभ्यास सहल: 1 शहर निवडा, 2 train book करा, 3 सामानाची यादी"), मग checklist एकेका मुद्द्याने पूर्ण करतो (किंवा मुद्दे कर्त्यांकडे सोपवतो). लांब कामांवर वीरश्रीपेक्षा रचना सरस ठरते — L04 मधली कामांची यादी, आता पहिल्या दर्जाच्या artifact च्या पदावर.

3. 🧑‍🏫 Critic loop (generate → check → fix) — एक विद्यार्थी लिहितो, दुसरा rubric नुसार GRADE देतो ("tests pass? स्रोत दिले?"), आणि grade हिरवा होईपर्यंत लिहिणारा दुरुस्त्या करतो. critic एखादे model असू शकते, पण सर्वोत्तम critics निर्दय आणि यांत्रिक असतात: test runners, compilers, linters (मतांपेक्षा खरे सत्य सरस — L06).

4. 🚧 Human-in-the-loop — विद्यार्थी सगळे तयार करतो; उलटता न येणाऱ्या step ला (deploy, send, pay) माणूस मंजुरी देतो. हे gate तुम्ही आतापर्यंत प्रत्येक शाळेत पाहिले आहे (इथे L05, MCP L05, ArgoCD चे sync button) — कारण संपूर्ण सभ्यता याच pattern वर चालते: मसुदे वाहतात, सह्या थांबवतात.

5. 👯 Team (multi-agent) — researcher, writer, checker, प्रत्येकाचा स्वतःचा पट्टा आणि desk, एकमेकांना artifacts देत. खरोखर समांतर कामासाठी शक्तिशाली; पण खर्च, latency आणि L06 चे compounding देखील गुणाकाराने वाढवते (researcher कडून आलेले एक चुकीचे "तथ्य" पुढच्या सगळ्यांना विषारी करते). Teams ना foreman लागतो: स्पष्ट हस्तांतरण, तपासता येणारे artifacts, एकच जबाबदार output.

आणि pattern शून्य — agent अजिबात नाही 🙅: steps माहीत आणि ठरलेल्या असतील, तर SCRIPT लिहा (स्वस्त, निश्चित, debug करता येणारा). एकच model call पुरेसा असेल, तर एकच call करा. मार्ग खरोखर वाटेत काय सापडते त्यानुसार बदलत असेल तेव्हाच agents त्यांच्या गुंतागुंतीचे मोल देतात. सर्वोत्तम agent architects दर आठवड्याला "याला agent ची गरज नाही" असे म्हणतात.

🗺️ आकृती (निर्णय, थोडक्यात)

flowchart TB
    q["a job arrives 📥"]
    s["🙅 steps known & fixed?<br/>→ write a SCRIPT"]
    one["🗣️ one answer needed?<br/>→ one model call"]
    solo["🧍 path varies by discovery?<br/>→ SOLO agent + tools (start here)"]
    plan["🗺️ long/structured?<br/>+ planner & checklist"]
    crit["🧑‍🏫 quality-critical?<br/>+ critic loop (prefer test runners)"]
    hitl["🚧 irreversible steps?<br/>+ human gates (always)"]
    team["👯 truly parallel workstreams?<br/>+ a team — with a foreman"]
    q --> s --> one --> solo --> plan --> crit --> hitl --> team

❓ काय (पुन्हा पुन्हा वापराल अशी checklist)

प्रत्येक pattern म्हणजे त्याच loop ची रचना — L02 चे तीन ठोके, वेगळ्या प्रकारे गुंडाळलेले. कोणत्याही framework ची आकृती वाचा आणि आता तुम्हाला दिसेल: planners म्हणजे संरचित output असलेले brains; critics म्हणजे दुसरा loop ज्याची tools graders आहेत; teams म्हणजे artifacts देवाणघेवाण करणारे loops.
अंदाजापेक्षा artifacts: हस्तांतरण तपासता येणाऱ्या गोष्टी असतील तेव्हाच patterns चालतात (files, PRs, JSON) — chat transcripts नाही.
प्रत्येक pattern साठी evals (L06): solo = परिणाम तपासणी; critic = grade खरोखर गुणवत्तेशी जुळतो का?; team = end-to-end आणि प्रत्येक भूमिकेसाठी.
खर्चाचे भान: जोडलेली प्रत्येक भूमिका tokens आणि latency गुणाकाराने वाढवते. patterns page प्रत्येक pattern स्वतःचा खर्च कुठे वसूल करतो ते दाखवते.

🧪 करून पाहा — capstone

तुमच्या आठवड्यातले एक खरे, वारंवार येणारे काम घ्या. निर्णयाची आकृती प्रामाणिकपणे चालून पाहा (script? एक call? solo?). त्यातून agent टिकला तर: त्याचा एका पानाचा spec लिहा — goal, पट्टा (READ/WRITE खूण केलेली tools), memory चा आराखडा, guardrails, ते काम झाल्याचे सिद्ध करणारे eval — आणि patterns-page च्या शैलीत त्याचा sequence diagram रेखाटा. तेच पान म्हणजे team ज्यावरून बांधकाम करू शकेल असा deliverable. 📋

🎓 कर्ता पदवीधर होतो

उत्तरे → परिणाम → loop → पट्टा → pad → नियम → failures ची यादी → file स्वतः → patterns. आता तुम्ही agent बनवू शकता, तो मोडू शकता, सुरक्षित करू शकता, त्याचे eval करू शकता — आणि, सर्वात दुर्मीळ कौशल्य म्हणजे, agent न बनवण्याचा निर्णय घेऊ शकता. 📋🎓

git checkout main
python3 agent/agent.py --drive    # one last errand, for fun

🌍 Lesson 08 — Agent patterns: teams, critics, and when NOT to

📍 You are here: Lesson 08 of 8 — the final lesson!

📦 What's in this branch

The complete course, plus the five patterns real deployments use — each drawn twice (numbered flow + sequence diagram) on 🌐 the patterns page ← open it beside this.

🧒 The five patterns, in school words

1. 🧍 The solo doer (single agent + tools) — our agent.py: one student, one belt, one loop. Start here, stay here as long as you can — most real value ships in this shape.

2. 🗺️ Planner + executor — one student BREAKS DOWN the project ("research trip: 1 pick city, 2 book train, 3 pack list"), then works the checklist item by item (or hands items to doers). Structure beats heroics on long tasks — the to-do list from L04, promoted to a first-class artifact.

3. 🧑‍🏫 The critic loop (generate → check → fix) — one student writes, another GRADES against a rubric ("tests pass? cites sources?"), and the writer fixes until the grade is green. The critic can be a model, but the BEST critics are merciless and mechanical: test runners, compilers, linters (ground truth beats opinions — L06).

4. 🚧 Human-in-the-loop — the student prepares everything; a human approves the irreversible step (deploy, send, pay). You've met this gate in every school now (L05 here, MCP L05, ArgoCD's sync button) — because it's THE pattern civilization runs on: drafts flow, signatures gate.

5. 👯 The team (multi-agent) — researcher, writer, checker, each with its own belt and desk, passing artifacts. Powerful for genuinely parallel work; also multiplies cost, latency and L06's compounding (a wrong "fact" from the researcher poisons everyone downstream). Teams need a foreman: clear handoffs, checkable artifacts, one responsible output.

And pattern zero — no agent at all 🙅: if the steps are known and fixed, write a SCRIPT (cheaper, deterministic, debuggable). If it's one model call, make one call. Agents earn their complexity only when the path genuinely varies by what's discovered along the way. The best agent architects say "this doesn't need an agent" weekly.

🗺️ Diagram (the decision, compressed)

flowchart TB
    q["a job arrives 📥"]
    s["🙅 steps known & fixed?<br/>→ write a SCRIPT"]
    one["🗣️ one answer needed?<br/>→ one model call"]
    solo["🧍 path varies by discovery?<br/>→ SOLO agent + tools (start here)"]
    plan["🗺️ long/structured?<br/>+ planner & checklist"]
    crit["🧑‍🏫 quality-critical?<br/>+ critic loop (prefer test runners)"]
    hitl["🚧 irreversible steps?<br/>+ human gates (always)"]
    team["👯 truly parallel workstreams?<br/>+ a team — with a foreman"]
    q --> s --> one --> solo --> plan --> crit --> hitl --> team

❓ What (the checklist you'll reuse)

Every pattern is composition of the same loop — L02's three beats, wrapped differently. Read any framework's diagram and you'll now see: planners are brains with structured output; critics are a second loop whose tools are graders; teams are loops passing artifacts.
Artifacts over vibes: patterns work when handoffs are checkable things (files, PRs, JSON) — not chat transcripts.
Evals per pattern (L06): solo = outcome checks; critic = does the grade actually correlate with quality?; team = end-to-end AND per-role.
Cost sanity: each added role multiplies tokens & latency. The patterns page marks where each pattern pays for itself.

🧪 Try it — capstone

Take a real recurring task from your week. Walk the decision diagram honestly (script? one call? solo?). If an agent survives the walk: write its one-page spec — goal, belt (tools marked READ/WRITE), memory plan, guardrails, the eval that proves it worked — and sketch its sequence diagram in the patterns-page style. That page IS the deliverable a team can build from. 📋

🎓 The doer graduates

Answers → outcomes → the loop → the belt → the pad → the rules → the failure catalog → the file itself → the patterns. You can now build an agent, break one, secure one, eval one — and, rarest skill of all, decline to build one. 📋🎓

git checkout main
python3 agent/agent.py --drive    # one last errand, for fun

← Previousbuild an agent Finished! Take the quiz →check what stuck

This page is the lesson's README from the lesson-08-patterns branch, shown here so the whole School stays on one site. Code files open on GitHub at the same branch.