AI Агенты: ReAct, планирование, память, цикл observe-think-act

Цели урока

• Понять архитектуру AI-агента и отличие от chain и простого API-вызова
• Реализовать ReAct-паттерн (Yao et al. 2022): цикл Thought → Action → Observation
• Спроектировать short-term и long-term memory для агентов
• Применять стратегии планирования: task decomposition, plan-and-execute, self-reflection
• Защитить агента от типичных ошибок: loops, cost explosion, галлюцинированные tools

Предварительные знания

• Tool calling: цикл request → execute → respond
• JSON Schema для описания функций

• Tool Calling

Агент - это LLM в цикле. Модель действует, смотрит на результат, решает что делать дальше. Теоретически. На практике агент застревает в петле, теряет контекст на 15-м шаге и уверенно делает не то. Это не баг - это архитектурная задача. Март 2024: Cognition показывает Devin - «первого AI-разработчика». Видео набирает 10 миллионов просмотров за 48 часов. Под капотом - не магия. Тот же GPT-4, но в ReAct-цикле с планированием и памятью. Архитектура агента - это то, что отделяет «умное автодополнение» от системы, способной довести задачу до конца.

• Cursor - агент с доступом к codebase: читает файлы, запускает тесты, исправляет ошибки компилятора через ReAct-цикл
• Devin (Cognition, 2024) - планирует, кодит, тестирует, деплоит в автономном цикле без вмешательства человека
• AutoGPT (2023) - первый вирусный open-source агент, 150K звёзд за месяц - и наглядная демонстрация failure modes без guardrails
• Claude Code (Anthropic) - агентный режим для работы с кодовыми базами: навигация, редактирование, запуск команд, loop detection

Как появились агенты

**Yao et al. 2022** - статья «ReAct: Synergizing Reasoning and Acting in Language Models». Простая идея - чередовать рассуждения и действия - дала +21% к точности на HotpotQA. Это стало основой всей агентной архитектуры. **Апрель 2023** - AutoGPT. 150K GitHub-звёзд за первый месяц. Люди ждали AGI. Получили агента, который бесконечно пишет в файл, тратит `50` за run и ничего не заканчивает. Но именно AutoGPT показал, что guardrails - не опция. **Март 2024** - Devin. Cognition показывает видео: агент получает задачу, открывает IDE, пишет код, запускает тесты, читает ошибки, исправляет - и деплоит. Без единого клика человека. Под капотом - ReAct + Plan-and-Execute + memory. Ничего магического. Только инженерия.

Что такое AI-агент: отличие от простого API-вызова

Агент - это LLM в цикле. Модель действует, смотрит на результат, решает что делать дальше. Теоретически. На практике агент застревает в петле, теряет контекст на 15-м шаге и уверенно делает не то. Это не баг - это архитектурная задача.

Обычный LLM-вызов - это **один вопрос → один ответ**. Даже с tool calling: пользователь спросил погоду - модель вызвала функцию - вернула результат. Но задача "найди самый дешёвый рейс в Барселону, проверь что отель рядом с пляжем, и забронируй всё" - это **цепочка решений**, где каждый шаг зависит от предыдущего. Никакой stateless API с этим не справится.

**AI-агент** - программа, где LLM работает в **цикле**: получает задачу, рассуждает, выбирает действие, наблюдает результат, рассуждает снова. И так до цели. Ключевое отличие от chain: агент сам решает следующий шаг, а не следует заранее прошитому маршруту. Это и есть автономность - и именно поэтому Cursor, Devin и Claude Code работают иначе, чем автодополнение.

Agent loop - это цикл с лимитом итераций, где LLM на каждой итерации решает: (a) вызвать tool и продолжить, или (b) вернуть финальный ответ. Именно это "право выбора" делает систему агентом, а не chain. MAX_ITERATIONS - не деталь реализации. Это первый рубеж защиты от бесконечной петли.

ReAct: Reasoning + Acting в одном цикле

**ReAct** (Reasoning + Acting) - паттерн из статьи Yao et al. 2022, ставший стандартом для AI-агентов. Идея проста до гениальности: модель чередует **рассуждения** (Thought) и **действия** (Action), а после каждого действия получает **наблюдение** (Observation). Цикл: Think → Act → Observe → Think → Act → Observe → ... → Final Answer. На HotpotQA это подняло точность с 52% до 73% по сравнению с act-only подходом.

Без ReAct модель попыталась бы ответить сразу из своих знаний - и нагаллюцинировала бы. ReAct заставляет модель **явно рассуждать** перед каждым действием и **корректировать план** на основе наблюдений. Это принцип, на котором работает Cursor: он не просто вставляет код - он думает, проверяет файлы, исправляет ошибки компилятора, думает снова.

ReAct работает лучше, когда system prompt явно требует рассуждений. Без инструкции "рассуждай перед действием" модель часто пропускает этап Thought и вызывает tools наугад - что приводит к лишним вызовам и ошибкам.

Память агента: short-term и long-term

Агент без памяти - это 128K токенов, которые тают с каждым шагом. GPT-4o: 128K токенов контекста. При активной работе с tools 50-60 итераций заполняют его полностью. На шаге 61 агент буквально «не помнит» начало задачи - и начинает ходить по кругу, уверенно и дорого.

