3,583 papers
arXiv:2602.17037 72 19 фев. 2026 г. FREE

Wink: три типа сбоев LLM-агентов и как их исправлять прямо в контексте

КЛЮЧЕВАЯ СУТЬ
Парадокс: переход на более умную модель не сокращает все сбои. У Opus 4.5 зависаний в петле оказалось больше, чем у Sonnet 4.5. Meta изучила 43 тысячи реальных сессий с AI-агентом — в 30% случаев агент сбоил по трём понятным паттернам. Метод позволяет исправить зависание или дрейф прямо в середине разговора, без перезапуска. Назови тип сбоя + дай DO/DON'T инструкцию — одно такое сообщение восстанавливает работу в 91% случаев.
Адаптировать под запрос

TL;DR

Исследователи Meta изучили ~43 000 реальных сессий с AI-агентом для кода и нашли, что в 30% случаев агент сбоит. Три главных типа: дрейф от задачи (игнорирует инструкции или делает незапрошенное), зацикливание (повторяет одно и то же без прогресса), ошибки с действиями (неправильно использует инструменты снова и снова). У каждого типа — своя механика и свой способ починки.

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

Wink — система, которая наблюдает за ходом работы агента, классифицирует тип сбоя и вставляет в контекст целевое DO/DON'T сообщение. Одна такая инъекция исправляет проблему в ~91% случаев.


🔬

Схема метода

ШАГ 1: Наблюдаем историю → выявляем тип сбоя
         (Дрейф / Петля / Ошибка действия)

ШАГ 2: Генерируем коррекцию → DO/DON'T инструкция
         (конкретная, адресная, про ЭТОТ сбой)

ШАГ 3: Вставляем инструкцию в контекст →
         агент продолжает с поправкой

⚠️ Если сбой повторился → повторяем ШАГ 1-3 (до 80% восстановления)

Все три шага в системе Wink — автоматические. Пользователь может воспроизвести ту же логику вручную в обычном чате: увидел сбой → распознал тип → дал адресную коррекцию.


🚀

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

Сначала определи ограничения: метод работает лучше всего при чётко видимых сбоях — когда модель явно делает не то. Не подходит для оценки качества субъективного контента.


Задача: Максим готовит питч-дек для инвестора на 12 слайдов. Просит ChatGPT подправить только формулировки в разделе «Проблема» (слайды 2-3) — сделать их острее. Модель вместо этого начинает переписывать весь раздел «Решение», добавляет новые слайды, меняет структуру.

Промпт для ручной коррекции:

СТОП.

Тип сбоя: дрейф от задачи — незапрошенные изменения.

Что происходит: ты редактируешь разделы и слайды,
которые я не просил трогать.

ИСПРАВЛЕНИЕ:
НЕ трогай слайды за пределами слайдов 2 и 3.
НЕ меняй структуру, количество слайдов, раздел «Решение».
СДЕЛАЙ одно: улучши только формулировки в слайдах 2-3
так, чтобы проблема звучала острее.

Покажи ТОЛЬКО изменённый текст этих двух слайдов.

Результат: Модель получит явный стоп-сигнал с названием сбоя, описанием проблемы и конкретными границами. В ответе будут только слайды 2-3 без лишних правок. Если сбой повторился — отправь ту же структуру снова.


🧠

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

Слабость: LLM генерирует следующий токен, опираясь на весь предыдущий контекст. Чем длиннее разговор, тем сильнее «тянет» в сторону от исходной инструкции — ранние ограничения «тонут» в общем объёме текста.

Сильная сторона: Модель хорошо реагирует на явные, свежие, конкретные инструкции в конце контекста. Последнее сообщение весит больше первого.

Как работает коррекция: Классификация сбоя + DO/DON'T команда убирает двусмысленность. Вместо «попробуй снова» — точное описание ЧТО пошло не так и КАК надо. Модель не угадывает желаемое, а следует явному переопределению задачи.

Рычаги управления: - Название типа сбоя → помогает модели активировать правильный паттерн поведения. Не "ты сделал не то", а "дрейф от задачи" - DO/DON'T формат → работает точнее, чем просто "исправь". Запрет конкретного действия снижает вероятность повтора - Граница видимого вывода ("покажи ТОЛЬКО...") → снижает вероятность дрейфа в следующем шаге


📋

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

СТОП.

Тип сбоя: {тип_сбоя}
(варианты: "дрейф от задачи", "незапрошенные изменения",
"зависание без прогресса", "игнор инструкций")

Что происходит: {описание_проблемы}

ИСПРАВЛЕНИЕ:
НЕ {что_делать_не_нужно}
СДЕЛАЙ {что_нужно_сделать}

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

