# AI агенты: полный гайд — что это, как создать, где использовать

> Исчерпывающее руководство по AI агентам: архитектура, фреймворки (LangGraph, CrewAI, OpenAI Agents SDK, Google ADK, Pydantic AI, MCP), практические use cases и пошаговый туториал.
> Author: Roman Belov · Published: 2026-06-25 · Source: https://futurecraft.pro/ru/blog/ai-agents-complete-guide/

AI агент — программа, в которой LLM управляет циклом выполнения. Получает задачу, декомпозирует на шаги, вызывает инструменты, анализирует результаты, решает что делать дальше. Генерирует текст — и сразу действует.

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

## Что такое AI агенты

### Агент vs чат-бот

Чат-бот — это LLM с интерфейсом. Пользователь задаёт вопрос, модель генерирует ответ. Один вход, один выход. Никаких действий за пределами текста.

Агент — это LLM с инструментами и циклом принятия решений. Разница фундаментальная:

| Характеристика | Чат-бот | AI агент |
|---|---|---|
| Модель взаимодействия | Вопрос → ответ | Задача → цепочка действий → результат |
| Инструменты | Нет (или минимально) | API, файловая система, БД, браузер |
| Автономность | Ноль — ждёт ввода | Работает самостоятельно до результата |
| Цикл | Однократный | Итеративный: думаю → действую → наблюдаю |
| Память | Только текущий диалог | Short-term + long-term между сессиями |

Пример: попросите ChatGPT «найти баг в коде» — получите текстовый разбор. Попросите [Claude Code](/ru/blog/claude-code-complete-guide/) — он прочитает файлы проекта, найдёт проблему, исправит код, запустит тесты, сделает коммит. Это агент.

### Три компонента агента

Каждый AI агент строится на трёх основах:

**1. Reasoning (мышление)** — способность LLM декомпозировать задачу на шаги, планировать последовательность действий, оценивать промежуточные результаты. «Мозг» агента. Слабая модель застревает уже на декомпозиции. Сильная разложит задачу на атомарные шаги и выберет оптимальный путь.

**2. Tool use (инструменты)** — функции, которые агент вызывает для взаимодействия с внешним миром. Чтение файлов, HTTP-запросы, работа с базой данных, выполнение shell-команд. Без инструментов LLM остаётся генератором текста.

**3. Memory (память)** — хранение контекста. Short-term memory — текущий разговор и промежуточные результаты. Long-term memory — знания между сессиями: что агент узнал раньше, какие решения принял, какие ошибки допустил.

### Примеры агентов в продакшене

**Claude Code** — агент для разработки. Работает в терминале, видит весь проект: файлы, зависимости, конфигурации. Получает задачу типа «добавь авторизацию через OAuth» и автономно находит нужные файлы, пишет код, запускает тесты, фиксит ошибки, делает коммит.

**Devin (Cognition)** — автономный software engineer. Работает в изолированной среде с IDE, терминалом и браузером. Может часами решать задачу без участия человека: исследовать codebase, писать код, деплоить.

**Cursor Agent Mode** — агентный режим в IDE. Анализирует кодовую базу, планирует изменения, редактирует несколько файлов параллельно, запускает команды.

**OpenAI Operator** — агент с computer use. Управляет браузером: заполняет формы, навигирует по сайтам, выполняет задачи в веб-интерфейсах.

## Типы AI агентов

### ReAct (Reasoning + Acting)

Базовый паттерн. Агент чередует три фазы в цикле:

1. **Thought** — размышление о текущем состоянии и следующем шаге
2. **Action** — вызов инструмента
3. **Observation** — анализ результата

```
Thought: Нужно найти файл с конфигурацией базы данных
Action: search_files("database config")
Observation: Найден файл config/database.yml

Thought: Прочитаю конфигурацию, чтобы понять текущие настройки
Action: read_file("config/database.yml")
Observation: PostgreSQL, host: localhost, port: 5432

Thought: Нужно изменить хост на production-адрес
Action: edit_file("config/database.yml", ...)
Observation: Файл успешно обновлён
```

ReAct работает как внутренний монолог разработчика: обдумал — сделал — проверил — обдумал следующий шаг.

### Tool-use agents

Специализируются на вызове внешних API и функций. LLM определяет, какой инструмент вызвать и с какими параметрами. Фокус — на правильном маршрутизировании запросов, а не на длинных цепочках рассуждений.

Типичный сценарий: агент получает «забронируй рейс Москва — Бали на 15 апреля» и раскладывает это в цепочку вызовов: поиск рейсов API → фильтрация → оплата API → отправка подтверждения.

### Multi-agent systems

