ИИ-агенты: что это такое, виды и фреймворки для разработки (CrewAI, LlamaIndex, LangChain, AutoGen)

Большая языковая модель может отвечать на вопросы, но для самостоятельного выполнения задачи ей нужны инструменты и механизм управления действиями. Система, в которой LLM планирует шаги, ищет информацию, пишет код и обращается к API, называется ИИ-агентом. Получив результат очередного действия, агент оценивает его и решает, что делать дальше, пока задача не будет выполнена. Эти возможности определяет архитектура вокруг модели: цикл выполнения, набор инструментов и память, а не размер самой LLM.

Разберём внутреннее устройство ИИ-агентов, паттерны их рассуждения и виды, а затем рассмотрим выбор фреймворка для конкретной задачи. Для LangChain, LlamaIndex, CrewAI и AutoGen приведём минимальные рабочие примеры на Python.

Чат-бот и RAG-система обрабатывают запрос за один проход: получают его, собирают контекст и генерируют ответ. ИИ-агент выполняет задачу в цикле: выбирает следующее действие, выполняет его, оценивает результат и на этой основе выбирает новый шаг. Этим объясняются остальные различия.

Рассмотрим разницу на задаче с уведомлением клиентов о задержке поставки.

Чат-бот получает запрос «Напиши письмо клиенту о задержке поставки» и возвращает текст. Человек сам находит клиента, подставляет даты, отправляет письмо и обновляет статус в CRM.

Агент получает более широкую задачу: «Найди все просроченные заказы в CRM, по каждому подготовь письмо с конкретными датами, отправь через API почтового сервиса и обнови статус в CRM». Для этого он обращается к CRM, обрабатывает список заказов, вызывает LLM для подготовки каждого письма, отправляет письма через почтовый API и записывает результаты в CRM. В конце он проверяет, что обработаны все заказы. Такой сценарий требует нескольких инструментов, переменного числа шагов и проверки результата.

Агентный подход полезен, когда число шагов и их порядок заранее неизвестны. Если последовательность действий определена, проще написать обычный скрипт и поручить LLM только генерацию текста.

Цикл работы агента

Агент выполняет задачу в цикле (agent loop): выбирает действие, получает результат и определяет следующий шаг. Цикл продолжается до достижения цели или срабатывания ограничения на число итераций.

Пользователь задаёт цель
        ↓
[Восприятие] — агент получает цель, историю и результаты предыдущих шагов
        ↓
[Рассуждение] — LLM определяет, достаточно ли данных и какой инструмент вызвать
        ↓
[Действие] — вызов инструмента (function call / tool use)
        ↓
[Наблюдение] — получение результата инструмента
        ↓
[Возврат к рассуждению] — цикл повторяется до достижения цели
        ↓
Финальный ответ пользователю

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

Четыре компонента ИИ-агента

1. LLM. Модель выбирает следующее действие: вызвать инструмент, задать уточняющий вопрос или ответить пользователю. В агентных сценариях особенно важно качество function calling — способность выбрать нужную функцию и правильно заполнить её аргументы. Модель, которая хорошо пишет тексты, но ошибается в структуре вызовов, может работать хуже менее сильной модели с надёжным tool use.

2. Инструменты (tools). Это функции, которые агент может вызывать: поиск в интернете, выполнение кода, запросы к базе данных, обращения к внешним API, чтение и запись файлов. Каждый инструмент описывается схемой с именем, описанием на естественном языке и параметрами, обычно в формате JSON Schema. Модель выбирает инструмент по этому описанию, поэтому его точность влияет на поведение агента не меньше, чем системный промпт. По расплывчатому описанию «работает с данными» модель может выбрать инструмент для неподходящей задачи.

3. Память (memory). В ней выделяют три слоя:

• краткосрочная память хранит историю текущего диалога в пределах контекстного окна;
• долгосрочная память использует внешнее хранилище, чаще векторную базу: агент записывает туда факты и извлекает их в следующих сессиях;
• рабочая память хранит промежуточные результаты текущей задачи: что найдено, что проверено и что ещё нужно сделать.

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

4. Оркестратор. Это код, который управляет циклом: передаёт модели контекст, разбирает ответ, вызывает инструменты и возвращает результаты. Он также обрабатывает исключения, считает итерации и определяет момент остановки. За таймауты, повторные попытки и логирование отвечает оркестратор. Фреймворки для ИИ-агентов прежде всего предоставляют готовые средства такой оркестрации.

Паттерн задаёт порядок, в котором агент рассуждает и выполняет действия. От этого порядка точность, стоимость и предсказуемость работы зависят сильнее, чем от выбранного фреймворка.

По числу агентов: одиночный и мультиагентный

