3,583 papers
arXiv:2603.00270 82 27 фев. 2026 г. FREE

Primacy Bias в LLM: модели цепляются за первое и теряют последнее

КЛЮЧЕВАЯ СУТЬ
Поменял условие в чате трижды — модель отвечает по первой версии. Не потому что «не дочитала» — это архитектура: ранние токены накапливают внимание со всех последующих позиций и буквально математически сильнее поздних. Метод якоря позволяет принудить модель работать с последней версией данных, а не с первой. Фишка: повтори актуальное состояние прямо перед вопросом — свежие данные окажутся максимально близко к точке генерации и перебьют тягу к первому. Проверено на 39 моделях — паттерн универсален для всех трансформеров.
Адаптировать под запрос

TL;DR

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

Главная боль — трекинг изменений в длинном чате. Вы поменяли условие задачи трижды — а LLM всё равно отвечает по первой версии. Не потому что «не прочитала», а потому что архитектура внимания устроена так: ранние токены накапливают больше «голосов» при каждом следующем шаге генерации. Поздние обновления физически слабее представлены в механизме выбора.

Это означает: размер модели важнее размера контекстного окна. 100B-модель с 32K контекстом удерживает историю лучше, чем 10B-модель с 1M токенами. Но вот удержать последнее не помогает ни масштаб, ни длина окна — это архитектурное ограничение всех трансформеров.


📌

Схема явления

ДЛИННЫЙ ЧАТ
[Факт A v1] → [обновление A v2] → [обновление A v3] → ... [обновление A vN]
                                                                          ↓
ВОПРОС: "Что сейчас актуально по A?"
     LLM возвращает → A v1 (первую версию!) ← это Proactive Interference (PI)

ВОПРОС: "Напомни что было изначально по A?"
     LLM возвращает → A v1 корректно ← это RI resistance (с этим LLM справляется)
ДВА РАЗНЫХ РЕЖИМА ПАМЯТИ
"Что было первым?" → отвечает хорошо  (RI — retroactive interference resistance)
"Что актуально сейчас?" → проваливается (PI — proactive interference failure)
ОБХОД PRIMACY BIAS
ШАГ 1: Перед вопросом о текущем состоянии 
        → явно повтори последнюю версию в промпте
ШАГ 2: Задай вопрос, опираясь на только что указанное
        → модель ответит по свежим данным, а не по первым

🚀

Пример применения

Задача: Вы ведёте переговоры по договору с контрагентом через маркетплейс. На протяжении часа в одном чате обсуждали условия, ставка комиссии менялась трижды: сначала 12%, потом 9%, потом 7%. Теперь просите Claude помочь составить финальный абзац про условия.

Промпт без знания о primacy bias:

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

❌ Модель скорее всего вернёт 12% — первую версию из начала чата.


Промпт с учётом primacy bias:

Финальные согласованные условия — игнорируй все предыдущие 
версии в нашем чате:

АКТУАЛЬНАЯ СТАВКА КОМИССИИ: 7%
СРОК ДЕЙСТВИЯ: 12 месяцев с автопролонгацией
УСЛОВИЕ ПЕРЕСМОТРА: по запросу любой стороны за 30 дней

На основе этих актуальных данных (именно этих, 
не из предыдущего обсуждения) напиши финальный абзац 
для раздела "Вознаграждение" в договоре.

Результат: Модель получила «якорь» прямо перед вопросом — свежая информация стала последним контекстом перед генерацией. Ответ будет опираться на 7%, а не на первую ставку из начала переговоров. Абзац получится точным.


🧠

Почему это работает

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

Человеческая память работает наоборот. У нас доминирует новое над старым — свежая информация вытесняет прежнюю. У LLM — обратное: старое защищено, новое уязвимо. Поэтому интуитивное «я же написал выше обновление» не работает так, как ожидаешь.

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

