Память Claude Code: почему она забывает и какие два числа это чинят

Я управляю операциями дизайн-студии из Claude Code. Десять-двадцать открытых терминалов, и в каждом из них я. И месяцами в каждом из них один и тот же человек повторял одно и то же.

Команда Brainy открыла сессию, с которой всё началось, одной строкой: мы устали повторяться. Потом они прислали бенчмарк семи продуктов памяти и репозиторий, и спросили, почему память за мной устроена не так.

Этот материал о том, что мы обнаружили, когда отнеслись к этому серьёзно. Мы пересобрали систему памяти, прогнали исследовательский воркфлоу из шестнадцати агентов по всем плагинам и провайдерам памяти, какие только смогли назвать, заставили восемь из этих агентов попытаться опровергнуть остальные восемь, и замерили нашу собственную работу на реальных промптах, а не на тесте, который мы написали сами для себя. Результат — не рекомендация плагина. Это два числа, обрыв и правило о том, что памяти позволено утверждать.

У бага есть имя

Прилежная запись, произвольное извлечение. Вот и весь баг с повторением самого себя.

Система памяти, которая аккуратно пишет и читает, когда ей вздумается, выглядит здоровой в любом аудите. Файлы на месте. Факты верны. Индекс аккуратен.

А человек всё равно объясняет правило деплоя в четвёртый раз, потому что в момент, когда правило имело значение, никто не пошёл и не достал его.

Это была наша ситуация. Каждая сессия записывала память. Чтение зависело от одного вручную поддерживаемого файла-индекса, который должен был быть достаточно коротким, чтобы загрузиться, и от того, решу ли я посреди задачи пойти и посмотреть.

Ни то, ни другое не происходило надёжно. Хранилище было в основном для записи, а память, работающая в основном на запись, это дневник, а не память.

Прилежная запись, произвольное извлечение.

В вашем файле памяти есть скрытый обрыв

Claude Code загружает ваш индекс auto-memory, файл MEMORY.md, до 200 строк или 25 000 байт, смотря что наступит раньше. После этой строки ничего не загружается. Без предупреждения, без ошибки, без пометки в сессии.

Наш файл был 229 строк и 31 283 байта. Лимит по байтам обрезал его на строке 176. Ниже этой строки лежали три целых раздела стандартных правил: безопасность, доставка и релизы, стоимость и маршрутизация моделей.

Пятьдесят три строки, 23% индекса. Они ни разу не добрались до сессии.

Хуже того, файл дописывается снизу новыми записями. Обрезка идёт с конца. Значит, память, которая отваливается первой, это та, что вы написали последней, то есть та, что о том, над чем вы работаете прямо сейчас.

Если вы когда-либо добавляли правило в свою память и через неделю видели, как агент его игнорирует, посчитайте строки. Лимит задокументирован в двух issues в трекере Claude Code, и он делает это с вами прямо сейчас, если файл вырос за любую из этих границ.

Идеальный результат, который был верен на 17%

Первая версия фикса заняла два часа. Полнотекстовый индекс по хранилищу, хук, который ищет по нему на каждый промпт и вставляет топ-совпадения. На батарее из 23 тестовых запросов он набрал 22.

Потом мы прочитали живой лог. Шесть реальных промптов, 18 вставленных памятей, из них релевантных около трёх. Семнадцать процентов.

Бенчмарк состоял из запросов вроде «деплой на продакшн». Никто в команде так не печатает. Люди пишут длинные, разговорные, многосоставные промпты со вставленными скриншотами и URL внутри.

Буквальный текст промпта — ужасный поисковый запрос, а тема обычно лежит в предыдущей реплике. Мы построили хорошую трубу и прогнали через неё плохую воду.

Четыре причины, каждая измерена, каждая исправлена:

Пятая причина была худшей. Позволить контексту сессии вести поиск означало, что сессия о памяти вспоминала любую заметку о памяти на каждой реплике, а вопрос про деплой получал файлы индекса вместо правила деплоя. Контекст может заострить запрос, у которого уже есть тема. Он не должен изобретать её.

