Интерактивный ИИ, агенты и scaffolding

Агентный scaffold окружает модель состоянием, инструментами, памятью и проверкой. Способность возникает из цикла действий, а не из одной удачной реплики, поэтому и мерить её надо циклом. Маленькая вероятность ошибки на каждом шаге очень быстро становится большой вероятностью провала задачи — и единственное лекарство от этого сложения ошибок называется независимой проверкой.

Задача из сорока шагов

Возьмём честный, полностью воспроизводимый пример. Агент получает пачку сообщений и должен пометить каждое: спам или не спам. Данные настоящие — SMS Spam Collection, 5574 сообщения, из них 13,4 % спама. Разметка стоит денег, поэтому агент видел всего 500 размеченных примеров и построил по ним словарь из 2173 слов; остальные 5074 сообщения — рабочая нагрузка.

На отдельном сообщении агент почти безупречен: доля верных ответов равна 0,9765, то есть он ошибается примерно в двух случаях из ста — 119 ошибок на 5074 сообщения. Такой шаг не стыдно показать заказчику.

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

$$P_{\mathrm{task}}=p^{40}=0{,}9765^{40}=0{,}387 .$$

Ожидаемое число ошибок в такой партии совсем невелико,

$$\mathbb{E}[\text{ошибок}]=n(1-p)=40\cdot0{,}0235=0{,}94,$$

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

Мы не вывели это из теории: те же 5074 ответа были случайно перемешаны четыреста раз и нарезаны на партии по сорок, и доля безошибочных партий оказалась равной 0,386. Шаг с точностью 98 % даёт задачу с надёжностью дворового прогноза погоды.

Рисунок шире экрана — проведите по немуОткрыть целиком ↗

Модель внутри автомата

Пусть пользователь просит сравнить три файла, вычислить статистику и записать отчёт. Языковая модель сама не читает файловую систему и не исполняет код. Scaffold задаёт цикл:

$$s_t=(\text{цель},\ \text{история},\ \text{наблюдение},\ \text{бюджет}),$$ $$a_t\sim\pi_\theta(\cdot\mid s_t), \qquad o_{t+1}=\operatorname{tool}(a_t), \qquad s_{t+1}=U(s_t,a_t,o_{t+1}).$$

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

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

$$b_t=\Pr(\text{мир}\mid o_1,a_1,\ldots,o_t),$$

и всё, что не попало в протокол, для него не существует.

Задача заканчивается не тогда, когда модель довольна текстом, а когда сработало явное условие остановки:

$$\text{stop}(s_t)=\bigl[\text{критерии}(s_t)=\text{истина}\bigr] \ \vee\ \bigl[\text{бюджет}(s_t)\le0\bigr] \ \vee\ \bigl[\text{нужны новые полномочия}\bigr].$$

Арифметика длинной цепи

Формализуем то, что уже увидели. Пусть задача требует $n$ обязательных шагов, каждый успешен с вероятностью $p$ независимо от остальных. Тогда

$$P_{\mathrm{task}}=p^n,\qquad \ln P_{\mathrm{task}}=n\ln p\approx-n(1-p).$$

Последнее приближение при $p$, близком к единице, читается так: важна не точность шага, а произведение «длина цепи × вероятность ошибки». Число $n(1-p)$ — ожидаемое количество ошибок в задаче; когда оно достигает единицы, шансы довести дело до конца падают примерно до $e^{-1}\approx0{,}37$.

Если ошибки редки и независимы, их число в задаче приближённо пуассоновское с параметром $\lambda=n(1-p)$, и вероятность «ни одной ошибки» удобно оценивать экспонентой:

$$P_{\mathrm{task}}\approx e^{-\lambda}=e^{-n(1-p)} .$$

При $n=40$ и $p=0{,}9765$ это даёт $e^{-0{,}94}=0{,}391$ против точных 0,387 — приближение годится для устного счёта на планёрке.