Плейсхолдеры: - {тип_сбоя} — выбери из 3 типов (см. ниже) или опиши своими словами - {описание_проблемы} — что конкретно сделала модель лишнего / не того - {что_делать_не_нужно} — конкретное действие, которое нужно прекратить - {что_нужно_сделать} — конкретное действие, которое нужно начать


Шпаргалка: три типа сбоев и сигналы

Тип Что видишь Формулировка в промпте
Дрейф от задачи Делает не то, что просил / переписывает лишнее "дрейф от задачи — незапрошенные изменения"
Зависание Повторяет один и тот же шаг / топчется на месте "зависание без прогресса — повтор действий"
Игнор инструкций Пропускает явное ограничение, которое ты задал "игнор ограничений из условия задачи"

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

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

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

LLM спросит про тип сбоя и что конкретно пошло не так — потому что без этого нельзя сформулировать точную DO/DON'T инструкцию.


⚠️

Ограничения

⚠️ Игнор коррекции: Почти в 40% случаев не-восстановления модель просто продолжает делать то же самое. Если после коррекции сбой повторился дважды — помогает только перезапуск с более чёткой исходной инструкцией.

⚠️ Сложные многошаговые сбои: Чем больше ошибочных шагов накопилось ДО коррекции, тем хуже восстановление (~79% против ~91%). Лучше вмешиваться рано.

⚠️ Внешние причины: Если проблема не в поведении модели, а в инструменте / системе / конфликте данных — DO/DON'T не поможет. Нужно решать причину, не симптом.

⚠️ Более умная модель ≠ меньше сбоев: У более мощного Opus 4.5 зависаний в петле стало больше, чем у Sonnet 4.5. Переход на новую модель не гарантирует исчезновения всех типов сбоев.


🔗

Ресурсы

Wink: Recovering from Misbehaviors in Coding Agents Rahul Nanda, Chandra Maddila, Smriti Jha, Euna Mehnaz Khan, Matteo Paltenghi, Satish Chandra Meta Platforms, Inc. (New York / Bellevue / Menlo Park)

Упомянутые методы: ReACT pattern, LLM-as-judge, Model Context Protocol (MCP)


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

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

Парадокс: переход на более умную модель не сокращает все сбои. У Opus 4.5 зависаний в петле оказалось больше, чем у Sonnet 4.5. Meta изучила 43 тысячи реальных сессий с AI-агентом — в 30% случаев агент сбоил по трём понятным паттернам. Метод позволяет исправить зависание или дрейф прямо в середине разговора, без перезапуска. Назови тип сбоя + дай DO/DON'T инструкцию — одно такое сообщение восстанавливает работу в 91% случаев.

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

Три типа сбоев — и у каждого своё лицо. Дрейф от задачи: модель делает незапрошенное или игнорирует ограничения — просил поправить заголовки, переписала весь документ. Зависание: повторяет один и тот же шаг без движения вперёд. Ошибка с инструментом: неправильно использует функцию и делает это снова и снова. Стандартный ответ на сбой — 'попробуй снова' — не работает. Нужно другое: дать модели явное переопределение. Последнее сообщение в контексте перевешивает первое: ранние инструкции тонут в объёме разговора, свежая коррекция в конце перебивает этот эффект. Структура коррекции: СТОП → название типа сбоя → что конкретно пошло не так → НЕ делай X → СДЕЛАЙ Y.

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

LLM генерирует следующий токен, опираясь на весь предыдущий контекст. Чем длиннее разговор, тем больше веса набирает 'средняя температура' текста — и тем сильнее исходные ограничения уходят на задний план. Не потому что модель их забыла. Просто они перестали быть 'свежими'. Называние типа сбоя помогает модели точнее попасть в нужный поведенческий режим: не просто 'исправь', а конкретный сигнал о том, что именно нарушено. Поэтому DO/DON'T работает точнее, чем просто переформулировка запроса. Вмешательство на раннем этапе даёт 91% восстановления. Если сбой накопился — падает до 79%. Чем раньше заметил, тем лучше.

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

Любая длинная задача в ChatGPT, Claude, Gemini — редактирование, написание кода, анализ документов, исследование — когда модель уходит от условий или ходит по кругу. Особенно хорошо работает когда сбой виден явно: модель делает не то, что просили. НЕ подходит, если проблема не в поведении модели, а в конфликте данных, ошибке инструмента или неточности исходного задания — коррекция лечит симптом, а не причину.

Мини-рецепт