Одиночный агент (single agent) использует одну модель и один набор инструментов для достижения одной цели. Его проще развёртывать и отлаживать, а расход токенов ниже: нужно отслеживать один лог, один цикл выполнения и одну последовательность решений. Такой подход подходит для большинства продуктовых задач.

Мультиагентная система (multi-agent) состоит из нескольких специализированных агентов, которые обмениваются результатами. Обычно оркестратор распределяет задачи между субагентами, а те выполняют свои части. У каждого своя роль, промпт и набор инструментов: например, исследователь, разработчик и ревьюер.

Мультиагентный подход оправдан, когда:

• задача не помещается в одно контекстное окно и её нужно разделить на части;
• для разных частей нужны отдельные роли и инструменты, а их объединение в одном промпте снижает качество работы;
• части задачи независимы и могут выполняться параллельно.

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

По типу взаимодействия

Эти типы можно сочетать. Например, мультиагентная система может запрашивать подтверждение человека перед записью в production-базу — это обычная конфигурация для корпоративных сценариев.

В России агентные платформы уже становятся самостоятельными продуктами. 30 апреля 2026 года VK Tech представила VK AI Space — платформу для разработки и запуска ИИ-агентов с изолированным контуром доступа для каждого агента. Доступны три варианта поставки: on-premise, в VK Cloud и в виде программно-аппаратного комплекса по подписке. 17 июня 2026 года в платформу добавили поддержку мультиагентных систем. Изоляция доступа помогает ограничить главный эксплуатационный риск: с каждым новым инструментом у агента появляется больше возможностей для действий с данными.

Минимального агента можно написать на чистом Python без фреймворка: организовать цикл, передать модели описание функций, разобрать ответ, вызвать выбранную функцию и вернуть результат модели. Полезно хотя бы раз собрать такой цикл самостоятельно, чтобы понять, какие задачи берёт на себя фреймворк. Он экономит время при дальнейшей разработке, предоставляя готовую оркестрацию, управление памятью, реестр инструментов, трейсинг и средства построения мультиагентных систем.

Все четыре фреймворка ниже распространяются под лицензией MIT и активно развиваются. Их публичные API меняются между минорными версиями, поэтому перед запуском примеров сверяйтесь с актуальной документацией. Код рассчитан на Python 3.10+ и требует ключей доступа к модели и внешним сервисам. Передавайте ключи через переменные окружения, не записывая их в код.

LangChain — open-source-фреймворк для приложений на основе LLM. Его публичный репозиторий ведётся с 2022 года. Сильная сторона LangChain — экосистема интеграций с провайдерами моделей, векторными хранилищами, загрузчиками документов и готовыми инструментами. Для нужного сервиса часто уже есть готовая интеграция.

LangGraph — библиотека той же команды для построения агентных и мультиагентных приложений в виде графов состояний. Это низкоуровневый фреймворк оркестрации, в котором явно задаются узлы, рёбра и условные переходы; подробнее в документации. Граф делает поведение агента понятнее: можно проследить, между какими состояниями он переходил и что определяло эти переходы.

Плюсы: самая широкая экосистема интеграций, большое сообщество, подробная документация и инструменты трейсинга.

Минусы: несколько слоёв абстракции между пользовательским кодом и запросом к модели в классическом LangChain затрудняют отладку. API заметно меняется между версиями, поэтому примеры из статей двухлетней давности часто уже не запускаются.

# pip install langchain langchain-openai langchain-community
# Ключ модели — в переменной окружения OPENAI_API_KEY
from langchain_openai import ChatOpenAI
from langchain.agents import create_react_agent, AgentExecutor
from langchain_community.tools import DuckDuckGoSearchRun
from langchain import hub

llm = ChatOpenAI(model="gpt-4o", temperature=0)
tools = [DuckDuckGoSearchRun()]
prompt = hub.pull("hwchase17/react")

agent = create_react_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True, max_iterations=5)

result = executor.invoke({"input": "Какой текущий курс доллара к рублю?"})
print(result["output"])

Параметр

LlamaIndex — фреймворк для LLM-приложений, работающих с данными. Он вырос из retrieval-augmented generation (RAG) и остаётся сильнейшим в этой нише благодаря разнообразию индексов и стратегий извлечения, а также средствам работы с большими массивами документов. На этой основе построены агентные возможности, в том числе мультиагентные сценарии через

LlamaIndex подходит прежде всего для задач, в которых агент анализирует корпус документов: регламенты, договоры, тикеты или техническую документацию. Поиск по индексу доступен ему как инструмент наряду с вызовами API. Агент сам определяет, когда и к какому индексу обратиться.

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

Минусы: экосистема сторонних инструментов меньше, чем у LangChain. Если агенту нужны многочисленные интеграции с разными внешними сервисами, часть из них придётся написать самостоятельно.

