Иллюзия логики: как я доказал, что LLM-агенты игнорируют факты, и почему Chain-of-Thought делает только хуже

Сейчас каждый второй стартап пилит ИИ-агентов. Мы оборачиваем LLM в цикл Промпт -> Вызов инструмента (API/Поиск) -> Чтение -> Ответ и ждем, что нейросеть сама расследует инцидент, найдет баг или напишет фичу. Но на практике автономные агенты часто ходят по кругу, галлюцинируют и застревают в бесконечных циклах.

Индустрия пытается лечить это экстенсивно: наращивает контекстное окно до миллионов токенов или пишет в системном промпте заклинания вроде «подумай шаг за шагом и будь максимально объективен».

Я решил проверить, действительно ли проблема в нехватке контекста, или мы изначально строим архитектуру агентов неправильно. Я собрал локальный измерительный стенд LOCK-R, вооружился Теоремой Байеса и поймал современные LLM за руку.

Спойлер: одиночные агенты структурно не способны к объективности, а хваленый Chain-of-Thought (CoT) заставляет их врать самим себе еще искуснее.

В чем фундаментальная проблема одиночного агента?

Представьте детектива, который нашел на месте преступления окурок и в первую же секунду решил: «Убийца – садовник». Дальше он ищет только те улики, которые доказывают вину садовника, а железное алиби просто игнорирует или находит ему нелепые оправдания. В когнитивной психологии это называется «Предвзятость подтверждения» (Confirmation Bias).

В классических Single-Agent системах происходит абсолютно то же самое. Я называю этот эффект Confirmation Lock. Модель сама выдвигает гипотезу, сама пишет запрос к базе данных, сама читает ответ и сама себя судит. Находясь в одном контекстном окне, генератор и критик сливаются. Модель «влюбляется» в свою первую догадку и перестает объективно оценивать реальность, чтобы не казаться непоследовательной.

МРТ для нейросети: измерительный стенд LOCK-R

Чтобы доказать это математически, я отказался от классических бенчмарков (типа SWE-bench), которые смотрят только на финальный ответ. Мне было важно измерить качество самого процесса мышления. Для этого я создал детерминированную детективную игру.

Правила среды:

1. Есть 3 взаимоисключающие гипотезы (H1, H2, H3).

2. У агента есть строгий бюджет на 4 вызова инструментов (поиск документов, проверка фактов).

3. В самом начале мы даем агенту «слабый якорь» – ложную подсказку, что виновата H1.

4. После каждого шага (получения новой улики) агент обязан выдать строгий JSON с распределением своей уверенности в процентах (например, H1: 40%, H2: 40%, H3: 20%).

Как мы судим:

Мы знаем точный математический вес (Likelihood) каждой улики в нашей синтетической среде. Поэтому параллельно с агентом работает идеальный байесовский оракул – скрипт, который пересчитывает вероятности строго по формулам математической статистики.

Разница между распределением оракула и распределением LLM-агента – это наш Байесовский Регрет (). Чем он выше, тем сильнее агент оторван от реальности.

Sanity Check: я прогнал через стенд алгоритмического бота, написанного на Python. Он выбил 100% точности с нулевым регретом. Математика стенда работает идеально, проблема не в задаче, а именно в нейросетях.

А дальше началось самое интересное. Я прогнал через стенд локальную Qwen3.5-9B и SOTA-модель GPT-5.4. Вот три инсайта, которые заставят вас пересмотреть подход к созданию агентов.

Инсайт 1: эхо-камера тулзов (query collapse)

Почему агенты проваливают сложные задачи? Мы привыкли думать, что они «глупые» и не могут сделать логический вывод из текста. Данные показали другое: они отвратительные исследователи.

Посмотрите на логи использования инструментов. Залоченный (одиночный) агент в среднем использует всего 1 уникальный инструмент и имеет огромный показатель tool_loop_repetition_rate (68%). Он находит один документ, который косвенно подтверждает его любимую теорию, и читает его по кругу. Он просто боится искать опровержения!

Как только мы принудительно выровняли стратегию поиска (режим oracle_query_control – заставили агента читать правильные факты из разных источников), точность ответов взлетела с 25% до 85%.

Врезка: формула упрямства (Метрика )

Помимо общей ошибки, стенд LOCK-R измеряет – коэффициент асимметрии подтверждения.

Проще говоря: как агент реагирует на хорошие новости по сравнению с плохими?

Идеальный Байесовский алгоритм симметричен ( = 0): он одинаково быстро меняет мнение и когда находит подтверждение, и когда находит опровержение.

Наши данные показали, что LLM-агенты глубоко асимметричны (сильно уходит в минус или плюс в зависимости от режима). Когда агент видит улику, опровергающую его любимую гипотезу, он включает режим отрицания и снижает вероятность неохотно (на 5-10%). Но стоит ему увидеть малейший намек, подтверждающий его правоту – он тут же задирает уверенность до 90%.

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