1. Определи тип сбоя: дрейф от задачи (делает незапрошенное), зависание (повторяет шаг без прогресса), игнор ограничений (пропускает явное условие).
2. Начни с СТОП: резкий сигнал разрывает инерцию контекста.
3. Назови тип: не 'ты сделал не то', а 'тип сбоя: дрейф от задачи — незапрошенные изменения'.
4. Дай DO/DON'T: одно конкретное 'НЕ делай X' + одно конкретное 'СДЕЛАЙ Y'. Без лишних слов.
5. Добавь границу вывода: 'покажи ТОЛЬКО...' — снижает вероятность нового дрейфа.
6. Если повторилось: отправь ту же структуру снова. Восстановление падает с 91% до ~80%, но всё ещё работает. Два повтора без результата — перезапускай с более чёткой исходной инструкцией.

Примеры

[ПЛОХО] : Ты делаешь не то что я просил, попробуй ещё раз
[ХОРОШО] : СТОП. Тип сбоя: дрейф от задачи — незапрошенные изменения. Что происходит: ты редактируешь разделы, которые я не просил трогать — меняешь структуру и добавляешь слайды. ИСПРАВЛЕНИЕ: НЕ трогай ничего за пределами слайдов 2 и 3. СДЕЛАЙ одно: улучши только формулировки в слайдах 2-3, чтобы проблема звучала острее. Покажи ТОЛЬКО изменённый текст этих двух слайдов.
Источник: Wink: Recovering from Misbehaviors in Coding Agents
ArXiv ID: 2602.17037 | Сгенерировано: 2026-02-20 10:42

Проблемы LLM

ПроблемаСутьКак обойти
Ранние инструкции теряют вес к середине разговораЧем длиннее контекст, тем слабее работают ограничения из начала. Сказал "трогай только слайды 2-3" — к пятому ответу модель уже правит весь документ. Не злой умысел. Просто последние сообщения весят больше первых. Проблема нарастает на любых длинных задачахДублируй ключевые ограничения явно в конце. Или вставь коррекцию (см. метод ниже) как только увидел первый уход от задачи

Методы

МетодСуть
Стоп-коррекция — назови тип сбоя + DO/DON'TКогда модель сбоит — не пиши "нет, не то". Пиши структурно: СТОП. Тип сбоя: {дрейф от задачи / зависание без прогресса / игнор ограничения}. Что происходит: {конкретно что делает не то}. НЕ {что прекратить}. СДЕЛАЙ {что нужно вместо этого}. Почему работает: Три элемента дают разное. Слово "СТОП" разрывает инерцию генерации. Название типа сбоя активирует нужный паттерн поведения — модель не угадывает что хочешь, а получает метку. DO/DON'T убирает двусмысленность: запрет конкретного действия снижает вероятность повтора сильнее чем просьба сделать лучше. Шпаргалка типов: "дрейф" — делает незапрошенное; "зависание" — повторяет один шаг без движения; "игнор" — пропускает явное ограничение. Когда не поможет: Если после двух коррекций сбой повторяется — дело не в поведении модели. Нужен перезапуск с более чёткой исходной задачей
📖 Простыми словами

Wink: Recovering from Misbehaviors in Coding Agents

arXiv: 2602.17037

AI-агенты для написания кода — это не магия, а обычные исполнители, которые со временем неизбежно начинают тупить. Проблема в самой архитектуре: LLM генерирует ответ, опираясь на всю историю переписки, и чем длиннее становится этот «хвост», тем слабее модель слышит твои исходные команды. В итоге контекстное окно превращается в болото, где важные инструкции тонут под весом собственных же логов и промежуточных правок. Исследователи из Meta прогнали через микроскоп 43 000 сессий и подтвердили диагноз: каждый третий агент ломается, просто потому что теряет нить реальности.

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

Авторы выделили три конкретных сценария, где всё идет прахом. Первый — дрейф от задачи, когда агент внезапно решает, что он умнее всех, и начинает рефакторить то, о чём его не просили. Второй — бесконечное зацикливание, самый бесячий баг, где модель повторяет одну и ту же ошибку в цикле, надеясь на другой результат. Третий — инструментальный паралич, когда агент просто разучивается пользоваться консолью или файлами. Статистика неумолима: 30% сессий заканчиваются этим мусором, если не внедрять механизмы самоконтроля.

Хотя исследование проводили на кодинге, этот принцип универсален для любого сложного взаимодействия с AI. Будь то написание длинной статьи, юридический анализ или планирование отпуска — как только диалог раздувается, модель начинает лажать. Метод Wink учит систему вовремя замечать, что она свернула не туда, и принудительно «откатывать» состояние к моменту, когда всё еще было нормально. Это база для любого автономного агента: если он не умеет признавать, что затупил, он бесполезен.

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

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

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

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