3,583 papers
arXiv:2610.12813 71 8 окт. 2026 г. FREE

VEPA: проверяемая эволюция правил-ограждений для агента через структурированные правила, проверку конфликтов и порог доверия

КЛЮЧЕВАЯ СУТЬ
Обнаружено: заметки агента о безопасности со временем портятся. Они становятся двусмысленными и спорят друг с другом. Чинишь одну ошибку, а ломается то, что раньше работало. Метод VEPA позволяет править правила агента и не ронять старые решения. Он нужен там, где агент читает почту, лезет в систему учёта клиентов (CRM) и шлёт письма наружу. Фишка: большая языковая модель (LLM) ничего не решает, а только предлагает правки в правилах. Правила записаны как короткие строгие условия «если [условие], то разрешить или отказать» над типизированными событиями (кто, что, кому, какие данные). Код отсекает правки с конфликтами, а новое правило получает слово только после подтверждений из реальной работы. Ни одна правка не попадает в работу без проверки на противоречия.
Адаптировать под запрос
⚡

TL;DR

VEPA — схема, в которой правила безопасности агента хранятся не как текстовые заметки, а как короткие строгие правила вида «если [условие], то разрешить/отказать» над типизированными событиями. LLM предлагает правки этих правил (добавить, удалить, переписать, разбить, слить). Затем код-проверяльщик отсекает правки с конфликтами, а правило получает право на решения только после достаточного числа подтверждений из реальной работы.

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

Метод разводит три роли: LLM предлагает правки, проверяльщик допускает только непротиворечивые, слой полномочий включает правило только по накопленным доказательствам. Для читателя без кода применима идея, а не сама система: правила держать строго и коротко, каждую правку проверять на конфликты и регрессии, новые правила не включать сразу.

🔬

Схема метода

ШАГ 0: Событие агента (письмо, вызов инструмента) → типизированная запись
        (кто, что делает, какие данные, кому, зачем, есть ли разрешение, инструмент)
        Поля, которые не определить → "unknown"

ШАГ 1: Есть ошибки (провалы) и верные решения (эталон)
        → LLM пишет «патч»: список правок Add / Delete / Rewrite / Split / Merge

ШАГ 2: Проверяльщик (код) → допускает только
        • корректные по схеме правила
        • без конфликтов (два правила с противоположным решением на одном событии)
        Отклонил → возвращает пример конфликта, LLM пробует снова

ШАГ 3: Компромисс между двумя целями:
        «починить новые ошибки» и «не сломать то, что работало»
        Хранится архив допущенных вариантов; итог — вариант, у которого слабейшая цель сильнейшая

ШАГ 4: Слой полномочий → правило «активно» только если накоплено
        достаточно подтверждений; противоречащая обратная связь отзывает его

Всё это работает на коде. В чате воспроизводятся только шаги 1–2, и без гарантий.

🚀

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

Метод сильнее всего там, где у агента есть доступ к чувствительному и необратимые действия. Слабая зона — субъективные и «творческие» решения. Поэтому берём агента с доступом к почте и CRM.

Задача: Магазин электроники на маркетплейсах запустил агента-помощника менеджера. Он видит amoCRM и почту и умеет отправлять письма. Два случая за неделю: - Агент отправил поставщику файл с закупочными ценами конкурентов. - Агент отказал бухгалтеру из своей компании в получении счёта-фактуры, хотя это штатная работа.

Нужно поправить правила, не сломав остальное.

Промпт:

Ты редактор набора правил-ограждений для агента. Правки строго типизированные.


R1: data.sensitivity = confidential И recipient.affiliation = external → refuse
R2: action.type = send_email И recipient.affiliation = internal → allow
R3: data.type = invoice → refuse




F1: send_email, data.type=price_list_competitors, sensitivity=unknown, recipient=supplier (external). Верно: refuse. Получили: allow.
F2: send_email, data.type=invoice, recipient=accountant (internal). Верно: allow. Получили: refuse (сработало R3).


C1: send_email, data.type=invoice, recipient=client (external), authorization=approved. Верно: refuse без одобрения руководителя. Сейчас refuse — не сломай.
C2: send_email, data.type=meeting_notes, recipient=internal. Верно: allow. Сейчас allow.


Прошлый кандидат отклонён: «data.type = invoice → allow» конфликтует с R3 на событии C1.



