📔 धडा 04 — Memory: scratchpad आणि गृहपाठाची डायरी

📍 तुम्ही इथे आहात: 8 पैकी धडा 04 · मागे: lesson-03-tools · पुढे: lesson-05-guardrails

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

धडे 01–03, आणि ठोक्यांच्या दरम्यान agent काय लक्षात ठेवतो — आणि लक्षात ठेवता येणार नाहीत एवढ्या मोठ्या कामांवर काय होते.

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

कर्ता-विद्यार्थी कसे काम करतो ते पाहा: प्रत्येक फेरीनंतर तो एका scratchpad 📔 मध्ये एक ओळ लिहून ठेवतो — "office म्हणते 3A मध्ये 12", "calc म्हणते 8". प्रत्येक नवीन विचाराआधी तो pad पुन्हा वाचतो. तो pad हीच agent ची working memory आहे — आपल्या code मध्ये अक्षरशः strings ची एक list (scratchpad.append(...)), जी प्रत्येक ठोक्याला brain ला परत दाखवली जाते.

पण pad desk वर असतो (AI course L08!) — आणि desk लहान आहे. लांब कामे तो भरून टाकतात: पन्नास tool results, प्रत्येक एक screen भर, आणि अचानक सुरुवातीची तथ्ये खाली घसरतात किंवा मधल्या गर्दीत बुडतात. विद्यार्थ्याला आपण सुरुवात का केली तेच आठवत नाही. 🫠

खरे agents desk भरण्याशी एखाद्या चांगल्या विद्यार्थ्यासारखे लढतात:

जाता जाता सारांश करा 🗜️ — दहा जुन्या नोंदींच्या जागी एक ओळ: "दोन्ही वर्ग मोजले: एकूण 23 मुले." (Compaction.)
वेगळी कामांची यादी ठेवा ✅ — GOAL आणि प्रगती harness सांभाळत असलेल्या संरचित योजनेत राहतात, फक्त pad वरच्या गद्यात नाही — त्यामुळे "काय बाकी आहे?" हे कितीही गोंधळात टिकते.
गोष्टी डोक्याबाहेर लिहून ठेवा 📁 — files, databases, notes (आपले write_note!). desk काम करण्यासाठी आहे; टिकणारी तथ्ये अशा टिकणाऱ्या जागी हवीत जिथून agent नंतर पुन्हा lookup करू शकेल.
कामांदरम्यानची दीर्घकालीन memory = नेमके RAG (AI course L10): जुने अनुभव embed करा, पुढच्या वेळी संबंधित अनुभव परत मिळवा. memory हा नवीन शोध नाही — ती तुमच्याच इतिहासावर घेतलेली open-book परीक्षा आहे.

🗺️ आकृती

flowchart LR
    subgraph desk["🪑 the desk - context window, finite!"]
        goal["📋 goal + to-do list"]
        pad["📔 scratchpad:<br/>[lookup 3A] → 12 kids<br/>[calc] → 8 …"]
    end
    think["💭 THINK reads it all"]
    comp["🗜️ compaction:<br/>10 jottings → 1 summary line"]
    ext["📁 durable memory OUTSIDE:<br/>files · DB · RAG over past runs"]
    pad --> think
    goal --> think
    comp -.->|"when the desk fills"| pad
    ext <-.->|"write_note / lookup"| pad

❓ काय

Working memory = प्रत्येक ठोक्याचा prompt: goal + tool labels + scratchpad(-summary). आपले खेळणे शुद्ध रूप दाखवते; production मध्ये compaction thresholds आणि संरचित योजना जोडल्या जातात.
desk चे गणित: N ठोके × M tokens/observation हे context window मध्ये बसलेच पाहिजे — लांब कामांसाठी हीच मुख्य scaling ची भिंत आहे. थोडक्यात text परत करणारी tools (L03) तुम्हाला जास्त ठोके मिळवून देतात.
Durable memory: agent tools द्वारे वाचतो आणि लिहितो त्या files/DBs; त्या काम, session आणि desk संपल्यावरही टिकतात.
design मधला धोक्याचा वास: काम मध्येच "विसरणाऱ्या" agent ला सहसा desk ची समस्या असते, model ची नाही — k8s L16 सारखीच निदानाची पद्धत.

🤔 का

"step 3 मधली माझी सूचना तो का विसरला?" आणि "30 steps नंतर तो का ढासळतो?" हे production मध्ये agents बद्दल सर्वाधिक विचारले जाणारे दोन प्रश्न आहेत, आणि दोन्ही म्हणजे हाच धडा: desk भरला, आणि कोणीही compaction किंवा बाहेर लिहून ठेवणे करत नव्हते. आता ही अडचण येण्याआधीच तुम्हाला उपाय माहीत आहे.

