3,583 papers
arXiv:2610.39899 78 29 окт. 2026 г. FREE

ExploreRepair: три независимых агента-специалиста и двухступенчатая сборка вместо одного «универсального» агента

КЛЮЧЕВАЯ СУТЬ
Парадокс: один агент, которому дали сразу три способа анализа, чинит уязвимости хуже, чем каждый из трёх специалистов по отдельности. ExploreRepair позволяет чинить уязвимости, когда описания бага и готового эксплойта нет, есть только подозрительная функция. Три агента работают в отдельных сессиях и не видят выводов друг друга. Каждый смотрит со своей стороны: структура кода, замысел разработчика, тест-воспроизведение. Потом два сборщика и один финальный сводят всё в один патч. Итог: чинятся и такие уязвимости, которые не смог починить ни один из трёх специалистов.
Адаптировать под запрос
⚡

TL;DR

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

Главная находка: один агент, которому дали все три способа анализа сразу, справляется хуже, чем каждый из специалистов по отдельности. Он путается в разнородных данных: граф вызовов, предположения о замысле, результаты запуска. Первая гипотеза, которая показалась убедительной, тянет за собой остальное рассуждение. «Просто несколько субагентов» без чёткой специализации тоже не помогают: результат получился хуже одиночного агента.

Метод в двух фазах. Сначала агенты работают независимо и не видят выводов друг друга. Потом выводы и патчи сжимаются в короткие «уроки» и сводятся: один сборщик работает по урокам (диагнозы), другой по патчам (реализация). Финальный сборщик сверяет оба предложения с кодом и выдаёт итог. В статье это починило и такие уязвимости, которые не смог починить ни один из трёх специалистов.

🔬

Схема метода

ФАЗА 1 — Исследование (3 агента, независимо, не видят друг друга)
  Агент СТРУКТУРА: как внешний ввод доходит до функции, валидаторы, похожие пути → диагноз + патч
  Агент НАМЕРЕНИЕ: 4 вопроса о контракте и доверии, до 5 ограничений → диагноз + патч
  Агент PoV:       написать тест-воспроизведение, запустить, чинить причину → диагноз + патч

ФАЗА 2 — Сборка
  ШАГ 1: отдельный вызов LLM сжимает траекторию + патч каждого агента → короткий «урок»
  ШАГ 2 (параллельно):
     Сборщик уроков  ← 3 урока   → патч A
     Сборщик патчей  ← 3 диффа   → патч B
  ШАГ 3: сжать работу обоих сборщиков в уроки
  ШАГ 4: Финальный сборщик ← патч A + патч B + их уроки
         → сверяет с кодом → берёт один / объединяет / отвергает общие допущения / пишет новый

Шаги требуют отдельных запросов или сессий. В одном промпте это не соберёшь.

🚀

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

Задача: Вы ведёте бэкенд на Python для сервиса доставки: интернет-магазин с выгрузкой накладных клиентам. Сканер зависимостей и аудит указали на функцию download_invoice(): возможен path traversal (выход за пределы папки через ../). Описания уязвимости нет, готового эксплойта тоже. Нужен безопасный патч, который не сломает остальное.

Промпт (Агент «Намерение», в отдельной сессии Claude Code или Cursor):

Ты исследуешь уязвимость в репозитории. Подозрительная функция: download_invoice() в services/invoices.py, строки 40–95.
Твоя специализация — реконструкция замысла разработчика. Не пиши код, пока не ответишь на вопросы по порядку:
1. Какая спецификация или контракт API управляет этим кодом?
2. Кто может до него достучаться и кто контролирует входные данные?
3. Какие ресурсы он защищает?
4. Какие ограничения должны выполняться для недоверенных данных?
На основе ответов сформулируй до 5 ограничений безопасности, которые должны соблюдаться.
Каждое утверждение подкрепляй ссылкой «файл:строка». Если репозиторий не даёт достаточно данных — прямо пометь «неизвестно».
Затем найди, где реализация нарушает ограничения, и предложи патч.
Верни: диагноз, список ограничений, неопределённости, патч (diff).

Два других агента получают тот же файл и те же строки, но другую специализацию. Затем запускаются три шага сборки.

