Многоагентные системы переходят из стадии экспериментов в промышленную эксплуатацию. Компании финансового сектора запускают кластеры из десятков специализированных агентов, которые мониторят рынки, оценивают риски и генерируют аналитику в реальном времени. Главный барьер на этом пути - оркестрация. Агенты должны не просто отрабатывать каждый свой цикл, но и восстанавливаться после сбоев, сохранять контекст между вызовами и предоставлять прозрачную картину происходящего для аудита.
Связка LangGraph и Strands решает эти задачи на архитектурном уровне. LangGraph берет на себя state-driven оркестрацию - управление потоком выполнения через граф состояний с автоматическим checkpointing. Strands добавляет агентам способность к многошаговым рассуждениям и динамическому выбору инструментов. Развертывание через Amazon Bedrock AgentCore замыкает контур: встроенная память, наблюдаемость и восстановление после сбоев работают из коробки, без самописных костылей. В этом разборе мы пройдем весь путь - от архитектурных решений до кода агентов для мониторинга рынка и запуска через AgentCore Python SDK.
Почему многоагентные системы требуют нового подхода к оркестрации
Традиционные пайплайны с жестко заданной последовательностью шагов ломаются при первой же нестандартной ситуации. Агент не смог вызвать API - пайплайн упал. Модель вернула неожиданный формат ответа - пайплайн упал. В production-окружении финансового мониторинга такие сбои стоят денег и времени. Система обязана продолжать работу даже при отказе отдельных компонентов, а после восстановления - подхватывать выполнение с того же места, не теряя накопленный контекст.
Вторая проблема - сложность рассуждений. Агент, анализирующий рыночные данные, не может действовать по жесткому скрипту. Он должен сам решать, какие источники опросить, как интерпретировать противоречивые сигналы и когда эскалировать ситуацию человеку. Обычные цепочки вызовов LLM с этим не справляются - нужен механизм планирования и динамического выбора инструментов.
LangGraph закрывает первый блок проблем. Это фреймворк, который представляет workflow как направленный граф: узлы - шаги выполнения, ребра - переходы между ними. После каждого шага LangGraph сохраняет полное состояние графа - это называется checkpointing. При сбое система автоматически перезапускается с последнего сохраненного состояния, а не с начала. Strands решает второй блок - дает агентам способность строить цепочки рассуждений, обращаться к инструментам и принимать решения на основе промежуточных результатов. Вместе они образуют архитектуру, готовую к реальным нагрузкам.
Кейс, который мы разберем, - система мониторинга рынка с четырьмя специализированными агентами: security_monitor отслеживает угрозы безопасности, broker_monitor мониторит состояние брокеров, risk_monitor оценивает риски, intel_analyst агрегирует и анализирует разведданные. Все они работают в едином графе LangGraph и развернуты через AgentCore.
Архитектура решения: как LangGraph и Strands работают вместе
Архитектура строится на четком разделении ответственности. LangGraph управляет потоком выполнения - какие агенты запускаются, в каком порядке, при каких условиях происходит переход между ними. Strands наделяет каждого агента интеллектом - способностью рассуждать, планировать действия и вызывать инструменты. AgentCore предоставляет среду выполнения с памятью, наблюдаемостью и восстановлением после сбоев.
Граф состояний LangGraph определяет workflow как конечный автомат. Состояние - это словарь с данными, которые передаются между узлами. Узлы - функции, выполняющие полезную работу (запуск агента, вызов API, трансформация данных). Ребра бывают двух типов: обычные - безусловный переход к следующему узлу, и условные - переход в зависимости от результата выполнения. Такая модель дает полный контроль над потоком и одновременно позволяет агенту влиять на маршрутизацию через возвращаемые значения.
Strands работает внутри узлов графа. Когда LangGraph передает управление агенту risk_monitor, тот использует Strands для построения цепочки рассуждений: получить данные от broker_monitor, проанализировать их, при необходимости запросить дополнительную информацию через API, оценить уровень риска и вернуть решение - эскалировать или продолжить наблюдение. Strands сам решает, какие инструменты вызывать и в какой последовательности, основываясь на промежуточных результатах.
Интеграция выглядит так: LangGraph определяет структуру workflow и управляет состоянием, Strands наполняет агентов способностью к сложным рассуждениям, AgentCore обеспечивает среду выполнения с гарантиями надежности. При сбое агента LangGraph откатывает состояние к последнему чекпоинту, AgentCore перезапускает узел, и выполнение продолжается без потери данных.
State-driven оркестрация с LangGraph: графы состояний и checkpointing
Граф состояний LangGraph - это направленный граф, где каждое ребро определяет допустимый переход. Состояние графа сериализуется после каждого шага и сохраняется в хранилище чекпоинтов. Это критически важный механизм для production-надежности: если узел упал из-за сетевой ошибки или таймаута модели, система не начинает workflow заново, а перезапускает только проблемный узел с тем же состоянием, с которым он был вызван в первый раз.
Пример определения графа для системы мониторинга рынка:
from langgraph.graph import StateGraph, END
from typing import TypedDict, List
class MarketMonitorState(TypedDict):
messages: List[str]
security_alerts: List[dict]
broker_status: dict
risk_assessment: dict
intel_report: str
next_agent: str
def create_monitor_graph():
workflow = StateGraph(MarketMonitorState)
workflow.add_node("security_monitor", run_security_monitor)
workflow.add_node("broker_monitor", run_broker_monitor)
workflow.add_node("risk_monitor", run_risk_monitor)
workflow.add_node("intel_analyst", run_intel_analyst)
workflow.set_entry_point("security_monitor")
workflow.add_edge("security_monitor", "broker_monitor")
workflow.add_edge("broker_monitor", "risk_monitor")
workflow.add_conditional_edges(
"risk_monitor",
route_after_risk,
{"escalate": "intel_analyst", "continue": "security_monitor"}
)
workflow.add_edge("intel_analyst", END)
return workflow.compile()Метод compile() возвращает скомпилированный граф со встроенной поддержкой checkpointing. При запуске через AgentCore чекпоинты автоматически сохраняются в управляемое хранилище, и система получает возможность восстановления после сбоев без дополнительного кода.
Условные ребра - ключевой механизм динамической маршрутизации. Функция route_after_risk анализирует результат работы risk_monitor и решает, отправить данные аналитику для составления отчета или вернуться к мониторингу безопасности. Это позволяет графу адаптироваться к ситуации без жестко заданных путей.
Интеллектуальные агенты на Strands: рассуждения и вызов инструментов
Strands - это слой, который превращает вызов LLM в многошаговый процесс рассуждения с возможностью вызова внешних инструментов. Агент получает задачу, Strands строит план, выполняет шаги, анализирует промежуточные результаты и при необходимости корректирует план. Такой подход принципиально отличается от одиночного вызова модели с промптом - агент может провести несколько раундов сбора данных и анализа, прежде чем выдать финальное решение.
Агент risk_monitor на Strands работает так: получает данные от broker_monitor (статусы брокеров, объемы торгов, аномалии), анализирует их через цепочку рассуждений, при обнаружении подозрительных паттернов запрашивает дополнительную информацию через API (историю транзакций, новостной фон), оценивает совокупный риск и возвращает вердикт. Strands сам решает, нужно ли вызывать дополнительные инструменты, основываясь на промежуточных выводах.
from strands import Agent, tool
@tool
def fetch_broker_health(broker_id: str) -> dict:
"""Получает метрики здоровья брокера: latency, error rate, volume."""
# Вызов API мониторинга брокеров
return {"latency_ms": 45, "error_rate": 0.02, "volume_1h": 15000}
@tool
def fetch_news_sentiment(ticker: str) -> dict:
"""Анализирует новостной фон по тикеру."""
return {"sentiment": "negative", "key_events": ["regulatory_filing"]}
risk_monitor = Agent(
name="risk_monitor",
instructions="Оценивай риски на основе данных брокеров и новостного фона. Эскалируй при уровне риска выше 0.7.",
tools=[fetch_broker_health, fetch_news_sentiment]
)Strands управляет циклом рассуждения внутри агента: модель решает, какой инструмент вызвать, Strands выполняет вызов, результат добавляется в контекст, модель анализирует и решает, продолжать сбор данных или выдавать финальный ответ. LangGraph при этом видит только факт завершения работы агента и полученный результат - внутренняя кухня рассуждений скрыта за интерфейсом узла графа.
Production-развертывание с Amazon Bedrock AgentCore
AgentCore - это управляемая среда выполнения для агентов на AWS. Она берет на себя три критически важные функции, которые сложно реализовать самостоятельно: сохранение состояния между вызовами (встроенная память), восстановление после сбоев (checkpoint-based) и наблюдаемость (логирование, метрики, трассировка). Для финансового мониторинга, где потеря контекста или пропуск аномалии недопустимы, эти возможности становятся обязательными.
Развертывание через AgentCore Python SDK выглядит как упаковка графа LangGraph и агентов Strands в единый артефакт с последующей загрузкой в облако. SDK автоматически настраивает инфраструктуру: хранилище чекпоинтов, сбор логов, метрики CloudWatch. Разработчик фокусируется на логике агентов, а не на инфраструктурном коде.
Восстановление после сбоев и управление состоянием
Механизм восстановления AgentCore работает на основе чекпоинтов LangGraph. После каждого успешного шага графа состояние сериализуется и сохраняется в DynamoDB. При сбое узла - таймаут вызова модели, ошибка API, падение контейнера - AgentCore определяет последний успешный чекпоинт и перезапускает выполнение с него. Для агента это выглядит как повторный вызов с теми же входными данными.
Типичный сценарий: risk_monitor вызвал API брокера, но запрос упал по таймауту. LangGraph выбрасывает исключение, AgentCore перехватывает его, откатывает состояние к чекпоинту перед вызовом risk_monitor и запускает узел заново. Strands внутри агента получает ту же задачу и повторяет вызов API - на этот раз успешно. Система продолжает выполнение, как будто сбоя не было. Никакие данные не потеряны, контекст рассуждений сохранен.
Встроенная память AgentCore решает другую задачу - сохранение контекста между разными запусками workflow. Данные, полученные агентом в одном цикле мониторинга, доступны в следующем. Это позволяет системе накапливать историю и выявлять тренды без внешней базы данных.
Observability и мониторинг многоагентной системы
AgentCore предоставляет три уровня наблюдаемости. Логи - структурированные записи о каждом шаге каждого агента: входные данные, выбранный инструмент, результат вызова, время выполнения. Метрики - агрегированные показатели: latency по узлам графа, частота сбоев, количество вызовов инструментов, расход токенов. Трассировки - полные цепочки вызовов с возможностью проследить путь конкретного запроса через всех агентов.
Эти данные критически важны для отладки рассуждений. Когда intel_analyst выдает неожиданный отчет, можно открыть трассировку и увидеть: какие данные получил risk_monitor, почему он принял решение об эскалации, какие инструменты вызывал intel_analyst и на основе чего сделал выводы. Без такой прозрачности многоагентная система превращается в черный ящик, тихие сбои накапливаются, а доверие к системе падает.
AgentCore также интегрируется с CloudWatch, что позволяет настроить алерты на критические события: падение узла графа, превышение порога latency, аномальный расход токенов. Команда получает уведомление до того, как проблема повлияет на бизнес-показатели.
Реализация агентов для мониторинга рынка: от кода до развертывания
Четыре агента в системе мониторинга покрывают полный цикл обработки рыночной информации. Каждый агент - это независимый узел графа LangGraph со своим набором инструментов и логикой рассуждений на Strands. Взаимодействие между ними организовано через состояние графа: выход одного агента становится входом для следующего.
Агенты и их роли: security_monitor, broker_monitor, risk_monitor, intel_analyst
security_monitor - входная точка графа. Его задача: отслеживать угрозы безопасности, которые могут повлиять на рыночную инфраструктуру. Агент мониторит источники данных о кибератаках, уязвимостях, подозрительной активности. Инструменты: API threat intelligence, сканеры уязвимостей, ленты инцидентов. Результат - список активных угроз с оценкой критичности, который передается в состояние графа.
broker_monitor - следующий узел. Получает контекст от security_monitor и опрашивает API брокеров: latency, объемы торгов, частота ошибок, статус соединений. Агент выявляет аномалии в работе брокеров - резкий рост задержек, падение объемов, участившиеся таймауты. Инструменты: API брокеров, системы мониторинга инфраструктуры. Результат - карта состояния брокеров с отмеченными отклонениями.
risk_monitor - центральный аналитический узел. Объединяет данные о безопасности и состоянии брокеров, добавляет новостной фон через анализ тональности. Strands строит цепочку рассуждений: есть ли корреляция между угрозами безопасности и аномалиями брокеров? Как новостной фон влияет на оценку? Агент вычисляет совокупный риск и принимает решение: эскалировать аналитику для составления отчета или продолжить наблюдение. Инструменты: API анализа тональности новостей, сервисы оценки рисков.
intel_analyst - финальный узел, который активируется только при эскалации. Получает полный контекст от всех предыдущих агентов и генерирует структурированный аналитический отчет: описание ситуации, цепочка событий, оценка влияния, рекомендуемые действия. Strands здесь работает с инструментами агрегации данных и шаблонами отчетов. Результат - готовый документ, который отправляется команде принятия решений.
Маршрутизация и оркестрация через AgentCore Python SDK
AgentCore Python SDK предоставляет класс AgentCore для упаковки и развертывания агентов. Граф LangGraph компилируется, агенты Strands инициализируются, все вместе упаковывается в артефакт и загружается в облако.
from agentcore import AgentCore
from agentcore.config import DeploymentConfig
config = DeploymentConfig(
name="market-monitor-system",
memory_enabled=True,
checkpoint_ttl_hours=24,
observability_level="full"
)
system = AgentCore(config)
system.register_agent("security_monitor", security_monitor_agent)
system.register_agent("broker_monitor", broker_monitor_agent)
system.register_agent("risk_monitor", risk_monitor_agent)
system.register_agent("intel_analyst", intel_analyst_agent)
system.set_graph(create_monitor_graph())
system.deploy()Метод deploy() загружает артефакт в AWS, настраивает хранилище чекпоинтов, включает сбор логов и метрик. После развертывания система готова принимать вызовы через API Gateway или запускаться по расписанию через EventBridge.
Динамическая маршрутизация между агентами работает через условные ребра графа LangGraph. Результат рассуждений risk_monitor определяет, пойдет ли поток к intel_analyst для составления отчета или вернется к security_monitor для следующего цикла наблюдения. AgentCore отслеживает все переходы и сохраняет полную историю выполнения для аудита.
Применимость в enterprise: финансы и не только
Финансовый сектор - естественная среда для многоагентных систем с жесткими требованиями к надежности. Скорость реакции на рыночные события напрямую конвертируется в деньги. Система мониторинга на LangGraph и Strands обрабатывает поток данных в реальном времени, автоматически эскалирует критические ситуации и предоставляет полный аудиторский след - кто из агентов принял решение, на основе каких данных, с какими промежуточными рассуждениями.
Преимущества для enterprise-сценариев:
- Отказоустойчивость из коробки. Checkpoint-based восстановление AgentCore устраняет целый класс проблем, связанных с падением компонентов. Система сама перезапускает упавшие узлы без потери прогресса.
- Аудируемость решений. Полная трассировка рассуждений каждого агента позволяет регуляторам и внутреннему комплаенсу проверять логику принятия решений.
- Масштабируемость. AgentCore работает на инфраструктуре AWS - при росте нагрузки достаточно увеличить ресурсы, без переписывания кода агентов.
- Гибкость маршрутизации. Граф состояний LangGraph позволяет менять логику workflow без изменения кода агентов - достаточно переопределить ребра и условия переходов.
Другие сценарии применения выходят далеко за пределы финансов. Логистика: агенты мониторят цепочки поставок, оценивают риски задержек и автоматически перестраивают маршруты. Кибербезопасность: агенты анализируют поток событий, коррелируют инциденты и эскалируют подтвержденные угрозы. Промышленный IoT: агенты следят за состоянием оборудования, прогнозируют отказы и инициируют профилактическое обслуживание. Корпоративная AI-архитектура на базе графовых оркестраторов становится стандартом для таких решений.
Ограничения тоже есть. Начальная настройка требует глубокого понимания как предметной области, так и архитектуры агентов. Проектирование графа состояний - нетривиальная задача: нужно предусмотреть все возможные переходы, определить условия маршрутизации, настроить обработку граничных случаев. Инфраструктура AWS добавляет операционные расходы - команде нужны компетенции в облачных сервисах. Для небольших проектов такая связка может быть избыточной, и стоит рассмотреть более легковесные альтернативы.
Сравнение с альтернативами и лучшие практики внедрения
LangGraph + Strands - не единственный способ построить многоагентную систему. Чистый LangChain дает базовую оркестрацию через цепочки, но не предоставляет ни графа состояний, ни checkpointing. При сбое цепочка падает целиком, и восстановление нужно писать вручную. AutoGen от Microsoft делает ставку на разговоры между агентами - удобно для прототипирования, но в production возникают проблемы с детерминизмом и отладкой. CrewAI предлагает ролевую модель с делегированием задач - хорошо для креативных сценариев, слабо для жестких enterprise-требований.
LangGraph выигрывает в сценариях, где важны предсказуемость и отказоустойчивость. Граф состояний дает полный контроль над потоком выполнения, а checkpointing - автоматическое восстановление. Strands добавляет интеллектуальную гибкость туда, где она нужна - внутрь агентов, не размывая детерминизм всего workflow. Открытые агентные системы вроде Deep Agents от LangChain идут еще дальше, предоставляя полный контроль над агентами через открытую архитектуру с изолированными песочницами.
Практические рекомендации для внедрения:
- Начинайте с малого. Разверните двух агентов с простым графом из трех узлов. Отладьте checkpointing и восстановление. Только потом добавляйте сложную маршрутизацию и новых агентов.
- Проектируйте граф от состояний, а не от процессов. Определите, какие данные передаются между агентами, и только потом - как они передаются. Состояние графа - это контракт между узлами, меняйте его осторожно.
- Используйте встроенную память AgentCore. Не создавайте отдельную базу для хранения контекста между запусками. Встроенная память AgentCore интегрирована с checkpointing и не требует дополнительного кода синхронизации.
- Тестируйте рассуждения агентов изолированно. Прежде чем подключать агента к графу, проверьте его на наборе сценариев с разными входными данными. Strands позволяет запускать агента в офлайн-режиме с замоканными инструментами.
- Настройте алерты на основе метрик AgentCore. Рост latency на узле графа, увеличение частоты перезапусков, аномальный расход токенов - эти сигналы позволяют обнаружить деградацию до того, как она станет заметна пользователям.
Типовые ошибки, которых стоит избегать:
- Переусложнение графа. Десятки узлов с каскадными условными переходами становятся неотлаживаемыми. Если граф не помещается на одном экране - делите на подграфы.
- Игнорирование таймаутов. Вызов LLM может занять и 2 секунды, и 20. Без таймаутов и повторных попыток агент зависнет, а граф не получит управление обратно. Strands и AgentCore позволяют настроить таймауты на уровне агента и графа.
- Недостаточное логирование рассуждений. Если агент принял неверное решение, без полной трассировки рассуждений вы не поймете причину. Включайте максимальный уровень observability в AgentCore на этапе разработки и первых месяцев эксплуатации.
- Хранение секретов в коде агентов. API-ключи и учетные данные должны передаваться через переменные окружения или Secrets Manager, а не хардкодиться в определении инструментов Strands. Архитектура самописного агента требует такого же внимания к безопасности, как и любое production-приложение.