Add(r), Delete(r), Rewrite(r→r'), Split(r→{r',r''}), Merge({r',r''}→r)


1. Каждое правило — условие из полей схемы + решение.
2. Два правила с разными решениями не должны покрывать одно событие.
3. Все события из RegressionWitnesses должны получить прежнее решение.
4. Все события из UnresolvedFailures должны получить верное решение.
5. Для каждого события из обоих списков выпиши, какое правило сработает, и проверь пересечения.


Выведи: (а) патч списком правок, (б) итоговый набор правил, (в) таблицу «событие → сработавшее правило → решение», (г) найденные пересечения или «пересечений нет».

Результат: Модель выдаст патч из нескольких типизированных правок. Вероятно, это Split слишком широкого R3 по получателю и Rewrite условия для F1. Затем она покажет итоговый набор правил и таблицу прогона по всем примерам. В конце будет явная проверка пересечений. Это проверка самой моделью, а не гарантия. Для критичных случаев прогоните правила через код или скрипт.

🧠

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

Слабость. Текстовое правило вроде «не делись конфиденциальным вовне» каждый раз трактуется заново. Две заметки легко противоречат друг другу, но это видно только в момент решения. Исправив одну ошибку, вы не знаете, что сломалось. Чтобы проверить, нужно перегонять все старые примеры через LLM, а это дорого и неповторимо.

Сильная сторона LLM. Модель хорошо обобщает: по нескольким провалам с разными внешними получателями она формулирует общее правило «конфиденциальное нельзя за пределы организации». Перебором такое правило не найти.

Как метод это использует. LLM дана только роль предложения правок. Решение и проверку отдали строгим правилам и коду, который не «трактует». Дополнительно правило допускается к работе, только когда его подтвердили события. Модель можно ошибиться, но ошибка не попадёт в работу сразу.

Рычаги управления: - Набор полей схемы (кто, что, кому, зачем, разрешение) → больше полей дают точнее правила, меньше упрощают проверку. - unknown для неопределимого → безопаснее, чем догадка; пусть правило явно решает, что делать с unknown. - Примеры-эталоны (RegressionWitnesses) → чем больше, тем надёжнее защита от поломок. - Порог доверия → выше для опасных решений (отказ в критичном или разрешение), ниже для мелких. - Возврат конкретного конфликта в следующий запрос → модель не повторяет ту же ошибку.

📋

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

Это реконструкция по описанию метода, а не дословный промпт из статьи. В доступной части работы текст промпта не приведён.

Ты редактор набора правил-ограждений для агента. Ты правишь правила только типизированными действиями.


{поля_и_допустимые_значения}



{текущие_правила}



{ошибки_с_верным_решением}
{примеры_которые_должны_остаться_верными}
{конфликты_прошлых_попыток_или_«нет»}


Add(r), Delete(r), Rewrite(r→r'), Split(r→{r',r''}), Merge({r',r''}→r)


1. Правило = условие по полям схемы + решение (allow/refuse). Значения только из схемы.
2. Нет двух правил с разными решениями, покрывающих одно событие.
3. Все примеры из RegressionWitnesses сохраняют прежнее решение.
4. Все примеры из UnresolvedFailures получают верное решение.
5. Если вариантов несколько — выдай 2–3 кандидата и выбери того, у которого слабейшая из двух целей (починка ошибок / отсутствие поломок) сильнее.


Выведи: (а) патч, (б) итоговые правила, (в) таблицу «событие → сработавшее правило → решение», (г) найденные пересечения.

Что подставлять: - {поля_и_допустимые_значения} — например, action.type ∈ {send_email, read_file}, data.sensitivity ∈ {public, confidential, unknown}. - {текущие_правила} — ваши действующие правила в виде «условие → решение». - {ошибки_с_верным_решением} — реальные случаи, где агент ошибся. - {примеры_которые_должны_остаться_верными} — случаи, где агент уже решал правильно.

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

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

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

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

⚠️

Ограничения

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

⚠️ Детерминизм только после разбора: гарантии действуют, когда событие уже превращено в типизированную запись. Эту запись делает LLM-разборщик, и он сам может ошибиться. Авторы это прямо признают.

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

⚠️ Покрытие неполное: метрики считаются на событиях, которые покрыты активной политикой. Остальное остаётся без детерминированной защиты, пока правила не накопят подтверждения.

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

🔍

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

Идея была в том, чтобы сравнить два подхода к «обучаемым» ограждениям: когда агент хранит заметки о безопасности текстом и когда держит строгие правила, проверяемые кодом. Команда Google Cloud AI Research и UNC прогнала их в режиме онлайн-развёртывания на трёх наборах: ASSEBench-Safety, ASSEBench-Security и ATBench. События приходят потоком, после каждого шага приходит обратная связь, и правила обновляются.

Сравнивали VEPA с LLM-ограждением без памяти и с адаптивными текстовыми вариантами (AGrail, LiSA). Главная метрика — F1 (баланс «не пропустить опасное» и «не блокировать нужное») на событиях, покрытых активной политикой. VEPA выигрывала на всех трёх наборах и постепенно расширяла долю событий с детерминированными решениями.

Затем усложнили условия: смешанные потоки с меняющимися типами рисков, испорченная обратная связь, более длинные периоды, другие LLM. Преимущество сохранилось. Для практики это значит: проверка и «порог доверия» защищают правила от шумной обратной связи, а свободный текст такого не умеет. Дополнительная деталь: проверка одного трёхусловного правила занимает около 0,25 мс. Разница со стоимостью вызова LLM огромна.

💡

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

🔧 Техника: «кандидат» вместо сразу действующего правила → защита от случайных правок

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

## Кандидаты (НЕ применять, только наблюдать)
- К1: письма с прайсами внешним адресатам требуют подтверждения. Подтверждений: 1, опровержений: 0.
Правило переходит в «Действующие» при 3 подтверждениях и 0 опровержениях.

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

Экстраполяция: аудит файла правил на конфликты и регрессии

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

Вот файл инструкций моего агента: {текст_файла}.
1. Перепиши каждое правило в виде «условие → решение».
2. Найди пары правил, которые дают противоположные решения на одном событии. Для каждой пары приведи пример такого события.
3. Для моих эталонных случаев {список_случаев} выпиши, какое правило сработает и совпадает ли это с верным решением.
Не предлагай правок, пока я не подтвержу найденные конфликты.
🔗

Ресурсы

  • Работа: VEPA: Verified Evolving Formal Policy for Lifelong LLM Agent Guardrails
  • Авторы: Duy Nguyen, Lesly Miculicich, Bhavana Dalvi Mishra, Shuo Li, Krishnamurthy Dj Dvijotham, Mohit Bansal, Tomas Pfister, Long T. Le
  • Организации: Google Cloud AI Research, UNC Chapel Hill, Google DeepMind
  • Наборы для проверки: ASSEBench-Safety и ASSEBench-Security (Luo et al., 2025a), ATBench (Li et al., 2026)
  • Сравнивались с: AGrail (Luo et al., 2025c), LiSA (Kim et al., 2026b)
  • Основа представления событий: теория контекстной целостности (Nissenbaum, 2004)

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

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

Обнаружено: заметки агента о безопасности со временем портятся. Они становятся двусмысленными и спорят друг с другом. Чинишь одну ошибку, а ломается то, что раньше работало. Метод VEPA позволяет править правила агента и не ронять старые решения. Он нужен там, где агент читает почту, лезет в систему учёта клиентов (CRM) и шлёт письма наружу. Фишка: большая языковая модель (LLM) ничего не решает, а только предлагает правки в правилах. Правила записаны как короткие строгие условия «если [условие], то разрешить или отказать» над типизированными событиями (кто, что, кому, какие данные). Код отсекает правки с конфликтами, а новое правило получает слово только после подтверждений из реальной работы. Ни одна правка не попадает в работу без проверки на противоречия.

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

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

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

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

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

Агенты с доступом к чувствительным данным и необратимыми действиями → особенно почта, система учёта клиентов, отправка файлов наружу, когда правила копятся месяцами, и каждая правка пугает: вдруг что-то сломается. В чате без кода воспроизводятся только шаги «модель предлагает правки» и «модель проверяет конфликты». Гарантий нет, таблицу проверки модель тоже может нарисовать криво. Для критичных случаев прогоняйте правила через скрипт. НЕ подходит для субъективных и творческих решений: там нечего записать строгим правилом. Не подходит и тогда, когда вы не знаете, какие решения агента были верными. Без размеченных ошибок и эталонов системе нечего исправлять.

Мини-рецепт

1. Опиши событие полями: кто действует, что делает, какие данные, кому, зачем, есть ли разрешение, какой инструмент.
2. Заведи значение unknown: если поле не определить, пусть будет «неизвестно». Догадка опаснее. Пусть правило явно решает, что делать с unknown.
3. Выпиши правила как «условие → решение»: одно условие, одно решение. Никаких абзацев с «обычно» и «как правило».
4. Собери два списка: ошибки с верным ответом и эталоны, которые должны остаться верными. Эталоны нужны больше, чем кажется. Чем их больше, тем надёжнее защита от поломок.
5. Отдай модели шаблон: она предлагает правки только типизированными действиями. Требуй таблицу «событие → сработавшее правило → решение» и список пересечений.
6. Верни конфликт, если он нашёлся: покажи модели конкретное событие, где два правила спорят. Так она не повторит ту же ошибку.
7. Не включай правило сразу: пусть сначала поработает в режиме подсказки. Включай, когда оно несколько раз совпало с решением живого человека. Для опасных решений требуй больше совпадений.
8. Если правил много: перенеси проверку из чата в скрипт. Модель предлагает, скрипт проверяет.

Примеры

Пример 1. Правка правил после двух инцидентов [ПЛОХО]: `Агент отправил поставщику лишнее, а бухгалтеру отказал в счёте. Поправь правила, чтобы так не повторялось.` [ХОРОШО]: `Ты редактор правил-ограждений. Правь только типизированными действиями Add, Delete, Rewrite, Split, Merge. Текущие правила: R1: data.sensitivity = confidential И recipient = external → refuse. R2: action = send_email И recipient = internal → allow. R3: data.type = invoice → refuse. Ошибка F1: прайс конкурентов, sensitivity = unknown, получатель поставщик. Верно: refuse, получили allow. Ошибка F2: счёт-фактура бухгалтеру внутри компании. Верно: allow, получили refuse по R3. Эталон C1: счёт клиенту без одобрения. Верно refuse, не сломай. Эталон C2: протокол встречи внутри. Верно allow. Выведи: патч, итоговые правила, таблицу «событие → сработавшее правило → решение» для F1, F2, C1, C2 и найденные пересечения.` После такого запроса вероятнее всего придут две правки. R3 будет разбито по получателю, а условие для F1 переписано, чтобы `unknown` вело к отказу для внешних. Таблица покажет, что C1 и C2 остались как были. Пример 2. Модель вернулась с конфликтом [ПЛОХО]: `Ты предложил плохое правило, попробуй ещё раз.` [ХОРОШО]: `Кандидат «data.type = invoice → allow» отклонён. Он конфликтует с R3 на событии C1: счёт клиенту, получатель внешний. Предложи правку, где C1 остаётся refuse, а F2 становится allow. Покажи таблицу для C1 и F2.` Модель получает конкретное событие, где правила спорят. Так проще поправить, чем гадать, что не так.
Источник: VEPA: Verified Evolving Formal Policy for Lifelong LLM Agent Guardrails
ArXiv ID: 2610.12813 | Сгенерировано: 2026-10-12 05:20

Проблемы LLM

ПроблемаСутьКак обойти
Правила в свободном тексте со временем портятсяТы ведёшь набор правил для модели обычными фразами: системный промпт, заметки, «память». Каждая новая правка чинит одну ошибку и ломает то, что работало. Фразы начинают противоречить друг другу. Это видно только в момент решения. Модель каждый раз трактует расплывчатый текст заново. На похожих случаях ответы разные. Проверить всё разом нельзя: текст не ищет противоречия самПиши правила коротко и строго: если [условие по полям] → разрешить/отказать. Поля фиксированы заранее: кто, что делает, с какими данными, кому. Перед каждой правкой давай модели старые верные примеры. Они должны остаться верными

Методы

МетодСуть
Правка правил с тремя наборами примеров — починка без поломокНе проси просто «поправь правила». Дай модели три набора примеров. 1. Провалы: случаи, где ответ был неверным, и какой ответ верный. 2. Эталоны: случаи, где всё уже работало. Их решение менять нельзя. 3. Прошлые конфликты: почему отклонена прошлая попытка, с конкретным примером. Синтаксис: , , . Ограничения: «Нет двух правил с разными решениями на одном случае. Все эталоны сохраняют решение. Все провалы получают верное». Попроси таблицу: случай → сработавшее правило → решение, затем список пересечений. Разреши типовые правки: добавить, удалить, переписать, разбить, слить. Почему работает: Эталоны защищают от поломки старого. Конкретный конфликт не даёт модели повторить ту же ошибку. Таблица заставляет пройти каждый случай, а не «в целом согласиться». Когда да: набор правил живёт долго и правится часто. Есть хотя бы 5–10 размеченных случаев. Когда нет: нет примеров с верным ответом. Тогда проверять нечем. Важно: таблицу строит сама модель, она может ошибиться. Для критичных правил прогони их скриптом
📖 Простыми словами

VEPA: Verified Evolving Formal Policy for LifelongLLMAgentGuardrails

arXiv: 2610.12813

Пытаться обезопасить AI-агента текстом в духе «не сливай секреты компании» — это как просить ребёнка «вести себя прилично». Каждый раз модель трактует фразу по настроению, а два соседних правила гарантированно войдут в клинч. Метод VEPA рубит эту самодеятельность под корень: вместо расплывчатых инструкций безопасность упаковывают в строгий код условий формата «если X, то запретить». Никакой философии — только детерминированная логика.

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

Система устроена цинично и просто. Сама LLM может генерировать правки через пять операций: добавить, удалить, переписать, разбить или слить правила. Но рулить базой ей никто не даёт — сверху стоит безжалостный код-проверяльщик, который отсекает любую шизофрению. Более того, новое правило не начинает действовать сразу: оно отправляется на испытательный срок и включается только после серии подтверждений на реальных кейсах.

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

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

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

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

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