Результат: Три независимые сессии вернут три диагноза и три патча с разных сторон: «как ввод доходит до функции», «что было задумано», «вот тест, который воспроизводит выход из папки». Сжатие превратит каждую сессию в короткий урок. Два сборщика выдадут два предложения. Финальный сборщик сверит их с кодом и предложит итоговый diff с пометкой, какие допущения отвергнуты.

🧠

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

Слабость. Когда одному агенту дают сразу все типы данных, он рассуждает хуже. Первое правдоподобное объяснение закрепляется, и дальше агент подгоняет под него всё остальное. Длинный контекст из трёх разных «историй поиска» ещё и путает рассуждение. Если агенты обсуждают задачу вместе, неверный начальный вывод одного заражает остальных.

Сильная сторона. Модель хорошо решает узкую задачу с чёткой рамкой («ответь на эти четыре вопроса», «напиши тест и запусти»). Она хорошо сжимает длинные траектории в короткие итоги. И она неплохо сверяет чужие предложения с реальным кодом, если ей прямо сказать «любое из них может быть ошибочным».

Как метод это использует. Независимость не даёт ошибке одного агента заразить остальных. Узкая специализация даёт каждому свой тип доказательств. Сжатие в «уроки» убирает шум, но патчи остаются отдельно, чтобы не потерять детали вроде «в какое место вставить проверку». Два сборщика видят разное (диагнозы и реализации), а финальный сводит их. Поэтому он может починить то, что не смог ни один специалист.

Рычаги управления: - Состав специалистов. Замени «структуру / намерение / PoV» на углы под свою задачу. Лучше брать разные типы доказательств, а не разные «личности». - Какой специалист сильнее, зависит от модели. В статье у одной модели выигрывал агент по структуре, у другой по намерению. Прогони всех трёх на нескольких своих случаях, не гадай. - Фраза «любое из предложений может быть неверным» держит сборщика критичным. Не убирай её. - Права финального сборщика. Он может принять один вариант, объединить, отвергнуть допущения, общие для обоих, или написать новое. Если сузить это до «выбери лучший», пропадёт случай «все ошиблись». - Запрет читерства у PoV-агента. Не ослаблять свой тест и не чинить под конкретный вход.

📋

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

Шаблон разбит на роли. Каждая запускается отдельно: три сессии исследования, затем сжатие и сборка.

=== АГЕНТ 1: СТРУКТУРА (отдельная сессия) ===
Исследователь структуры кода

Уязвимость/проблема: {описание_или_алерт}. Место: {файл_и_строки}.
Проследи, как внешний ввод доходит до этой функции (вызывающие функции, импорты).
Найди помощников и валидаторы. Сравни с похожими путями в коде, делающими то же самое.
Проверь, нет ли других мест в репозитории, где нужно такое же исправление
(файлы, которые обычно меняются вместе: {git_история_если_есть}).
Диагностируй проблему и предложи патч.

Диагноз; пути, которые ты проследил; патч (diff)

=== АГЕНТ 2: НАМЕРЕНИЕ (отдельная сессия) ===
Реконструктор замысла разработчика

Место: {файл_и_строки}. Отвечай по порядку, до написания кода:
1. Какая спецификация или контракт API управляет кодом?
2. Кто может до него достучаться и контролировать вход?
3. Какие ресурсы он защищает?
4. Какие ограничения должны выполняться для недоверенных данных?
Сформулируй до 5 ограничений безопасности. Каждое утверждение — со ссылкой «файл:строка».
Если данных не хватает — пиши «неизвестно».
Найди, где реализация нарушает ограничения, и предложи патч.

Ограничения; неопределённости; диагноз; патч (diff)

=== АГЕНТ 3: PoV (отдельная сессия) ===
Исследователь через воспроизведение

Место: {файл_и_строки}. Проследи ввод атакующего от публичной точки входа ({API/CLI/эндпоинт}) до этого кода.
Напиши тест, который демонстрирует нарушение, и запусти его на текущем коде.
Дорабатывай тест, пока он не покажет именно подозреваемое нарушение.
Затем исправь первопричину в рабочем коде и перезапусти тот же тест.


- Нельзя ослаблять тест, чтобы он прошёл.
- Нельзя делать исправление под конкретный вход из теста.
- Чини причину, а не симптом.

Что показал запуск; диагноз; патч (diff)