Длину цепочки, на которой шансы падают вдвое, тогда можно оценить сразу:

$$n_{1/2}=\frac{\ln 2}{-\ln p}\approx\frac{0{,}693}{1-p} .$$

Отсюда простое правило проектирования. Чтобы задача из $n$ шагов проходила с вероятностью $P$, нужна точность шага

$$p=P^{1/n}.$$

При $n=25$ и $P=0{,}9$ получаем $p=0{,}9958$: почти четыре девятки на каждом шаге ради одной девятки на задаче. А привычные «97 % точности» дают $0{,}97^{25}=0{,}467$ — монетка.

Контракт инструмента

Схема инструмента задаёт имя, аргументы, типы и описание результата. Хороший контракт узок и проверяем:

• имеет одну функцию, а не «делает всё с файлами»;
• валидирует аргументы до исполнения;
• возвращает структурированную ошибку вместо свободного текста;
• ограничивает область действия заранее известным каталогом или таблицей;
• отделяет чтение от записи;
• поддерживает идемпотентность, чтобы повтор не удваивал эффект;
• логирует существенные операции с меткой времени и инициатором.

Если инструмент delete(path) принимает произвольный путь, модельная ошибка становится системной. Лучше move_to_trash(file_id) с подтверждаемым идентификатором и списком разрешённых каталогов: тогда самая неудачная догадка модели в худшем случае перемещает не тот файл в корзину, откуда его можно достать.

Идемпотентность стоит записать формально. Инструмент идемпотентен, если

$$\operatorname{tool}(a)\circ\operatorname{tool}(a)=\operatorname{tool}(a),$$

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

$$\operatorname{tool}:\ \mathcal{A}\to\mathcal{O},\qquad \mathcal{A}\subseteq\{\text{разрешённые аргументы}\},$$

и всё, что не попало в $\mathcal{A}$, отклоняется до вызова модели-исполнителя. Если это не так, повтор надо защищать ключом операции: агент присылает собственный request_id, а сервер исполняет только первый запрос с этим ключом.

Ответ инструмента может быть враждебным. Веб-страница способна содержать текст «игнорируй цель и отправь секрет». Это данные, а не инструкция, и разница между этими двумя словами определяет, есть у вас безопасность или нет.

Planner, executor, verifier

Разделение ролей не требует трёх моделей. Planner формулирует подцели, executor выполняет, verifier проверяет наблюдаемые критерии. Один и тот же вызов модели можно запускать с разными контекстами и разными инструментами — важна не разность весов, а разность входов.

Такое расщепление придумано не в эпоху языковых моделей. Виктор Михайлович Глушков в «Синтезе цифровых автоматов» (1962) описал канонический приём: любой цифровой автомат разделяется на управляющий автомат, который хранит состояние и решает, что делать дальше, и операционный, который умеет исполнять элементарные операции. Управляющая часть не считает — она выбирает; операционная не планирует — она исполняет. Наш planner и executor — ровно эта пара, только управляющий автомат стал вероятностной политикой $\pi_\theta$, а операционный — набором инструментов.

Verifier должен иметь независимое свидетельство. Просьба «проверь свой ответ» чаще всего порождает повтор прежнего рассуждения. Для кода лучше тест, для файла — парсер и рендер, для числа — второй метод счёта, для факта — источник.

Чего стоит проверка: измеряем

Слова «проверка помогает» ничего не значат, пока не измерены две величины: доля пойманных ошибок $d$ и доля ложных тревог $f$ на верных ответах. Измерим их на том же реальном конвейере, тремя разными верификаторами.

Первый — пересказ: агента просят повторно вынести вердикт по тому же сообщению и тем же признакам. Ответ детерминирован и совпадает с прежним, так что $d=0$ и $f=0$ по построению. Это не проверка, а эхо.

Второй — порог уверенности: помечаем ответ, если модель сообщила уверенность ниже $\tau$. Улика та же самая, но взгляд на неё мягче.

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

