AgentAuditor: локальная проверка в точках расхождения вместо голосования большинством

Оригинальный метод (требует кода/API для полной реализации):

ШАГ 1: Получить N решений от агентов → набор трейсов {o₁, o₂, ..., oₙ}

ШАГ 2: Атомизация — разбить каждый трейс на semantic steps
       → каждый трейс = последовательность шагов ⟨s₁, s₂, ..., sₗ⟩

ШАГ 3: Построение Reasoning Tree
       - Каждый шаг кодируется в embedding
       - Если шаг семантически близок существующему узлу (cos_sim ≥ τ) → слияние
       - Если далёк от всех детей → новая ветвь (divergence point)
       → Дерево где общие мысли = общий ствол, расхождения = развилки

ШАГ 4: Нахождение Critical Divergence Points (CDP)
       → узлы где ≥2 ветви расходятся

ШАГ 5: Для каждого CDP — построить Divergence Packet:
       - Shared prefix (общая история до развилки)
       - Branch evidence (аргументы каждой ветви после развилки, k шагов)
       → не весь контекст, только локальная зона вокруг расхождения

ШАГ 6: Аудит в CDP
       Auditor оценивает ветви по критериям:
       - Factual accuracy (факты верны?)
       - Logical soundness (логика связна?)
       - Constraint adherence (условия соблюдены?)
       → выбор победившей ветви на основе доказательств, не частоты

ШАГ 7: Адаптивный поиск
       Если аудит уверенный (α ≥ λ) → commit в выбранную ветвь
       Если неуверенный (α < λ) → beam search (держать K лучших путей)

ШАГ 8: Финальный ответ
       → ответ из выбранного пути в дереве

Выполняется: Требует код для построения дерева, embeddings, обученная модель-аудитор (ACPO).

Задача: Ты запускаешь разбор стратегии привлечения клиентов для онлайн-школы. Делегируешь трём "агентам": маркетолог из performance-команды, контент-мейкер из edtech, growth-хакер из стартапа. Каждый предлагает своё решение. Двое говорят "лей в таргет ВКонтакте", один — "делай контент на YouTube". Обычно выбрал бы большинство (таргет), но хочешь проверить — может YouTube обоснован лучше, хоть и непопулярен?

Промпт (симуляция принципа в одном чате):

Сгенерируй 3 стратегии привлечения клиентов для онлайн-школы по программированию:

Агент 1: Performance-маркетолог (фокус: платный трафик, быстрые конверсии)
Агент 2: Контент-мейкер из edtech (фокус: органика, доверие через контент)
Агент 3: Growth-хакер (фокус: вирусные механики, community)

Каждый агент: подробное рассуждение по шагам → итоговая рекомендация.

---

Затем выполни аудит по методу Reasoning Tree:

1. ПОСТРОЙ ДЕРЕВО: Покажи где агенты мыслят одинаково (общие шаги), где впервые расходятся (первая развилка)

2. НАЙДИ КРИТИЧЕСКУЮ ТОЧКУ РАСХОЖДЕНИЯ: В какой момент возникает главное стратегическое расхождение? (например: "платный vs органический трафик")

3. АУДИТ В ТОЧКЕ РАСХОЖДЕНИЯ:
   - Покажи аргументы каждой ветви сразу после развилки (не весь текст, только релевантное обоснование)
   - Оцени каждую ветвь:
     * Фактическая точность (цифры, данные верны?)
     * Логическая связность (выводы следуют из предпосылок?)
     * Соответствие условиям (бюджет 150к₽/мес, старт через 2 недели, B2C)

4. ВЫБОР: Какая ветвь обоснована сильнее? ИГНОРИРУЙ сколько агентов её поддерживают — смотри только на силу аргументов в точке расхождения.

5. Если есть следующие развилки внутри выбранной ветви → повтори процесс.

Итог: Рекомендация с обоснованием почему выбрали именно эту стратегию (даже если её поддерживал только 1 из 3).

Результат:

