📋 धडा 11 — Agents आणि tools: to-do यादी आणि hall pass असलेला विद्यार्थी

📍 तुम्ही इथे आहात: 12 पैकी धडा 11 · मागे: lesson-10-rag · पुढे: lesson-12-diffusion

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

धडे 01–10, आणि "AI agents" म्हणताना सगळ्यांना अभिप्रेत असलेला नमुना: असे models जे फक्त उत्तर देत नाहीत — ते loop मध्ये, tools वापरून कृती करतात.

🧒 5 वर्षांच्या मुलाला समजावल्यासारखे

आतापर्यंत आपला विद्यार्थी फक्त बोलतो. "847×293 किती?" विचारा आणि तो शक्य वाटणारे अंक ओळखतो 😬 (धडा 05 — खरे गणित नाही!). विचारा "माझ्या calendar वर काय आहे?" आणि त्याला ते कळू शकत नाही (desk वर काहीच नाही, L08).

आता त्याला शाळेचे तीन विशेषाधिकार द्या:

🧰 Tools: एक calculator, ग्रंथालयाचा catalog, एक phone, forms submit करण्याची परवानगी. औपचारिकपणे: functions ची वर्णने — "calculator: मला एक expression द्या, मी त्याची किंमत परत देतो."
📋 एक to-do यादी: प्रश्न नव्हे, एक ध्येय — "वर्गाची सहल आयोजित करा."
🎫 एक hall pass: जाऊन गोष्टी करून परत येण्याची परवानगी.

आणि तो agent loop चालवतो: विचार → कृती → निरीक्षण → पुन्हा — ध्येय पूर्ण होईपर्यंत, किंवा steps चे बजेट, timeout किंवा वारंवार अपयश थांबायला सांगेपर्यंत:

विचार: "सहल. आधी: किती मुले? मी roster तपासतो." कृती: roster.count() बोलावतो — गद्य नव्हे, tool-call लिहितो. निरीक्षण: result (23) त्याच्या desk वर येतो. विचार: "23 मुले, म्हणजे 3 pizzas… पुढे हवामान तपासतो." …

प्रत्येक फेरी अजूनही धडा 05 चा next-token खेळच आहे! "tool बोलावणे" = model ने एक खास token नमुना लिहिणे जो harness चालवतो; result desk वर paste होतो; अंदाज पुढे चालू राहतो. बोलणे, परिणामांसह.

दोन प्रामाणिक इशारे: चुका वाढत जातात (सुरुवातीला एक चुकीचे वळण = त्यानंतर सगळीकडे आत्मविश्वासाने चूक — पाय फुटलेला धडा 09 🦿), आणि स्वायत्ततेला guardrails लागतात: मुळात read-only tools, खर्चाच्या मर्यादा, human sign-off gates ("सहलीच्या forms वर शिक्षिकेची सही लागते"), आणि प्रत्येक step चे logs.

🗺️ आकृती

flowchart LR
    goal["📋 goal: 'organize<br/>the class picnic'"]
    think["🧠 THINK<br/>next-token prediction<br/>planning in words"]
    act["🧰 ACT<br/>writes a tool call:<br/>roster.count()"]
    look["👀 LOOK<br/>result lands on the desk:<br/>23 kids"]
    done["✅ goal met - report back"]
    guard["🚧 guardrails: read-only default ·<br/>caps · human sign-off · logs ·<br/>max steps · timeout · stop on repeated failure"]
    goal --> think -->|"1"| act -->|"2 harness executes"| look -->|"3 loop"| think
    think -->|"4 eventually"| done
    guard -.-> act

❓ काय

Tool/function calling: तुम्ही tools चे वर्णन करता (नाव, params, उद्देश); model structured calls output करतो; तुमचा code ते चालवून results परत देतो. model थेट कशालाच हात लावत नाही — ते harness करते.
Agent = LLM + tools + loop + ध्येय. RAG (L10) हे agent बोलावू शकेल असे एक tool आहे; "agentic RAG" = search केव्हा करायचा हे ठरवणे.
Design च्या कळा: कोणती tools (क्षमता), कोणता model (विवेक), loop च्या मर्यादा — max steps, timeout, वारंवार अपयशावर थांबणे (बेलगाम होण्यापासून संरक्षण), लांब कामांसाठी memory/scratchpads, आणि evals — अंदाजाने नव्हे, कामाचे यश मोजा.
Multi-agent = विद्यार्थ्यांनी विद्यार्थ्यांना काम सोपवणे (एक संशोधक, एक लेखक, एक तपासणारा). ताकदवान, आणि वाढत जाणाऱ्या चुकांचा इशारा अनेक पटीने वाढवते — एका विद्यार्थ्याने आणि थोड्या tools ने सुरुवात करा.
तुम्ही एक पाहिला आहे: files वाचणारे, tests चालवणारे, code edit करणारे, पुन्हा प्रयत्न करणारे coding assistants — हाच loop, कामाचे कपडे घालून.

🤔 का

Agents मध्ये AI सल्ल्या कडून परिणामां कडे वळतो — booking, दुरुस्ती, filing, संशोधन. प्रत्येक framework ची मोठी बातमी ("autonomous agents! computer use!") म्हणजे हाच एक loop, चांगल्या tools आणि लांब दोरीसह. हा loop — आणि तो अजूनही पावत्यांसह next-token prediction च आहे हे — जाणल्याने तुम्ही जादू आणि धोका दोन्ही शांतपणे तोलू शकता.