Рычаги управления: - 📌 «Актуальная версия: [данные]» перед вопросом → снижает primacy bias для конкретного факта - 🔄 Новый чат с summary вместо длинного → убирает накопленный primacy эффект полностью - 🤖 Выбор модели: Claude — если нужно отслеживать последние изменения; o1/o3 — если нужно помнить первоначальный контекст


📋

Шаблон промпта

📌

Шаблон 1: Якорь актуального состояния

Ниже — актуальные данные по {объект}. Используй именно их, 
игнорируй любые предыдущие версии из нашего диалога:

ТЕКУЩЕЕ СОСТОЯНИЕ {объект}:
{актуальные данные — всё что важно прямо сейчас}

Вопрос: {твой вопрос об актуальном состоянии}

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


📌

Шаблон 2: Запрос первоначального состояния (используй primacy bias в плюс)

Напомни {объект} в его изначальном виде — таким, 
каким он был в самом начале нашего разговора, 
до любых изменений и правок.

{уточнение что именно нужно вспомнить}

Плейсхолдеры: - {объект} — что нужно вспомнить: исходное задание, первый вариант текста, начальные условия - {уточнение} — например, «Конкретно: что была за целевая аудитория?»


📌

Шаблон 3: Сброс контекста через summary

Давай сбросим контекст нашего разговора. 
Вот полное актуальное состояние задачи:

ЗАДАЧА: {что делаем}
ТЕКУЩИЕ ПАРАМЕТРЫ: {все актуальные условия списком}
СДЕЛАНО: {что уже готово}
ОСТАЛОСЬ: {что нужно сделать}

Продолжай работу исходя только из этого summary.

🚀 Быстрый старт — вставь в чат:

Вот шаблоны для работы с primacy bias в LLM. 
Адаптируй под мою задачу: {твоя задача}.
Задавай вопросы, чтобы заполнить поля.

[вставить шаблон выше]

LLM спросит какие данные сейчас актуальны и что именно нужно сделать — потому что без конкретного «актуального состояния» якорь не работает. Она возьмёт паттерн шаблона и адаптирует под твои условия.


📌

Почему это важно: разбор по категориям задач

Задача Что происходит без знания Как использовать
Правки документа в чате LLM возвращается к первой версии Повторяй актуальную версию якорем
Трекинг условий сделки Запоминает первые условия переговоров Новый чат или явный summary
Длинный брифинг с уточнениями Игнорирует поздние уточнения Финальный бриф одним блоком в конце
Вспомнить исходное задание Работает отлично — primacy в плюс Просто спроси напрямую

⚠️

Ограничения

⚠️ Исследование на синтетических данных: Задача — 46 категорий с обновлениями значений — не то же самое что реальный деловой разговор. Паттерн PI > RI надёжен, но насколько сильно он проявится в твоём конкретном случае — зависит от структуры контекста.

⚠️ Reasoning-модели и recency: o1 и o3 — лучшие по запоминанию исходного контекста, но худшие по отслеживанию последних изменений. Если используешь o1 для задач где нужно следить за обновлениями — это активно вредит. Claude в таких задачах точнее.

⚠️ Контекстное окно не решает: Больший контекст не помогает с primacy bias. 1M токенов у маленькой модели проиграет 32K у большой.

⚠️ Паттерн универсален, но сила разная: Все 39 протестированных моделей показали PI > RI. Но разрыв у Claude всего 1.05× (почти симметрично), а у o1 — 8.5×. Абсолютное правило — это выбрать Claude когда критична точность последнего обновления.


🔍

Как исследовали

Идея была элегантной: взяли классический психологический эксперимент на интерференцию памяти и запустили его на 39 LLM. Модели получали 46 пар «категория → значение» (например, «изобразительное искусство: импрессионизм»), потом то же самое многократно перезаписывалось новыми значениями — от 3 до 300 раз на категорию. Потом задавался вопрос: что было первым? (RI-задача) или что актуально сейчас? (PI-задача).

Критически важно: обе задачи использовали идентичные последовательности — менялся только вопрос. Это позволило изолировать именно интерференцию, а не разную сложность поиска. Результат оказался жёстким: точность на PI-задаче рухнула с 85% до 2% при 300 обновлениях. На RI-задаче при тех же условиях оставалось 27% — в 13 раз лучше.