Несколько агентов с разными ролями, работающих над общей задачей в рамках единой [мультиагентной архитектуры](/ru/blog/multi-agent-architecture/). Каждый агент — специалист в своей области:

- **Architect agent** — проектирует решение
- **Coder agent** — пишет код
- **Reviewer agent** — проверяет код
- **Tester agent** — запускает и анализирует тесты

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

### Autonomous agents

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

Примеры: мониторинг инфраструктуры (обнаружил аномалию → диагностировал → исправил → отчитался), непрерывный сбор данных с адаптацией стратегии поиска.

Самый сложный класс агентов. Без надёжных guardrails поведение выходит из-под контроля.

### Coding agents

Специализированный класс агентов для разработки ПО. Понимают код на уровне AST, работают с файловой системой, git, пакетными менеджерами, CI/CD.

| Агент | Тип | Особенности |
|---|---|---|
| Claude Code | CLI-агент | Полный доступ к файлам, shell, MCP. Агентный цикл с верификацией |
| Cursor | IDE-агент | Встроен в VS Code fork. Agent mode + tab-completion |
| Devin | Автономный | Изолированная среда. Часы работы без участия человека |
| Codex (OpenAI) | Cloud-агент | Sandboxed execution. Оптимизирован для PR и задач из трекера |
| Windsurf | IDE-агент | Cascade flows. Контекстно-зависимые действия |

## Архитектура агента

### Общая схема

```
┌─────────────────────────────────────────────────┐
│                   USER INPUT                     │
│            "Проанализируй логи за неделю"        │
└──────────────────────┬──────────────────────────┘
                       ▼
┌─────────────────────────────────────────────────┐
│               SYSTEM PROMPT                      │
│  Роль, ограничения, формат ответа, инструкции   │
└──────────────────────┬──────────────────────────┘
                       ▼
┌─────────────────────────────────────────────────┐
│                 LLM ("мозг")                     │
│  Claude Opus 4.8 / Sonnet 4.6 / GPT-5.5 / Gemini 3.1 Pro  │
│                                                  │
│  ┌───────────┐  ┌──────────┐  ┌──────────────┐ │
│  │ Reasoning │  │ Planning │  │ Tool Select  │ │
│  └───────────┘  └──────────┘  └──────────────┘ │
└──────────────────────┬──────────────────────────┘
                       ▼
          ┌────────────────────────┐
          │    OBSERVATION LOOP    │
          │                        │
          │  Think → Act → Observe │
          │       ↺ repeat         │
          └───────────┬────────────┘
                      ▼
┌─────────────────────────────────────────────────┐
│                   TOOLS                          │
│                                                  │
│  ┌──────────┐ ┌──────────┐ ┌──────────────────┐│
│  │File I/O  │ │ HTTP/API │ │  Database query  ││
│  └──────────┘ └──────────┘ └──────────────────┘│
│  ┌──────────┐ ┌──────────┐ ┌──────────────────┐│
│  │  Shell   │ │ Browser  │ │  MCP servers     ││
│  └──────────┘ └──────────┘ └──────────────────┘│
└─────────────────────────────────────────────────┘
                      ▼
┌─────────────────────────────────────────────────┐
│                  MEMORY                          │
│                                                  │
│  Short-term: контекстное окно (текущая сессия)  │
│  Long-term: файлы, БД, vector store             │
└─────────────────────────────────────────────────┘
```

### LLM как «мозг»

Выбор модели задаёт потолок агента. Сложные задачи — архитектурные решения, многошаговый дебаг, рефакторинг — требуют сильных моделей: Claude Opus 4.8, GPT-5.5, Gemini 3.1 Pro. Простые задачи — поиск, форматирование, рутина — решают модели класса Claude Sonnet 4.6 или GPT-5.5 Instant.

Практический подход — иерархия моделей:

- **Orchestrator** (Opus 4.8 / GPT-5.5) — планирование, декомпозиция, финальная сборка
- **Worker** (Sonnet 4.6 / GPT-5.5 Instant) — выполнение подзадач, поиск, трансформации данных

Стоимость падает в 3-5 раз без потери качества на верхнем уровне.

### System prompt

Определяет поведение агента: роль, ограничения, формат вывода, доступные инструменты. System prompt — «должностная инструкция» агента.

```python
SYSTEM_PROMPT = """
Ты — DevOps-агент. Твоя задача — мониторинг и обслуживание
инфраструктуры.

Правила:
- Никогда не удаляй production-данные без подтверждения
- Логируй каждое действие
- При ошибке — три попытки, потом эскалация

Доступные инструменты:
- check_service_status(service_name)
- restart_service(service_name)
- read_logs(service_name, lines=100)
- send_alert(channel, message)
"""
```