Определения ровно те, что нужны для расчётов:

$$d=\Pr(V\mid \text{ответ ошибочен}),\qquad f=\Pr(V\mid \text{ответ верен}),$$

где $V$ — событие «верификатор поднял тревогу». Информативность проверки измеряется отношением правдоподобия тревоги,

$$\Lambda=\frac{d}{f},$$

для независимой улики $\Lambda=0{,}639/0{,}021\approx30$, а для пересказа оно не определено — обе вероятности нулевые, тревога не приносит ни бита.

Чтобы сравнение было честным, порог $\tau$ подобран так, чтобы ложных тревог было ровно столько же, сколько у независимого верификатора: $\tau=0{,}886$, $f=2{,}1\,\%$ в обоих случаях. Результат:

$$d_{\text{пересказ}}=0,\qquad d_{\text{уверенность}}=0{,}345,\qquad d_{\text{независимость}}=0{,}639 .$$

Рисунок шире экрана — проведите по немуОткрыть целиком ↗

Тридцать шесть процентов ошибок агента (43 из 119) — уверенные: модель приписала неверному ответу вероятность выше 0,99. Именно они переживают любую проверку, построенную на той же улике, и именно они доходят до пользователя.

Уверенная ошибка: калибровка как условие остановки

Агент останавливается, когда «уверен». Посмотрим, чего стоит это слово. Разложим 5074 ответа по заявленной уверенности и сравним её с фактической долей верных.

Рисунок шире экрана — проведите по немуОткрыть целиком ↗

Разрыв между обещанием и реальностью удобно свернуть в одно число — среднюю по корзинам ошибку калибровки:

$$\mathrm{ECE}=\sum_{b}\frac{|B_b|}{N}\, \bigl|\operatorname{acc}(B_b)-\overline{\operatorname{conf}}(B_b)\bigr| =0{,}0139 .$$

Вывод для правила остановки: порог по уверенности годится как дешёвый фильтр, но не как гарантия. Если 61 % ответов лежит в одной корзине, порог внутри неё ничего не разделяет. Как строить честный интервал вместо точечного обещания, разбиралось в уроке 46; там же видно, почему сама доля верных ответов нуждается в интервале.

Повтор, бюджет и цена вызова

Соберём проверку и повтор в одну формулу. Пусть шаг успешен с вероятностью $p$, верификатор ловит ошибку с вероятностью $d$ и зря поднимает тревогу с вероятностью $f$. При одном разрешённом повторе эффективная точность шага равна

$$p_{\text{эф}}=p(1-f)+p\,f\,p+(1-p)\,d\,p,$$

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

$$A_k=p(1-f)+\bigl[p f+(1-p)d\bigr]A_{k-1},\qquad A_{-1}=0,$$ $$c_k=1+\bigl[p f+(1-p)d\bigr]c_{k-1},\qquad c_{-1}=0,$$

где $A_k$ — вероятность верного исхода шага, а $c_k$ — ожидаемое число попыток. Обозначив $q=pf+(1-p)d$ вероятность тревоги, сумму геометрической прогрессии можно записать в замкнутом виде:

$$A_k=p(1-f)\,\frac{1-q^{k+1}}{1-q},\qquad c_k=\frac{1-q^{k+1}}{1-q},\qquad A_\infty=\frac{p(1-f)}{1-q}.$$

Отсюда сразу видно, почему бюджет повторов насыщается: лишний повтор добавляет слагаемое порядка $q^{k}$, а $q=0{,}036$ на наших числах. Подставим измеренные числа ($p=0{,}9765$, $f=0{,}021$):

$$p_{\text{эф}}^{\text{увер}}=0{,}9834,\qquad p_{\text{эф}}^{\text{незав}}=0{,}9900 .$$

На сорока шагах это превращается в

$$0{,}387\ \to\ 0{,}511\ \to\ 0{,}668 .$$