# pip install llama-index
# Ключ модели — в переменной окружения OPENAI_API_KEY
from llama_index.core.agent import ReActAgent
from llama_index.llms.openai import OpenAI
from llama_index.core.tools import FunctionTool

def get_weather(city: str) -> str:
    """Возвращает погоду в городе."""
    # заглушка: в рабочем коде здесь запрос к погодному API
    return f"В городе {city} сейчас +15 °C, облачно"

weather_tool = FunctionTool.from_defaults(fn=get_weather)

llm = OpenAI(model="gpt-4o")
agent = ReActAgent.from_tools(
    tools=[weather_tool],
    llm=llm,
    verbose=True,
)

response = agent.chat("Какая погода в Москве?")
print(response)

Докстринг функции попадает в описание инструмента. По нему модель определяет, подходит ли инструмент для текущей задачи и нужно ли его вызвать.

CrewAI строится вокруг ролей агентов в мультиагентной системе. Основные абстракции:

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

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

Минусы: для одиночного агента эти абстракции избыточны. Передача контекста между участниками команды расходует токены, поэтому на простой задаче затраты могут оказаться выше, чем при использовании одного ReAct-агента.

# pip install crewai crewai-tools
# Ключи моделей и поискового сервиса — в переменных окружения
from crewai import Agent, Task, Crew, Process
from crewai_tools import SerperDevTool

search_tool = SerperDevTool()

researcher = Agent(
    role="Исследователь",
    goal="Найти актуальную информацию по теме",
    backstory="Аналитик данных с доступом к интернет-поиску",
    tools=[search_tool],
    verbose=True,
)

writer = Agent(
    role="Автор",
    goal="Написать структурированный отчёт на основе исследования",
    backstory="Технический писатель с опытом в ИТ-тематике",
    verbose=True,
)

research_task = Task(
    description="Собери данные о подходах к мониторингу LLM-приложений",
    expected_output="Список подходов с кратким описанием каждого",
    agent=researcher,
)

write_task = Task(
    description="Напиши краткий отчёт на основе результатов исследования",
    expected_output="Отчёт объёмом 300–500 слов в формате Markdown",
    agent=writer,
)

crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, write_task],
    process=Process.sequential,
)

result = crew.kickoff()
print(result)

Подробно описывайте результат в поле

AutoGen — фреймворк Microsoft Research для мультиагентных приложений, в котором агенты взаимодействуют через сообщения. Код доступен в репозитории проекта на GitHub. Работа строится как диалог между агентами, к которому человек может подключиться как ещё один участник.

Такая модель подходит для задач, где обсуждение и критика помогают улучшить результат: один агент пишет код, второй проверяет его, третий определяет, когда работу можно завершить.

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

Минусы: порог входа выше, чем у остальных рассмотренных фреймворков. Нужно разобраться в модели сообщений и условиях завершения диалога. Между мажорными ветками API менялся с нарушением обратной совместимости, поэтому старые примеры требуют доработки.

# pip install autogen-agentchat autogen-ext[openai]
# Ключ модели — в переменной окружения OPENAI_API_KEY
import asyncio
from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.teams import RoundRobinGroupChat
from autogen_ext.models.openai import OpenAIChatCompletionClient

async def main():
    model_client = OpenAIChatCompletionClient(model="gpt-4o")

    coder = AssistantAgent(
        name="Coder",
        model_client=model_client,
        system_message="Ты Python-разработчик. Пиши чистый код с комментариями.",
    )

    reviewer = AssistantAgent(
        name="Reviewer",
        model_client=model_client,
        system_message="Ты код-ревьюер. Находи баги и предлагай улучшения.",
    )

    team = RoundRobinGroupChat([coder, reviewer], max_turns=4)
    result = await team.run(task="Напиши функцию для разбора CSV-файла в список словарей")
    print(result.messages[-1].content)

asyncio.run(main())

Параметр

Выбирайте фреймворк по требованиям задачи:

• LlamaIndex — если агенту нужно анализировать корпус документов и точно находить в нём информацию.
• CrewAI — если нужна команда с явно заданными ролями: исследователь, аналитик, автор.
• LangGraph — если важен точный контроль над выполнением и состоянием агента.
• AutoGen — если агенты улучшают результат в ходе обсуждения, а человек участвует в диалоге.
• LangChain — если нужно как можно больше готовых интеграций с внешними сервисами.

Если ни одно из этих требований пока не актуально, начните с цикла на чистом Python. Подключайте фреймворк, когда появится конкретное ограничение, которое он поможет снять.

Агентная архитектура позволяет выполнять задачи, для которых нельзя заранее задать последовательность действий. Но её поведение труднее предсказать, выполнение занимает больше времени и обходится дороже. Если выполняется хотя бы одно из условий ниже, стоит выбрать более простое решение.