Модель покажет: - Шаг 1-2 общие для всех: "Нужен стабильный поток лидов", "Целевая аудитория: 20-35 лет без опыта в IT" - Развилка в шаге 3: Агент 1+3 → "Платный трафик (таргет ВК, реклама)", Агент 2 → "Органика (YouTube образовательный)" - Локальное сравнение аргументов в развилке: - Ветвь "Таргет ВК": "CPL 800₽, быстрый старт, но выгорание за 2-3 месяца, нужен постоянный бюджет" - Ветвь "YouTube": "0₽ на старте, долгий разгон 3-6 мес, но накопительный эффект и доверие, CPL падает со временем" - Оценка по критериям: При бюджете 150к₽/мес и старте через 2 недели → таргет фактически выполним, YouTube не уложится в сроки - Выбор: Таргет ВК (обоснован по timing constraint), несмотря на то что YouTube стратегически может быть сильнее в долгой перспективе

Ты увидишь не просто "2 против 1 = побеждает таргет", а почему в точке расхождения один путь обоснован сильнее другого при заданных условиях. Если бы условия были "старт через 3 месяца, органический рост важнее скорости" — модель могла бы выбрать YouTube даже при перевесе 2:1 против.

LLM-агенты не независимы — они обучены на пересекающихся данных, имеют схожие bias, могут клюнуть на одну и ту же ловушку в формулировке задачи. Поэтому частота ошибки ≠ случайный шум, а системная слабость которую разделяют многие агенты. Мажоритарное голосование предполагает независимость (Condorcet Jury Theorem) — если ошибки независимы, большинство скорее всего право. Но когда 4 из 5 агентов ошиблись по одной причине (например, неправильно интерпретировали условие), голосование даёт 0% шанс на исправление — пятый правый агент будет проигнорирован. Popularity ≠ validity.

LLM отлично сравнивают локальные аргументы при прямом сопоставлении. Задача "Выбери правильное решение из 5" — сложна (много контекста, поздние ошибки размазаны). Задача "Вот развилка: путь A говорит X, путь B говорит Y, shared context одинаковый — какой аргумент точнее?" — проще для верификации. Принцип comparative hardness: проверить легче чем сгенерировать. AgentAuditor не просит модель решить задачу с нуля, а показывает конфликтующие ветви и просит судить — опираясь на сильную сторону LLM (critique, evaluation).

Метод превращает глобальную проверку в локальные сравнения: не "прочитай 5 длинных решений и найди ошибку" (внимание размывается, поздние галлюцинации маскируются), а "вот точка где решения разошлись, вот аргументы сразу после — какой обоснован лучше?". Дерево изолирует момент расхождения — убирает дублирующийся общий контекст (все агенты согласны до шага 7 → не проверяем повторно) и фокусирует внимание на критическом выборе. Это экономит токены (только локальный контекст вместо полного) и повышает точность (модель не отвлекается на нерелевантное).

ACPO нейтрализует sycophancy bias — склонность LLM соглашаться с большинством даже когда оно неправо. Стандартное RLHF учит на данных где большинство обычно право → модель запоминает shortcut "больше поддержки = вероятнее верно". ACPO тренирует на инвертированных случаях: "3 агента говорят A (неправильно), 1 говорит B (правильно) — выбери B". Модель учится игнорировать социальный сигнал (популярность) и искать доказательства в аргументах.

• Число агентов/ролей: 3 агента = базовая триангуляция, 5+ = больше diversity но дороже. Для простых задач 3 достаточно.
• Критерии аудита: По умолчанию (факты, логика, условия) — замени на специфичные для домена (в креативе: оригинальность, tone of voice; в коде: безопасность, performance).
• Порог уверенности для commit/defer: В простой версии можешь попросить модель "если неуверен в выборе → держи обе ветви и проверь дальше".
• Глубина branch evidence: "Покажи 2 следующих шага после развилки" vs "Покажи всю ветвь до конца" — меньше = фокус на immediate consequence, больше = видишь долгосрочные последствия.

Упрощённая симуляция принципа (работает в обычном чате):

Задача: {описание_задачи_с_условиями}

Сгенерируй {N} независимых решений от разных ролей/подходов:

{роль_1}: {фокус_роли_1}
{роль_2}: {фокус_роли_2}
{роль_N}: {фокус_роли_N}

Каждая роль: пошаговое рассуждение → итоговый ответ.

---

АУДИТ ПО МЕТОДУ REASONING TREE:

1. ПОСТРОЙ ДЕРЕВО:
   - Покажи общие шаги (где все роли согласны)
   - Найди первую развилку (где возникает расхождение)
   - Структура: Ствол → Развилка → Ветви

