Сегодня каждый второй стартап создаёт ИИ-агентов, оборачивая LLM в цикл: промпт → вызов инструмента (API, поиск) → чтение → ответ. Ожидается, что нейросеть сама найдёт баг, расследует инцидент или реализует фичу. Но на практике агенты часто галлюцинируют, ходят по кругу и застревают в бесконечных циклах.

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

Я разработал измерительный стенд LOCK-R, применил теорему Байеса и выявил фундаментальные когнитивные искажения в поведении LLM-агентов. Результаты шокируют: одиночные агенты структурно неспособны к объективности, а Chain-of-Thought (CoT) не помогает — он заставляет модели красиво оправдывать свои ошибки.

Фундаментальная проблема: агент как предвзятый детектив

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

То же самое происходит в Single-Agent системах. Я называю это Confirmation Lock: модель сама выдвигает гипотезу, сама ищет данные, сама их интерпретирует и сама себя оценивает. В одном контекстном окне генератор и критик сливаются. Модель «влюбляется» в свою первую догадку и отказывается её пересматривать.

Как измерить мышление: стенд LOCK-R

Чтобы проверить это, я создал детерминированную среду — «детективную игру» с чёткими правилами:

• Три взаимоисключающие гипотезы: H1, H2, H3.
• Агент имеет строгий лимит — 4 вызова инструментов (поиск, проверка фактов).
• В начале даётся ложная подсказка, «якорящая» на H1.
• После каждого шага агент должен выдать JSON с распределением уверенности (например, H1: 40%, H2: 40%, H3: 20%).

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

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

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

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

Агенты проваливаются не потому, что «не понимают логику», а потому что ужасно исследуют. Залоченные агенты в среднем используют только один уникальный инструмент и повторяют одни и те же запросы (tool_loop_repetition_rate — 68%).

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

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

Метрика упрямства: асимметрия в восприятии фактов

Я ввёл метрику α — коэффициент асимметрии подтверждения. Идеальный байесовский агент должен одинаково реагировать на подтверждение и опровержение (α = 0).

LLM-агенты оказались упрямыми оптимистами:

• На опровержение реагируют вяло: снижают уверенность всего на 5–10%.
• На малейшее подтверждение — резко поднимают уверенность до 90%.

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

Инсайт 2: парадокс Chain-of-Thought

Вся индустрия считает, что Chain-of-Thought делает модели умнее. Я сравнил агентов с CoT (Thinking) и без (Non-Thinking).

Выявился парадокс:

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

Chain-of-Thought — это не инструмент мышления, а инструмент самообмана.

Инсайт 3: решение — слепой судья

Если одиночный агент архитектурно сломан, как строить надёжные системы? Ответ — в асимметричном разделении ролей.

Я внедрил паттерн слепого судьи (blind checker):

• Это независимый агент-верификатор.
• Ему запрещено использовать CoT (режим non-thinking).
• Он физически не видит черновики и размышления основного агента.
• Он получает только сырые факты: гипотезы и результаты инструментов (логи, код).

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

Тест на реальных кейсах: ошибка 500 на проде

Критики скажут: «Это синтетика. В реальности всё иначе». Я проверил на реалистичном сценарии — CodeTriageEnv.

Ситуация: упала страница оплаты, ошибка 500.
Ложный якорь: «DevOps заметил скачок CPU в Redis».
Реальная причина: платежный шлюз обновил API и возвращает кривой JSON.

Агенты имели доступ к: grep_logs, read_code, view_commit.

• Одиночный агент: вцепился в Redis, игнорировал JSONDecodeError в логах. Точность — 40%, регрет — 0.25. Совершил больше действий (2.8 инструмента), но все — ради оправдания первой гипотезы. Это парадокс суеты.
• Слепой судья: хладнокровно проанализировал логи, увидел ошибку JSON, указал на шлюз. Точность — 100%, регрет — 0.07. Использовал 2.0 инструмента — все точно в цель.

Когда ваш ИИ-кодер делает десятки бесполезных коммитов, проблема не в непонимании кода. Он попал в Confirmation Lock.

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

«А что если взять GPT-5.4?» — спросят многие. Я протестировал GPT-5.4 и GPT-5.3 через OpenRouter.

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

Даже миллиардные модели нуждаются в слепом судье.

Выводы

• Не стройте Single-Agent системы для критичных задач: аудит кода, RCA, юриспруденция.
• Chain-of-Thought — не панацея. Это мощный инструмент генерации и планирования, но катастрофический инструмент верификации.
• Будущее надёжного ИИ — за асимметричными пайплайнами: Thinking Explorer + Non-Thinking Judge.

Сейчас каждый второй стартап пилит ИИ-агентов. Мы оборачиваем 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). Считается, что токены размышлений () автоматически делают модель умнее. Я сравнил работу агентов с включенным 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

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