=== СЖАТИЕ (для каждой из трёх сессий) ===
Сожми ход работы и патч агента «{роль}» в короткий урок:
подозреваемая уязвимость; подтверждающие места в коде или результаты запуска; предложенное изменение; нерешённые утверждения.
Акцент по роли: {структура: пути и места правки | намерение: ожидаемое поведение и границы доверия | PoV: наблюдаемое нарушение и эффект патча}.

=== СБОРЩИК УРОКОВ ===
Вот три урока: {урок_1}, {урок_2}, {урок_3}.
Собери исправление на основе диагнозов. Любой из уроков может быть ошибочным — проверяй по коду репозитория.

=== СБОРЩИК ПАТЧЕЙ (отдельная сессия, параллельно) ===
Вот три патча: {diff_1}, {diff_2}, {diff_3}.
Собери исправление на основе реализаций. Любой из патчей может быть ошибочным — проверяй по коду репозитория.

=== ФИНАЛЬНЫЙ СБОРЩИК ===
Вот два предложения: патч A + его урок: {A}; патч B + его урок: {B}.
Проверь их утверждения по репозиторию. Ты можешь: принять один, объединить совместимые изменения,
отвергнуть допущения, общие для обоих, или написать новый патч.
Верни итоговый патч и кратко: что принял, что отверг, почему.

Подставляйте: описание проблемы, файл и строки (подсказка, где искать, нужна всегда), точку входа атакующего, если известна, и результаты предыдущих шагов вместо {урок_N}, {diff_N}.

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

Вот шаблон ExploreRepair. Адаптируй под мою задачу: [опиши баг/уязвимость и стек].
Задавай вопросы, чтобы заполнить поля.

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

LLM спросит, где в коде проблема, какая точка входа у пользователя, есть ли тесты и как их запускать. Это нужно, чтобы каждый из трёх агентов получил свою рамку и чтобы PoV-агент смог проверить гипотезу запуском.

⚠️

Ограничения

⚠️ Узкая задача: метод проверен только на исправлении уязвимостей в коде с готовой подсказкой, где искать. Перенос на другие баги и другие задачи — ваша догадка, статья его не проверяла.

⚠️ Цена: три полные сессии агентов, затем сжатие и три шага сборки. Это в разы больше токенов и времени, чем у одного агента. Для простых багов не окупается.

⚠️ Выигрыш от последнего шага невелик: финальная сборка добавила лишь одну-четыре уязвимости к лучшему из отдельных сборщиков. Основной прирост даёт связка «независимые специалисты + любая разумная сборка».

⚠️ Нужна проверка запуском: исход в статье мерили тестами. Без тестов вы не узнаете, какой патч «успешный», и можно получить уверенный, но неправильный итог.

⚠️ Инженерная часть: граф кода и поиск по эмбеддингам авторы написали кодом. В обычном агенте их заменяют обычный поиск по коду и чтение файлов, но точный эффект такой замены не проверен.

⚠️ Не универсальный лучший специалист: какой из трёх агентов сильнее, зависит от модели. Заранее выбрать одного нельзя.

⚠️ Текст усечён: часть раздела об агрегаторах и приложения с оригинальными промптами в доступном материале отсутствуют. Шаблон выше составлен по описанию в тексте статьи.

🔍

Как исследовали

Команда взяла 169 реальных уязвимостей на Python, JavaScript и Go из PatchEval и 35 на C/C++ из VulnLoc+. Агенту дали только репозиторий и подсказку, где искать. Описание уязвимости, тип слабости и готовый эксплойт были спрятаны. Успехом считали патч, который проходит тест на эксплойт и не ломает тесты проекта.

Сравнивали с одним агентом, с обычным «много субагентов», с современным агентом Codex и с лучшими на тот момент методами. Главный контроль: «3-в-1», один агент со всеми тремя инструментами сразу. Он оказался слабее каждого специалиста. Метод показал около 40% и около 72% успешных починок на двух моделях. Одиночный агент дал около 33% и 57%. Это прирост примерно в 7 и 14 процентных пунктов. Над одним из прежних лучших методов, EvoRepair, разрыв составил 16 и 25 пунктов.

