Предпосылки повышения точности мультиагентных LLM-систем

Проблема

Есть интуиция: «запустишь несколько агентов — станет точнее». Она верна лишь наполовину.

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

• Эмпирика по LLM-ensemble в анализе тональности: добавление более крупной и точной модели давало мизерный выигрыш. Потому что независимость, заложенная теоремой Condorcet, была нарушена (arXiv:2409.00094).
• Мультиагентные дебаты (MAD): даже подключив дебаты, не удаётся устойчиво обыграть self-consistency одиночного агента (ICML 2024, arXiv:2311.17371).
• Моё анекдотическое наблюдение (выборка 1, без контроля): в задаче ZenFlow я запустил Grok Build восемью одновременными агентами, и на 3 из 10 endpoint’ов всё застряло и не прошло validate. Это лишь анекдот, так что не будем придавать ему такой же вес, как двум исследованиям выше.

Голосование большинством — не магия. Теорема Condorcet о жюри присяжных 200 лет назад прямо сформулировала предпосылки. И если эти предпосылки выполнены, мультиагентность действительно работает. Этот текст — о том, каковы эти предпосылки и как их выполнить.

Две предпосылки Condorcet

В 1785 году Condorcet вывел в формуле условия, при которых голосование большинством сходится к истине.

1. Точность каждого голосующего > 50%
2. Ошибки голосующих независимы

(Строго говоря, есть и третья — предпосылка однородности, что у всех одинаковая точность. Для упрощения её опустим.)

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

Это не только интуиция. Одно исследование, проанализировавшее более 350 LLM, сообщает, что когда две модели ошибаются одновременно, с вероятностью 60% они сходятся к одному и тому же неверному ответу (ICML 2025, arXiv:2506.07962). В том же исследовании наблюдался ещё больший парадокс — чем крупнее и точнее модель, тем выше корреляция ошибок. Так было даже при разных архитектурах. (Это единичный масштабный анализ, широкого воспроизведения пока нет. И всё же направление — ровно такое, какое предсказал Condorcet.)

Математика коррелированных ошибок

Если ошибки независимы, ensemble срезает неверные ответы. Если они коррелированы, срезать нечего.

• При независимости: P(оба ошиблись) = 0,1 × 0,1 = 0,01
• При полной корреляции: P(оба ошиблись) ≈ 0,1 (если ошибся один, ошибся и другой)

Эта интуиция уходит корнями в теорему 30-летней давности. Разложение ambiguity у Krogh & Vedelsby (NeurIPS 1994): ошибка ensemble = средняя ошибка участников − разнообразие ensemble. Чем сильнее коррелированы ошибки участников, тем ближе член разнообразия к 0, и сколько модель ни добавляй — выигрыш исчезает. Объединённая теория из JMLR 2023 обобщила это — разнообразие не отдельный рычаг, а измерение, спрятанное внутри bias-variance разложения (arXiv:2301.03962).

Итого:

• Условие, при котором ensemble повышает точность: чем ниже корреляция ошибок, тем больше выигрыш (максимум при отрицательной корреляции).
• Условие, при котором выигрыш ensemble сходится к 0: корреляция ошибок → 1 (одни данные, одно смещение).

Важна и форма голосования. Голосование большинством (majority) при независимости поднимает точность по Condorcet. Но если связать всё консенсусом «должны пропустить все» (unanimity, AND-гейт), точность рушится произведением — если точность классификатора 0,977 и связать n штук единогласием, получится 0,977ⁿ. Спроектируешь гейт неправильно — и больше агентов дают меньшую точность.

До этого места — диагноз. Теперь лечение разветвляется надвое — корреляцию ошибок либо снижают (ось 1), либо обходят (ось 2).

Ось 1 — Обеспечьте независимость, и мультиагентность работает

Скажем прямо. Мультиагентность не ошибочна. Ошибочно голосование без независимости. Если выполнить вторую предпосылку Condorcet — сделать ошибки агентов некоррелированными — голосование большинством поднимает точность, как и обещано. Путей к независимости два.

(а) Разбейте задачу — это самый мощный путь.

Не давайте агентам одну и ту же задачу и не заставляйте голосовать; давайте им разные подзадачи. Если входы различаются, ошибки становятся структурно независимыми — даже у одной и той же модели. Два агента, читающие разные документы, не могут ошибиться в одном месте. Ведь они смотрят на разные места.

