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

-William Hu

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

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

Возрождение таких агентов во многом обусловлено недавними достижениями в области моделей, благодаря которым постоянно действующих агентов стало практичнее использовать. Во-первых, последние модели обладают более развитым суждением: они надёжнее понимают намерения пользователя и определяют, когда следует выйти с ним на связь. Во-вторых, интеллектуальные возможности становятся дешевле, причём наибольшую выгоду от этого получают задачи с длительным горизонтом выполнения. Например, в одном бенчмарке для программирования с длительным горизонтом выполнения стоимость решения одной задачи с помощью Opus 5.5 была на 78% ниже, чем с помощью Opus 5, тогда как для типичных рабочих нагрузок снижение составляло 40%.

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

В этой статье рассматриваются базовые компоненты постоянно действующих агентов и объясняется, как они взаимодействуют друг с другом.

Цикл работы постоянно действующего агента

На самом деле постоянно действующий агент не «работает постоянно». Это лишь описание пользовательского опыта.

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

Основные примитивы

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

Входящая очередь событий

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

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

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

Самая простая версия состоит из трёх компонентов:

  • Постоянный список событий, обычно представляющий собой таблицу базы данных;

  • Обработчик, обычно HTTP-эндпоинт, которая записывает события в список;

  • Рабочий процесс, обычно фоновая служба, которая считывает данные из списка.

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

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

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

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

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

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

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

Таймеры

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

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

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

1.     Сканирует хранилище и находит таймеры, срок выполнения которых наступил.

2.     Обновляет каждый таймер в зависимости от его категории.

  • Напоминание должно быть отмечено как выполненное.

  • Для расписания необходимо обновить время выполнения на время следующего запланированного срабатывания.

3.     Добавляет событие во входящую очередь и пробуждает рабочий процесс

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

Память

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

Как и входящая очередь событий и таймеры, память должна иметь собственное хранилище. В наших продуктах, таких как автоматическая память Claude Code и инструмент памяти Messages API, это реализовано в виде каталога файлов. Для постоянно действующего агента каталоги должны соответствовать постоянному хранилищу, обычно базе данных или объектному хранилищу. Таким образом, память сохраняется дольше, чем рабочий процесс.

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

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

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

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

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

    На диаграмме ниже показан один из возможных вариантов такой конфигурации.

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

Внутри контекстного окна

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

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

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

Права доступа

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

  • Хранилище учётных данных: постоянно действующим агентам часто необходимы конфиденциальные учётные данные пользователя, такие как пароли или токены доступа, чтобы быть полезными. Рекомендуемый подход: использовать прокси-сервер за пределами среды агента, который добавляет учётные данные к исходящим запросам. Агент отправляет запросы без учётных данных, а прокси-сервер вставляет реальные учётные данные перед их пересылкой.

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

  • Отложенные вызовы инструментов: в Claude Code хук может отложить вызов инструмента и дождаться дополнительной информации от пользователя. Тот же подход применим к постоянно действующим агентам, которым может потребоваться уточнение или одобрение перед выполнением определённых действий. Когда вызов откладывается, запуск завершается, а сессия сохраняется в промежуточном состоянии — во время вызова. Запрос отображается пользователю (например, через интерактивную карточку, созданную с помощью MCP Apps), а его ответ возвращается в виде события во входящей очереди. Это событие инициирует новый запуск, который возобновляет сохранённую сессию с учётом ввода пользователя. Пока отложенный вызов ожидает ответа, рабочий процесс может обрабатывать другие события, поэтому работа агента не блокируется.

Исходящая очередь

В случае большинства ИИ-агентов ответ передаётся пользователю в потоковом режиме по мере его генерации, поэтому пользователь может следить за тем, как Claude анализирует проблему, вызывает инструменты и формирует ответ.

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

Запуск может завершиться одним из трёх способов:

  • Агент отправляет сообщение в исходящую очередь,

  • Агент решает, что отправлять ничего не нужно, или

  • Агент использует отложенный вызов инструмента, чтобы запросить разрешение или дополнительную информацию

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

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

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

Как всё взаимодействует между собой

Вот как взаимодействуют пять основных примитивов:

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

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

Благодарности

Автор: Уильям Ху. Особая благодарность Родриго Оливаресу и Майклу Сегнеру за их вклад.

Комментарии (0)