Расплывчатые инструкции дают непредсказуемое поведение. Конкретные ограничения — контролируемый результат.

### Tools — инструменты агента

Инструменты — функции, которые агент вызывает. Каждый описывается JSON-схемой: название, описание, параметры, тип возвращаемого значения.

```python
tools = [
    {
        "name": "search_database",
        "description": "Поиск записей в PostgreSQL по SQL-запросу",
        "parameters": {
            "type": "object",
            "properties": {
                "query": {
                    "type": "string",
                    "description": "SQL SELECT запрос"
                }
            },
            "required": ["query"]
        }
    },
    {
        "name": "send_email",
        "description": "Отправка email через SMTP",
        "parameters": {
            "type": "object",
            "properties": {
                "to": {"type": "string"},
                "subject": {"type": "string"},
                "body": {"type": "string"}
            },
            "required": ["to", "subject", "body"]
        }
    }
]
```

LLM читает описания инструментов и решает, какой вызвать. Точные описания здесь критичны: расплывчатое описание — и модель вызовет не тот инструмент или передаст некорректные параметры.

### Memory — кратковременная и долговременная

**Short-term memory** — контекстное окно текущей сессии. Промежуточные результаты, вызовы инструментов, рассуждения агента. Ограничение — размер контекста модели (100K–1M токенов). При достижении лимита — суммаризация или отсечение ранних сообщений.

**Long-term memory** — данные между сессиями. Реализации:

- Файловая система (CLAUDE.md, memory-файлы)
- Vector store (embeddings в Pinecone, Qdrant, pgvector)
- Structured storage (SQLite, PostgreSQL)

Пример: Claude Code сохраняет memory-файлы в `~/.claude/projects/`. При следующей сессии агент «помнит» решения, ошибки и контекст проекта.

### Observation loop

Ядро агента — цикл «думаю → действую → наблюдаю → повторяю»:

```python
while not task_completed:
    # 1. Think — LLM анализирует текущее состояние
    thought = llm.think(context, task, observations)

    # 2. Act — LLM выбирает и вызывает инструмент
    action = llm.select_tool(thought, available_tools)
    result = execute_tool(action)

    # 3. Observe — LLM анализирует результат
    observations.append(result)

    # 4. Decide — продолжить или завершить
    task_completed = llm.evaluate(observations, task)
```

Цикл идёт, пока агент не решит, что задача выполнена, или не достигнет лимита итераций. Лимит критически важен — без него агент зациклится.

## Фреймворки для создания агентов

### Claude Agent SDK (Anthropic)

Официальный SDK от Anthropic. Тот же агентный цикл, инструменты и управление контекстом, что лежат в основе Claude Code.

**Установка:**

```bash
# Python
pip install claude-agent-sdk

# TypeScript
npm install @anthropic-ai/claude-agent-sdk
```

**Ключевые возможности:**

- Встроенные инструменты: Read, Write, Edit, Bash, Glob, Grep, WebSearch
- [MCP-серверы как кастомные инструменты](/ru/blog/mcp-production-custom-servers/)
- Streaming вывода через async итератор
- Управление разрешениями (`permission_mode`)
- Кастомные system prompt и hooks

**Пример:**

```python
import asyncio
from claude_agent_sdk import query, ClaudeAgentOptions, AssistantMessage, TextBlock

async def main():
    async for message in query(
        prompt="Найди все TODO в проекте и создай issues в GitHub",
        options=ClaudeAgentOptions(
            system_prompt="Ты — project manager agent",
            allowed_tools=["Read", "Glob", "Grep", "Bash"],
            model="claude-sonnet-4-6"
        ),
    ):
        if isinstance(message, AssistantMessage):
            for block in message.content:
                if isinstance(block, TextBlock):
                    print(block.text)

asyncio.run(main())
```

**Когда выбирать:** надёжный агент с доступом к файловой системе и shell. Лучший выбор для coding agents и DevOps-автоматизации.

### LangGraph (LangChain)

Фреймворк для построения агентов как направленных графов с состоянием. Каждый узел графа — шаг обработки, рёбра — условные переходы.

**Ключевая идея:** агент — граф, где состояние явно описано и передаётся между узлами. Полный контроль над потоком выполнения, checkpoints, human-in-the-loop.