Мультиагентная исследовательская система Anthropic сообщила о улучшении на 90,2% по сравнению с одиночным агентом именно благодаря этому принципу. Ведущий агент разбивает задачу и распределяет по параллельным субагентам, а результаты, которые каждый исследует независимо, сводятся вместе. Verifier не понадобился. Потому что декомпозиция сделала независимость бесплатной.

Но есть условие. Задача должна быть декомпозируемой. Там, где подзадачи зависят друг от друга и требуют непрерывной координации — например, когда несколько агентов одновременно правят один кусок кода, — параллельные субагенты, наоборот, конфликтуют. Контекст фрагментируется, и они принимают взаимно противоречивые решения (Cognition, “Don’t Build Multi-Agents”). Независимость декомпозиции бесплатна лишь тогда, когда подзадачи действительно независимы.

(б) Сделайте модели разнородными — это работает, но есть потолок.

Если ту же задачу решают разные модели (GPT, Claude, Gemini), веса различаются, поэтому корреляция ошибок падает. Мультиагентные дебаты тоже обыгрывают одиночный baseline лишь тогда, когда смешивают разнородные модели (arXiv:2502.08788) — я с этим не спорю. Суть в том, что важна не индивидуальная точность, а корреляция. Есть теоретико-информационный результат: даже при выборе моделей для ensemble нужно выбирать не самую сильную, а наименее коррелированную комбинацию — слабые, но разнообразные обыгрывают сильнейшую одиночную модель (arXiv:2602.08003). Однако у этого рычага потолок низок. Интернет-корпусы пересекаются, и, как мы видели, чем крупнее модель, тем снова ошибаются вместе (arXiv:2506.07962). Разнообразие снижает корреляцию, но не доводит её до 0.

В-третьих, self-consistency, рассеивающая пути рассуждения внутри одной и той же модели, тоже декоррелирует поверхностные ошибки и даёт выигрыш (GSM8K +17,9 п.п., arXiv:2203.11171). Но этот выигрыш останавливается перед местом, где модель ошибается систематически — перед тем самым смещением, которое впечатали одни и те же данные. Как ни разнообразь пути, способ, которым модель не знает того, чего не знает, — один.

Вывод по оси 1: мультиагентность работает, если независимость спроектирована. И самая надёжная независимость рождается не из поиска другой модели, а из разбиения задачи на независимые части.

Ось 2 — Verifier обходит независимость

Третий рычаг — иного рода. Ось 1 спасает голосование, снижая корреляцию ошибок. Verifier обходит корреляцию — даже если агенты ошибаются все вместе, внешний критерий, не связанный с их ошибками, блокирует прохождение. Это не голосование, а гейт. Поэтому он работает даже там, где независимости не добиться, — лишь бы область была верифицируемой.

Этот диагноз — не только мой. “Consensus is Not Verification” (arXiv:2603.06612) первым прибил тот же вывод — агрегация на основе консенсуса не даёт устойчивого выигрыша по сравнению с единичным сэмплом и усиливает разделяемое заблуждение, а масштабирование во время вывода работает в верифицируемой области (математика), но проваливается в неверифицируемой. Дело не в том, что консенсус — сигнал истины и потому срабатывает в математике, а в том, что verifier отсеивает кандидатов. Я принимаю этот диагноз и иду на шаг дальше — к лечению. Сильнейший источник независимости — декомпозиция; независимость и верификация не соперничают, а дополняют друг друга; а детерминированный verifier расходится с LLM-судьёй в трёх точках (ниже).

Однако индустрия даже эту верификацию доверяет LLM — LLM-as-Judge.

Начнём по-честному. LLM-судья часто работает хорошо. В MT-Bench судья GPT-4 совпадал с человеческими предпочтениями более чем на 80%, и это тот же уровень, что и согласие между людьми (arXiv:2306.05685). Для расплывчатой оценки предпочтений LLM-судья вполне годится. Вопрос в том, где он ломается.

Судья ломается там, где разделяет ту же ловушку, что и генератор. Судящая LLM оценивает привычный ей вывод (с низкой perplexity) выше, чем человек (self-preference bias, NeurIPS 2024 WS, arXiv:2410.21819). Если судья разделяет ту же распределение, что и генератор, он пропускает галлюцинацию, созданную той же моделью, «потому что она привычна». 80% согласия не утешают, потому что те 20% ошибок концентрируются именно там, где ошибается и генератор — проблема не в средней точности, а в корреляции ошибок. Судья колеблется и от не относящихся к делу переменных, например от позиции подачи кандидата, а не от правильности (position bias, arXiv:2406.07791).