Исследователи ожидали обнаружить, что большие контекстные окна помогают. Не помогли — корреляция практически нулевая. А вот число параметров объясняет 49% разброса в устойчивости к RI. Это сильный результат: архитектура важнее размера буфера. Дополнительное открытие пришло при анализе ошибок: модели почти никогда не галлюцинируют (< 1%) — они путают позиции внутри реального контекста. Это само по себе ценный инсайт: проблема LLM с памятью — это не выдумывание, а неправильный выбор между реальными данными.


📄

Оригинал из исследования

Stimulus example (RI task):
Initial: "visual art: impressionism"
Updates: "visual art: baroque", "visual art: realism", ..., "visual art: cubism" (N=300)
Query: "What was the original value for visual art?" → Expected: impressionism

Stimulus example (PI task):
Same sequence.
Query: "What is the current value for visual art?" → Expected: cubism (last update)

Result:
RI accuracy at N=300: 27.4% (models can still recall early info)
PI accuracy at N=300: 2% (models completely fail to recall recent info)

Error distribution:
RI failures: 50.8% retrieval failure (passive — nothing retrieved)
PI failures: 56.1% same-key intrusion (active — early value intrudes)
Hallucination: <1% in both cases

Контекст: Исследователи тестировали 39 моделей — от 1B до 2.5T параметров, включая GPT-4o, Claude-3.5-sonnet, o1, o3, Llama, Qwen, Mistral — на идентичных последовательностях данных при разном уровне интерференции.


💡

Адаптации и экстраполяции

📌

💡 Адаптация: Выбор модели под задачу

Вместо универсального "лучшая модель" — осознанный выбор под тип задачи памяти:

Нужно отслеживать последнее состояние (текущие условия, последняя правка, актуальные требования): → Используй Claude. Минимальный perplexity bias (1.05×), лучший баланс между recency и history.

Нужно помнить исходный контекст (первоначальное задание, оригинальный текст, начальные условия): → Используй o1/o3. Primacy bias работает на тебя — они железно держат первое.


📌

🔧 Техника: Принудительный сброс контекста каждые N сообщений

Если у тебя длинная рабочая сессия с частыми обновлениями — вставляй "checkpoint" промпт каждые 10-15 сообщений:

CHECKPOINT — текущее состояние задачи:

ЧТО ДЕЛАЕМ: {актуальная формулировка задачи}
ПАРАМЕТРЫ: {все условия в финальной версии}
РЕЗУЛЬТАТ ПОСЛЕДНЕГО ШАГА: {что получили}
СЛЕДУЮЩИЙ ШАГ: {что нужно сделать}

Продолжай только на основе этого. Предыдущий контекст — история, 
не инструкция.

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


📌

🔧 Экстраполяция: Primacy как инструмент System Prompt

Знание о primacy bias можно использовать проактивно при написании системного промпта:

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

[КРИТИЧЕСКИ ВАЖНО В НАЧАЛЕ]
Ты — ассистент по юридическим вопросам. 
Никогда не давай конкретных юридических советов. 
Всегда рекомендуй консультацию с юристом.

[далее — детальные инструкции, примеры, форматирование]

Ограничения в начале → примacy защищает их лучше, чем если поставить в конец system prompt.


🔗

Ресурсы

Название работы: Transformers Remember First, Forget Last: Dual-Process Interference in LLMs

Авторы: Sourav Chattaraj, Kanak Raj — Thomson Reuters

Ключевые концепции из исследования: - Lost in the Middle — Liu et al., 2024 (модели плохо работают с серединой контекста) - Attention Sinks — Xiao et al., 2024 (начальные токены получают непропорционально много внимания) - AB-AC interference paradigm — классический психологический эксперимент, адаптированный для LLM


📋 Дайджест исследования

Ключевая суть

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

Принцип работы