Любопытные детали: - Самый сильный специалист на одной модели оказался не самым сильным на другой. Универсального «лучшего угла» нет. - Обычная многоагентная схема без специализации оказалась хуже одиночного агента. - На 11 уязвимостях (с одной моделью) и 3 (с другой) итоговая сборка сработала там, где ни один из трёх специалистов не справился. Информация из неудачных попыток сложилась в рабочий патч.

Вывод для практики: ценность в разнообразии доказательств и независимости, а не в числе агентов.

💡

Адаптации и экстраполяции

💡 Адаптация для разбора причин инцидента (не проверено в статье): тот же принцип «независимые специалисты по типам доказательств» можно применить к расследованию, например падения конверсии на сайте. Три отдельных чата: «логи и метрики по воронке», «что менялось в продукте и по каким причинам» (аналог намерения), «воспроизведи сбой руками на тестовом аккаунте» (аналог PoV). Потом четвёртый чат сводит три итога с инструкцией «любой вывод может быть неверным, проверь по данным».

🔧 Техника: убрать общий контекст → меньше заражения ошибкой. Не показывайте агентам выводы друг друга до сборки. Если дать второму агенту диагноз первого, он, скорее всего, подтянется к нему.

🔧 Техника: сборщику разрешить «ничего из этого не годится» → ловит общие ошибки. В шаблоне финальный сборщик может отвергнуть допущения, общие для обоих предложений. Это возможность, которую легко забыть и тем самым потерять самый ценный случай.

🔗

Ресурсы

  • Название работы: ExploreRepair: Evidence-Specialized Agents for Vulnerability Repair under Information Constraints
  • Авторы: Duc Manh Tran, Ratnadira Widyasari, Ivana Clairine Irsan, Huihui Huang, Ting Zhang, David Lo, Rahul Gopinath, Hong Jin Kang
  • Университеты: University of Sydney, University of Victoria, Singapore Management University, Monash University
  • Бенчмарки: PatchEval (Wei et al., 2025), VulnLoc+ (Ye et al., 2026)
  • Связанные методы: IntentFix (Heo et al., 2026) — источник четырёх вопросов про намерение; EvoRepair (Hu et al., 2026); LoopRepair (Ye et al., 2026); ContraFix (Liu et al., 2026)
  • Ссылок на код или сайт в доступном тексте нет.

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

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

Парадокс: один агент, которому дали сразу три способа анализа, чинит уязвимости хуже, чем каждый из трёх специалистов по отдельности. ExploreRepair позволяет чинить уязвимости, когда описания бага и готового эксплойта нет, есть только подозрительная функция. Три агента работают в отдельных сессиях и не видят выводов друг друга. Каждый смотрит со своей стороны: структура кода, замысел разработчика, тест-воспроизведение. Потом два сборщика и один финальный сводят всё в один патч. Итог: чинятся и такие уязвимости, которые не смог починить ни один из трёх специалистов.

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

Процесс в два этапа. Сначала исследование. Агент «Структура» прослеживает, как ввод доходит до функции. Агент «Намерение» отвечает на 4 вопроса о контракте и доверии и выписывает до 5 ограничений. Агент «Тест» (PoV, доказательство уязвимости) пишет тест, запускает его и чинит причину. Каждый отдаёт диагноз и патч. Потом сборка. Отдельный вызов сжимает работу каждого агента в короткий «урок». Сборщик уроков работает с диагнозами. Сборщик патчей работает с кодом правок. Финальный сборщик сверяет оба предложения с репозиторием и может принять, объединить, отвергнуть общие допущения или написать новый патч. Это как консилиум врачей. Каждый осматривает пациента сам, не слушая коллег. Потом заведующий сводит заключения. Главное: независимость до сборки. Шаги идут отдельными сессиями. В одном промпте это не соберёшь.

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

Когда одному агенту дают все данные сразу, он цепляется за первую убедительную версию. Дальше он подгоняет под неё всё остальное. Три разные «истории поиска» в одном контексте ещё и путают рассуждение. Если агенты обсуждают баг вместе, ошибка одного заражает остальных. Простые «несколько субагентов» без чёткой специализации дали результат хуже одиночного агента. Модель хорошо решает узкую задачу с чёткой рамкой: «ответь на эти четыре вопроса» или «напиши тест и запусти». Она хорошо сжимает длинные траектории в короткие итоги. Она неплохо сверяет чужие патчи с кодом, если прямо сказать, что любой из них может быть ошибочным. Независимость не даёт одной ошибке расползтись. Специализация даёт каждому агенту свой тип доказательств. Два сборщика видят разное: диагнозы и реализации. Поэтому финальный сборщик ловит то, что упустили все трое. Остужу восторг. Финальный шаг добавил лишь 1-4 уязвимости к лучшему из отдельных сборщиков. Основной прирост дают независимые специалисты плюс любая разумная сборка.

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