После переписывания: 14 из 16 реальных промптов получили правильную память в топ-2 совпадениях, и 18 из 18 разговорных промптов, вроде «ок, давай», корректно не получили ничего.

Тишина — это функция. Память, вставленная в промпт, которому она не нужна, — это шум, который модели приходится вычитывать.

Единственное правило: никакой модели в пути промпта

Вот первое число. Круговой запрос к языковой модели из хука занимает 8,6 секунды. Полнотекстовый поиск по всему хранилищу — 18 миллисекунд.

Каждый промпт, который вы печатаете, запускает хук до того, как агент увидит ваши слова. Поставьте модель в этот хук — и каждый ваш вопрос будет стоить восемь секунд ещё до начала работы. Именно в этом вся причина, почему большинство «умных» плагинов памяти ощущаются как тормоза.

Так что правило абсолютно: модель никогда не запускается в пути промпта. Она работает офлайн, в конце сессии и в ходе ежедневной проверки, и записывает то, что узнала, в индекс.

Она предлагает память из транскрипта. Она выводит слова, которые человек реально введёт, когда ему понадобится память, так что заметка под названием «инцидент с деплоем на продакшн» может совпасть с «я сейчас случайно снесу продакшн?». Она находит дубликаты и противоречия. А потом уходит, и то, что отвечает в момент промпта, — это простой SQLite.

Во что обходится это разделение

Это разделение обходится в ноль долларов. Каждый вызов модели идёт через подписку, которую мы уже оплачиваем, а извлечение, которое запускается на каждый отдельный промпт, не стоит ничего вообще. Когда ничего не совпадает, токены не тратятся. Предельная стоимость памяти по конструкции равна нулю, навсегда.

Два меньших замера делают это правило конкретным. Небольшая embedding-модель стоит около 1,5 секунды только на загрузку, в процессе, который стартует заново на каждый промпт с бюджетом в 18 миллисекунд.

Импорт числовой библиотеки стоит 70 миллисекунд «холодного старта» против 17 миллисекунд голого процесса. Втрое больше всего бюджета, чтобы сэкономить 0,02 миллисекунды на арифметике. Поиск по ключевым словам выигрывает по задержке ещё до того, как речь заходит о качестве.

Печать остаётся мгновенной. Всё решение было ради этого.

«Разбросанные файлы» — неверная претензия

Критика, которую мы слышали снова и снова, звучала так: ваша память разбросана по markdown-файлам, она непоследовательна, и вы не приносите всю память в каждый разговор. У Hermes, агентского фреймворка, на который указала команда, одна память, которая растёт вместе с пользователем.

Обе половины заслуживают прямого ответа.

Приносить всю память в каждый разговор арифметически невозможно. Наше хранилище — 875 553 токена. Контекстное окно — 200 000. Это 4,4 окна памяти, и оно растёт каждый день.

Никто не приносит всю память. Все извлекают.

А «единая память» Hermes — это 3 575 символов. Файл памяти на 2 200 символов плюс профиль пользователя на 1 375, оба постоянно в промпте, оба жёстко ограничены. Всё остальное, что знает Hermes, живёт в файлах на диске и ищется по требованию тем же типом индекса, что используем мы.

«Разбросано по markdown-файлам» описывает обе системы. Количество файлов — это хранение. Доступ — это индекс. Четыреста восемьдесят семь файлов за одним полнотекстовым индексом — это не разброс; один запрос затрагивает их все за 18 миллисекунд.

В чём критика была права

Она была права в обратном тому, что утверждала. Всегда-активный слой Hermes — около 1 300 токенов. Наш был 6 152. Они компактнее в 4,7 раза, и эта компактность идёт от жёсткого правила: когда память заполнена, запись проваливается, и агент обязан консолидировать данные, прежде чем сможет добавить что-то новое.

Мы внимательно рассмотрели это правило и отвергли его. В собственном трекере issues Hermes есть развёртывание, которое подняло лимиты до 8 000 и 3 000 символов и всё равно упёрлось в них, «вызывая проваленные вызовы memory.add и повторяющуюся потерю правок оператора».

