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

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

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

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

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

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

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

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

Пример: попросите ChatGPT «найти баг в коде» — получите текстовый разбор. Попросите Claude Code — он прочитает файлы проекта, найдёт проблему, исправит код, запустит тесты, сделает коммит. Это агент.

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

Каждый 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)

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

Thought — размышление о текущем состоянии и следующем шаге
Action — вызов инструмента
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

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

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 — «должностная инструкция» агента.

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-схемой: название, описание, параметры, тип возвращаемого значения.

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

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

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.

Установка:

# Python
pip install claude-agent-sdk

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

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

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

Пример:

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.

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

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

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.

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-описаний действий.

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.

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). Агент подключает нужные серверы и получает доступ к их возможностям.

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

{
  "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-запросы, анализирует результаты, строит визуализации и формулирует выводы.

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

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

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

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

Сценарий:

Prometheus alert: высокая latency на API
Агент проверяет метрики сервиса
Анализирует логи — находит OOM в одном из подов
Проверяет текущие лимиты ресурсов
Увеличивает memory limit и перезапускает под
Верифицирует: latency вернулась в норму
Отправляет отчёт в 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 строк — анализирует проект и генерирует отчёт:

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:

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

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

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 — валидация пользовательского ввода перед передачей агенту

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

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

Как измерить, что агент работает хорошо? Стандартных метрик нет, поэтому тестирование и оценка AI-агентов выделились в отдельную дисциплину. Каждая задача уникальна, результаты субъективны.

Подходы:

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 — для межагентного взаимодействия между сервисами разных провайдеров.