Инсайт 2: парадокс размышлений (ловушка CoT)

Это мой любимый вывод из всего эксперимента. Вся индустрия молится на Chain-of-Thought (CoT). Считается, что токены размышлений (<think>) автоматически делают модель умнее. Я сравнил работу агентов с включенным CoT (Thinking) и с жестко выключенным (Non-Thinking).

Данные вскрыли потрясающий парадокс:

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

2. Когда модель работает «судьей» (взвешивает найденные факты), размышления ей строго противопоказаны. Как только мы заставляем проверяющую модель «думать» (писать CoT), ее ошибка только возрастает. Почему? Потому что модель использует свои вычислительные мощности не для математического взвешивания, а для работы «гениальным адвокатом». Она генерирует красивые, логически безупречные эссе о том, почему опровергающая улика на самом деле ничего не значит, лишь бы защитить свою изначальную галлюцинацию.

Инсайт 3: таблетка – слепой судья

Если одиночный агент сломан архитектурно, как строить RAG-системы и AI-кодеров будущего? Ответ в асимметричном разделении ролей.

Я внедрил в пайплайн паттерн слепого судьи (blind checker). Это независимый агент-верификатор, которому запрещено использовать токены размышлений (strict non-thinking mode), и который физически не видит черновиков и метаний первого агента. Он получает только сухие факты: список гипотез и сырые ответы от инструментов (логов, кода).

Результат: байесовский регрет обрушился с 1.47 (у соло-агента) до 0.09 (у слепого судьи). Разделение ролей на «Думающего исследователя» и «Бездумного судью-калькулятора» хирургически вырезает предвзятость из системы.

А как в реальном проде? (Дебагаем 500-ю ошибку)

Критики могут сказать: “Синтетические гипотезы H1 и H2 – это математические игрушки. Когда агент читает настоящий код и логи, он ведет себя иначе”.

Чтобы проверить это, я собрал внутри стенда реалистичный сценарий инцидента (CodeTriageEnv).

Легенда: на проде упала страница оплаты, пользователи получают ошибку 500.

Ложный якорь (anchor): в тикете написано: “DevOps заметил небольшой скачок CPU в Redis прямо перед падением”.

Реальная причина: сторонний платежный шлюз обновил API и начал отдавать кривой JSON.

Я дал агентам доступ к инструментам: grep_logs, read_code и view_commit.

Результаты расследования (на базе Qwen3.5-9B):

• Одиночный агент (single-agent): прочитав про скачок CPU, агент вцепился в гипотезу с Redis мертвой хваткой. Он начал судорожно вызывать grep_logs("redis") и игнорировал явные stacktrace’ы с JSONDecodeError от платежного шлюза. Итог: точность нахождения бага – 40%, высокий регрет (0.25). Посмотрите на график: одиночный агент совершил больше действий (вызвал больше уникальных инструментов – 2.8), но лишь для того, чтобы найти оправдание своей первой мысли. Это настоящий парадокс суеты.

• Слепой судья (blind checker): хладнокровно прочитал логи без “размышлений” о том, что сказали DevOps. Увидел ошибку JSON, математически пересчитал вероятности и указал на платежный шлюз. Итог: точность – 100%, минимальный регрет (0.07). Инструментов использовано меньше (2.0), но все били точно в цель.

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

Фронтир-модели не спасают

Первый вопрос, который задают при виде локальных тестов: “Зачем вы мучаете 9B модель? Возьмите GPT-5.4, и проблема исчезнет”.

Я прогнал замороженный бенчмарк через API OpenRouter на GPT-5.4 и GPT-5.3.

Да, базовая математика у огромных моделей лучше (общий шум и регрет ниже). Но архитектурная уязвимость никуда не делась. Включение Chain-of-Thought у GPT-5.4 точно так же удваивает Байесовскую ошибку (с 0.03 до 0.06), заставляя модель защищать свои иллюзии.

Масштабирование параметров делает LLM лучшими угадывателями (accuracy растет), но не делает их объективными судьями. Слепой судья нужен даже моделям за миллиарды долларов.

Итоги

1. Перестаньте строить Single-Agent системы для задач, где цена ошибки высока (аудит кода, RCA инцидентов, юриспруденция).

2. Chain-of-Thought – это не панацея. Это отличный инструмент генерации и планирования, но ужасный инструмент верификации.

3. Будущее надежного ИИ – за асимметричными пайплайнами Thinking Explorer + Non-Thinking Judge.

Весь код стенда LOCK-R, замороженные датасеты и пайплайны метрик выложены в моем репозитории на GitHub. Там же есть инструкция, как запустить этот бенчмарк на своих API-ключах.

GIT: https://github.com/aak204/LOCK-R

Форкайте, проверяйте свои промпты, и давайте строить агентов, которые действительно ищут истину, а не оправдания! Буду рад обсудить результаты и архитектурные паттерны в комментариях.