Multi-Agent | The .NET Blog

Шаблон Handoff: Когда Одного Агента Недостаточно

Emiliano Montesdeoca — Mon, 01 Jun 2026 00:00:00 +0000

В какой-то момент каждая мультиагентная система перерастает простой маршрутизатор. Первый признак — когда агент-специалист должен задать уточняющий вопрос или в середине хода понимает, что должен продолжить другой агент. Фиксированный пайплайн ломается в этот момент. Одноразовый маршрутизатор ломается в этот момент.

Именно для этой проблемы разработан шаблон оркестрации Handoff в Microsoft Agent Framework.

Как Работает Handoff

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

Три вещи делают это отличным от простого вызова агентами друг друга:

Единый транскрипт — принимающий агент видит полную историю разговора. Без начала с нуля.
Соблюдение топологии — агент может передавать управление только объявленным целям. Ошибки маршрутизации обнаруживаются при создании, не в продакшене.
Естественное завершение — когда активный агент заканчивает свой ход без вызова инструмента handoff, рабочий процесс уступает пользователю. Без опроса, без явных условий выхода.

Минимальный Пример

В .NET создание рабочего процесса handoff выглядит так:

using Microsoft.Agents.AI;
using Microsoft.Agents.AI.Workflows;

AIAgent triage = chatClient.AsAIAgent(
 instructions: "Route to the right specialist.",
 name: "Triage");

AIAgent billing = chatClient.AsAIAgent(
 instructions: "Handle billing questions.",
 name: "Billing");

AIAgent tech = chatClient.AsAIAgent(
 instructions: "Handle technical support.",
 name: "Tech");

var workflow = HandoffWorkflow.Create()
 .Add(triage, targets: [billing, tech])
 .Add(billing, targets: [triage])
 .Add(tech, targets: [triage, billing]);

Triage может отправлять к любому специалисту. Оба специалиста могут отправлять обратно к triage. Граф поддерживает ацикличность, но допускает обратные рёбра когда нужно (“нужно больше информации” → обратно к исследованию).

Когда Использовать Handoff (и Когда Не Стоит)

Handoff хорошо подходит когда:

Владение может меняться в середине разговора — агент может понять, что он не тот специалист
Обратные рёбра важны — может понадобиться вернуться к более раннему шагу без перезапуска
Решения о маршрутизации размыты — решение о передаче управления контекстуально и лучше принимается моделью, чем типизированными предикатами

Это не правильный выбор когда:

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

Обратные Рёбра и Human-in-the-Loop

Одна из интересных форм, которые Handoff позволяет — настоящие обратные рёбра. Агент может решить “у меня недостаточно информации” и вернуться к шагу исследования — не с жёстко закодированным циклом, а потому что модель решает, что это правильный ход.

Взаимодействия human-in-the-loop также естественно компонуются. Когда специалисту нужен ввод пользователя, рабочий процесс уступает пользователю через стандартный цикл хода, собирает ответ и возобновляется с полным контекстом. Агент никогда не потерял разговор.

Заключение

Handoff — один из тех шаблонов, который звучит просто, но позволяет много, как только вы его усвоите: децентрализованная маршрутизация, общий контекст, обеспечиваемая топология, естественное завершение. Это правильный следующий шаг, когда ваши агенты начинают говорить “на самом деле, это должен обработать кто-то другой.”

Прочитайте полное руководство в оригинальном посте: A Tour of the Handoff Orchestration Pattern

Создаём мультиагентные UI в реальном времени, которые не выглядят как чёрный ящик

Emiliano Montesdeoca — Fri, 10 Apr 2026 00:00:00 +0000

Этот пост был переведён автоматически. Оригинал можно прочитать здесь.

Вот в чём дело с мультиагентными системами: в демо они выглядят невероятно. Три агента передают друг другу работу, решают задачи, принимают решения. А потом ты пытаешься показать это реальным пользователям и… тишина. Крутящийся индикатор. Непонятно, какой агент чем занимается и почему система встала на паузу. Это не продукт — это проблема доверия.

Команда Microsoft Agent Framework только что опубликовала отличный walkthrough о том, как связать рабочие процессы MAF с AG-UI — открытым протоколом для потоковой передачи событий выполнения агентов на фронтенд через Server-Sent Events. И честно? Это именно тот мост, которого нам не хватало.

Почему это важно для .NET-разработчиков

Если вы строите приложения с ИИ, наверняка уже упирались в эту стену. Ваша серверная оркестрация работает отлично — агенты передают задачи друг другу, инструменты запускаются, решения принимаются. Но фронтенд понятия не имеет, что происходит за кулисами. AG-UI решает это, определяя стандартный протокол для потоковой передачи событий агентов (RUN_STARTED, STEP_STARTED, TOOL_CALL_*, TEXT_MESSAGE_*) напрямую в ваш UI-слой через SSE.