```python
from langgraph.graph import StateGraph, MessagesState
from langgraph.prebuilt import ToolNode
from langchain_anthropic import ChatAnthropic
from langchain_core.tools import tool

@tool
def search_web(query: str) -> str:
    """Поиск информации в интернете."""
    return f"Результаты поиска по запросу: {query}"

tools = [search_web]
tool_node = ToolNode(tools)

model = ChatAnthropic(model="claude-sonnet-4-6").bind_tools(tools)

def analyst(state: MessagesState):
    response = model.invoke(state["messages"])
    return {"messages": [response]}

def should_continue(state: MessagesState):
    last = state["messages"][-1]
    if last.tool_calls:
        return "tools"
    return "end"

graph = StateGraph(MessagesState)
graph.add_node("analyst", analyst)
graph.add_node("tools", tool_node)
graph.add_edge("__start__", "analyst")
graph.add_conditional_edges("analyst", should_continue)
graph.add_edge("tools", "analyst")

app = graph.compile()
```

**Когда выбирать:** сложные workflow с ветвлениями, checkpoints, human-in-the-loop. Production-системы, где нужен явный контроль над состоянием.

### CrewAI

Фреймворк для мультиагентных систем с ролевой моделью. Каждый агент — специалист с определённой ролью, целью и набором инструментов.

```python
from crewai import Agent, Task, Crew

researcher = Agent(
    role="Senior Research Analyst",
    goal="Найти актуальные данные о рынке AI агентов",
    backstory="Ты — аналитик с 10-летним опытом в AI-индустрии",
    tools=[search_tool, scrape_tool],
    llm="claude-sonnet-4-6"
)

writer = Agent(
    role="Technical Writer",
    goal="Написать аналитический отчёт на основе данных",
    backstory="Ты — технический автор, специализирующийся на AI",
    llm="claude-sonnet-4-6"
)

research_task = Task(
    description="Исследуй рынок AI агентов: ключевые игроки, тренды, размер рынка",
    agent=researcher,
    expected_output="Структурированный отчёт с цифрами"
)

writing_task = Task(
    description="Напиши аналитический отчёт на основе исследования",
    agent=writer,
    expected_output="Готовый отчёт в markdown",
    context=[research_task]
)

crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task],
    verbose=True
)

result = crew.kickoff()
```

**Когда выбирать:** задачи, которые декомпозируются на роли. Быстрое прототипирование мультиагентных систем. Самый низкий порог входа — 20 строк для рабочего агента.

### Microsoft Agent Framework (Microsoft)

Официальный production-фреймворк Microsoft для агентов, достигший версии 1.0 в апреле 2026. Объединяет концепции AutoGen и Semantic Kernel в единый стек с поддержкой .NET и Python.

Ключевые концепции: **Agent Harness** — пакетирует вызов функций, персистентность истории, планирование и поиск в один вызов; **CodeAct** — вместо выбора инструмента модель пишет короткую Python-программу, запускает её в sandbox и получает результат. Глубокая интеграция с Azure AI Foundry: hosted agents, managed session state, observability, автоскейлинг.

**Важно:** AutoGen переведён в maintenance mode — для новых проектов на стеке Microsoft используйте Agent Framework.

**Когда выбирать:** Azure-ориентированные системы, enterprise .NET/Python, multi-agent workflows с управляемым деплоем.

### OpenAI Agents SDK

Официальный SDK от OpenAI для построения агентов. Ключевые концепции: **Agent** — LLM с инструкциями, набором инструментов и моделью; **handoffs** — передача управления между агентами (паттерн оркестратор → специалист); **guardrails** — встроенные проверки на входе и выходе. Нативная поддержка OpenAI Responses API и sandboxed code execution.

```python
from agents import Agent, Runner

agent = Agent(
    name="Analyst",
    instructions="Ты — аналитик данных. Отвечай чётко и структурированно.",
    model="gpt-5.5",
)

result = Runner.run_sync(agent, "Проанализируй топ-5 трендов AI-агентов в 2026")
print(result.final_output)
```

**Когда выбирать:** OpenAI-ориентированные системы, быстрый старт с handoffs между специализированными агентами, проекты где нужны встроенные guardrails и sandboxed execution.

### smolagents (Hugging Face)

Минималистичный фреймворк. ~1000 строк основного кода. Агенты пишут и выполняют Python-код вместо JSON-описаний действий.

```python
from smolagents import CodeAgent, tool, LiteLLMModel

model = LiteLLMModel(model_id="anthropic/claude-sonnet-4-6")

@tool
def get_weather(city: str) -> str:
    """Получает текущую погоду в указанном городе."""
    # Реализация запроса к weather API
    return f"В {city} сейчас +22°C, солнечно"

agent = CodeAgent(
    tools=[get_weather],
    model=model
)

result = agent.run("Какая погода в Москве и Токио?")
```

**Преимущества:** code agents на 30% эффективнее JSON-based tool calling — меньше шагов, меньше вызовов LLM. Плотная интеграция с Hugging Face Hub: инструменты импортируются прямо из сообщества.

