До сих пор мы смотрели на простые задачи: ответь на вопрос, вызови один инструмент, верни результат. Но настоящая сила агентов — в сложных задачах из нескольких шагов. Агент сам разбивает задачу на части, выполняет каждую, адаптируется к результатам и собирает итог. Эти принципы одинаковы для любого AI-агента — Claude, GPT, Gemini или локальных моделей.
Простая задача:
"Какая погода в Москве?"
→ Один вызов инструмента → Один ответ
Мульти-шаговая задача:
"Проанализируй этот проект и напиши документацию"
→ Найти все файлы
→ Прочитать каждый
→ Понять структуру
→ Написать описание каждого модуля
→ Собрать всё в один документ
→ Сохранить файл
В простой задаче — один шаг. В мульти-шаговой — агент сам решает, какие шаги нужны, в каком порядке их делать, и когда остановиться.
Аналогия. Простая задача — попросить курьера доставить посылку по адресу. Мульти-шаговая — попросить ассистента организовать переезд: он сам решает, что паковать первым, какую машину заказать, и в каком порядке всё делать.
Прежде чем разбирать мульти-шаговые задачи, соберём всё, что знаем об агентах, в одну картину. По данным Anthropic и OpenAI, любой AI-агент строится из четырёх компонентов:
┌──────────────────────────────────────────────┐
│ AI-АГЕНТ │
│ │
│ 1. Модель (мозг) │
│ LLM, которая думает, планирует, решает │
│ │
│ 2. Инструменты (руки) │
│ Функции: файлы, интернет, API, терминал │
│ │
│ 3. Инструкции (правила) │
│ Системный промпт: как себя вести │
│ │
│ 4. Оркестрация (цикл) │
│ Как шаги соединяются: цикл, проверки, │
│ передача между агентами │
│ │
└──────────────────────────────────────────────┘
Источник: OpenAI — Agents, Anthropic — Building Effective Agents
Эти 4 компонента одинаковы в любом фреймворке: OpenAI Agents SDK, Claude Agent SDK, LangChain, CrewAI. Меняется синтаксис, но архитектура та же.
Агент работает в цикле: получает задачу → думает → действует → смотрит результат → думает снова → действует снова → ... → возвращает ответ.
Anthropic описывает это так: на каждом шаге агент получает обратную связь от окружения (результаты инструментов), оценивает прогресс и решает, что делать дальше.
┌──────────────┐
│ Задача │
└──────┬───────┘
│
┌──────▼───────┐
┌────►│ LLM думает │
│ │ "Что дальше?"│
│ └──────┬───────┘
│ │
│ ┌──────▼───────┐
│ │ Вызывает │
│ │ инструмент │
│ └──────┬───────┘
│ │
│ ┌──────▼───────┐
│ │ Получает │
│ │ результат │
│ └──────┬───────┘
│ │
│ ┌──────▼───────┐
│ да │ Задача │ нет
└─────┤ выполнена? ├──────► Финальный ответ
└──────────────┘
Этот цикл может крутиться 3 раза (простая задача) или 30 раз (сложная). Агент сам определяет, когда остановиться.
Шаг 1: Поиск файлов → "*.py"
Результат: [main.py, utils.py, api.py, tests/test_main.py]
Шаг 2: Поиск текста "TODO" в найденных файлах
Результат:
main.py:15 # TODO: добавить обработку ошибок
utils.py:42 # TODO: оптимизировать эту функцию
api.py:8 # TODO: добавить аутентификацию
Шаг 3: Анализ результатов
"Найдено 3 TODO. Самое важное — аутентификация в api.py"
Шаг 4: Формирование ответа
Оформленный список задач с приоритетами
Агент не знал заранее, какие файлы найдёт и сколько TODO будет. Он адаптировался на каждом шаге.
Самое важное отличие агента от обычной программы — он меняет план на ходу.
Обычная программа (скрипт):
Не нашёл файл → ошибка → стоп
Агент:
Не нашёл .py файлы → "Попробую .js" →
Нашёл → продолжает работу
Anthropic в своём гайде подчёркивает: агент получает обратную связь от окружения (результаты инструментов, результаты выполнения кода) на каждом шаге. Эта обратная связь — основа адаптации.
Примеры адаптации:
Ситуация 1: проект с 3 файлами
→ Читает каждый → 4 шага
Ситуация 2: проект с 200 файлами
→ "Слишком много. Сгруппирую по папкам и прочитаю
по одному из каждой" → ~10 шагов
Ситуация 3: тесты упали после исправления
→ Читает ошибку → исправляет снова → запускает тесты →
тесты прошли → продолжает
Последний пример особенно важен: агент не сдаётся при ошибке. Он читает, что пошло не так, и пробует снова. Обычный скрипт просто упадёт.
Anthropic в своём исследовании "Building Effective Agents" выделяет 5 паттернов, как можно организовать работу агента. От простого к сложному:
Задача разбивается на фиксированную последовательность шагов:
Шаг 1 → Шаг 2 → Шаг 3 → Результат
Пример:
Написать статью → Перевести на английский → Проверить грамматику
Каждый шаг использует результат предыдущего. Между шагами можно вставить проверку: "Результат нормальный? Если нет — переделать."
Когда использовать: задача чётко делится на последовательные части.
Входящая задача классифицируется и отправляется на нужный путь:
┌─ Простой вопрос → быстрая модель (дешёвая)
Запрос → Классификатор ─┤
├─ Сложный вопрос → мощная модель (дорогая)
└─ Жалоба → специальный обработчик
Пример из жизни: служба поддержки. Вопрос "какой у вас график работы" не нужно отправлять эксперту — с ним справится простой бот. А жалоба "сломался товар" требует человека или мощного агента.
Когда использовать: разные типы задач требуют разного подхода.
Несколько шагов выполняются одновременно:
┌─ Агент 1: проверяет безопасность кода
Задача ──────►├─ Агент 2: проверяет качество кода ──► Объединение
└─ Агент 3: проверяет документацию
Два варианта: - Разделение: разные подзадачи параллельно (как выше) - Голосование: одна задача выполняется несколько раз, результаты сравниваются (для надёжности)
Когда использовать: подзадачи независимы друг от друга.
Главный агент разбивает задачу и раздаёт подзадачи рабочим агентам:
┌─ Работник 1: изменить файл A
Оркестратор ──├─ Работник 2: изменить файл B ──► Оркестратор собирает
└─ Работник 3: написать тесты
В отличие от параллелизации, здесь оркестратор сам решает, какие подзадачи создать — на основе конкретной задачи.
Пример: кодинг-агент получает задачу "добавь авторизацию". Оркестратор анализирует код и решает: нужно изменить 3 файла и добавить тесты. Три работника выполняют каждый свою часть.
Когда использовать: сложные задачи, где заранее неизвестно, какие подзадачи понадобятся.
Один агент делает, другой проверяет. И так по кругу:
Генератор → Оценщик → "Не очень, вот замечания" →
Генератор (улучшает) → Оценщик → "Теперь хорошо" → Результат
Пример: агент пишет код, второй агент запускает тесты. Если тесты не прошли — первый агент исправляет. Повторяется, пока все тесты не пройдут.
Когда использовать: есть чёткие критерии качества, и результат можно проверить автоматически.
OpenAI и Anthropic сходятся в одном: агенту нужно давать цель, а не пошаговую инструкцию.
"Сделай что-нибудь полезное с этим проектом"
Агент не знает, что конкретно нужно → результат непредсказуем.
"Выполни grep -r 'import' *.py, потом для каждого файла
выполни wc -l, потом отсортируй по количеству строк"
Если расписывать каждый шаг — зачем агент? Это можно сделать скриптом.
"Проанализируй Python-проект.
Мне нужно понять:
- Какая общая структура
- Какие основные модули
- Есть ли очевидные проблемы"
Правило: описывай ЧТО нужно получить, а не КАК это делать. Агент сам знает, какие инструменты использовать и в каком порядке.
Anthropic пишет: "Агенты — это системы, где LLM сам управляет процессом и использованием инструментов, сохраняя контроль над тем, как выполнить задачу." Если ты контролируешь каждый шаг — это не агент, а скрипт.
Anthropic опубликовала отдельное исследование "Writing Tools for Agents" о том, как правильно создавать инструменты. Главные выводы:
Обычные API делают для программистов: они знают точный формат, читают документацию. Агент — не программист. Он выбирает инструмент по описанию. Поэтому:
Плохой инструмент: Хороший инструмент:
──────────────── ──────────────────
list_contacts search_contacts
(вернёт ВСЕ контакты — (вернёт только нужные —
агент утонет в данных) агент работает эффективно)
get_customer_by_id get_customer_context
(нужно знать ID заранее) (найдёт по имени или email)
Anthropic обнаружила, что даже маленькие изменения в описании инструмента кардинально меняют результат. Описание нужно писать так, будто объясняешь новому сотруднику — делая неявный контекст явным.
Плохая ошибка: Хорошая ошибка:
────────────── ────────────────
"Error 422" "Неверный формат даты.
Ожидается: YYYY-MM-DD.
Пример: 2026-03-15"
Когда инструмент возвращает понятную ошибку — агент исправляется и пробует снова. Непонятная ошибка ведёт в тупик.
Каждый шаг — запрос к API, а каждый запрос стоит денег (урок 2.5). Мульти-шаговая задача из 20 шагов стоит в 20 раз дороже простого вопроса.
Поэтому важно ставить ограничения:
Ограничение по шагам: "Максимум 10 шагов"
Ограничение по бюджету: "Максимум 50 центов"
Anthropic рекомендует: "Обычно в агентов включают условия остановки (например, максимальное количество итераций) для сохранения контроля."
В Claude Agent SDK:
options = ClaudeAgentOptions(
allowed_tools=["Read", "Glob", "Grep"],
max_turns=10, # максимум 10 шагов
max_budget_usd=0.50 # максимум 50 центов
)
Другие фреймворки (OpenAI Agents SDK, LangChain) имеют аналогичные настройки.
Anthropic подчёркивает: "Начинайте с простых промптов, оптимизируйте их, и добавляйте мульти-шаговые агентные системы только когда простые решения не справляются."
Задача: Классифицировать текст (позитивный/негативный)
→ Один вызов API. Агент не нужен.
Задача: Перевести 10 предложений
→ Один вызов API. Агент не нужен.
Задача: Проанализировать проект из 50 файлов и написать отчёт
→ Мульти-шаговая задача. Нужен агент.
Задача: Исправить баг, запустить тесты, пофиксить если упали
→ Нужна адаптация. Нужен агент.
Правило: если задача решается одним вызовом — не усложняй. Агент нужен, когда задача требует нескольких шагов и адаптации.
Агент для программирования в терминале. Anthropic описывает типичный цикл:
Задача: "Исправь баг в функции calculate_total"
1. Ищет функцию в проекте → находит файл
2. Читает файл → видит код
3. Анализирует → находит ошибку
4. Исправляет файл
5. Запускает тесты → тесты упали
6. Читает ошибку → понимает, что нужно ещё
7. Исправляет снова
8. Запускает тесты → тесты прошли ✓
Ключевое: шаги 5–8 — автоматическое восстановление после ошибки. Агент не сдался, а прочитал ошибку и попробовал снова.
Облачный кодинг-агент. Получает задачу и работает автономно в изолированном окружении: читает код, пишет код, запускает тесты, создаёт pull request. Всё — без участия человека между шагами.
Агент для исследований. Google описывает его как систему для "сложных, мульти-шаговых задач по поиску информации". Агент сам ищет в интернете, читает источники, сопоставляет данные и пишет отчёт с ссылками.
Anthropic опубликовала исследование "Effective Harnesses for Long-Running Agents" о том, как агенты работают часами над сложными проектами:
progress.txt)Это уже не просто мульти-шаговая задача — это мульти-сессионный агент, который работает как программист: пишет, тестирует, коммитит, ведёт заметки.
За этап 3 ты узнала все ключевые компоненты AI-агента:
| Урок | Тема | Главный вывод |
|---|---|---|
| 3.1 | Чат-бот vs Агент | Агент = LLM + цикл + инструменты |
| 3.2 | Tools | Инструменты — функции, которые агент вызывает сам |
| 3.3 | Память | Без памяти агент забывает всё после каждого разговора |
| 3.4 | Agent SDK | SDK — готовая библиотека, чтобы не собирать всё вручную |
| 3.5 | Мульти-шаги | Настоящая сила — сложные задачи, где агент планирует и адаптируется |
Эти принципы одинаковы для любого AI-агента: Claude Code, ChatGPT, Copilot, Gemini, OpenClaw. Разные модели, разные SDK, но архитектура одна.
Без кода — просто подумай. Как бы агент выполнил эту задачу?
"Найди в проекте все файлы, которые не менялись больше года,
и создай список: что удалить, что обновить"
Какой из 5 паттернов (цепочка, маршрутизация, параллелизация, оркестратор, оценщик) подходит для каждой задачи?
A) Написать статью, потом перевести на английский
B) Проверить код на безопасность, качество и стиль одновременно
C) Рассортировать письма: спам, работа, личные
D) Написать код, запустить тесты, исправить ошибки, повторить
Какая формулировка лучше и почему?
Вариант А:
"Выполни grep -r 'import' *.py, потом для каждого файла
выполни wc -l, потом отсортируй"
Вариант Б:
"Проанализируй Python-проект: какие файлы самые сложные
и какие внешние библиотеки используются?"
Задача 1: Чем мульти-шаговая задача отличается от простой?
Задача 2: Чем агент отличается от скрипта?
Задача 3: Назови 5 паттернов организации агентов (по Anthropic).
Задача 4: Когда агент НЕ нужен?
| Термин | Что значит |
|---|---|
| Мульти-шаговая задача | Задача из нескольких шагов, где каждый зависит от предыдущего |
| Цепочка действий | Последовательность: инструмент → результат → следующий инструмент |
| Адаптация | Способность агента менять план на основе результатов |
| Оркестрация | Управление тем, как шаги агента соединяются между собой |
| Prompt Chaining | Цепочка промптов — задача разбита на фиксированные последовательные шаги |
| Routing | Маршрутизация — классификация входа и отправка на нужный обработчик |
| Parallelization | Параллелизация — независимые подзадачи выполняются одновременно |
| Orchestrator-Workers | Главный агент раздаёт подзадачи рабочим агентам |
| Evaluator-Optimizer | Один агент делает, другой проверяет, цикл до нужного качества |
| max_turns | Ограничение количества шагов агента |
| Guardrails | Ограничители — правила, которые не дают агенту выйти за рамки |
Этот урок основан на публикациях и документации:
Мульти-шаговые задачи — главная сила агентов.
Агент сам:
✓ Разбивает задачу на шаги
✓ Выбирает инструменты
✓ Адаптируется к результатам
✓ Пробует снова при ошибке
5 паттернов (Anthropic):
1. Цепочка промптов — шаг за шагом
2. Маршрутизация — разные задачи → разные пути
3. Параллелизация — одновременно
4. Оркестратор-работники — главный раздаёт задачи
5. Оценщик-оптимизатор — делает + проверяет в цикле
Как давать задачи:
✗ "Сделай grep, потом wc" — микроменеджмент
✗ "Сделай что-нибудь" — слишком размыто
✓ "Проанализируй проект и найди проблемы" — цель + контекст
Когда НЕ нужен агент:
Задача решается одним вызовом → не усложняй
Этап 3 завершён! Вот что ты теперь знаешь об AI-агентах:
| Урок | Тема | Главный вывод |
|---|---|---|
| 3.1 | Чат-бот vs Агент | Агент = LLM + цикл + инструменты |
| 3.2 | Tools | Инструменты — функции, которые агент вызывает сам |
| 3.3 | Память | Без памяти агент забывает всё после разговора |
| 3.4 | Agent SDK | SDK — готовая библиотека, не нужно собирать с нуля |
| 3.5 | Мульти-шаги | Настоящая сила — планирование и адаптация |
Ты понимаешь, как устроены AI-агенты изнутри. В следующем этапе — Продукты и интеграции: как превратить агента в продукт для реальных людей (Telegram-бот, сервер, база данных, деплой).
Этап 3 завершён! Ты знаешь, как устроены AI-агенты: от простого чат-бота до мульти-шаговых задач. В Этапе 4 — превратим агента в продукт: Telegram-бот, база данных, деплой на сервер, безопасность.