🧪 करून पाहा (harness तुम्ही व्हा — 10 मिनिटे)

कोणत्याही chatbot मध्ये हे paste करा:

You have one tool: calc(expression) → number. To use it, reply with
ONLY: CALL calc("..."). I'll reply with the result. Then continue.
Task: what's 847×293, minus 12% of it, split across 23 kids?

त्याचे calls तुम्ही स्वतः चालवा (कोणताही calculator), results परत paste करा, आणि तो loop करत उत्तरापर्यंत पोहोचताना पाहा. कामाची वाटणी कशी चालते ते अनुभवा — model विचार करतो, tools गणना करतात, desk स्थिती वाहून नेते. guardrail तुम्ही आहात. 🚧

⏭️ पुढे

शेवटचा धडा: चित्र काढणारे models 🎨 — "TV static → चित्र" कसे चालते (diffusion), आणि एका model ला पाहता आणि ऐकताही कसे आले.

git checkout lesson-12-diffusion

📋 Lesson 11 — Agents & tools: a student with a to-do list and a hall pass

📍 You are here: Lesson 11 of 12 · Previous: lesson-10-rag · Next: lesson-12-diffusion

📦 What's in this branch

Lessons 01–10, plus the pattern everyone means by "AI agents": models that don't just answer — they act, in a loop, with tools.

🧒 Explain like I'm 5

So far our student only talks. Ask "what's 847×293?" and he predicts likely digits 😬 (lesson 05 — not actual math!). Ask "what's on my calendar?" and he can't know (nothing on the desk, L08).

Now give him three school privileges:

🧰 Tools: a calculator, the library catalog, a phone, permission to submit forms. Formally: function descriptions — "calculator: give me an expression, I return the value."
📋 A to-do list: a GOAL, not a question — "organize the class picnic."
🎫 A hall pass: permission to go do things and come back.

And he works the agent loop: think → act → look → repeat — until the goal is met, or a step budget, timeout or repeated failure says stop:

Think: "Picnic. First: how many kids? I'll check the roster." Act: calls roster.count() — writes a tool-call, not prose. Look: the result (23) lands on his desk. Think: "23 kids, so 3 pizzas… check the weather next." …

Each round is still lesson 05's next-token game! "Calling a tool" = the model writing a special token pattern the harness executes; the result is pasted onto the desk; prediction continues. Talking, with consequences.

The two honest warnings: errors compound (one wrong turn early = confidently wrong everywhere after — lesson 09 with legs 🦿), and autonomy needs guardrails: read-only tools by default, spending caps, human sign-off gates ("field-trip forms need the teacher's signature"), and logs of every step.

🗺️ Diagram

flowchart LR
    goal["📋 goal: 'organize<br/>the class picnic'"]
    think["🧠 THINK<br/>next-token prediction<br/>planning in words"]
    act["🧰 ACT<br/>writes a tool call:<br/>roster.count()"]
    look["👀 LOOK<br/>result lands on the desk:<br/>23 kids"]
    done["✅ goal met - report back"]
    guard["🚧 guardrails: read-only default ·<br/>caps · human sign-off · logs ·<br/>max steps · timeout · stop on repeated failure"]
    goal --> think -->|"1"| act -->|"2 harness executes"| look -->|"3 loop"| think
    think -->|"4 eventually"| done
    guard -.-> act

❓ What

Tool/function calling: you describe tools (name, params, purpose); the model outputs structured calls; YOUR code executes and returns results. The model never touches anything directly — the harness does.
Agent = LLM + tools + loop + goal. RAG (L10) is one tool an agent might call; "agentic RAG" = deciding when to search.
Design levers: which tools (capability), which model (judgment), loop limits — max steps, a timeout, stop on repeated failure (runaway protection), memory/scratchpads for long tasks, and evals — measure task success, not vibes.
Multi-agent = students delegating to students (a researcher, a writer, a checker). Powerful, and multiplies the compounding-error caveat — start with ONE student and few tools.
You've SEEN one: coding assistants that read files, run tests, edit code, retry — that's this exact loop wearing work clothes.

🤔 Why

Agents are where AI shifts from advice to outcomes — booking, fixing, filing, researching. Every framework headline ("autonomous agents! computer use!") is this one loop with better tools and longer leashes. Knowing the loop — and that it's still next-token prediction with receipts — lets you judge both the magic and the risk soberly.

🧪 Try it (be the harness — 10 minutes)

In any chatbot, paste:

You have one tool: calc(expression) → number. To use it, reply with
ONLY: CALL calc("..."). I'll reply with the result. Then continue.
Task: what's 847×293, minus 12% of it, split across 23 kids?

Execute its calls yourself (any calculator), paste results back, watch it loop to the answer. Feel how the division of labor works — model thinks, tools compute, desk carries state. You are the guardrail. 🚧

⏭️ Next

The finale: models that paint 🎨 — how "TV static → picture" works (diffusion), and how one model learned to see and hear too.

git checkout lesson-12-diffusion

← Previousrag Next →diffusion

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