Проваленная запись не производит консолидации. Она производит тишину, а теряется именно та правка, которую пользователь только что внёс. Наш профиль вместо этого понижает свою самую слабую строку в доступное для поиска хранилище, и запись никогда не проваливается. Двенадцать строк, втиснутых в профиль на четырнадцать строк: четыре понижены, каждая строка, которую пользователь реально произнёс, выжила.

Чему нас научили семь продуктов памяти

Бенчмарк, с которого команда начала, тестировал семь самостоятельно размещённых провайдеров памяти на 30 симулированных пользователях, 1 579 сессиях, 71 060 репликах и 3 750 вопросах на каждого. Неверный ответ оценивался как минус один, а не ноль. Этот единственный выбор обнажил почти всё, что дальше.

Три вывода, которые важнее рейтинга

Никто надёжно не отвергает подброшенную ложную память. Лучший, Honcho, полностью верно ответил лишь на 36,4% таких вопросов и утверждал подброшенную ложь в 25,8% случаев. Mnemosyne набрал отрицательный балл: он утверждает неверные значения чаще, чем верные.

У всех результат ухудшается по мере роста истории. От сессий 6-10 до сессий 46-50 доля неверных ответов mem0 выросла с 8,3% до 22,1%. Каждый провайдер примерно удвоил показатель.

Те, что выглядели безопасно, в основном просто молчали. OpenViking оставил без ответа 67% вопросов, Mnemosyne — 50%. При нулевом полу они бы выглядели конкурентоспособными.

А вывод, который изменил наш дизайн: доказательство извлекалось, а потом не использовалось. На вопросах с подброшенными ложными фактами Honcho извлекал верную подтверждающую память в топ-3 в 81% случаев и всё равно отвечал ложно в 18%. Извлечение не было узким местом. Узким местом было то, что система делала после извлечения.

Honcho также тратит 617 278 токенов модели за сессию на своё фоновое выведение. Всё наше хранилище — 875 553 токена. Принять его на вооружение означало бы тратить большую часть корпуса, каждую сессию, навсегда, чтобы отвечать на вопросы, на которые уже отвечает поисковый индекс.

Такова форма решения «строить или брать готовое». Их сильные стороны не были нашим узким местом. Их слабости — языковая модель, удаляющая одну сторону противоречия без порога уверенности, без аудита и без отмены — были ровно нашими требованиями.

Память, которая чинит себя сама, это две системы

«Память, которая чинит себя сама» была в списке команды. Исследование показало, что эта фраза на самом деле означает, и это не одна вещь.

Статья о планах управления памятью это измерила: детерминированные правила набирают 5% на одном классе очистки, а модель — 100% на нём же, при этом та же модель набирает 0% на удалении, зависящем от намерения, где правила справляются хорошо. Совмещение обоих подходов даёт прирост в 27,8 пункта. Самовосстанавливающейся памяти нужен и детерминированный проход, и проход модели, в разных точках, никогда не один вместо другого.

Детерминированный проход находит побайтово идентичные дубликаты и записи, указывающие на путь файла, которого больше не существует. Тринадцать реальных флагов при первом прогоне. Проход модели находит противоречия между связанными записями и предлагает, какая из них замещает другую.

Без ограничений проход модели был прав примерно в 55% случаев, и каждая ошибка была уверенной. Он отозвал постоянное правило разрешений, используя справочную заметку о облачных сессиях. Он убил факт о CDN одного продукта, используя релиз-ноут другого продукта, потому что в обоих упоминался «CloudFront».

Он позволил карте указателей отозвать реальную память, на которую она указывала. Он отозвал список из шести открытых решений, потому что новая запись разрешила одно из них.

Четыре страховки и отмена

Четыре страховки это исправили. Уверенность не ниже 0,75. Реальное пересечение по теме, два общих топика или две общие сущности, никогда одна общая технология. Одинаковый класс, так что правило и событие никогда не замещают друг друга.

