Как остановить цикл вызовов инструментов у ИИ‑агента

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

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

Что сделать, пока агент ещё работает

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

1. Зафиксируйте состояние задачи как остановленное. Очередь, автоматические повторы и дочерние исполнители должны проверять это состояние перед отправкой новой работы.
2. Запросите отмену через предусмотренный механизм среды выполнения. Отдельно проверьте состояние уже работающих исполнителей и операций: запрос отмены ещё не является подтверждением их остановки.
3. Сохраните идентификатор задачи, время, последние вызовы, классифицированные результаты, остаток бюджетов и последнюю подтверждённую контрольную точку. Секреты и персональные данные в аргументах скройте.
4. Разделите операции на подтверждённо завершённые, подтверждённо не выполненные и операции с неизвестным исходом. Последние требуют сверки с целевой системой до повторной записи.
5. Верните вызывающему коду причину остановки и разрешённое следующее действие. Не превращайте исключение лимита в новый автоматический запуск с обнулёнными счётчиками.

Например, для Amazon Bedrock AgentCore существует StopRuntimeSession. Он относится к конкретной сессии среды выполнения; его идемпотентный токен защищает повтор запроса остановки, а не отменяет проведённый платёж или отправленное письмо. Выбирайте механизм своей среды, сохраняя эту границу: остановка новых действий не откатывает уже зафиксированные изменения.

Как отличить зацикливание от полезного повторения

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

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

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

Лимит итераций не равен лимиту инструментов

Задайте границу каждому виду работы. Одна итерация модели может вызвать несколько инструментов; новый запуск процесса не обязательно означает новую пользовательскую задачу.

У n8n Tools Agent параметр Max Iterations по документации ограничивает число обращений модели для ответа; значение по умолчанию — 10. Это не предел числа отдельных внешних операций и не бюджет всех повторных запусков workflow.

В LangChain для JavaScript/TypeScript ограничения вызовов модели и инструментов разделены. У toolCallLimitMiddleware поведение continue по умолчанию блокирует превышающие лимит вызовы, но модель и другие инструменты могут продолжать работу. Режим error прерывает выполнение исключением; режим end имеет ограничения при нескольких одновременно ожидающих вызовах. Лимит на запуск сбрасывается при новом пользовательском ходе, а предел для диалога требует сохранения состояния с тем же идентификатором и checkpointer. Поэтому локальный лимит нельзя считать общим бюджетом задачи.

Там же toolRetryMiddleware по умолчанию допускает две повторные попытки после первоначальной, то есть до трёх исполнений. Его onFailure: "continue" возвращает ошибку модели, которая может предложить новый вызов. Если повторяется ещё и внешний контроллер, число действий растёт на обоих уровнях. Классификация повторяемых ошибок зависит от версии; в документации отдельно описано изменение начиная с LangChain 1.5.9. Каждый внутренний повтор должен расходовать общий бюджет.

OpenAI Agents SDK продолжает цикл после вызовов инструментов и передач управления до точки завершения. Достигнутый предел и пауза для согласования — разные состояния. В Google ADK предел LoopAgent считает циклы подагентов, а не все вложенные обращения к модели и инструментам; для Python и Go документация помечает этот шаблон как прежний подход после перехода к ADK 2.0. Сверяйте точные параметры со своей версией, а общий бюджет храните выше отдельных запусков.

Ограниченный контроллер: исполнять, завершить или остановиться

Ниже — самостоятельный пример на JavaScript для одного последовательного исполнителя с синхронными подставными инструментами. Он не использует агентный SDK, модель или сеть. Счётчики принадлежат объекту состояния и сохраняются между вызовами; завершение необратимо в рамках этого объекта. beforeModel() нужно вызывать перед каждым выбором следующего действия, а call() — перед каждым исполнением инструмента.

inspect() — доверенный адаптер приложения. Он проверяет результат и состояние предметной области, затем возвращает status, монотонную version и, при необходимости, taskDone. Возвращать сюда текст модели без проверки нельзя. В демонстрации эту роль выполняют синтетические данные.