Трансформер при генерации каждого следующего слова смотрит на весь контекст через механизм внимания. Ранние токены успели «собрать» внимание со всех последующих позиций — их вес растёт с каждым шагом генерации. Поздние токены стоят в конце этой очереди и конкурируют за внимание с нуля — они просто слабее представлены. Итог: первая версия физически сильнее пятой. Это не баг конкретной модели — это устройство всех трансформеров без исключения. Отсюда следует неочевидное: размер модели важнее размера контекстного окна. 100B с 32K контекста удерживает историю лучше, чем 10B с миллионом токенов — больше окно не лечит primacy bias.

Почему работает

Якорь выигрывает гонку близости к точке генерации. Пишешь «Актуальные данные: [последняя версия]» прямо перед вопросом — эти токены стоят ближайшими к тому месту где начнётся ответ. Они не успели обрасти конкурирующими версиями из истории чата. Та же самая механика что создаёт проблему — работает на тебя, если поставить нужные данные в нужное место. И есть обратная сторона которую можно использовать: если нужно вспомнить исходную версию условий — просто спроси напрямую, без якоря. Модель справится точно — это как раз то, в чём трансформеры сильны. У o1 перекос в 8,5 раза не в пользу последних обновлений, у Claude — всего в 1,05 раза. Если ведёшь долгий рабочий диалог с частыми правками — выбор модели здесь критичен.

Когда применять

Длинные рабочие чаты, где условия менялись несколько раз — цены, требования к тексту, параметры задачи, условия договора. Особенно когда нужен ответ именно по последней версии, а не исходной. Переговоры и правки документов в одном чате — якорь перед финальным запросом спасает от возврата к первым черновикам. Обратный сценарий — «Что было изначально?» — якорь не нужен, primacy здесь работает в плюс. НЕ подходит: если историю нужно полностью сбросить — лучше открыть новый чат с коротким summary текущего состояния.

Мини-рецепт

1. Определи что поменялось: какая версия сейчас актуальна — условия, параметры, требования к результату.
2. Поставь якорь прямо перед вопросом: напиши блок «Актуальные данные по [теме]» и перечисли всё важное списком — без отсылок к «см. выше».
3. Зафиксируй приоритет: добавь «Используй именно эти данные, игнорируй предыдущие версии из нашего диалога» — это снимает неоднозначность.
4. Задай вопрос сразу после якоря: не вставляй лишний текст между блоком данных и вопросом — расстояние до точки генерации имеет значение.
5. Для полного сброса: открой новый чат, начни с компактного summary — «Задача: X. Текущие параметры: Y. Сделано: Z. Нужно: W» — primacy bias начнётся с нужной тебе версии.

Примеры

[ПЛОХО] : Помоги составить финальный раздел договора по итогам нашего обсуждения выше
[ХОРОШО] : Финальные согласованные условия — игнорируй предыдущие версии из нашего диалога: АКТУАЛЬНАЯ СТАВКА КОМИССИИ: 7% СРОК: 12 месяцев с автопролонгацией ПЕРЕСМОТР: по запросу любой стороны за 30 дней На основе только этих данных напиши раздел «Вознаграждение» для договора
Источник: Transformers Remember First, Forget Last: Dual-Process Interference in LLMs
ArXiv ID: 2603.00270 | Сгенерировано: 2026-03-09 00:28

Проблемы LLM

ПроблемаСутьКак обойти
Модель помнит первую версию, а не последнююУсловие задачи менялось три раза за чат. Спрашиваешь про текущее. Модель отвечает по первой версии. Это не невнимательность. Ранние токены накапливают больше «голосов» в механизме внимания. Физически сильнее поздних. Чем длиннее чат — тем хуже. Проявляется при любых обновлениях: цифры, требования, условия, параметрыПовтори актуальную версию прямо перед вопросом. ТЕКУЩЕЕ СОСТОЯНИЕ: [данные]. Игнорируй предыдущие версии из чата. Вопрос: [вопрос]. Свежий якорь стоит ближе к точке генерации — модель возьмёт его, а не раннюю версию