**Когда выбирать:** простые агенты, эксперименты, обучение. Когда нужен минимум абстракций.

### Pydantic AI

Python-first production-фреймворк от команды Pydantic, в июне 2026 достигший версии 2.0. Центральная идея — **capability** как примитив: одна компосируемая единица, объединяющая инструменты, хуки, инструкции и настройки модели агента. Полная безопасность типов (Pydantic-схемы), структурированные output-контракты, dependency injection, нативная интеграция с Logfire/OpenTelemetry, поддержка MCP и durable execution.

```python
from pydantic_ai import Agent

agent = Agent(
    model="anthropic:claude-sonnet-4-6",
    system_prompt="Ты — аналитик данных. Отвечай структурированно.",
)

result = agent.run_sync("Какой тренд у метрики конверсии за последний квартал?")
print(result.data)
```

**Когда выбирать:** typed Python-бэкенды, строгие output-контракты, проекты где тестируемость и type safety приоритетнее гибкости.

### Google ADK (Agent Development Kit)

Open-source toolkit от Google, версия 2.0 (GA с мая 2026). Многоязычный (Python, Java), граф-ориентированный runtime с поддержкой multi-agent, A2A и MCP. Ключевые возможности: **Workflow Runtime** — граф-движок с роутингом, fan-out/fan-in, retry, human-in-the-loop; **Task API** — структурированная агент-агентная делегация с контролем вывода.

**Когда выбирать:** Google Cloud/Vertex AI, production-системы с A2A, мультиязычные мультиагентные стеки.

### MCP (Model Context Protocol)

MCP — не фреймворк для агентов, а протокол интеграции инструментов. Стандарт от Anthropic: как LLM-приложение взаимодействует с внешними данными и функциями.

97 млн установок в месяц, поддержка от OpenAI, Google, Microsoft, AWS и сотен других поставщиков. С декабря 2025 протокол под управлением Agentic AI Foundation (AAIF) — нейтрального фонда под эгидой Linux Foundation, сооснованного Anthropic, Block и OpenAI. Де-факто — USB-C для AI-инструментов.

**Архитектура:**

```
┌──────────────┐     ┌───────────────┐     ┌──────────────┐
│  LLM App     │────▶│  MCP Client   │────▶│  MCP Server  │
│  (агент)     │◀────│               │◀────│  (GitHub,    │
│              │     │               │     │   Slack, DB) │
└──────────────┘     └───────────────┘     └──────────────┘
```

MCP-сервер предоставляет инструменты (tools), ресурсы (resources) и промпты (prompts). Агент подключает нужные серверы и получает доступ к их возможностям.

**Пример конфигурации:**

```json
{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "${GITHUB_TOKEN}"
      }
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "DATABASE_URL": "${DATABASE_URL}"
      }
    }
  }
}
```

Один протокол — любые инструменты: GitHub, Slack, Notion, PostgreSQL, Stripe и десятки других.

### Сравнение фреймворков

| Фреймворк | Подход | Сложность | Production-ready | Лучший use case |
|---|---|---|---|---|
| Claude Agent SDK | Agent loop + tools | Низкая | Да | Coding agents, DevOps |
| LangGraph 1.x | Stateful graphs | Средняя | Да | Сложные workflow, durable execution |
| OpenAI Agents SDK | Agents + handoffs + sandbox | Низкая | Да | OpenAI-centric агенты, sandbox |
| CrewAI 1.x | Role-based teams + Flows | Низкая | Да | Мультиагентные бизнес-автоматизации |
| Pydantic AI 2.0 | Typed agent + capabilities | Средняя | Да | Python backends, строгие контракты |
| Google ADK 2.x | Graph workflows + A2A | Средняя | Да | Google Cloud, мультиязычный стек |
| Microsoft Agent Framework 1.0 | Harness + CodeAct | Средняя | Да | Azure, .NET/Python enterprise |
| smolagents | Code agents | Низкая | Средне | Прототипы, обучение |
| MCP | Protocol (tools) | Низкая | Да | Интеграция инструментов |

## Практические use cases

### Coding agents — автоматизация разработки

Coding agents — самый зрелый класс AI агентов. Claude Code, Cursor, Devin, Codex — все работают в production.

**Типичные задачи:**

- Имплементация фич по описанию в задаче (Jira, Linear, GitHub Issue)
- Поиск и исправление багов с запуском тестов
- Рефакторинг с сохранением обратной совместимости
- Генерация тестов на существующий код
- Code review с автоматическим исправлением замечаний
- Миграции: обновление зависимостей, изменение API

**ROI:** разработчик с coding agent выполняет задачи в 2-5 раз быстрее. Основной выигрыш — на рутине: бойлерплейт, тесты, миграции, документация.

