Разрешённое действие ≠ допустимое поведение

Ваш личный ассистент бронирует стол в ресторане на пятницу — и заодно отменяет вашу тренировку в фитнес-клубе, решив, что так вам будет удобнее по времени.

Вы его об этом не просили.

Но он не нарушил ни одного правила: календарь ему доступен, ресторан он нашёл в переписке, к которой вы сами дали доступ, отменить тренировку он тоже технически может.

Разрешения были на каждый шаг.

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

Право на действие было. Оснований делать именно это в рамках поставленной задачи — не было.

В бизнес-системах цена такой ошибки уже совсем другая.

ИИ-агент получает задачу: подготовить отчёт по просроченной дебиторской задолженности.

Читает ERP — данные по счетам.

Разрешено.

Читает CRM — контакты клиента.

Разрешено.

Читает переписку с клиентом в почте, чтобы понять контекст просрочки.

Это уже более спорный шаг, но он всё ещё объясним исходной задачей.

А затем агент меняет статус платежа в ERP.

Формально ему это разрешено: у него есть право на запись в ERP.

IAM не блокирует действие — соответствующее право у агента есть.

Система защиты API тоже может не увидеть проблемы, если сам запрос корректен, аутентифицирован и укладывается в разрешённый шаблон работы с API.

Но ни один из этих ответов сам по себе не отвечает на другой вопрос:

должен ли агент делать это сейчас, в рамках именно этой задачи?

Ему поручили подготовить отчёт. Трогать статус платежа его не просили.

Разрешено — не значит уместно

Мы привыкли проверять доступ на уровне отдельного действия: кто субъект, к какому ресурсу он обращается, есть ли у него право.

У традиционных приложений это работало не потому, что система автоматически была безопасной, а потому что код, сценарий и роль заранее ограничивали пространство возможных действий.

С ИИ-агентом это предположение меняется.

Агент не просто вызывает заранее определённый API по заранее заданному сценарию.

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

Поэтому риск может возникать не в одном запросе. Он может возникать в последовательности запросов.

И по отдельности почти ни один из них не будет выглядеть подозрительным.

Риск начинает жить не только в действии, но и в траектории поведения.

То, что каждый шаг разрешён, не означает, что допустима вся последовательность, которая из этих шагов складывается.

Есть ещё одно различие, которое кажется мне важным.

У агента могут быть постоянные полномочия, необходимые для разных задач. Например, тот же финансовый агент в одних сценариях действительно должен уметь изменять данные в ERP.

Но это не означает, что он должен использовать все доступные полномочия в каждой конкретной задаче.

Постоянные полномочия ≠ полномочия, уместные в текущей задаче.

Что упускает проверка на уровне запроса

Проверка отдельного запроса задаёт примерно такой вопрос:

Может ли агент A выполнить действие B над ресурсом C?

Для агентных систем этого может оказаться недостаточно.

Новая единица анализа требует другого вопроса:

Объясняется ли это действие исходной задачей, текущим контекстом и уже совершённой последовательностью действий?

Это две разные модели.

Агент → действие → ресурс

и

Исходная задача → последовательность действий → результат

В первом случае мы принимаем решение, глядя на один запрос. Во втором — на накопленную историю поведения.

Чтобы принять такое решение, системе нужно видеть значительно больше:

·       кто агент;

·       от чьего имени он действует;

·       какая задача ему поставлена;

·       что он уже сделал;

·       что хочет сделать сейчас;

·       насколько это действие объяснимо исходной задачей;

·       к какому результату ведёт вся последовательность.

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

Не новый продукт, а новый вопрос о том, где живёт решение

Было бы соблазнительно сразу сказать, что для этого нужен ещё один продукт информационной безопасности.

Мне кажется, вопрос интереснее: где вообще должен жить такой контроль?

В IAM? В среде исполнения агента? В MCP-шлюзе? В API-шлюзе? В системе наблюдаемости?

Или вообще между ними — в отдельном слое принятия решений с состоянием, который собирает контекст из нескольких систем?

Сегодня необходимые данные уже частично существуют, но они распределены между разными слоями:

·       IAM знает, кто действует и какими правами обладает;

·       среда исполнения знает внутренний контекст работы агента;

·       шлюзы видят вызовы;

·       система наблюдаемости хранит телеметрию;

·       журналы приложений фиксируют итоговые действия.

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

У меня есть рабочая гипотеза на этот счёт. Но это тема отдельного разговора, и я вернусь к ней в одной из следующих статей этой серии.

Цена того, что никто не спросил

Это не абстрактная угроза.

В бытовом примере цена — пропущенное письмо. В финансовой системе — ложное состояние данных, которое начинают использовать зависимые процессы.

Если система останавливается на решении «разрешить или запретить» для отдельного вызова, изменение статуса платежа может остаться незамеченным до следующей сверки.

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

И при этом каждый отдельный шаг агента останется в журналах как разрешённый.

Открытый вопрос

Я не думаю, что у этой проблемы уже есть окончательный и универсальный ответ. Иначе не стоило бы её обсуждать.

Мне интереснее всего другой вопрос:

где проходит граница между нормальной адаптивностью агента и отклонением от исходной задачи?

Агент, который читает переписку с клиентом, чтобы точнее собрать отчёт, — это ещё адаптивность или уже отклонение?

А если он для того же отчёта дополнительно проверит платёжную историю за три года вместо одного квартала?

А если обнаружит аномалию и захочет исправить её сам?

В какой момент полезная автономность превращается в нежелательное поведение? И кто должен принять это решение?

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

Следующий вопрос логически следует отсюда: можем ли мы вообще увидеть действия агента как одну связную историю, а не как поток разрозненных API-вызовов?

Потому что, возможно, следующая важная единица безопасности для агентных систем — не запрос и не отдельное право доступа.

А поведение во времени.