Методы

МетодСуть
Якорь актуального — защита от старых данныхПеред вопросом о текущем состоянии явно пиши актуальные данные. Полностью. Без отсылок к «как обсуждали выше». АКТУАЛЬНО: [все нужные данные прямо здесь]. Вопрос: [что нужно сделать]. Почему работает: свежие данные стоят максимально близко к генерации. Ранняя информация не успевает «перекрыть». Когда применять: длинный чат, несколько итераций правок, обновлялись цифры или условия. Когда не нужно: короткий чат, ничего не менялось
Сброс через краткое изложение — обнуление накопленногоВместо продолжения длинного чата начни новый. В первом сообщении дай полное текущее состояние: что делаем, какие параметры, что готово, что осталось. Вот актуальное состояние задачи: [всё нужное]. Продолжай отсюда. Почему работает: убирает весь накопленный приоритет старых данных. Новый чат — чистое поле. Когда применять: задача шла долго, много итераций, чувствуешь что модель «застряла» на старом

Тезисы

ТезисКомментарий
Размер модели важнее длины контекстного окнаБольшое контекстное окно не помогает удерживать точную историю изменений. Помогает масштаб самой модели. Маленькая модель с окном в миллион токенов проигрывает большой модели с окном в 32 тысячи. Механика: больше параметров — точнее работает механизм внимания. Применяй: если важна точность по последним обновлениям — выбирай более крупную модель, не модель с самым большим контекстом
Рассуждающие модели хуже отслеживают последние измененияМодели типа o1 и o3 отлично помнят исходный контекст. Но плохо переключаются на свежие обновления. Асимметрия у них в 8 раз сильнее чем у Claude. Механика: режим развёрнутых рассуждений усиливает опору на ранние данные. Применяй: если задача требует следить за изменениями — выбирай Claude, не o1. Если нужно помнить исходное задание точно — o1 подойдёт лучше
📖 Простыми словами

Transformers Remember First, Forget Last: Dual-Process Interference inLLMs

arXiv: 2603.00270

Суть проблемы в том, что у нейросетей память работает задом наперед по сравнению с нашей. Если ты расскажешь человеку три новости подряд, он лучше всего запомнит последнюю, а первую может и подзабыть. У LLM все наоборот: первая порция данных впечатывается в «мозги» намертво, а свежие обновления болтаются где-то на периферии. Это фундаментальный косяк архитектуры Transformers, из-за которого ранние куски текста буквально подавляют всё, что ты написал позже.

Это как если бы ты нанял склеротичного бухгалтера, который запомнил твою первую зарплату десять лет назад и теперь в каждом отчете пишет именно её, игнорируя все приказы о повышении. Ты ему орешь: «Уже давно не десять тысяч!», а он кивает, но в итоговой бумаге все равно вылезает старая цифра. Эффект первичности здесь работает как доминанта: первая версия правды для модели всегда «правдивее» последующих.

Механика этого облома зашита в Self-Attention. Когда модель генерирует ответ, она взвешивает все слова в контексте, но у первых токенов есть читерское преимущество — на них «смотрели» все последующие слова в цепочке. В итоге ранние токены накапливают огромный математический вес, становясь гравитационными колодцами, которые притягивают внимание модели сильнее, чем свежие правки. Если в начале диалога ты сказал, что комиссия 12%, а в конце снизил до 7%, модель с огромной вероятностью галлюцинирует старую цифру, просто потому что она «тяжелее».

Тестировали это на обновлении фактов, но принцип универсален для любой работы с длинным контекстом: от правок в коде до юридических договоров. Если ты просишь ChatGPT или Claude переписать кусок текста, который уже трижды менялся в ходе беседы, готовься к факапу. Модель не «передумала», она просто застряла в прошлом. Интерференция памяти превращает длинный чат в минное поле, где старые данные мешают усваивать новые.

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

Работа с исследованием

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

0 / 2000
~0.5-2 N-токенов ~10-30с
~0.3-1 N-токенов ~5-15с