🧪 करून पाहा

python3 agent/agent.py --yes && cat note.txt && rm note.txt

एकाच run मध्ये तिन्ही memories ओळखा: scratchpad (प्रत्येक THINK ला पुरवल्या जाणाऱ्या छापलेल्या नोंदी), अप्रत्यक्ष to-do (brain pad पाहून "अजून काय झाले नाही?" हे तपासतो), आणि durable note (process संपल्यावरही टिकते — म्हणूनच agent बाहेर पडल्यावरही cat चालते). मग एक कागदी सराव: तुमच्या agent ला 500 invoices तपासायच्या आहेत; desk मध्ये 20 बसतात. memory चा आराखडा design करा (batch करा, प्रत्येक batch चा सारांश करा, चालू बेरीज एका file मध्ये लिहा, शेवटी file वर एक फेरी — अभिनंदन, हाच production pattern आहे).

⏭️ पुढे

शक्तिशाली tools + न थकणारा loop = असा विद्यार्थी जो मोठ्या प्रमाणावर चुकूही शकतो. Guardrails — सहलीचे नियम.

git checkout lesson-05-guardrails

📔 Lesson 04 — Memory: the scratchpad and the homework diary

📍 You are here: Lesson 04 of 8 · Previous: lesson-03-tools · Next: lesson-05-guardrails

📦 What's in this branch

Lessons 01–03, plus what the agent remembers between beats — and what happens on tasks too big to remember.

🧒 Explain like I'm 5

Watch the doer-student work: after every errand they jot one line in a scratchpad 📔 — "office says 3A has 12", "calc says 8". Before every new thought, they re-read the pad. That pad IS the agent's working memory — in our code, literally a list of strings (scratchpad.append(...)) shown back to the brain each beat.

But the pad lives on the desk (AI course L08!) — and the desk is small. Long tasks fill it: fifty tool results, each a screenful, and suddenly the early facts slide off or drown in the middle. The student forgets why they started. 🫠

Real agents fight desk-overflow like a good student would:

Summarize as you go 🗜️ — replace ten old jottings with one line: "counted both classes: 23 kids total." (Compaction.)
Keep a separate to-do list ✅ — the GOAL and progress live in a structured plan the harness maintains, not just prose on the pad — so "what's left?" survives any amount of noise.
Write things DOWN outside your head 📁 — files, databases, notes (our write_note!). The desk is for working; durable facts belong in durable places the agent can re-lookup later.
Long-term memory between tasks = exactly RAG (AI course L10): embed past experiences, retrieve the relevant ones next time. Memory isn't a new invention — it's the open-book exam pointed at your own history.

🗺️ Diagram

flowchart LR
    subgraph desk["🪑 the desk - context window, finite!"]
        goal["📋 goal + to-do list"]
        pad["📔 scratchpad:<br/>[lookup 3A] → 12 kids<br/>[calc] → 8 …"]
    end
    think["💭 THINK reads it all"]
    comp["🗜️ compaction:<br/>10 jottings → 1 summary line"]
    ext["📁 durable memory OUTSIDE:<br/>files · DB · RAG over past runs"]
    pad --> think
    goal --> think
    comp -.->|"when the desk fills"| pad
    ext <-.->|"write_note / lookup"| pad

❓ What

Working memory = the prompt each beat: goal + tool labels + scratchpad(-summary). Our toy shows the pure form; production adds compaction thresholds and structured plans.
The desk math: N beats × M tokens/observation must fit the context window — this is THE scaling wall for long tasks. Tools that return concise text (L03) buy you more beats.
Durable memory: files/DBs the agent reads and writes via tools; survives the task, the session, the desk.
Design smell: an agent that "forgets" mid-task usually has a desk problem, not a model problem — same diagnosis energy as k8s L16.

🤔 Why

"Why did it forget my instruction from step 3?" and "why does it fall apart after 30 steps?" are the two most-asked agent questions in production, and both are THIS lesson: the desk filled, and nobody was compacting or externalizing. You now know the fix before you hit it.

🧪 Try it

python3 agent/agent.py --yes && cat note.txt && rm note.txt

Spot all three memories in one run: the scratchpad (printed jottings feeding each THINK), the implicit to-do (the brain checks "what's not done yet?" against the pad), and the durable note (survives the process — that's why cat works after the agent exits). Then a paper drill: your agent must audit 500 invoices; the desk fits 20. Design the memory plan (batch, summarize per batch, write running totals to a file, final pass over the file — congratulations, that's the production pattern).

⏭️ Next

Power tools + a tireless loop = a student who can also get it wrong at scale. Guardrails — the field-trip rules.

git checkout lesson-05-guardrails

← Previoustools Next →guardrails

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