### Customer support — автоответы с базой знаний

Агент с доступом к базе знаний, CRM и истории обращений. Ищет по контексту, а не по ключевым словам — находит релевантные статьи, формулирует ответ.

**Архитектура:**

```
Клиент → Агент → [KB search, CRM lookup, Order status] → Ответ
                → Эскалация на человека (если уверенность < threshold)
```

**Ключевые метрики:**

- Resolution rate: 40-70% обращений без участия человека
- First response time: секунды вместо минут
- CSAT: сопоставим с человеком при правильном покрытии базы знаний

### Data analysis — аналитика и отчёты

Агент подключается к базе данных, пишет SQL-запросы, анализирует результаты, строит визуализации и формулирует выводы.

```python
# Пример задачи для аналитического агента:
# "Проанализируй конверсию воронки за март, сравни с февралём,
#  найди узкие места и предложи гипотезы для A/B тестов"

# Агент выполнит:
# 1. SQL: SELECT step, count(*) FROM funnel WHERE month = '2026-03' GROUP BY step
# 2. SQL: то же для февраля
# 3. Расчёт конверсии на каждом шаге
# 4. Сравнительный анализ
# 5. Генерация гипотез на основе данных
# 6. Формирование отчёта с графиками
```

### DevOps — мониторинг, алерты, автофикс

Агент мониторит инфраструктуру, реагирует на алерты, выполняет диагностику и автоматическое восстановление.

**Сценарий:**

1. Prometheus alert: высокая latency на API
2. Агент проверяет метрики сервиса
3. Анализирует логи — находит OOM в одном из подов
4. Проверяет текущие лимиты ресурсов
5. Увеличивает memory limit и перезапускает под
6. Верифицирует: latency вернулась в норму
7. Отправляет отчёт в Slack с root cause и действиями

### Research — сбор и синтез информации

Агент собирает данные из множества источников, фильтрует, структурирует и синтезирует в отчёт.

**Примеры:**

- Competitive intelligence: мониторинг продуктов конкурентов, ценовых изменений, новых фич
- Market research: сбор данных из отчётов, новостей, соцсетей
- Academic research: поиск по arxiv, PubMed, анализ и суммаризация papers
- Due diligence: проверка компаний перед инвестициями

### Sales — квалификация лидов и outreach

Агент разбирает входящие лиды, обогащает данные из открытых источников, квалифицирует по ICP (Ideal Customer Profile) и пишет персонализированные сообщения.

**Пайплайн:**

```
Новый лид → Обогащение (LinkedIn, CrunchBase, сайт компании)
          → Скоринг по ICP
          → Персонализированный email/сообщение
          → Автоматический follow-up через N дней
          → Эскалация на менеджера при ответе
```

## Как создать простого агента

### Агент на Claude Agent SDK

Рабочий агент за 20 строк — анализирует проект и генерирует отчёт:

```python
import asyncio
from claude_agent_sdk import query, ClaudeAgentOptions, AssistantMessage, TextBlock

async def analyze_project(path: str):
    results = []

    async for message in query(
        prompt=f"""Проанализируй проект в {path}:
        1. Определи стек технологий
        2. Найди потенциальные проблемы безопасности
        3. Оцени качество кода
        4. Предложи улучшения
        Сформируй структурированный отчёт.""",
        options=ClaudeAgentOptions(
            allowed_tools=["Read", "Glob", "Grep"],
            model="claude-sonnet-4-6",
        ),
    ):
        if isinstance(message, AssistantMessage):
            for block in message.content:
                if isinstance(block, TextBlock):
                    results.append(block.text)

    return "\n".join(results)

report = asyncio.run(analyze_project("/path/to/project"))
print(report)
```

SDK берёт на себя всё: агентный цикл, вызовы инструментов, контекст, retries. Разработчик описывает задачу — SDK выполняет.

### Агент с MCP-инструментами

Агент с подключением к GitHub через MCP:

```python
import asyncio
from claude_agent_sdk import query, ClaudeAgentOptions, AssistantMessage, TextBlock

MCP_CONFIG = {
    "github": {
        "command": "npx",
        "args": ["-y", "@modelcontextprotocol/server-github"],
        "env": {"GITHUB_TOKEN": "ghp_..."}
    }
}

async def triage_issues():
    async for message in query(
        prompt="""Проверь открытые issues в репозитории owner/repo:
        1. Прочитай каждый issue
        2. Определи приоритет (critical/high/medium/low)
        3. Добавь лейблы
        4. Назначь на подходящего разработчика на основе
           истории коммитов""",
        options=ClaudeAgentOptions(
            allowed_tools=["Read", "Bash", "mcp__github__*"],
            mcp_servers=MCP_CONFIG,
            model="claude-sonnet-4-6"
        ),
    ):
        if isinstance(message, AssistantMessage):
            for block in message.content:
                if isinstance(block, TextBlock):
                    print(block.text)

asyncio.run(triage_issues())
```