Один вспомогательный довод. LLM-судья колеблется и на уровне железа. Даже при одном входе и T=0 greedy decoding результат расходится в зависимости от конфигурации GPU из-за неассоциативности чисел с плавающей точкой и динамического батчинга — на BF16 точность менялась вплоть до 9 п.п. (arXiv:2506.09501). Это проблема воспроизводимости, а не валидности, так что я не делаю её главным доводом. Просто сажать на финальное судейское кресло то, что не гарантирует даже одинакового ответа на один и тот же вопрос, как-то неуютно.

Поэтому есть обратное направление. Слабый генератор + сильный verifier. Слабая модель, подключив тот же verifier, приближается к сильной, а ошибки слабой модели даже легче обнаружить (arXiv:2509.17995). Можно и собрать сильного верификатора из нескольких слабых через взвешенную комбинацию (Weaver, arXiv:2506.18203), и обеспечить согласованность, очищая вывод LLM обратной связью formal verifier (AlphaVerus, arXiv:2412.06176). Это не маргинальное утверждение — модели рассуждения и кодинг-агенты, обучаемые на верифицируемом вознаграждении, сейчас развиваются быстрее всего, и Jason Wei свёл это в verifier’s law: насколько ИИ становится сильнее, пропорционально верифицируемости задачи.

Здесь нужно быть честным. Verifier — не волшебный оракул. Тест может что-то упустить, спецификация может быть ошибочной. А ещё острее — если verifier пишет LLM, то критика, которую я только что обрушил на LLM-as-Judge, воскресает в неизменном виде. Если генератор и верификатор — одна и та же модель, тест, ошибочный в одном месте, пропускает код, ошибочный в том же месте. Корреляция ошибок не исчезает, а лишь переезжает на слой верификации.

Так как же предотвратить воскрешение? Поднять надёжность verifier’а за пределами самого генератора. Три вещи идут вместе.

• Человеческая проверка. Критерий верификации (спецификацию, тесты, свойства) человек проверяет один раз и фиксирует. Даже если LLM пишет черновик, критерий прохождения утверждает человек, находящийся вне распределения генератора. Затрата — единократна, а раз зафиксированный критерий переиспользуется бесконечно — в этом решающее отличие от LLM-as-Judge, который судит заново при каждой генерации.
• Сведение к математике и логике. Насколько возможно, переносите верификацию в механически разрешимую форму — проверку типов, инварианты (invariant), формальные доказательства, математические свойства. Здесь нет места для «суждения» LLM. Истина/ложь определяются не мнением модели, а правилом.
• Повторное тестирование. Ошибка verifier’а воспроизводима, поэтому улучшается накопительно. Если расширять покрытие регрессионными тестами и property-based testing, дыра, однажды пропущенная verifier’ом, фиксируется тестом и больше никогда не протекает в том же месте. LLM-судья колеблется даже на одном входе, и это накопление невозможно.

Эти три вещи делают verifier критерием, независимым от смещения генератора. Способ разорвать корреляцию ошибок и на слое верификации — прибить verifier не внутри модели, а снаружи: к человеку, математике, тестовому набору.

Так в чём же тогда отличие детерминированного verifier’а? Не в безошибочности. В трёх точках. Первое, критерий верификации находится вне весов генератора — написан человеком или создан другой процедурой, можно установить критерий, независимый от смещения генератора (для LLM-судьи это структурно невозможно). Второе, ошибка verifier’а проявляется не как самоуверенная галлюцинация, а как обнаружимый и воспроизводимый отказ — на один вход даёт одно и то же суждение, поэтому отлаживается и улучшается накопительно. Третье, доверие переезжает на малую и поддающуюся аудиту поверхность (спецификация, тесты), и стоит человеку проверить её один раз — она переиспользуется бесконечно. Не то чтобы verifier гарантировал точность; качество verifier’а становится верхней границей точности — а не размер генератора.

Ключевое озарение

Формула точности мультиагентности:

точность = f(индивидуальная точность, независимость ошибок, механизм верификации)

Индустрия инвестирует только в первое (более крупная модель). Второе (независимость) не проектирует, а третье (верификацию) доверяет LLM. И стратегия, инвестирующая только в первое, упирается в парадокс — чем крупнее модель, тем выше корреляция ошибок, поэтому чем больше умных агентов соберёшь, тем дружнее они ошибаются вместе.

Второе и третье — вот настоящие рычаги. И эти два не соперничают. Независимость (ось 1) спасает голосование, verifier (ось 2) отсекает то, до чего голосование не дотягивается. Сильнее всего — когда есть оба.