**Short-term memory** (массив messages в контексте) хранит текущую задачу и промежуточные результаты. **Long-term memory** (внешнее хранилище - vector DB или БД) сохраняет знания между сессиями. MemGPT (2023) решает именно эту проблему: OS-подобная виртуальная память, где агент сам управляет тем, что держать в контексте, а что выгрузить.

Context window - главный враг агентов. GPT-4o имеет 128K токенов, но при активной работе с tools 50-60 шагов заполняют контекст полностью. Без стратегии сжатия (summarization, sliding window) агент «забывает» начало задачи и начинает ходить по кругу.

Стратегии планирования: decomposition и tree-of-thought

Простой ReAct-агент действует **реактивно**: шаг за шагом, без общего плана. Он похож на разработчика, который открывает задачу и сразу начинает писать код - без понимания архитектуры. Для сложных задач ("спланируй миграцию базы данных" или "подготовь отчёт по 5 конкурентам") нужна **стратегия планирования**: сначала план, потом выполнение с корректировкой.

• **Task Decomposition** - разбиение задачи на подзадачи. "Подготовь отчёт" → ["Собрать данные A", "Собрать данные B", "Сравнить", "Оформить"]
• **Plan-and-Execute** - сначала полный план, потом пошаговое выполнение с возможностью корректировки
• **Tree-of-Thought (ToT)** - для каждого шага генерируется несколько вариантов, оценивается каждый, выбирается лучший
• **Reflection/Self-Critique** - после каждого шага агент оценивает прогресс: "Приближает ли этот результат к цели?"

Plan-and-Execute эффективен для задач с чёткой структурой: исследование, сравнение, генерация отчётов. Для творческих и неопределённых задач чистый ReAct работает лучше - жёсткий план мешает адаптации.

Ошибки агентов: loops, галлюцинации, cost explosion

AutoGPT появился в апреле 2023 и за месяц набрал 150K звёзд на GitHub. Все хотели автономного агента. Все запускали его. Почти никто не мог довести задачу до конца: агент застревал в петлях, галлюцинировал функции, тратил `50` за один run и падал с timeout. Это был первый массовый урок: **агент без guardrails - это не фича, это liability.**

Реальная статистика раннего тестирования автономных агентов: 30% сессий заканчиваются бесконечным циклом, 15% - вызовом несуществующих tools, 8% - cost explosion (один запрос обходится в `50+`). Это не экзотика - это дефолтное поведение без защиты.

Золотое правило: **агент без лимитов - это liability, а не feature**. Всегда устанавливайте maxIterations, token budget и timeout. В production добавьте алерты: если агент использует более 50% бюджета - логируйте; если 100% - graceful termination.

Агент = умный ChatGPT, который сам всё сделает - достаточно дать задачу

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

ChatGPT даёт один ответ. Агент принимает десятки решений в цикле - и каждое решение может быть неверным. Без maxIterations агент будет крутиться бесконечно. Без token budget один run может стоить `50+`. Без loop detection агент будет вызывать один tool сотни раз. Автономность - это инженерная ответственность, не магия.

Ключевые выводы

• AI-агент = LLM в цикле, который сам решает следующий шаг - в отличие от chain с фиксированным маршрутом
• ReAct (Yao et al. 2022): Think → Act → Observe - рассуждение перед действием поднимает accuracy с 52% до 73%
• Short-term memory (messages, 128K токенов) и long-term memory (vector DB) - оба нужны; без сжатия контекст заполняется на 50-60 шагах
• Plan-and-Execute для структурированных задач: план из подзадач, каждая выполняется ReAct-подагентом
• Production-агент обязан иметь: maxIterations, token budget, timeout, loop detection, graceful termination - агент без лимитов это liability

Вопросы для размышления

• AutoGPT в 2023 провалился несмотря на хайп - какие конкретно failure modes не были предусмотрены? Как их решают современные агентные фреймворки?
• Cursor работает как агент, но пользователь его не замечает - как достигается это ощущение? Что прячется за UX?
• Когда агент с Plan-and-Execute хуже простого ReAct? Приведи сценарий где жёсткий план вредит.

Что дальше

Архитектура агента понятна. Но писать agent loop с нуля для каждого проекта - утомительно. Существуют фреймворки, абстрагирующие типовые задачи: управление состоянием, оркестрацию tools, memory.

• Agent Frameworks — LangGraph, CrewAI, Vercel AI SDK - готовые фреймворки для построения агентов
• Multi-Agent Systems — Когда одного агента недостаточно - несколько специализированных агентов работают вместе
• RAG и Knowledge Base — Long-term memory через retrieval - как агент получает доступ к базе знаний

Связанные уроки

• aie-16-tool-calling — Агенты действуют в мире через вызовы инструментов
• aie-18-agent-frameworks — Паттерны отсюда закреплены в фреймворках агентов
• aie-12-rag-fundamentals — Долгосрочная память использует retrieval по базе знаний
• aie-19-multi-agent — Цикл одного агента масштабируется в мультиагентные системы
• ml-48-rl-intro — Цикл observe-act повторяет петлю агент-среда в RL
• alg-13-dfs
• alg-14-dijkstra