Агент использует GitHub MCP-сервер для чтения issues, добавления лейблов и назначения разработчиков. Сервер можно заменить без изменения кода агента — протокол единый.

### Мультиагентная система на CrewAI

Команда агентов для подготовки технического отчёта:

```python
from crewai import Agent, Task, Crew
from crewai_tools import SerperDevTool

search = SerperDevTool()

analyst = Agent(
    role="Data Analyst",
    goal="Собрать и проанализировать данные",
    tools=[search],
    llm="claude-sonnet-4-6",
    verbose=True
)

writer = Agent(
    role="Report Writer",
    goal="Написать чёткий технический отчёт",
    llm="claude-sonnet-4-6",
    verbose=True
)

analysis = Task(
    description="Исследуй текущее состояние рынка AI агентов: "
                "размер, рост, ключевые игроки, тренды",
    agent=analyst,
    expected_output="Структурированные данные с источниками"
)

report = Task(
    description="Создай отчёт на основе анализа: "
                "executive summary, ключевые findings, рекомендации",
    agent=writer,
    expected_output="Готовый отчёт в markdown",
    context=[analysis]
)

crew = Crew(agents=[analyst, writer], tasks=[analysis, report])
result = crew.kickoff()
print(result)
```

## Проблемы и ограничения

### Галлюцинации

Агент может «придумывать» факты, несуществующие API, некорректные команды. У чат-бота галлюцинация выражается в неверном тексте. У агента — в вызове несуществующей функции, некорректной команде или ложных данных в базе.

**Митигация:**

- Ограничение набора инструментов (whitelist, не blacklist)
- Валидация выходных данных перед выполнением
- Human-in-the-loop для критичных операций
- Grounding: подключение RAG для фактчекинга

### Стоимость

Агентный цикл — десятки вызовов LLM на одну задачу. Каждая итерация think → act → observe — это входные и выходные токены. Сложная задача: 20–50 итераций.

**Примерные затраты (Claude Sonnet 4.6, $3/$15 за 1M токенов):**

| Задача | Итерации | Токены | Стоимость |
|---|---|---|---|
| Простой поиск по файлам | 3-5 | ~10K | ~$0.05 |
| Исправление бага | 10-15 | ~50K | ~$0.23 |
| Имплементация фичи | 20-40 | ~200K | ~$1-3 |
| Рефакторинг модуля | 30-60 | ~500K | ~$3-8 |

**Оптимизация:**

- Иерархия моделей: Opus 4.8 / GPT-5.5 для orchestrator, Sonnet 4.6 / GPT-5.5 Instant для workers
- Кэширование промежуточных результатов
- Prompt caching (Anthropic API поддерживает нативно)
- Ранняя остановка при достижении цели

### Надёжность

Агент не всегда даёт стабильный результат. Одна и та же задача при повторном запуске может решиться за 5 шагов или за 50. Или не решиться вовсе.

**Причины:**

- Температура модели → разные пути решения
- Зависимость от порядка наблюдений
- Деградация reasoning на длинных контекстах

**Митигация:**

- Чёткие system prompts с ограничениями
- Лимиты на количество итераций
- Retry с экспоненциальным backoff
- Fallback на человека после N неудач

### Безопасность

Агент с доступом к инструментам — вектор атаки. Prompt injection может заставить агента выполнить произвольную команду. Агент с доступом к shell — высокий риск.

**Принципы защиты:**

- **Least privilege** — минимальные права для каждой задачи
- **Sandboxing** — изолированная среда выполнения (контейнеры, VM)
- **Confirmation** — критичные действия требуют подтверждения
- **Audit log** — логирование каждого действия
- **Input validation** — валидация пользовательского ввода перед передачей агенту

```python
# Пример: ограничение инструментов
options = ClaudeAgentOptions(
    allowed_tools=["Read", "Glob", "Grep"],  # только чтение
    # НЕ включаем: "Bash", "Write", "Edit"  — агент не может модифицировать
    permission_mode="default"  # каждое действие требует подтверждения
)
```

### Оценка качества

Как измерить, что агент работает хорошо? Стандартных метрик нет, поэтому [тестирование и оценка AI-агентов](/ru/blog/ai-agent-testing-evaluation/) выделились в отдельную дисциплину. Каждая задача уникальна, результаты субъективны.

**Подходы:**