const canonical = (x) => {
  if (Array.isArray(x)) return `[${x.map(canonical).join(",")}]`;
  if (x && typeof x === "object") {
    return `{${Object.keys(x).sort().map(k =>
      `${JSON.stringify(k)}:${canonical(x[k])}`).join(",")}}`;
  }
  return JSON.stringify(x);
};

function makeGuard(now, limits = {}) {
  const cap = { models: 12, tools: 8, repeats: 2,
    stalled: 3, ms: 30000, ...limits };
  const s = { models: 0, tools: 0, version: 0, stalled: 0,
    recent: [], deadline: now() + cap.ms, terminal: null };
  const operations = new Map(); // Только память одного исполнителя.
  const stop = (reason, next = "review", value = null) => {
    s.terminal ??= { state: reason === "complete" ? "completed" : "stopped",
      reason, next, value };
    return s.terminal;
  };
  const boundary = () => s.terminal ??
    (now() >= s.deadline ? stop("deadline") : null);
  return {
    state: s, operations,
    beforeModel() {
      const halted = boundary();
      if (halted) return halted;
      if (s.models >= cap.models) return stop("model_budget");
      s.models++;
      return null;
    },
    call(call, execute, inspect) {
      const halted = boundary();
      if (halted) return halted;
      // Адаптер допускает лишь нормализованные JSON-аргументы.
      if (!call || !["read", "write"].includes(call.kind) ||
          typeof call.tool !== "string" || !call.args ||
          typeof call.args !== "object") return stop("invalid_call");
      let sig;
      try { sig = call.tool + ":" + canonical(
        JSON.parse(JSON.stringify(call.args))); }
      catch { return stop("invalid_call"); }
      const key = call.operationKey;
      if (call.kind === "write" && (typeof key !== "string" || !key))
        return stop("missing_operation_key");
      const old = key ? operations.get(key) : null;
      if (old) {
        if (old.sig !== sig) return stop("operation_conflict");
        if (old.state !== "done") return stop("unknown_commit", "reconcile");
        return stop("operation_already_recorded", "use_saved_result", old.value);
      }
      if (s.tools >= cap.tools) return stop("tool_budget");
      if (s.recent.filter(x => x === sig).length >= cap.repeats)
        return stop("repeated_call");
      const r = s.recent;
      if (r.length >= 3 && r.at(-3) === r.at(-1) &&
          r.at(-2) === sig && r.at(-1) !== sig) return stop("short_cycle");
      s.tools++;
      s.recent.push(sig);
      if (call.kind === "write") operations.set(key, { sig, state: "pending" });
      let checked;
      try { checked = inspect(execute(call), call); }
      catch {
        if (call.kind === "write") operations.set(key, { sig, state: "unknown" });
        return stop(call.kind === "write" ? "unknown_commit" : "unknown_result",
          call.kind === "write" ? "reconcile" : "review");
      }
      const valid = checked &&
        ["progress", "waiting", "operation_done", "complete",
         "retryable", "fatal", "human_required", "unknown"].includes(checked.status) &&
        Number.isSafeInteger(checked.version) && checked.version >= s.version;
      if (!valid || checked.status === "unknown") {
        if (call.kind === "write") operations.set(key, { sig, state: "unknown" });
        return stop(call.kind === "write" ? "unknown_commit" : "unknown_result",
          call.kind === "write" ? "reconcile" : "review");
      }
      if (call.kind === "write") {
        // Любой неподтверждённый исход записи требует сверки.
        if (checked.committed !== true) {
          operations.set(key, { sig, state: "unknown" });
          return stop("unknown_commit", "reconcile");
        }
        operations.set(key, { sig, state: "done", value: checked.value });
      }
      if (s.terminal) return s.terminal;
      if (checked.version > s.version) {
        s.version = checked.version; s.stalled = 0; s.recent = [];
      } else s.stalled++;
      // Сохраняем подтверждённую запись даже при истечении срока.
      if (now() >= s.deadline) return stop("deadline");
      if (checked.status === "complete") return checked.taskDone === true
        ? stop("complete", "none", checked.value) : stop("unverified_completion");
      if (checked.status === "fatal") return stop("fatal");
      if (checked.status === "human_required") return stop("human_required", "human");
      if (checked.status === "retryable") return stop("retryable", "resume_after_change");
      if (s.stalled >= cap.stalled) return stop("no_progress");
      return { state: "running", version: s.version };
    },
    cancel() { return stop("cancelled"); },
    exhaust() { return stop("plan_exhausted"); }
  };
}