Безопасность кода → исправление уязвимости, когда известна подозрительная функция, но нет описания бага и готового эксплойта, особенно если есть тесты, которыми можно проверить патч. Метод проверен только на уязвимостях с подсказкой «где искать». Перенос на другие баги — ваша догадка. НЕ подходит для простых багов: три полные сессии, сжатие и сборка стоят в разы больше токенов и времени. НЕ подходит, если нечем проверить результат запуском. Иначе получите уверенный, но неверный патч.

Мини-рецепт

1. Назови место: файл и строки подозрительной функции. Без подсказки, где искать, метод не проверялся.
2. Запусти трёх специалистов в трёх отдельных сессиях: <роль>Исследователь структуры кода, <роль>Реконструктор замысла разработчика, <роль>Исследователь через воспроизведение. Они не видят друг друга.
3. Дай каждому рамку: структуре — пути от входа до функции и похожие места. Намерению — 4 вопроса и до 5 ограничений со ссылками «файл:строка». Тесту — написать тест, запустить, чинить причину.
4. Запрети читерство тест-агенту: тест не ослаблять, под конкретный вход не чинить.
5. Сожми каждую сессию в урок: подозреваемая уязвимость, подтверждения в коде, предложенная правка, нерешённые утверждения.
6. Запусти двух сборщиков параллельно: один получает три урока, другой три диффа. Обоим скажи: «любой из них может быть ошибочным, проверяй по коду».
7. Отдай оба результата финальному сборщику: пусть принимает, объединяет, отвергает общие допущения или пишет новое. Попроси кратко: что принял, что отверг, почему.
8. Прогони тесты на итоговом патче: без запуска не узнаешь, успешен ли он.

Быстрый старт: вставь в чат Вот шаблон ExploreRepair. Адаптируй под мою задачу: [опиши баг и стек]. Задавай вопросы, чтобы заполнить поля. и приложи шаблон.

Примеры

[ПЛОХО] : Найди и исправь уязвимость в download_invoice(), используй структуру кода, замысел разработчика и тесты Один агент, один контекст, три способа сразу. Он схватит первую версию и подгонит под неё остальное.
[ХОРОШО] : три отдельные сессии. В одной из них агент «Намерение»: Ты исследуешь уязвимость. Функция: download_invoice() в services/invoices.py, строки 40–95. Твоя специализация — замысел разработчика. Не пиши код, пока не ответишь по порядку: 1) Какой контракт API управляет кодом? 2) Кто может до него достучаться и контролирует вход? 3) Какие ресурсы он защищает? 4) Какие ограничения должны выполняться для недоверенных данных? Сформулируй до 5 ограничений безопасности, каждое со ссылкой «файл:строка». Если данных не хватает, пиши «неизвестно». Затем найди, где код нарушает ограничения, и предложи патч (diff). Два других агента получают те же строки, но другую рамку. Для финального шага: Вот два предложения: патч A + урок: [A]; патч B + урок: [B]. Проверь утверждения по репозиторию. Можешь принять один, объединить совместимое, отвергнуть допущения, общие для обоих, или написать новый патч. Верни итог и кратко: что принял, что отверг, почему.
Источник: ExploreRepair: Evidence-Specialized Agents for Vulnerability Repair under Information Constraints
ArXiv ID: 2610.39899 | Сгенерировано: 2026-10-30 17:20

Проблемы LLM