2. ДЛЯ КАЖДОЙ РАЗВИЛКИ:

   a) Локальный контекст:
      - Shared prefix: что общего до этой точки
      - Branch evidence: аргументы каждой ветви сразу после развилки

   b) Аудит ветвей по критериям:
      • Фактическая точность (данные верны?)
      • Логическая связность (выводы обоснованы?)
      • Соответствие условиям задачи

   c) Выбор победившей ветви:
      ИГНОРИРУЙ количество ролей поддерживающих ветвь
      ФОКУС на силе аргументов и доказательств

3. ЕСЛИ внутри выбранной ветви есть следующие развилки → повтори процесс

4. ИТОГОВЫЙ ОТВЕТ:
   - Выбранное решение
   - Обоснование: почему эта ветвь выбрана (покажи key divergence points и почему выбрал именно так)
   - Отметь если выбрал МЕНЬШИНСТВО (важно видеть что метод работает против консенсуса)

ПРАВИЛО: Evidence over popularity. Если 1 роль обоснована сильнее чем 4 другие — выбирай 1.

Что подставлять: - {описание_задачи_с_условиями} — конкретная задача с ясными constraints (бюджет, сроки, критерии успеха) - {N} — число решений, обычно 3-5 (меньше — мало diversity, больше — дорого) - {роль_X} и {фокус_роли_X} — роли с разными приоритетами чтобы guaranty расхождение (performance vs quality, speed vs reliability, creative vs analytical)

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

Вот шаблон метода Reasoning Tree Audit. Адаптируй под мою задачу: [твоя задача]. 
Подбери роли которые дадут разные подходы и спроси какие условия нужны для аудита.

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

LLM спросит: какие роли выбрать (чтобы создать содержательные расхождения), какие критерии важны для твоей задачи (чтобы аудит оценивал релевантное), есть ли жёсткие constraints. Она возьмёт паттерн "дерево → развилки → локальный аудит → выбор на основе доказательств" и адаптирует под контекст — подберёт роли, настроит критерии, структурирует вывод.

⚠️ Требует diversity входов: Если агенты/роли генерируют одинаковые решения — дерево без развилок, метод не работает. Нужно задать роли с разными приоритетами или подходами чтобы guaranty расхождение. В оригинале это решается через разные MAS frameworks, в симуляции — через дизайн ролей в промпте.

⚠️ Не для задач без верифицируемых критериев: Метод оценивает аргументы по фактической точности, логике, условиям. Для чисто субъективных задач (креатив, стиль) где "правильного ответа" нет — принцип работает слабее. Можно адаптировать критерии (оригинальность, соответствие tone of voice), но валидация остаётся субъективной.

⚠️ Упрощённая симуляция ≠ полный метод: Шаблон выше симулирует принцип в одном чате — модель играет роли, строит дерево текстом, делает аудит. Оригинальный AgentAuditor использует semantic embeddings для точного выравнивания шагов и обученную ACPO-модель для аудита устойчивого к sycophancy bias. В симуляции базовая модель может всё ещё поддаваться давлению большинства — эффект будет, но слабее чем в полной реализации.

⚠️ Вычислительная стоимость: Генерация N решений + построение дерева + аудит развилок = больше токенов чем одно решение. Экономия относительно "N полных решений + LLM читает все целиком" (локальный аудит дешевле), но всё равно дороже simple single-pass. Используй для сложных задач где цена ошибки высока, не для рутины.

⚠️ Поздние расхождения теряют контекст: Если первые 20 шагов общие, потом развилка — в Divergence Packet будет shared prefix (краткое резюме) + локальные аргументы. Если для понимания расхождения критичен весь ранний контекст — сжатие может потерять нюансы. В оригинале это балансируется размером prefix summary, в симуляции можешь попросить "сохрани полный контекст до развилки если он важен".

Исследователи из USC взяли 5 популярных мультиагентных фреймворков (LLM-Debate, Group-Debate, DyLan, GPTSwarm, AgentPrune) и протестировали на 4 бенчмарках: GSM8K (математика начальная школа), MATH (конкурсная математика), AMC (American Mathematics Competition), MMLU (широкая эрудиция). Для каждого фреймворка сравнили три способа агрегации: - Majority Vote (что ответило большинство агентов) - LLM-as-Judge (одна модель читает все решения и выбирает лучшее) - AgentAuditor (их метод с деревом и локальным аудитом)