• Исследовательская система Anthropic: декомпозиция оси 1, доведённая до крайности — разбить задачу на независимый параллельный поиск. Улучшение на 90,2% без verifier’а.
• SciencePedia (Китай, 2026): несколько независимых solver’ов решают каждый по-своему (ось 1), и сохраняется лишь то, в чём ответы между моделями согласованы (cross-model consensus, arXiv:2510.26854). Но поскольку финальный фильтр — «согласие моделей», ось 2 поймана лишь наполовину — консенсус не есть детерминированная верификация. Именно поэтому ему можно доверять лишь в верифицируемых областях вроде математики и логики.
• Почему 8 агентов одной модели проваливаются: обе оси отсутствуют. Независимости — ноль, цикла верификации — ноль. 8 штук застревают в одном месте вместе.
• Почему yongol работает даже на Haiku: прямая реализация оси 2. Даже при низкой точности модели детерминированный verifier фильтрует на каждом шаге — пока его качество держит планку.

Аналогия с демократией

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

Связь с эволюцией

Та же интуиция читается и в алгоритмах обучения. У backpropagation направления gradient коррелированы, у эволюции мутации рассеиваются независимо. Есть сообщение, что генетический алгоритм, вовсе не использующий gradient, исследует в глубоком обучении с подкреплением иное пространство решений, чем gradient-методы (Deep Neuroevolution, arXiv:1712.06567). Независимый поиск достаёт туда, куда не доходит коррелированный, — принцип, увиденный в ensemble, той же формы и в оптимизации. Правда, «лучше из-за независимости» — пока апостериорная интерпретация — оставлю это гипотезой, а не доказательством.

Заключение

Мультиагентность — это не «много значит точно». Мишень атаки — не мультиагентность, а голосование без независимости. Собрать N штук одной модели и голосовать большинством — значит растить хор, ошибающийся в унисон.

Лечений два, и оба настоящие. Первое — проектируйте независимость — если разбить задачу на независимые части (это самое надёжное), мультиагентность работает даже на одной модели. Второе — если область верифицируема, поставьте verifier за пределами LLM — он поднимает верхнюю границу точности независимо от независимости.

Честно прибьём границы. Ось verifier’а (ось 2) — ответ только в верифицируемых областях — там, где правильный ответ можно отсечь внешним критерием: код, математика, формальные спецификации. В областях без такого критерия — открытая генерация, реферирование, консультирование, творчество, стратегические суждения — единственным оставшимся рычагом остаётся ось 1, то есть проектирование независимости. Запертый рычаг — это не размер модели, а независимость ошибок и, где возможно, внешний verifier.

(Раскрытие конфликта интересов: я создаю инструмент yongol, у которого детерминированный verifier — keystone. Поэтому моё сердце склоняется к оси verifier’а. Читайте аргументацию выше с учётом этого смещения — если хребет ошибочен, ошибочен и инструмент.)

Справочные материалы

Condorcet и теория ensemble

• Теорема Condorcet о жюри присяжных (1785) — две предпосылки сходимости голосования большинством: индивидуальная точность >50%, независимость ошибок
• Krogh & Vedelsby, Neural Network Ensembles, Cross Validation, and Active Learning (NeurIPS 1994) — разложение ambiguity
• Wood et al., A Unified Theory of Diversity in Ensemble Learning (JMLR 2023, arXiv:2301.03962) — разложение bias-variance-diversity

Корреляция ошибок LLM / пределы консенсуса

• Kim et al., Correlated Errors in Large Language Models (ICML 2025, arXiv:2506.07962) — при одновременной ошибке двух моделей 60% одинаковых неверных ответов, чем крупнее модель, тем выше корреляция↑
• Lefort et al., Examining Independence in Ensemble Sentiment Analysis … Condorcet Jury Theorem (arXiv:2409.00094) — предпосылка независимости Condorcet нарушается у LLM
• Denisov-Blanch et al., Consensus is Not Verification: Why Crowd Wisdom Strategies Fail for LLM Truthfulness (2026, arXiv:2603.06612) — агрегация консенсуса усиливает разделяемое заблуждение, масштабирование во время вывода работает только в верифицируемой области (тот же диагноз, что и в этом тексте — в основной части различается лечением)

Мультиагентность: независимость и декомпозиция