ПроблемаСутьКак обойти
Одна сессия с разными типами данных рассуждает хуже, чем узкие специалистыДаёшь модели всё сразу: структуру кода, замысел автора, результаты запуска. Она цепляется за первую убедительную гипотезу. Остальные данные подгоняет под неё. Длинный контекст из разных «историй поиска» ещё и путает рассуждение. Выходит хуже, чем если бы каждый тип данных разобрали отдельно. Это касается любой диагностики: баги, сбои, разбор инцидентовНе смешивай типы доказательств в одной сессии. Дай каждый тип отдельному запуску со своей узкой рамкой. Потом сведи выводы отдельным шагом. См. метод ниже
Несколько «агентов» без чёткой специализации не помогаютЗапускаешь несколько ролей или субагентов с одинаковой задачей. Если они видят друг друга, ошибка одного заражает остальных. Если у всех одна рамка, они повторяют одно и то же. Результат хуже одиночного запускаРазводи агентов по типам доказательств, а не по «личностям». Запускай независимо. Пусть не видят выводов друг друга до сборки

Методы

МетодСуть
Независимые специалисты по типам доказательств + двухканальная сборка — диагностика сложной проблемы при нехватке данныхФаза 1. Запусти 3 отдельные сессии. У каждой свой угол и свои узкие вопросы. Пример углов: структура (как данные доходят до места, чем это место окружено), замысел (4 вопроса: что задумано, кто контролирует вход, что защищается, какие ограничения обязательны; до 5 выводов со ссылками «файл:строка»; пометка «неизвестно», если данных нет), воспроизведение (напиши тест, запусти, чини причину, не ослабляй тест). Каждая сессия выдаёт диагноз и решение. Фаза 2. Сожми каждую сессию в короткий «урок»: гипотеза, подтверждения, предложенное изменение, нерешённое. Затем два сборщика работают параллельно в разных сессиях. Один видит только уроки (диагнозы). Другой видит только готовые решения (реализации). В обоих запросах пиши: Любой из них может быть ошибочным — проверяй по первоисточнику. Финальный сборщик получает оба предложения с уроками и сверяет их с первоисточником. Он вправе принять один вариант, объединить, отвергнуть допущения, общие для обоих, или написать новое. Почему работает: независимость не даёт ошибке заразить остальных. Узкая рамка даёт каждому свой тип доказательств. Сжатие убирает шум. Решения идут отдельно от уроков, поэтому не теряются детали вроде «куда вставить проверку». Два сборщика видят разное, поэтому финальный может починить то, что не смог ни один специалист. Когда да: сложная проблема, мало входных данных, есть способ проверить итог (тесты, запуск). Когда нет: простые случаи (дорого: в разы больше токенов и времени) и задачи без проверки результата (получишь уверенный, но неверный итог). Оговорка: проверено на исправлении уязвимостей в коде. Перенос на другие задачи — твоя догадка, проверь на своих случаях. Какой специалист сильнее, зависит от модели. Прогони всех трёх на нескольких своих примерах

Тезисы

ТезисКомментарий
Сборщику нужно право сказать «все ошиблись»Если попросить «выбери лучший из вариантов», сборщик выберет один из плохих. Если разрешить объединять, отвергать общие допущения и писать новое, он может найти то, чего не было ни в одном варианте. Почему: предложения часто ошибаются одинаково. Тогда выбор между ними не поможет. Применяй: добавь в запрос сборщика фразу «любое из предложений может быть неверным» и перечисли его права: принять, объединить, отвергнуть общие допущения, написать новое
📖 Простыми словами

ExploreRepair: Evidence-Specialized Agents for Vulnerability Repair under Information Constraints

arXiv: 2610.39899

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

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

В методе ExploreRepair задачу пилят три изолированных агента под разными углами. Первый агент анализирует структуру кода, второй восстанавливает замысел разработчика (что функция должна была делать до поломки), а третий пишет воспроизводящий тест. Каждый предлагает свою версию правки, не видя чужих гипотез, после чего отдельный агент-сборщик сводит независимые улики в единый безопасный патч.

Тестировали схему на слепых уязвимостях вроде path traversal, где нет готовых инструкций по взлому, но паттерн универсален. Он одинаково эффективен для отлова плавающих багов, разгребания древнего легаси или поиска утечек памяти. Везде, где исходных данных кот наплакал, сваливать всё в одно контекстное окно — верный путь к провалу.

Хватит уповать на всемогущих ботов-одиночек и разводить пустой трёп в мультиагентных чатах. Если хочешь, чтобы AI реально закрывал дыры в коде, разделяй сбор улик и синтез решения. Либо ты держишь агентов в информационном вакууме до финала, либо получаешь красивую заплатку, которая в первом же бою уронит прод.

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

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

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