Демо — это рабочий процесс клиентской поддержки с тремя агентами: агент триажа маршрутизирует запросы, агент возвратов обрабатывает денежные вопросы, и агент заказов управляет заменами. У каждого агента свои инструменты, а топология передач определена явно — никакого «разберись из промпта».

Топология передач — настоящая звезда

Что зацепило мой взгляд — как HandoffBuilder позволяет объявить направленный граф маршрутизации между агентами:

builder = HandoffBuilder(
 name="ag_ui_handoff_workflow_demo",
 participants=[triage, refund, order],
 termination_condition=termination_condition,
)

(
 builder
 .add_handoff(triage, [refund], description="Refunds, damaged-item claims...")
 .add_handoff(triage, [order], description="Replacement, exchange...")
 .add_handoff(refund, [order], description="Replacement logistics needed after refund.")
 .add_handoff(order, [triage], description="After replacement/shipping tasks complete.")
)

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

Human-in-the-loop, который действительно работает

Демо показывает два паттерна прерываний, без которых не обойтись ни одному реальному агентному приложению:

Прерывания для одобрения инструментов — когда агент вызывает инструмент с approval_mode="always_require", рабочий процесс ставится на паузу и отправляет событие. Фронтенд рендерит модальное окно одобрения с названием инструмента и аргументами. Никаких циклов повторных попыток, сжигающих токены — просто чистый поток пауза-одобрение-возобновление.

Прерывания запроса информации — когда агенту нужно больше контекста от пользователя (например, ID заказа), он ставит на паузу и спрашивает. Фронтенд показывает вопрос, пользователь отвечает, и выполнение возобновляется с того же места, где остановилось.

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

Подключение удивительно простое

Интеграция между MAF и AG-UI — это один вызов функции:

from agent_framework.ag_ui import (
 AgentFrameworkWorkflow,
 add_agent_framework_fastapi_endpoint,
)

app = FastAPI()

demo_workflow = AgentFrameworkWorkflow(
 workflow_factory=lambda _thread_id: create_handoff_workflow(),
 name="ag_ui_handoff_workflow_demo",
)

add_agent_framework_fastapi_endpoint(
 app=app, agent=demo_workflow, path="/handoff_demo",
)

workflow_factory создаёт свежий рабочий процесс для каждого потока, так что каждый диалог получает изолированное состояние. Эндпоинт автоматически обрабатывает всю SSE-обвязку. Если вы уже используете FastAPI (или можете добавить его как лёгкий слой), это практически без трения.

Моё мнение

Для нас, .NET-разработчиков, немедленный вопрос: «Можно ли сделать это на C#?» Agent Framework доступен и для .NET, и для Python, а протокол AG-UI не зависит от языка (это просто SSE). Так что хотя конкретная демка использует Python и FastAPI, паттерн переносится напрямую. Вы можете настроить минимальный API ASP.NET Core с SSE-эндпоинтами, следуя той же схеме событий AG-UI.

Более важный вывод — мультиагентные UI становятся полноценной задачей первого класса, а не чем-то придуманным постфактум. Если вы строите что-либо, где агенты взаимодействуют с людьми — клиентская поддержка, рабочие процессы утверждения, обработка документов — эта комбинация оркестрации MAF и прозрачности AG-UI является паттерном, которому стоит следовать.

Подведём итоги

AG-UI + Microsoft Agent Framework даёт вам лучшее из обоих миров: надёжную мультиагентную оркестрацию на бэкенде и видимость в реальном времени на фронтенде. Больше никаких взаимодействий агентов как чёрный ящик.

Посмотрите полный walkthrough и репозиторий протокола AG-UI, чтобы погрузиться глубже.

Microsoft Agent Framework Достиг 1.0 — Вот Что Действительно Важно для .NET-Разработчиков

Emiliano Montesdeoca — Fri, 03 Apr 2026 00:00:00 +0000

Этот пост был переведён автоматически. Оригинальную версию можно найти здесь.

Если вы следили за путешествием Agent Framework с ранних дней Semantic Kernel и AutoGen, это событие значительное. Microsoft Agent Framework только что достиг версии 1.0 — готов к продакшену, стабильные API, обязательство долгосрочной поддержки. Он доступен и для .NET, и для Python, и действительно готов к реальным нагрузкам.

Давайте пробьёмся через шум анонса и сосредоточимся на том, что важно, если вы создаёте AI-приложения на .NET.

Коротко

Agent Framework 1.0 объединяет то, что раньше было Semantic Kernel и AutoGen, в единый SDK с открытым исходным кодом. Одна абстракция агента. Один движок оркестрации. Множество AI-провайдеров. Если вы метались между Semantic Kernel для корпоративных паттернов и AutoGen для исследовательских мульти-агентных рабочих процессов, можете остановиться. Теперь это единственный SDK.

Начать работу почти нечестно просто