И полный охват: вердикт обязан утверждать, что победитель покрывает всё, что заявляет проигравший, и «в случае сомнения говорить „частично"» прописано в промпте. С включёнными страховками та же проверка автоматически применила ровно одно замещение, правильное, и отправила три подлинных противоречия в очередь на ревью.

Причина, по которой безопасно запускать это без присмотра, не в том, что модель хороша в этом деле. Причина в том, что ничего никогда не удаляется, каждое решение попадает в журнал аудита, и одна команда всё отменяет.

Замещённые записи остаются в хранилище с видимой меткой и штрафом к рейтингу. Старые факты угасают по периоду полураспада, а не исчезают: заметка о проекте теряет половину веса каждые 150 дней, а правило, данное пользователем, не угасает никогда.

Никогда не ослабляй страховки, чтобы куратор выглядел продуктивнее.

Память — это утверждение, поэтому проверяй его

Вот часть, которую больше никто из изученного нами не делает.

Память, которая была верна в мае и незаметно перестала быть верной, невидима. Она ничему не противоречит, не называет мёртвый путь, она просто лежит и остаётся неверной.

У нас была такая, которая гласила, что токены Instagram «автоматически ротируются еженедельно Lambda-функцией». Никакой Lambda не было. Ничто не ротировало токен за всю его жизнь. Она читалась как верная месяцами.

Так что теперь каждая память рассматривается как набор утверждений, и эти утверждения проверяются. Модель читает память и заполняет типизированные аргументы для фиксированного набора проверок: существует ли этот путь, существует ли эта ветка, влит ли этот pull request, существует ли этот проект Doppler, существует ли этот секрет, существует ли этот инстанс, отвечает ли этот URL.

Модель никогда не пишет команду. Каждый аргумент валидируется до того, как что-либо выполняется, и девять попыток prompt-инъекции против этого механизма были все отклонены. Написанный моделью shell по расписанию — это дыра для удалённого выполнения кода с дополнительными шагами.

Первый полный прогон извлёк 383 утверждения из 365 записей памяти. Триста двадцать восемь прошли проверку. Двадцать пять провалились.

Пять записей указывали на проекты Doppler, которых больше не существует. Пять pull request'ов, которые записи называли открытыми, были влиты. Семь путей файлов были мертвы. Одна запись утверждала, что репозиторий приватный, а он был публичным.

Что памяти позволено говорить

Из провалов вышли два правила, и оба о том, что памяти позволено говорить.

Статус pull request'а — не факт, это настроение. Он меняется за секунды. Экстрактор теперь принимает только «влит», потому что «влит» — терминальное состояние, и отказывается от «открыт» или «закрыт». Одиннадцать утверждений отброшены.

А проверка разделена по тому, что означает её провал. Путь, который не существует, — это доказательство: файловая система говорит правду откуда угодно. URL, который не отвечает, доказательством не является, потому что «недоступен с этого ноутбука» не то же самое, что «упал».

Так что проверка URL механически не способна вернуть «провал». Она может доказать жизнь. Ей запрещено доказывать смерть. Это правило существует, потому что я трижды за один аудит называл здоровый, огороженный файрволом продукт «упавшим», а правило, которое приходится держать в памяти, не является правилом.

Провалившееся утверждение записывает на память пометку «непроверено». Извлечение показывает её рядом с совпадением. Человеку не нужно ничего трогать; память приходит с ярлыком.

Что мы украли и у кого

Шестнадцать исследовательских агентов прочитали репозитории, клонировали их на закреплённых коммитах, запустили код и попытались опровергнуть друг друга. Из 64 утверждений 55 выжили. Две «цитаты» были сфабрикованы, а одна таблица оказалась подменена другой. Вот почему нужно проверять факты за исследовательскими агентами.

Взять и отвергнуть: три агента

Взять и отвергнуть: остальное поле

Цитата — это гипотеза

Один эпизод из исследования заслуживает отдельного раздела, потому что это та самая ошибка, которую вот-вот совершит любой читатель подобного материала.