• Cemri et al., Why Do Multi-Agent LLM Systems Fail? (UC Berkeley, 2025, arXiv:2503.13657) — анализ 1 600+ трасс выполнения по 7 фреймворкам. 14 режимов отказа классифицированы по 3 категориям: проектирование системы, сбой выравнивания между агентами, верификация (task verification)
• Smit et al., Should we be going MAD? (ICML 2024, arXiv:2311.17371) — дебаты устойчиво не обыгрывают простой baseline
• Zhang et al., Stop Overvaluing Multi-Agent Debate (arXiv:2502.08788) — разнородность как противоядие (работает при восстановлении независимости)
• Du et al., Improving Factuality and Reasoning through Multiagent Debate (ICML 2024, arXiv:2305.14325) — исходное позитивное утверждение MAD
• Wang et al., Self-Consistency Improves Chain of Thought Reasoning (ICLR 2023, arXiv:2203.11171) — выигрыш от разнообразия путей
• Turkmen et al., Don’t Always Pick the Highest-Performing Model: An Information Theoretic View of LLM Ensemble Selection (2026, arXiv:2602.08003) — критерий выбора ensemble — не индивидуальная производительность, а корреляция↓ (максимизация взаимной информации). Слабые, но разнообразные побеждают

Надёжность LLM-as-Judge

• Zheng et al., Judging LLM-as-a-Judge with MT-Bench and Chatbot Arena (NeurIPS 2023, arXiv:2306.05685) — судья GPT-4 совпадает с человеком на 80%+ (позитивное свидетельство)
• Wataoka et al., Self-Preference Bias in LLM-as-a-Judge (NeurIPS 2024 WS, arXiv:2410.21819)
• Shi et al., Judging the Judges: Position Bias in LLM-as-a-Judge (arXiv:2406.07791)
• Numerical Sources of Nondeterminism in LLM Inference (arXiv:2506.09501) — вывод колеблется даже при T=0

Слабый генератор + сильный verifier

• Saad-Falcon et al., Shrinking the Generation-Verification Gap with Weak Verifiers (Weaver, arXiv:2506.18203)
• Aggarwal et al., AlphaVerus: Formally Verified Code Generation (arXiv:2412.06176)
• Variation in Verification: Understanding Verification Dynamics in LLMs (arXiv:2509.17995)

Примеры верифицируемой генерации

• SciencePedia (DP Technology / DeepModeling, 2026) — Inverse Knowledge Search over Verifiable Reasoning (arXiv:2510.26854). Независимые solver’ы + фильтр cross-model consensus

Эволюция vs gradient

• Such et al., Deep Neuroevolution (arXiv:1712.06567) — GA исследует пространство решений, иное чем gradient

Первичная эмпирика (сам автор)

• ZenFlow / Grok Build: 8 concurrent agents, 3 из 10 endpoint’ов не завершены (не прошли validate)
• ZenFlow / yongol: Haiku дошёл до конца, Sonnet 131 минута, Opus 76 минут

Что почитать вместе

• Don’t Build Multi-Agents — Cognition (создатели Devin), 2025. Полевой манифест, прямо утверждающий, что лучше не строить мультиагентов. Когда контекст фрагментируется, агенты конфликтуют друг с другом — ловушка задач, которые не декомпозируются. (Вместе с продолжением Multi-Agents: What’s Actually Working, 2026.)
• How we built our multi-agent research system — Anthropic, 2025. Читать в паре с текстом выше. Показывает условие, при котором мультиагентность работает — когда подзадачи независимо распараллеливаются (декомпозиция оси 1) — через улучшение на 90,2%.
• Asymmetry of verification and verifier’s law — Jason Wei, 2025. «Насколько ИИ становится сильнее, пропорционально верифицируемости задачи.» Теоретический хребет оси 2 (слабый генератор + сильный verifier).
• Hallucinations in code are the least dangerous form of LLM mistakes — Simon Willison, 2025. Код выдаёт галлюцинацию в момент запуска. Самый наглядный пример того, почему детерминированная верификация — решающий рычаг.
• Using LLM-as-a-Judge For Evaluation — Hamel Husain, 2024. Почему нельзя слепо верить LLM-судье, и практическая процедура масштабирования через автоматизацию лишь после выравнивания с человеком.
• Defeating Nondeterminism in LLM Inference — Thinking Machines Lab, 2025. Настоящая причина, по которой LLM колеблется даже при temperature=0. Инфраструктурное обоснование того, почему verifier нужно держать вне модели.
• The Wisdom of Crowds — мудрость толпы испаряется, когда рушатся разнообразие и независимость. Лёгкое введение в предпосылку независимости Condorcet в не-ИИ контексте.

• Обложка: сгенерировано ИИ (Google Gemini)