- **Task completion rate** — процент задач, решённых без вмешательства человека
- **Steps to completion** — количество шагов до решения (меньше — лучше)
- **Cost per task** — стоимость решения задачи
- **Regression testing** — фиксированный набор задач, прогоняемый при изменениях
- **Human eval** — экспертная оценка качества результатов

## Будущее AI агентов в 2026

### Computer use

Агенты управляют графическими интерфейсами: кликают, скроллят, заполняют формы, навигируют по приложениям. Anthropic, OpenAI и Google активно развивают это направление.

Автоматизация задач в SaaS без API. Заполнение форм в legacy-системах. End-to-end тестирование через UI.

Ограничения: скорость (скриншот → анализ → действие занимает секунды), нестабильность на сложных интерфейсах, высокая стоимость (каждый скриншот — тысячи токенов).

### Agent-to-agent протоколы

Два ключевых стандарта:

**MCP (Model Context Protocol)** — стандарт подключения инструментов к агентам. 97M+ установок в месяц. С декабря 2025 под управлением Agentic AI Foundation (AAIF, Linux Foundation). Поддерживают все крупные AI-провайдеры — фактически USB-C для AI-инструментов. В 2026 активно развиваются remote MCP, OAuth-авторизация и динамическое обнаружение инструментов.

**A2A (Agent-to-Agent Protocol)** — стандарт коммуникации между агентами. Версия 1.0 вышла в марте 2026, 150+ организаций-участников: Google, Microsoft, AWS, Salesforce, SAP, IBM. Ключевые концепции: agent cards (машиночитаемые описания возможностей агента), cross-vendor handoff (делегирование задач агенту другого провайдера), task-mode delegation. Агенты от разных вендоров взаимодействуют напрямую без кастомных интеграций.

MCP решает «агент ↔ инструмент», A2A решает «агент ↔ агент». Вместе — полная экосистема для распределённых агентных систем.

### Специализация vs универсальность

Тренд 2026 — специализированные агенты вместо универсальных. Один для кода, другой для аналитики, третий для DevOps. Каждый заточен под свою область: специфичные инструменты, оптимизированные промпты, релевантная память.

Универсальные агенты («сделай всё») проигрывают специализированным по качеству и стоимости. Будущее — оркестрация команд под конкретную задачу.

### Agentic coding как мейнстрим

Coding agents перешли из «эксперимента» в стандартный инструмент разработчика. Claude Code, Cursor, Copilot Agent — ежедневно используют тысячи команд.

Следующий этап — агенты в CI/CD: автоматический code review, тесты на каждый PR, автофикс линтинга, миграция зависимостей. Разработчик ставит задачу — агент выполняет от начала до конца.

Сдвиг ролей: разработчик становится reviewer, а не автором кода. Задача формулируется на естественном языке, агент генерирует реализацию, разработчик проверяет и корректирует. Скорость итерации вырастает на порядок.

### Managed agents — агенты как сервис

Anthropic, OpenAI и Google запустили managed agent platforms: агенты работают в облаке, подключаются к корпоративным системам через стандартные коннекторы, управляются через API.

Для бизнеса это означает: не нужно поднимать серверы, управлять промптами, мониторить поведение. Компания определяет задачи и ограничения — платформа выполняет.

Типичный сценарий: подключить агент к Zendesk, Salesforce и внутренней wiki. Агент обрабатывает тикеты первой линии, квалифицирует лиды, генерирует отчёты — без единой строки кода.

### Мультимодальные агенты

Агенты 2026 работают не только с текстом. Мультимодальные модели дают агенту возможность анализировать изображения, диаграммы, скриншоты интерфейсов, видео.

**Практические применения:**

- QA-агент делает скриншот приложения и сравнивает с макетом в Figma
- Аналитический агент «читает» графики из PDF-отчётов
- DevOps-агент анализирует скриншоты дашбордов Grafana при инциденте
- Дизайн-агент генерирует UI-компоненты на основе wireframes

Агенты работают с теми же артефактами, что и люди: скриншотами, схемами, документами.

---

AI агенты — инфраструктурный сдвиг, а не хайп. LLM перестаёт быть генератором текста и становится runtime для автоматизации. Фреймворки зрелые. Протоколы стандартизированы. Практические use cases работают в production.

Начать проще всего с Claude Agent SDK, OpenAI Agents SDK или CrewAI — 20 строк кода до работающего агента. Дальше — MCP для интеграции инструментов, LangGraph для сложных stateful workflow, Pydantic AI для typed Python-бэкендов, Google ADK или Microsoft Agent Framework для облачных production-систем. A2A — для межагентного взаимодействия между сервисами разных провайдеров.
