Memory — מה שורד מעבר לשיחה

ברירת המחדל: שום דבר לא נשמר

כברירת מחדל, agent לא זוכר כלום מעבר לשיחה הנוכחית: כשה-session מסתיים, ה-context window שלו נעלם לגמרי — כל מה שנלמד, כל העדפה שהמשתמש ציין, כל החלטה שהתקבלה, פשוט לא קיימים יותר בפעם הבאה שהוא מופעל, גם אם זה היה עשר שניות אחרי.

זה נובע ישירות ממה שנלמד בפרק הקודם: ה-context window הוא כל מה שהמודל "רואה", ואין לו שום דבר "מעבר" לזה מובנה מאליו — הוא לא רשת נוירונים שמתעדכנת בזמן אמת מהשיחה, אלא מודל קבוע שמקבל טקסט טרי בכל פעם.

תרשים המציג תיבת session 1 מלאה בשורות טקסט (כחול), קו מקווקו אנכי המסמן את סיום ה-session, תיבה מקווקווית דהויה המסמלת את היעלמות הקונטקסט, ותיבת session 2 ריקה לגמרי בצד ימין — ממחיש שהקונטקסט נעלם לחלוטין בסיום כל session ו-session חדש מתחיל מאפס.
כברירת מחדל, הקונטקסט נעלם לגמרי בסיום ה-session — ה-session הבא מתחיל ריק, בלי זיכרון מהקודם

מה זה בעצם Memory

Memory הוא שכבת שמירה חיצונית לגמרי לקונטקסט — קובץ, מסד נתונים, או אינדקס וקטורי — שה-agent יכול לכתוב אליה במפורש ("שמור את זה") ולקרוא ממנה במפורש ("מה כבר ידוע לי?") בתחילת session חדש. זה לא יכולת מובנית של המודל, אלא עוד יכולת שנחשפת אליו כ-tool, בדיוק כמו קריאת קובץ או שאילתת מסד נתונים.

בגלל זה, memory הוא בעצם עניין הנדסי לגמרי: מישהו צריך להחליט מה שווה לשמור, מתי לשמור אותו, ואיך למצוא אותו שוב בפעם הבאה — המודל לא "זוכר" באופן אינהרנטי, הוא רק כותב וקורא מידע חיצוני ביוזמתו (או ביוזמת ה-harness).

תרשים המציג תיבת קונטקסט מימין עם שני חצים אל גליל אחסון חיצוני משמאל: חץ כחול 'כתיבה' מהקונטקסט אל הגליל, וחץ כתום 'קריאה' מהגליל בחזרה אל הקונטקסט — ממחיש ש-Memory היא שכבה חיצונית שה-agent כותב אליה וקורא ממנה במפורש, נפרדת מהקונטקסט עצמו.
Memory היא שכבת אחסון חיצונית שה-agent כותב אליה וקורא ממנה במפורש — לא יכולת מובנית של המודל

שני דפוסים נפוצים: קובץ הערות מול Retrieval

הדפוס הפשוט ביותר: קובץ טקסט (או כמה קבצים לפי נושא) שה-agent מעדכן כשהוא לומד עובדה שכדאי לזכור לפעם הבאה — העדפת סגנון של המשתמש, החלטה ארכיטקטונית שהתקבלה, מבנה פרויקט. הוא נטען במלואו בתחילת כל session חדש, כך שהמידע פשוט "נמצא שם" מההתחלה.

כשנפח המידע הנצבר גדול מדי מכדי לטעון הכול תמיד, עוברים לדפוס retrieval: המידע נשמר כ-embeddings באינדקס וקטורי (בדיוק כפי שנלמד בנושא ה-Vector Search), וה-agent שולף רק את הקטעים הרלוונטיים לשאלה הנוכחית, במקום לטעון את כל הזיכרון בכל פעם. זה בעצם אותו עיקרון RAG שנלמד שם, רק שהמסמכים המאוחזרים הם "זיכרונות" של הסוכן עצמו במקום מסמכים חיצוניים.

תרשים המחולק לשני חלקים: משמאל קובץ הערות עם ארבע שורות טקסט וחץ יורד המראה שהכול נטען במלואו לתוך תיבת קונטקסט. מימין פיזור של נקודות כתומות (אינדקס וקטורי של זיכרונות), כשרק שתיים מודגשות ומחוברות בחצים לתיבת קונטקסט — שאר הנקודות נשארות בחוץ, ממחיש ששולפים רק את הקטעים הרלוונטיים.
קובץ הערות נטען במלואו תמיד; דפוס Retrieval שולף רק את קטעי הזיכרון הרלוונטיים לשאלה הנוכחית

זיכרון קצר טווח מול ארוך טווח

כדאי להבחין בין שתי רמות: זיכרון קצר טווח הוא בדיוק ה-context window של ה-session הנוכחי — עשיר בפרטים, אבל נעלם בסיום. זיכרון ארוך טווח הוא כל מה שנכתב במפורש לשכבת ה-memory החיצונית ונועד לשרוד גם אחרי שה-session הנוכחי כבר לא קיים.

המעבר בין השניים תמיד דורש פעולה מכוונת: משהו (המודל, ה-harness, או המשתמש) צריך להחליט במפורש מה מתוך הזיכרון הקצר-טווח העשיר ראוי להצטמצם ולעבור לזיכרון הארוך-טווח — זה לא קורה מעצמו.

דוגמה מלאה: agent שמשתמש בקובץ זיכרון בין שתי שיחות

session א׳: המשתמש מבקש מה-agent לבנות פיצ'ר, ותוך כדי עבודה מציין שהוא מעדיף named exports על פני default exports. ה-agent שומר את ההעדפה הזו בקובץ memory ייעודי, ומסיים את המשימה.

session ב׳, יום למחרת: המשתמש מבקש פיצ'ר חדש ואחר לגמרי. בתחילת ה-session, ה-harness טוען את קובץ ה-memory אל תוך הקונטקסט לפני שהעבודה מתחילה — ה-agent "נזכר" בהעדפה מבלי שהמשתמש יצטרך לחזור ולציין אותה, ופשוט כותב את הקוד החדש בהתאם.

JSON
// memory.json - נטען אוטומטית בתחילת כל session
{
  "preferences": [
    "named exports, not default exports"
  ],
  "updated_at": "2026-09-22"
}