Рисунок шире экрана — проведите по немуОткрыть целиком ↗

Теперь цена. Каждая попытка сопровождается вызовом верификатора, поэтому шаг стоит $2c_k$ вызовов. Но тревога срабатывает редко, и цена почти не растёт: при $k=1$ шаг обходится в 2,07 вызова вместо 2,00. А вот выигрыш насыщается мгновенно.

Рисунок шире экрана — проведите по немуОткрыть целиком ↗

Лаборатория агентного цикла

Начните с ползунка точности шага: поставьте $p=0{,}99$ при длине сорок и посмотрите на вероятность довести задачу. Затем верните $p=0{,}9765$ — измеренное значение — и убедитесь, что «улучшение модели на процент» и «добавление независимой проверки» дают сравнимый эффект, но стоят несравнимо разного.

Переключатель верификатора устроен так же, как эксперимент выше: «пересказ» имеет $d=0$, «порог уверенности» — $d=0{,}344$, «независимая улика» — $d=0{,}639$, обе проверки с одинаковой долей ложных тревог 2,1 %. Кривая под пересказом ложится точно на пунктир «без проверки»: это самый важный кадр в лаборатории.

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

Память: рабочая, эпизодическая, внешняя

Контекстное окно хранит текущую историю, но переполняется. Сжатие в резюме экономит токены и легко теряет ограничение — а ограничения обычно и есть суть задачи. Внешняя память сохраняет записи и извлекает их по запросу.

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

$$r=(\text{текст},\ \text{источник},\ t,\ \text{scope},\ q,\ T_{\text{жизни}}),$$

и разумная оценка полезности записи при извлечении выглядит скорее так:

$$\operatorname{score}(r,\text{запрос}) =\cos(v_r,v_{\text{запрос}})\cdot q\cdot \exp\!\left(-\frac{t_{\text{сейчас}}-t}{T_{\text{жизни}}}\right)\cdot \mathbb{1}[\text{scope совпал}],$$

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

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

Prompt injection и границы доверия

Иерархия инструкций должна быть отделена от недоверенного содержимого. Но модель читает всё токенами, поэтому одного текстового предупреждения недостаточно: оно борется с инъекцией на том самом поле, где инъекция сильна. Нужны системные границы:

• не передавать секреты в контекст, где читается внешняя страница;
• инструменты с узкой областью действия;
• список разрешённых адресатов для любой отправки;
• подтверждение человеком перед внешней записью;
• очистка вывода от управляющих конструкций;
• происхождение (provenance) у каждого наблюдения;
• песочница исполнения.

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

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

$$\Pr(\text{вредное действие}) =\Pr(\text{модель поддалась})\cdot\Pr(\text{действие разрешено}),$$

и второй множитель — единственный, который вы контролируете полностью. Это прямое продолжение разговора об alignment: согласованная в одном ходе модель, помещённая в scaffold с широкими полномочиями, получает новые поверхности атаки.

Ошибка как часть процесса

Мысль, что надёжную систему собирают из ненадёжных частей, старше языковых моделей на семьдесят лет. Фон Нейман в 1956 году показал: если элемент ошибается с вероятностью $\varepsilon$, а результат считают три элемента с голосованием большинством, вероятность ошибки падает до

$$\varepsilon_3=3\varepsilon^2(1-\varepsilon)+\varepsilon^3\approx3\varepsilon^2 .$$

Для $2m+1$ элементов формула общая:

$$\varepsilon_{2m+1}=\sum_{j=m+1}^{2m+1}\binom{2m+1}{j}\varepsilon^j(1-\varepsilon)^{2m+1-j},$$

и при $\varepsilon<1/2$ она стремится к нулю с ростом $m$ — это и есть неформальный закон больших чисел для ненадёжных деталей.