// Вызывающий код обязан вернуть остановку, а не просить модель попробовать снова.
function runFake(plan, guard, execute, inspect) {
  for (const call of plan) {
    const halted = guard.beforeModel();
    if (halted) return halted;
    const result = guard.call(call, execute, inspect);
    if (result.state !== "running") return result;
  }
  return guard.exhaust();
}

let clock = 0;
const guard = makeGuard(() => clock);
const read = { kind: "read", tool: "read_page", args: { page: 1 } };
const result = runFake([read, read, read], guard,
  () => ({ status: "waiting", version: 0 }), raw => raw);
console.log(result.reason, guard.state.tools); // repeated_call 2

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

waiting разрешает лишь ограниченное ожидание: оно не сбрасывает отсутствие прогресса. Проверенный рост версии сбрасывает окно повторов, но не общий бюджет и срок задачи. Значения лимитов здесь выбраны для демонстрации; перенесите их в настройки своей задачи после определения допустимого объёма работы.

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

Запись выполнена, но задача ещё не закончена

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

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

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

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

Что проверено в офлайн-примере

Пример проверен локально в Node.js с подставными результатами, часами и последовательным журналом операций. В проверках нет модели, SDK, сети, реальных записей или отмены работающего сервиса. Поэтому результат подтверждает ветвление контроллера в заданных ситуациях, а не сходимость любой модели или надёжность распределённого исполнения. Для отдельной проверки короткого цикла порог отсутствия прогресса поднят до 10; иначе стандартный порог остановит эту последовательность ещё раньше.

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

Когда можно безопасно продолжить

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

Терминальное состояние старого исполнения оставьте неизменным. Разрешённое продолжение оформляйте отдельной попыткой, связанной с той же задачей, журналом операций и накопленными расходами. Для пауз согласования следуйте протоколу своей среды: например, руководство OpenAI Agents SDK описывает продолжение прерванного состояния. Не подменяйте такую паузу обычным повтором с новой пустой историей.

Почему после успешного инструмента агент вызывает его снова

Успех инструмента может не отвечать условию завершения из инструкции. В обсуждении n8n от августа 2025 года автор описал повторные обновления HubSpot после успешного ответа; уточнение условий использования инструмента улучшило поведение. Это отдельный пользовательский случай, а не гарантия исправления всех циклов одним промптом.

Проверьте также параметры драйвера. В OpenAI function calling режим required требует один или несколько вызовов функций. Если приложение принудительно оставляет его на каждом шаге, обычный финальный ответ без инструмента может быть недоступен в этом запросе. Переключение режима должно зависеть от проверенного состояния задачи, а не от желания модели обойти защиту.

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

Частые вопросы

Нужно ли запрещать любой повтор инструмента?

Нет. Повтор может быть следующей страницей или ограниченным опросом операции. Разрешайте его при проверяемом продвижении либо в пределах заранее ограниченного ожидания. Одни новые аргументы или прошедшее время не доказывают полезность повторения.

Достаточно ли вернуть ошибку «лимит достигнут» в ответ инструмента?

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

Можно ли просто очистить память и перезапустить агента?

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

Тайм-аут означает, что запись не выполнена?

Нет. Сервер мог выполнить действие до разрыва соединения. Тайм-аут сообщает об отсутствии подтверждения у клиента; повтор записи допустим после сверки или по надёжному протоколу идемпотентности целевой системы.