Вот работающий агент на .NET:

// dotnet add package Microsoft.Agents.AI.OpenAI --prerelease
using Microsoft.Agents.AI;
using Microsoft.Agents.AI.Foundry;
using Azure.Identity;

var agent = new AIProjectClient(endpoint: "https://your-project.services.ai.azure.com")
 .GetResponsesClient("gpt-5.3")
 .AsAIAgent(
 name: "HaikuBot",
 instructions: "You are an upbeat assistant that writes beautifully."
 );

Console.WriteLine(await agent.RunAsync("Write a haiku about shipping 1.0."));

Вот и всё. Несколько строк — и у вас есть AI-агент, работающий через Azure Foundry. Эквивалент на Python столь же лаконичен. Добавляйте инструменты-функции, многоходовые диалоги и стриминг по мере необходимости — поверхность API масштабируется без странностей.

Мульти-агентная оркестрация — это серьёзно

Одиночные агенты подходят для демо, но продакшен-сценарии обычно требуют координации. Agent Framework 1.0 поставляется с проверенными в бою паттернами оркестрации прямо из Microsoft Research и AutoGen:

Последовательная — агенты обрабатывают по очереди (писатель → рецензент → редактор)
Параллельная — распределение по нескольким агентам параллельно, объединение результатов
Handoff — один агент делегирует другому на основе намерения
Групповой чат — несколько агентов обсуждают и сходятся к решению
Magentic-One — исследовательский мульти-агентный паттерн от MSR

Все поддерживают стриминг, чекпоинты, одобрения с участием человека и паузу/возобновление. Часть с чекпоинтами критически важна — долго работающие процессы переживают перезапуски. Для нас, .NET-разработчиков, строивших устойчивые рабочие процессы с Azure Functions, это знакомое ощущение.

Самые важные возможности

Вот мой список того, что стоит знать:

Middleware-хуки. Знаете, как ASP.NET Core имеет middleware-конвейеры? Тот же концепт, но для выполнения агентов. Перехватывайте каждый этап — добавляйте безопасность контента, логирование, политики соответствия — не трогая промпты агента. Именно так вы делаете агентов готовыми для enterprise.

Подключаемая память. История разговоров, персистентное key-value состояние, векторный поиск. Выбирайте бэкенд: Foundry Agent Service, Mem0, Redis, Neo4j или создайте свой. Память — это то, что превращает stateless-вызов LLM в агента, который действительно помнит контекст.

Декларативные YAML-агенты. Определяйте инструкции агента, инструменты, память и топологию оркестрации в версионируемых YAML-файлах. Загружайте и запускайте одним вызовом API. Это меняет правила игры для команд, которые хотят итерировать поведение агента без редеплоя кода.

Поддержка A2A и MCP. MCP (Model Context Protocol) позволяет агентам динамически обнаруживать и вызывать внешние инструменты. A2A (протокол Agent-to-Agent) обеспечивает кросс-рантайм взаимодействие — ваши .NET-агенты могут координироваться с агентами в других фреймворках. Поддержка A2A 1.0 появится в ближайшее время.

Превью-возможности, за которыми стоит следить

Некоторые возможности вышли в превью в 1.0 — функциональны, но API могут измениться:

DevUI — локальный отладчик в браузере для визуализации выполнения агента, потоков сообщений и вызовов инструментов в реальном времени. Представьте Application Insights, но для рассуждений агента.
GitHub Copilot SDK и Claude Code SDK — используйте Copilot или Claude как агентную обвязку прямо из кода оркестрации. Составляйте агента с возможностями программирования рядом с другими агентами в одном рабочем процессе.
Agent Harness — настраиваемый локальный рантайм, дающий агентам доступ к шеллу, файловой системе и циклам обмена сообщениями. Думайте о кодинг-агентах и паттернах автоматизации.
Skills — переиспользуемые пакеты доменных возможностей, дающие агентам структурированные способности из коробки.

Миграция с Semantic Kernel или AutoGen

Если у вас есть существующий код на Semantic Kernel или AutoGen, есть специальные помощники миграции, которые анализируют ваш код и генерируют пошаговые планы миграции. Руководство по миграции с Semantic Kernel и руководство по миграции с AutoGen проведут вас через всё.

Если вы были на RC-пакетах, обновление до 1.0 — это просто смена версии.

Подводя итог

Agent Framework 1.0 — это продакшен-веха, которую ждали корпоративные команды. Стабильные API, поддержка нескольких провайдеров, паттерны оркестрации, реально работающие в масштабе, и пути миграции как с Semantic Kernel, так и с AutoGen.

Фреймворк полностью открыт на GitHub, и вы можете начать прямо сейчас с dotnet add package Microsoft.Agents.AI. Посмотрите руководство по быстрому старту и примеры, чтобы попробовать на практике.

Если вы ждали сигнала «безопасно использовать в продакшене» — вот он.