Хорошо цитируемая статья о поиске измеряла расширение документов на стандартном бенчмарке. Расширение документа перефразировками показало результат ниже базовой линии без расширения. Расширение путём копирования собственных терминов документа показало результат значительно выше.

Наш промпт для обогащения памяти прямо говорил модели, что сгенерированные ею слова не должны встречаться в самой заметке. Мы генерировали проигравшую половину, подавляли выигравшую половину и усиливали проигравшую половину коэффициентом 1,75x.

Так что мы применили этот вывод. Заново вывели все 474 записи памяти. Батарея опустилась с 14 из 16 до 13 из 16. Хуже.

Базовая линия в статье была документом, проиндексированным без его собственных терминов, где копирование их обратно и есть расширение. Наш индекс уже включает заголовок, описание и тело. Копирование их в поле алиасов было дублированием и вытеснило перефразировки, которые были единственным настоящим расширением, какое у нас было.

Откатили, вывели заново, вернулись к 14 из 16. Сорок минут, и это были бы нулевые потери, если бы мы измерили до того, как поверили.

Цитата — это гипотеза о чужой системе.

Система памяти после этого сделала кое-что примечательное. Она захватила эту гипотезу автоматически, в конце сессии. Она не захватила опровержение.

Заметка со словами «включай термины» до сих пор лежит в хранилище как живая память. Захват записывает то, во что верили; он не знает, когда убеждение было опровергнуто час спустя. Это открытая проблема, и она в списке ниже.

Позволить агенту писать собственные навыки делает хуже

Команда попросила автономное создание навыков: когда процедура повторяется, агент должен записать её как переиспользуемый навык и сообщить об этом. Это суперспособность, и исследование говорит, что наивная версия — это обуза.

На бенчмарке из 87 задач с детерминированными проверками навыки, которые агент сгенерировал сам для себя, показали результат на 8,1 пункта ниже, чем вообще без навыков, на Claude Code с самой сильной моделью. Та же картина повторилась на двух других фреймворках.

Навыки, курируемые человеком, подняли долю успешных прохождений с 33,9% до 50,5%. А модель, которую просят выбрать, какой из двух навыков лучше, выбирает худший 84 раза из 100, когда разница реальна.

Длина имеет значение неожиданным образом. Компактные навыки дали прирост в 19 пунктов, стандартные — 21,5, подробные — 14,5, исчерпывающие — 0,7. Это горб, а не наклонная. За пределами одной страницы документация перестаёт помогать.

Противоположность автономности

Так что версия, которую мы построили, — это противоположность автономности. Она обнаруживает только процедуру, которая повторяется в трёх или более отдельных сессиях, и знает это благодаря подсчёту, потому что 67 704 реплики транскриптов проиндексированы, так что «повторяется ли это» — запрос к базе данных, а не догадка модели.

Она записывает навык неактивным, так что его описание никогда не попадает ни в чей контекст. Порог допуска структурный, никогда не оценка на прозе: назови конкретный сбой, который навык предотвращает, и каждый путь, который он упоминает, проверяется по файловой системе. Продвигает навык только человек.

Протестировано на шести враждебных черновиках: подмена встроенного навыка, «экономит время», увиденное однажды, выдуманные пути, раздутое тело — все отклонены, валидный допущен.

Первый реальный прогон за тридцать сессий не нашёл ничего для черновика. Это был правильный ответ. С тех пор продвинут один навык, страховка от команды деплоя, которая незаметно нацелена на продакшн.

Что до сих пор не так

Честность обходится дешевле альтернативы, так что вот остаток.

Всегда-активный слой всё ещё в три-четыре раза тяжелее, чем у Hermes, около 24 000 байт сегодня, и это индекс, а не профиль. Компактность, которой мы восхищались, идёт от механизма, который мы отвергли, и мы ещё не нашли более мягкого способа добиться той же дисциплины.

Согласованность не обеспечивается на стыках границ. В момент, когда появился профиль пользователя, каждый факт в нём стал существовать дважды. Куратор сверяет память с памятью, но не профиль с хранилищем, и не память с собственным файлом инструкций проекта. Honcho — доказательство того, что два производных представления одного факта в конце концов расходятся, и модель следует за неверным.

