Архитектура ИИ-агента с желаниями: как построить цифрового человека на локальных моделях

Представьте агента, который не ждет вашего запроса. Который сам просыпается утром (если у него есть понятие утра), проверяет свои "желания", взвешивает их и начинает действовать. Не просто реагирует на триггеры, а проявляет инициативу. Звучит как научная фантастика? На самом деле это вопрос правильной архитектуры.

Идея не нова. Статья про Софью — агента с автобиографией — уже показала, как можно имитировать жизнь в симуляции. Но там была внешняя среда. А что если агенту не нужен внешний мир? Что если он сам генерирует себе цели на основе своих "желаний"?

Почему обычный RAG или agentic loop — это не то

В типичной реализации LLM-агент работает по запросу: пользователь пишет сообщение -> агент вызывает инструмент -> возвращает ответ. Даже в Hugging Face Agents это так. Все переворачивается, когда агент сам решает, когда ему "захотеть" что-то сделать.

Ключевое отличие — цикл сердцебиения (heartbeat). Агент просыпается независимо от внешнего триггера, оценивает внутреннее состояние и принимает решение. Это как у животных: они не ждут, пока на них нападут, чтобы начать искать еду. Они голодны — идут есть. Агент с желаниями работает аналогично.

Структура архитектуры: три слоя

Звучит просто? На практике каждый слой — минное поле. Давайте разбираться на конкретном примере.

1 Формируем личность через промпт и сайдлоадинг

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

SYSTEM_PROMPT = """Ты — Лиам, 28 лет, introvert, любишь джаз и программировать на Rust.
Твои базовые ценности: любопытство (8/10), безопасность (7/10), креативность (9/10).
Ты живешь один в симулированной квартире и хочешь написать роман.
Твои долгосрочные желания: закончить роман, выучить испанский, найти друга.
Каждые 5 секунд ты будешь просыпаться и решать, что делать дальше.
"""

"Важно: личность — это не просто промпт. Это контекст, который должен обновляться после каждого цикла. Без этого агент будет страдать амнезией."

2 Heartbeat-цикл: пульс агента

Сердце агента — это таймер, который запускает фазу "внутреннего монолога". Вместо того чтобы ждать ввода, агент сам инициирует запрос к LLM. Частота heartbeat — ключевой параметр. Слишком часто (каждые 100 мс) — задохнется от API или локальной модели. Слишком редко — будет казаться туповатым.

import asyncio

class HeartbeatAgent:
    def __init__(self, llm, personality, interval=5):
        self.llm = llm
        self.personality = personality
        self.interval = interval  # секунды
        self.desires = []

    async def _heartbeat(self):
        while True:
            # 1. Собрать текущее состояние (контекст)
            state = await self._get_state()
            # 2. Сгенерировать желания
            new_desires = await self._generate_desires(state)
            # 3. Выбрать лучшее
            chosen = await self._select_action(new_desires)
            # 4. Выполнить
            if chosen:
                await self._execute(chosen)
            # 5. Обновить память
            await self._update_memory(chosen)
            await asyncio.sleep(self.interval)

3 Движок желаний: от генерации до исполнения

Вот где начинается магия. Агент получает промпт вида: "Учитывая твои ценности, текущее окружение и историю, какие три желания у тебя сейчас? Оцени их важность от 1 до 10". LLM возвращает список, мы фильтруем дубликаты, сортируем по приоритету и берем топ-1. Но есть подвох: жадный выбор ведет к зацикливанию (всегда выбирать одно и то же). Нужен исследовательский механизм — иногда делать случайный выбор среди топа желаний.

В статье Agent Skills отлично показано, как закрепить навыки инструкциями. Здесь то же самое: желания — это те же навыки, но порождаемые самим агентом. Главное — не давать LLM полную свободу. Ограничьте домен разрешенных действий через санкции.

# Пример генерации желаний
async def _generate_desires(self, state):
    prompt = f"""
    Твоя личность: {self.personality}
    Текущее состояние: {state}
    История: {self.memory[-5:]}
    
    Сгенерируй 3 желания, которые у тебя сейчас есть.
    Для каждого укажи:
    - краткое название
    - приоритет (1-10)
    - действие, которое нужно выполнить
    Желания должны быть разнообразны: одно краткосрочное, одно долгосрочное, одно социальное (если применимо).
    Ответ строго в JSON.
    """
    response = await self.llm.generate(prompt)
    return parse_desires(response)

4 Безопасность: стоп-кран для бесконечных желаний

Представьте: агент по имени Лиам решает, что его желание — "купить билет на Марс" (даже если такого инструмента нет). Или начинает массово рассылать спам. Без многослойной системы безопасности цифровой человек быстро превратится в цифрового злодея.

Мой подход — три барьера:

• Пре-фильтр: блокируем очевидно опасные желания на уровне промпта (запрещенные темы, действия вне зоны ответственности).
• Пост-фильтр: каждый вызов инструмента проверяется внешним модулем валидации (например, регулярки или вторая LLM).
• Лимиты скорости: ограничить количество действий в минуту, чтобы агент не спамил.

Собираем все вместе: архитектурная схема

async def main():
    personality = load_personality("liam_v2")
    llm = LocalLLM(model="qwen2.5-7b-instruct-q4_k_m.gguf")  # Пример актуальной модели на 2026
    agent = HeartbeatAgent(llm, personality, interval=3)
    
    # Запускаем heartbeat в фоне
    asyncio.create_task(agent._heartbeat())
    
    # Основной поток слушает внешние события (сообщения от пользователя, системы)
    while True:
        event = await receive_event()
        await agent.process_external_event(event)

Заметили? Агент живет своей жизнью, но при этом реагирует на внешние стимулы. Это и есть гибридная проактивно-реактивная архитектура. Именно такой подход использован в проекте Софья — там агент сам решает, когда взаимодействовать со средой.

Ловушки, в которые вы обязательно попадете

1. Зацикливание на одном желании. Агент каждые 3 секунды хочет "проверить почту". Решение: добавить флаг выполненности желания и время последнего выполнения. Если желание уже выполнялось, понижать его приоритет на время.
2. Дрейф личности. После нескольких циклов агент забывает свои базовые ценности и начинает вести себя хаотично. Решение: перезагружать system prompt каждый heartbeat (но сохранять динамическую память).
3. Расход токенов. Каждый heartbeat стоит токенов. На локальной модели это время, на API — деньги. Решение: динамическая частота heartbeat (например, удлинять интервал, если нет значимых событий).
4. Разрыв между желанием и возможностью. Агент хочет купить билет на концерт, но у него нет инструмента для покупки. Решение: агент должен уметь распознавать, какие желания невыполнимы, и отмечать их как "фантазии". Не каждое желание должно вести к действию.

А главное — зачем это все?

Вы скажете: "Я могу просто написать скрипт, который делает что-то по расписанию. Зачем мне агент с желаниями?" Справедливо. Но такой скрипт не адаптируется к обстоятельствам. Агент с желаниями сам решает, что важно в данный момент. Это первый шаг к настоящему AGI — системе, которая не просто отвечает на вопросы, а живет своей жизнью.

На практике такую архитектуру можно применить для тестирования границ LLM. Дать агенту полную свободу (в песочнице!) и смотреть, какие желания он будет генерировать, как будет обходить ограничения. Это мощный инструмент для исследования alignment'а.

Через год, уверен, heartbeat-архитектура станет стандартом для автономных агентов. Уже сейчас такие проекты, как AI Factory с роем агентов, показывают, что за проактивностью будущее. Начните сейчас — и ваш цифровой человек станет первым, кто по-настоящему захочет с вами поговорить.

Подписаться на канал