Пам'ять агента: що він пам'ятає і навіщо

Коли агент виконує задачу, він не просто реагує на поточну інструкцію.

Він враховує те, що вже сталося раніше: що ти просив, що вже зробив, і який результат отримав.

Без цього кожна нова дія була б як перша спроба.

Він знову викликав би той самий API або повторював крок, який уже не спрацював

— іноді нескінченно.

Саме памʼять дозволяє агенту рухатись вперед, а не по колу.

Що таке пам'ять агента — з чого вона складається

Пам'ять агента — це не одне місце, де зберігається вся інформація.

Це набір механізмів, які дозволяють йому:

• зберігати контекст поточної задачі
• і використовувати досвід з попередніх

Без них агент не знає: що вже було зроблено
що спрацювало
і що потрібно зробити далі

Короткострокова vs довгострокова пам'ять

Не вся пам'ять агента однакова.

Є пам'ять на час задачі.
І є пам'ять між задачами.

Короткострокова — існує лише під час задачі.

Це контекст поточної розмови:

• твої інструкції
• відповіді агента
• результати попередніх кроків

Коли задача завершена — цей контекст зникає.

Наступного разу агент стартує “з чистого листа”.

Довгострокова — зберігається між задачами.

Вона дозволяє:

• пам'ятати налаштування
• враховувати попередній досвід
• використовувати дані з минулих задач

Без неї кожна нова задача для агента — як перша.

Простий приклад:

Ти просиш агента: «Зроби звіт, як минулого разу».

З короткостроковою пам'яттю він не знає, що було "минулого разу".
З довгостроковою — знає формат, джерела й структуру — і може повторити.

Що агент пам'ятає в межах задачі

Коли агент працює над задачею, він "бачить" лише поточну розмову.

Усе, що ти пишеш.
Усе, що відповідає агент.
Усі результати, які він отримує від інструментів.

Це і є його короткострокова пам'ять — контекст.

Він використовує її, щоб:

• Зрозуміти, що відбувається зараз
• Вирішити, який крок зробити далі
• І не повторювати те, що вже було зроблено

Але цей контекст не безмежний.

Якщо розмова стає занадто довгою — частина старої інформації просто "випадає".

Агент більше її не бачить.

І може:

• Забути початкову вимогу
• Втратити важливу деталь
• Або зробити дію, яка вже виконувалась раніше

Що агент може пам'ятати між задачами

Коли задача завершується, контекст розмови зникає.

Але це не означає, що агент має забути все назавжди.

Він може зберегти частину інформації у зовнішній пам'яті.

Це може бути:

• База даних
• Файл
• Або інше сховище

Де агент записує:

• Налаштування
• Попередні рішення
• Або важливі факти

І при наступній задачі — може зчитати ці дані назад.

Так він пам'ятає:

• Як ти працюєш
• Які формати використовуєш
• Або що вже робив раніше

Навіть якщо попередня розмова давно завершена.

Обмеження пам'яті — контекстне вікно

Короткострокова пам'ять агента має обмеження.

Він не може пам'ятати всю розмову повністю.

Є максимальний обсяг контексту, який модель може "бачити" одночасно.

Це називається контекстне вікно.

Коли розмова стає занадто довгою — частина старої інформації просто перестає в нього поміщатися.

Вона випадає з контексту.

Агент більше її не враховує.

Через це він може:

• Забути початкову вимогу
• Втратити важливу деталь
• Або повторити дію, яку вже виконував раніше

У коді це виглядає так

Нижче той самий принцип у простому форматі:
є короткострокова пам'ять (контекст задачі) і довгострокова (зовнішнє сховище між задачами).

1) Короткострокова пам'ять: що агент "бачить" зараз

Це поточні повідомлення і результати останніх кроків:

short_memory = [
    {"role": "user", "content": "Підготуй щотижневий звіт по продажах"},
    {"role": "assistant", "content": "Ок, починаю збирати дані"},
    {"role": "tool", "content": "sales_total=12400"},
]

2) Обмеження контексту: старе може випадати

Якщо контекст обмежений, система залишає лише останні елементи:

MAX_ITEMS = 3
short_memory = short_memory[-MAX_ITEMS:]

Через це агент може не бачити ранні інструкції.

3) Довгострокова пам'ять: що зберігаємо між задачами

Окремо тримаємо сховище з корисними фактами:

long_memory_store = {
    "user:anna": {
        "report_format": "short-bullets",
        "currency": "USD",
    }
}

4) На новій задачі читаємо ці дані назад

Перед відповіддю агент підтягує збережені налаштування:

user_prefs = long_memory_store.get("user:anna", {})

task_context = {
    "request": "Зроби звіт, як минулого разу",
    "prefs": user_prefs,
}

5) Агент формує відповідь уже з урахуванням пам'яті

def build_report(context: dict):
    fmt = context["prefs"].get("report_format", "default")
    currency = context["prefs"].get("currency", "USD")
    return f"Report format={fmt}, currency={currency}"


result = build_report(task_context)
# "Report format=short-bullets, currency=USD"

Без довгострокової пам'яті це було б format=default.

Аналогія з життя

Уяви, що ти говориш по телефону — але чуєш лише останні 30 секунд розмови.

Ти знаєш, що співрозмовник сказав щойно.
Пам'ятаєш останню відповідь.
І можеш продовжити діалог.

Але якщо він каже:

"Як я вже пояснював на початку…"

— ти цього початку не чув.

Він просто випав.

І ти можеш:

• Перепитати те саме
• Неправильно зрозуміти задачу
• Або відповісти не в тему

Якщо ж у тебе є нотатки з попередніх дзвінків — ти можеш їх перечитати і зрозуміти контекст.

Саме так агент використовує короткострокову і довгострокову пам'ять.

Коротко

FAQ

Q: Чи пам’ятає агент попередні задачі?
A: Лише якщо ця інформація збережена у довгостроковій пам’яті поза поточною розмовою.

Q: Чому агент може забути початкову інструкцію?
A: Через обмеження контекстного вікна — частина старої інформації може випасти з короткострокової пам’яті.

Q: Навіщо агенту довгострокова пам’ять?
A: Щоб зберігати важливі дані між задачами і використовувати їх у майбутньому.

Що далі

Тепер ти знаєш, що агент пам'ятає — і як це допомагає йому рухатись вперед.

Але пам'ять — це лише частина картини.

Бо агент не просто пам'ятає дії.
Він їх виконує.

І не всі дії однаково безпечні.

Одна справа — прочитати дані.
Інша — змінити їх.
Або видалити.
Або витратити гроші на API.

Саме тому агенту потрібно не лише знати, що робити.
Йому потрібно знати, що робити дозволено.