Ключевой инсайт дизайна: они специально выделили subset "Minority-Correct" — случаи где большинство агентов дало неправильный ответ, но хотя бы один дал правильный. Это жёсткий тест на confabulation consensus: мажоритарное голосование на этом subset даёт 0% по определению (оно выбирает популярное = выбирает ошибку). Результаты: AgentAuditor восстановил 65% правильных ответов на GSM8K и 82% на AMC в minority-correct режиме — значит смог систематически выбирать обоснованное меньшинство против ошибочного большинства. LLM-as-Judge показал только 7% и 73% соответственно — judge-модель поддавалась sycophancy bias (видела что 3 агента говорят A, 1 говорит B → выбирала A даже когда B правильнее).

Почему такая разница? AgentAuditor тренировали через ACPO — собрали датасет из ~3000 случаев где большинство ошиблось, нашли в дереве рассуждений First Point of Disagreement (где правый minority отделился от ошибочного majority), составили preference pairs (minority-correct как winner, majority-wrong как loser) и файнтюнили модель-аудитора через DPO. Модель научилась игнорировать популярность как сигнал истины и искать локальные доказательства в развилке. Эффект метода оказался консистентным across frameworks: улучшение на 3-5% абсолютной точности над majority vote на всех пяти MAS, причём максимальный выигрыш именно на сложных задачах (AMC: +5.7%, GSM8K: +5.5% в лучших cases).

Удивило: token efficiency — AgentAuditor использовал на 45% меньше токенов чем LLM-as-Solver (который пытается решить задачу с нуля после прочтения всех трейсов). Причина: локальный аудит в развилках короче чем re-generation полного решения, и точнее потому что comparative evaluation (выбрать между A и B) проще чем generative (создать правильное C). Это подтверждает принцип: verification cheaper than generation, и структурная декомпозиция (дерево) позволяет превратить дорогую глобальную проверку в дешёвые локальные сравнения.

🔧 Техника: явные имена агентов вместо "Role 1, Role 2" → острее различия

Copy

Агент "Скептик-финансист Олег": консервативный подход, фокус на риски
Агент "Оптимист-growth Катя": агрессивный рост, фокус на возможности
Агент "Реалист-операционист Михаил": выполнимость, фокус на ресурсы

Персонализация ролей усиливает diversity рассуждений — модель лучше держит character consistency когда роль = персонаж с бэкграундом, а не абстрактная метка.

🔧 Техника: взвешенные критерии аудита → кастомизация под приоритеты

Вместо равного веса (факты = логика = условия), можешь задать:

Copy

Критерии аудита (по убыванию важности):
1. КРИТИЧНО: Соблюдение бюджета (hard constraint)
2. ВАЖНО: Выполнимость за 2 недели (timeline)
3. ЖЕЛАТЕЛЬНО: Масштабируемость решения (quality)

Это адаптирует метод под domain constraints — в финансах compliance критичнее креатива, в стартапе скорость критичнее perfection.

🔧 Техника: multi-level tree → вложенные развилки

Copy

После выбора победившей ветви в первой развилке:
"Теперь внутри выбранного пути найди следующую развилку и повтори аудит"

Оригинальный метод это делает, но в упрощённой версии можно забыть. Явное указание "iterate deeper" превращает single-choice в sequential refinement — сначала выбрали стратегию (платный vs органика), потом внутри платного выбрали канал (ВК vs Инста), потом внутри ВК выбрали креатив (видео vs карусель).

Экстраполяция: комбинация с self-consistency для генерации входов

Оригинальный AgentAuditor работает с готовыми трейсами из MAS frameworks. Для solo-use в чате можешь генерировать diversity через temperature + role sampling:

Copy

# Шаг 1: Генерация diversity
Промпт с temperature=1.0 и 5 разными ролями → 5 разных решений

# Шаг 2: AgentAuditor принцип
Построй дерево, найди развилки, аудит локальных аргументов

# Шаг 3: Если топ-2 ветви близки по score
→ запроси дополнительное решение от "tie-breaker" роли (эксперт в узкой зоне расхождения)

Это создаёт adaptive sampling: не генерируешь фиксированные N трейсов, а наращиваешь по необходимости — если первые 3 решения согласны, можно остановиться (экономия), если развилка 50/50 — добавить решающий голос.

Auditing Multi-Agent LLM Reasoning Trees Outperforms Majority Vote and LLM-as-Judge

Wei Yang, Shixuan Li, Heng Ping, Peiyu Zhang, Paul Bogdan, Jesse Thomason

University of Southern California

Preprint, February 2026