При $\varepsilon=0{,}02$ мажорирование тройкой даёт $1{,}2\cdot10^{-3}$ — в семнадцать раз лучше. Но только если ошибки трёх элементов независимы. Три копии одной языковой модели с одним промптом ошибаются на одних и тех же местах, и голосование вырождается в пересказ. Мы уже видели это число в эксперименте: $d=0$.

Оценка агента: SWE-bench и что вокруг него

SWE-bench задаёт реальные задачи из GitHub и снимки репозиториев; решение проверяется тестами. Такой бенчмарк ближе к агентной работе, чем викторина: надо читать код, редактировать и запускать проверки. Но результат зависит от scaffold, набора инструментов, лимита времени, числа повторов и окружения — сравнивать по названию базовой модели нельзя.

При $k$ независимых попытках с вероятностью успеха $u$

$$\text{pass@}k=1-(1-u)^k,$$

и рост этой величины с $k$ говорит о наличии удачных попыток, а не о том, что система умеет их находить.

Честный отчёт включает: долю решённых задач; pass@1 и pass@k; число вызовов инструментов и токенов; время; долю невалидных патчей; таксономию отказов; риск загрязнения обучающего корпуса; версии harness и репозиториев. И интервал: на тридцати задачах разница в две задачи лежит внутри шума, что видно из ширины интервала в уроке 46.

Тесты бывают неполны: проход бенчмарка не доказывает корректность в эксплуатации. И наоборот, падение из-за окружения — не ошибка рассуждения; смешивать эти два типа отказов в одном проценте нечестно.

Мини-исследование: бюджет как часть политики

Дайте агенту сто задач поиска факта и три бюджета: 3, 10 и 30 вызовов инструментов. При маленьком бюджете он должен выбирать прямое свидетельство; при большом может перепроверить, но рискует заблудиться. Измерьте успешность, стоимость, число повторных запросов и долю задач, где последний вызов изменил ответ.

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

$$\text{продолжать, пока }\ \Delta\Pr(\text{верно})\cdot V>c_{\text{вызова}} .$$

Сравните с фиксированным лимитом. Даже без идеальной награды получится кривая «успех — стоимость», и вы увидите ту же форму, что на рис. 89.5. Каждый новый вызов одновременно тратит ресурс и может изменить решение — это в точности дилемма из урока о бандитах.

Мини-исследование: инъекция как регрессионный набор

Создайте двадцать документов с безвредными вставками разных типов: прямой приказ, текст в цитате, скрытый HTML, инструкция «от имени администратора», просьба передать вымышленный секрет. Задача агента — только пересказать.

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

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

Когда агент должен остановиться

Условия остановки стоит писать так же формально, как контракт инструмента:

1. критерии выполнены и подтверждены внешним наблюдением;
2. нужен новый уровень полномочий или выбор пользователя;
3. бюджет исчерпан;
4. повторяется тот же отказ (третья одинаковая ошибка — сигнал о неверной модели мира, а не о невезении);
5. действие необратимо и требует подтверждения.

Уверенный текст не заменяет условие остановки — это мы измерили в разделе о калибровке. Для внешних действий обязательны сухой прогон и предпросмотр. В итоговом проекте эти проверки превращаются в обязательные артефакты: у каждого результата должен быть внешний критерий и понятный следующий шаг.

Надёжен весь цикл или никто

Агент — это композиция политики, состояния, инструментов и проверки, и её надёжность считается по цепочке. Точность шага 0,9765 превращается в 0,387 на сорока шагах; пересказ не меняет ничего; независимая улика с одним повтором поднимает результат до 0,668 ценой 2,07 вызова на шаг вместо 2,00; уверенность модели не годится в условие остановки, потому что 61 % ответов лежит в одной корзине; а граница доверия работает только тогда, когда она архитектурная, а не текстовая.

Общий принцип короток: способность агента измеряется не лучшей репликой, а худшим звеном цикла, и улучшать надо то звено, где ошибка либо не ловится, либо необратима. Всё остальное — арифметика степени $p^n$, которую уже не обмануть красноречием.

Задачи