Захват срабатывает в конце сессии и перед компакцией, то есть ровно тогда, когда уверенное описание последовательности, которая на самом деле не сработала, наиболее вероятно. Опровергнутая цитата выше — живой пример.

Память проверяема ровно настолько, насколько проверяемы её утверждения. Путь, ветка, pull request, секрет и инстанс можно проверить. «Три тысячи из этих строк принадлежат странице» — нельзя, а «пользователь предпочитает X» вообще не является утверждением.

Хранилище всё ещё может держать тихо ложное высказывание; оно просто не может держать тихо ложный путь.

И собственная память системы памяти о самой себе устарела. Одна заметка указывает на файл хука, который система удалила, когда перенесла свои хуки в плагин. Она сидит в очереди на ревью, помеченная как непроверенная, ждёт как и остальные.

Пять правил

Если вы возьмёте из этого материала одну вещь, возьмите список.

Более крупный урок — тот, который вся отрасль продолжает переоткрывать не с той стороны. Половина памяти, отвечающая за извлечение, найти нужную заметку, хорошо изучена и в основном решена поисковым индексом, который ничего не стоит. Половина, отвечающая за контроль, решить, что заметке позволено утверждать, когда она замещается и как ловится ложная, вот где память гниёт.

Этой половиной никто не торгует, потому что это не фича. Это дисциплина, и её нужно встроить в код, чтобы никому не приходилось её помнить.

Если хотите увидеть, на чём ещё работает Boon, начните с Claude Code для дизайнеров, MCP-серверов, которые дают агенту руки, AI-агентов для дизайнеров, и сколько стоят токены агента, а именно эта память держит этот счёт на нуле. Если хотите такого же уровня заботы для своего бренда, Brainy Studio — это то, с чего всё начинается.

FAQ

Почему Claude Code забывает то, что я записал в MEMORY.md?

Claude Code загружает индекс auto-memory до 200 строк или 25 000 байт, в зависимости от того, какой лимит наступит раньше, и молча игнорирует остальное. Файл дописывается снизу новыми записями и обрезается с конца, так что самая свежая память отваливается первой. Если агент игнорирует правило, добавленное недавно, посчитайте строки и байты файла.

Стоит ли устанавливать плагин памяти для Claude Code?

Проверьте две вещи: запускает ли он модель в пути промпта, что добавляет секунды к каждому промпту, и запускает ли он фонового демона, где живёт большинство открытых issues крупнейшего плагина. Нашу проблему решил полнотекстовый индекс, поиск по которому идёт на каждый промпт, офлайн-проходы модели и шаг верификации. Ничему из этого демон не нужен.

Действительно ли поиск по ключевым словам достаточно хорош для памяти AI-агента?

Для этой задачи да. На стандартном бенчмарке zero-shot-извлечения каждая одновекторная embedding-модель проиграла обычному ключевому поиску BM25, а единственное, что его победило, кросс-энкодер-реранкер, стоит около 1,5 секунды загрузки модели против бюджета в 18 миллисекунд. Расширение документов, то есть запись слов, которые человек реально введёт, прямо в индекс офлайн, это техника, которая помогает, и она бесплатна.

Как не дать памяти поверить в ложь?

Двумя способами. Куратор, который никогда не удаляет: противоречие помечает более старую память как замещённую с видимым ярлыком и штрафом к рейтингу, каждое решение логируется, и одна команда всё отменяет. И верификатор, который рассматривает каждую память как типизированные утверждения, проверяет их против реального мира и помечает память как непроверенную, если проверка не прошла.

Сколько стоит запуск этой системы памяти?

Ноль долларов по предельной стоимости. Извлечение — это локальный запрос к базе данных, ничего не стоящий на каждый промпт. Каждый вызов модели, захват в конце сессии, обогащение новых записей и ежедневная проверка на противоречия, всё идёт через уже оплаченную подписку, никогда через тарифицируемый API. Реальная стоимость — это квота плана, примерно один небольшой вызов на сессию.