Agent Framework | The .NET Blog

CodeAct w Agent Framework: Jak zmniejszyć opóźnienie agenta o połowę

Emiliano Montesdeoca — Sat, 25 Apr 2026 00:00:00 +0000

Ten post został przetłumaczony automatycznie. Aby zobaczyć oryginalną wersję, kliknij tutaj.

W każdym projekcie agentów przychodzi moment, gdy patrzysz na ślad i myślisz: „Dlaczego to tak długo trwa?" Model działa dobrze. Narzędzia działają. Ale jest siedem rund komunikacji, żeby uzyskać wynik, który można obliczyć za jednym razem.

To właśnie problem, który rozwiązuje CodeAct — a zespół Agent Framework właśnie wydał wsparcie alfa przez nowy pakiet agent-framework-hyperlight.

Czym jest CodeAct?

Wzorzec CodeAct jest elegancko prosty: zamiast dawać modelowi listę narzędzi do wywoływania jedno po drugim, dajesz mu jedno narzędzie execute_code i pozwalasz wyrazić cały plan jako krótki program w Pythonie.

Podejście	Czas	Tokeny
Tradycyjne	27,81s	6 890
CodeAct	13,23s	2 489
Poprawa	52,4%	63,9%

Bezpieczeństwo: Mikro-VM Hyperlight

Pakiet agent-framework-hyperlight używa mikro-VM Hyperlight. Każde wywołanie execute_code otrzymuje własną, świeżo utworzoną mikro-VM. Uruchomienie mierzone jest w milisekundach. Izolacja jest praktycznie bezpłatna.

Twoje narzędzia nadal działają na hoście. Kod kleju wygenerowany przez model działa w piaskownicy. To właściwy podział.

Minimalna konfiguracja

from agent_framework import Agent, tool
from agent_framework_hyperlight import HyperlightCodeActProvider

codeact = HyperlightCodeActProvider(
 tools=[get_weather],
 approval_mode="never_require",
)

agent = Agent(
 client=client,
 name="CodeActAgent",
 instructions="You are a helpful assistant.",
 context_providers=[codeact],
)

Kiedy używać CodeAct (a kiedy nie)

Używaj CodeAct, gdy:

Zadanie łączy wiele małych wywołań narzędzi (wyszukiwania, łączenia, obliczenia)
Ważne są opóźnienie i koszt tokenów
Potrzebujesz silnej izolacji dla kodu generowanego przez model

Zostań przy tradycyjnym wywołaniu narzędzi, gdy:

Agent robi tylko jedno lub dwa wywołania na turę
Każde wywołanie ma skutki uboczne wymagające indywidualnego zatwierdzenia
Opisy narzędzi są skąpe lub niejednoznaczne

Wypróbuj teraz

pip install agent-framework-hyperlight --pre

Przeczytaj pełny post na blogu Agent Framework.

Gdzie Twój Agent Pamięta Rzeczy? Praktyczny Przewodnik po Przechowywaniu Historii Czatu

Emiliano Montesdeoca — Sat, 25 Apr 2026 00:00:00 +0000

Ten post został automatycznie przetłumaczony. Aby zobaczyć oryginalną wersję, kliknij tutaj.

Budując agenta AI, większość energii poświęcasz na model, narzędzia i prompty. Pytanie gdzie żyje historia rozmowy wydaje się szczegółem implementacyjnym — ale jest jedną z najważniejszych decyzji architektonicznych, jakie podejmiesz.

Decyduje o tym, czy użytkownicy mogą rozgałęziać rozmowy, cofać odpowiedzi, wznawiać sesje po restarcie oraz czy Twoje dane kiedykolwiek opuszczają Twoją infrastrukturę. Zespół Agent Framework opublikował szczegółową analizę.

Dwa podstawowe wzorce

Zarządzane przez usługę: usługa AI przechowuje stan rozmowy. Twoja aplikacja trzyma referencję, a usługa automatycznie dołącza odpowiednią historię do każdego żądania.

Zarządzane przez klienta: Twoja aplikacja utrzymuje pełną historię i wysyła odpowiednie wiadomości z każdym żądaniem. Usługa jest bezstanowa. Kontrolujesz wszystko.

Jak Agent Framework to abstrahuje

AgentSession session = await agent.CreateSessionAsync();
var first = await agent.RunAsync("Mam na imię Alice.", session);
var second = await agent.RunAsync("Jak mam na imię?", session);

session = agent.create_session()
first = await agent.run("Mam na imię Alice.", session=session)
second = await agent.run("Jak mam na imię?", session=session)

Szybki przegląd dostawców

Dostawca	Przechowywanie	Model	Kompaktowanie
OpenAI/Azure Chat Completions	Klient	N/A	Ty
Foundry Agent Service	Usługa	Liniowy	Usługa
Responses API (domyślnie)	Usługa	Rozgałęziający	Usługa
Anthropic Claude, Ollama	Klient	N/A	Ty

Jak wybrać

Potrzebujesz rozgałęzień lub „cofnij"? → Responses API zarządzane przez usługę
Potrzebujesz suwerenności danych? → Zarządzane przez klienta z backendem DB
Prosty chatbot? → Liniowe zarządzane przez usługę wystarczy

Przeczytaj pełny post po kompletne drzewo decyzyjne.

GPT-5.5 Jest Tutaj i Trafia do Azure Foundry — Co Muszą Wiedzieć Deweloperzy .NET

Emiliano Montesdeoca — Sat, 25 Apr 2026 00:00:00 +0000

Ten post został automatycznie przetłumaczony. Aby zobaczyć oryginalną wersję, kliknij tutaj.

Microsoft właśnie ogłosił, że GPT-5.5 jest ogólnie dostępny w Microsoft Foundry. Jeśli budujesz agentów na Azure, to jest aktualizacja, na którą czekałeś.

Ewolucja GPT-5

GPT-5: połączył rozumowanie i szybkość w jednym systemie
GPT-5.4: silniejsze rozumowanie wieloetapowe, wczesne możliwości agentyczne dla enterprise
GPT-5.5: głębsze rozumowanie w długim kontekście, bardziej niezawodne wykonanie agentyczne, lepsza wydajność tokenów

Co naprawdę się zmieniło

Ulepszone kodowanie agentyczne: GPT-5.5 utrzymuje kontekst w dużych bazach kodu, diagnozuje awarie architektoniczne i przewiduje wymagania testowe. Model rozumuje, na co jeszcze wpływa poprawka, zanim zadziała.

Wydajność tokenów: Wyższa jakość danych wyjściowych przy mniejszej liczbie tokenów i mniej prób. Bezpośrednio obniżone koszty i opóźnienia w produkcji.

Cennik

Model	Wejście ($/M tokenów)	Pamięć podręczna	Wyjście ($/M tokenów)
GPT-5.5	$5,00	$0,50	$30,00
GPT-5.5 Pro	$30,00	$3,00	$180,00

Dlaczego Foundry jest ważny

Foundry Agent Service umożliwia definiowanie agentów w YAML lub połączenie ich z Microsoft Agent Framework, GitHub Copilot SDK, LangGraph lub OpenAI Agents SDK — i uruchamianie ich jako izolowanych hostowanych agentów z trwałym systemem plików, tożsamością Microsoft Entra i cenami scale-to-zero.

AIAgent agent = aiProjectClient
 .AsAIAgent("gpt-5.5", instructions: "Jesteś pomocnym asystentem.", name: "MójAgent");

Sprawdź pełne ogłoszenie.

Umiejętności agentów w .NET stały się naprawdę elastyczne

Emiliano Montesdeoca — Tue, 14 Apr 2026 00:00:00 +0000

Ten post został automatycznie przetłumaczony. Aby przejść do oryginału, kliknij tutaj.

Jeśli budujesz agenty z Microsoft Agent Framework, znasz schemat: definiujesz umiejętności, podłączasz je do dostawcy i pozwalasz agentowi zdecydować, którą wywołać. Co nowego to sposób tworzenia tych umiejętności — a skok elastyczności jest znaczący.

Najnowsza aktualizacja wprowadza trzy odmienne wzorce tworzenia umiejętności agentów: oparty na plikach, oparty na klasach i zdefiniowany w kodzie inline. Wszystkie trzy podłączają się do jednego AgentSkillsProviderBuilder, co oznacza, że możesz je mieszać i dopasowywać bez żadnej logiki routingu ani specjalnego kodu spinającego. Przeprowadzę cię przez każdy z nich i kiedy po który sięgać.

Umiejętności oparte na plikach: punkt startowy

Umiejętności oparte na plikach to dokładnie to, na co wskazuje nazwa — katalog na dysku z plikiem SKILL.md, opcjonalnymi skryptami i dokumentami referencyjnymi. Pomyśl o tym jako o najprostszym sposobie na danie agentowi nowych możliwości:

skills/
└── onboarding-guide/
├── SKILL.md
├── scripts/
│ └── check-provisioning.py
└── references/
└── onboarding-checklist.md

Metadane w SKILL.md deklarują nazwę i opis umiejętności, a sekcja instrukcji mówi agentowi, jak używać skryptów i referencji:

---
name: onboarding-guide
description: >-
 Walk new hires through their first-week setup checklist.
---

## Instructions

1. Ask for the employee's name and start date.
2. Run `scripts/check-provisioning.py` to verify accounts.
3. Walk through `references/onboarding-checklist.md`.
4. Follow up on incomplete items.

Następnie podłączasz to za pomocą SubprocessScriptRunner.RunAsync do wykonania skryptów:

var skillsProvider = new AgentSkillsProvider(
 Path.Combine(AppContext.BaseDirectory, "skills"),
 SubprocessScriptRunner.RunAsync);

AIAgent agent = new AzureOpenAIClient(new Uri(endpoint), new DefaultAzureCredential())
 .GetResponsesClient()
 .AsAIAgent(new ChatClientAgentOptions
 {
 Name = "HRAgent",
 ChatOptions = new() { Instructions = "You are a helpful HR assistant." },
 AIContextProviders = [skillsProvider],
 },
 model: deploymentName);

Agent automatycznie wykrywa umiejętność i wywołuje skrypt sprawdzania uprawnień, gdy jest to potrzebne. Czyste i proste.

Umiejętności oparte na klasach: dostarcz przez NuGet

Tu robi się interesująco dla zespołów. Umiejętności oparte na klasach dziedziczą z AgentClassSkill<T> i używają atrybutów takich jak [AgentSkillResource] i [AgentSkillScript], dzięki czemu framework odkrywa wszystko przez refleksję:

public sealed class BenefitsEnrollmentSkill : AgentClassSkill<BenefitsEnrollmentSkill>
{
 public override AgentSkillFrontmatter Frontmatter { get; } = new(
 "benefits-enrollment",
 "Enroll an employee in health, dental, or vision plans.");

 protected override string Instructions => """
 1. Read the available-plans resource.
 2. Confirm the plan the employee wants.
 3. Use the enroll script to complete enrollment.
 """;

 [AgentSkillResource("available-plans")]
 [Description("Plan options with monthly pricing.")]
 public string AvailablePlans => """
 ## Available Plans (2026)
 - Health: Basic HMO ($0/month), Premium PPO ($45/month)
 - Dental: Standard ($12/month), Enhanced ($25/month)
 - Vision: Basic ($8/month)
 """;

 [AgentSkillScript("enroll")]
 [Description("Enrolls employee in the specified benefit plan.")]
 private static string Enroll(string employeeId, string planCode)
 {
 bool success = HrClient.EnrollInPlan(employeeId, planCode);
 return JsonSerializer.Serialize(new { success, employeeId, planCode });
 }
}

Piękno polega na tym, że zespół może spakować to jako pakiet NuGet. Dodajesz go do projektu, wrzucasz do buildera i działa obok umiejętności opartych na plikach bez żadnej koordynacji:

var skillsProvider = new AgentSkillsProviderBuilder()
 .UseFileSkill(Path.Combine(AppContext.BaseDirectory, "skills"))
 .UseSkill(new BenefitsEnrollmentSkill())
 .UseFileScriptRunner(SubprocessScriptRunner.RunAsync)
 .Build();

Obie umiejętności pojawiają się w prompcie systemowym agenta. Agent decyduje, którą użyć na podstawie rozmowy — bez kodu routingu.

Umiejętności inline: szybki pomost

Znasz ten moment, gdy inny zespół buduje dokładnie tę umiejętność, której potrzebujesz, ale nie wyda jej przez sprint? AgentInlineSkill to twój pomost:

var timeOffSkill = new AgentInlineSkill(
 name: "time-off-balance",
 description: "Calculate remaining vacation and sick days.",
 instructions: """
 1. Ask for the employee ID if not provided.
 2. Use calculate-balance to get the remaining balance.
 3. Present used and remaining days clearly.
 """)
 .AddScript("calculate-balance", (string employeeId, string leaveType) =>
 {
 int totalDays = HrDatabase.GetAnnualAllowance(employeeId, leaveType);
 int daysUsed = HrDatabase.GetDaysUsed(employeeId, leaveType);
 int remaining = totalDays - daysUsed;
 return JsonSerializer.Serialize(new { employeeId, leaveType, totalDays, daysUsed, remaining });
 });

Dodajesz ją do buildera tak samo jak pozostałe:

var skillsProvider = new AgentSkillsProviderBuilder()
 .UseFileSkill(Path.Combine(AppContext.BaseDirectory, "skills"))
 .UseSkill(new BenefitsEnrollmentSkill())
 .UseSkill(timeOffSkill)
 .UseFileScriptRunner(SubprocessScriptRunner.RunAsync)
 .Build();

Gdy pakiet NuGet w końcu się pojawi, wymieniasz umiejętność inline na opartą na klasach. Agent nie zna różnicy.

Ale umiejętności inline nie są tylko dla pomostów. Są też właściwym wyborem, gdy musisz dynamicznie generować umiejętności w czasie działania — pomyśl jedna umiejętność na jednostkę biznesową ładowaną z konfiguracji — albo gdy skrypt musi zamykać się na lokalnym stanie, który nie należy do kontenera DI.

Zatwierdzanie skryptów: człowiek w pętli

Dla nas, programistów .NET, budujących agenty produkcyjne, to jest część, która naprawdę odblokowuje rozmowy o wdrożeniu. Niektóre skrypty mają realne konsekwencje — rejestrowanie kogoś w świadczeniach, zapytania do infrastruktury produkcyjnej. Włącz UseScriptApproval i agent wstrzymuje się przed wykonaniem jakiegokolwiek skryptu:

var skillsProvider = new AgentSkillsProviderBuilder()
 .UseFileSkill(Path.Combine(AppContext.BaseDirectory, "skills"))
 .UseSkill(new BenefitsEnrollmentSkill())
 .UseSkill(timeOffSkill)
 .UseFileScriptRunner(SubprocessScriptRunner.RunAsync)
 .UseScriptApproval(true)
 .Build();

Gdy agent chce uruchomić skrypt, zamiast tego zwraca żądanie zatwierdzenia. Twoja aplikacja zbiera decyzję — zatwierdź lub odrzuć — i agent kontynuuje odpowiednio. W regulowanych środowiskach to jest różnica między “możemy to wdrożyć” a “dział prawny mówi nie”.

Dlaczego ta kombinacja ma znaczenie

Prawdziwa moc nie leży w żadnym pojedynczym wzorcu tworzenia — to w kompozycji. Możesz:

Zacząć mało z umiejętnością opartą na plikach, iterować instrukcje i dostarczyć bez pisania C#
Dostarczać umiejętności wielokrotnego użytku jako pakiety NuGet, które inne zespoły mogą dodać jedną linijką
Pomost luk z umiejętnościami inline, gdy potrzebujesz czegoś teraz
Filtrować współdzielone katalogi umiejętności za pomocą predykatów, by agent ładował tylko to, co powinien
Dodawać nadzór ludzki dla skryptów dotykających systemów produkcyjnych

Wszystko to komponuje się przez AgentSkillsProviderBuilder. Żadnego specjalnego routingu, żadnej logiki warunkowej, żadnych sprawdzeń typów umiejętności.

Podsumowanie

Umiejętności agentów w .NET mają teraz naprawdę elastyczny model tworzenia. Czy jesteś samotnym programistą szkicującym prototyp z umiejętnościami opartymi na plikach, czy zespołem enterprise dostarczającym spakowane możliwości przez NuGet — wzorce się dopasowują. A mechanizm zatwierdzania skryptów sprawia, że jest gotowe do produkcji dla środowisk, gdzie potrzebujesz tego ludzkiego punktu kontrolnego.

Sprawdź oryginalne ogłoszenie po pełny przewodnik, dokumentację Agent Skills na Microsoft Learn i przykłady .NET na GitHub, by zacząć pracę.

Tworzenie interfejsów użytkownika dla multi-agentowych systemów w czasie rzeczywistym — bez efektu czarnej skrzynki

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

Ten post został automatycznie przetłumaczony. Aby przejść do oryginału, kliknij tutaj.

Oto rzecz o systemach wieloagentowych: w demonstracjach wyglądają niesamowicie. Trzy agenty przekazują sobie pracę, rozwiązują problemy, podejmują decyzje. Potem próbujesz pokazać to prawdziwym użytkownikom i… cisza. Kręcący się wskaźnik. Nikt nie wie, który agent co robi ani dlaczego system jest wstrzymany. To nie jest produkt — to problem zaufania.

Zespół Microsoft Agent Framework właśnie opublikował świetny przewodnik dotyczący łączenia przepływów pracy MAF z AG-UI — otwartym protokołem do strumieniowania zdarzeń wykonania agentów do frontendu przez Server-Sent Events. I szczerze? To jest właśnie ten most, którego nam brakowało.

Dlaczego to ważne dla programistów .NET

Jeśli budujesz aplikacje oparte na AI, prawdopodobnie trafiłeś już na tę ścianę. Twoja orkiestracja backendowa działa świetnie — agenty przekazują sobie zadania, narzędzia się uruchamiają, decyzje są podejmowane. Ale frontend nie ma pojęcia, co dzieje się za kulisami. AG-UI rozwiązuje to, definiując standardowy protokół do strumieniowania zdarzeń agentów (takich jak RUN_STARTED, STEP_STARTED, TOOL_CALL_*, TEXT_MESSAGE_*) bezpośrednio do warstwy interfejsu przez SSE.

Demonstracja, którą zbudowali, to przepływ pracy obsługi klienta z trzema agentami: agent triaży kierujący żądaniami, agent zwrotów obsługujący pieniądze i agent zamówień zarządzający wymianami. Każdy agent ma własne narzędzia, a topologia przekazywania jest jawnie zdefiniowana — żadnego “wyczuj to z kontekstu prompta”.

Topologia przekazywania to prawdziwa gwiazda

Zwróciło moją uwagę to, jak HandoffBuilder pozwala zadeklarować skierowany graf routingu między agentami:

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.")
)

Każde add_handoff tworzy skierowaną krawędź z opisem w języku naturalnym. Framework generuje narzędzia przekazywania dla każdego agenta na podstawie tej topologii. Decyzje dotyczące routingu są zakorzenione w strukturze orkiestracji, a nie w tym, na co ma ochotę LLM. To ogromna rzecz dla niezawodności produkcji.

Człowiek w pętli, który naprawdę działa

Demonstracja prezentuje dwa wzorce przerwań, które są potrzebne w każdej prawdziwej aplikacji agentowej:

Przerwania zatwierdzania narzędzi — gdy agent wywołuje narzędzie oznaczone jako approval_mode="always_require", przepływ pracy wstrzymuje się i emituje zdarzenie. Frontend renderuje modal zatwierdzenia z nazwą narzędzia i argumentami. Żadnych pętli ponownych prób — tylko czysty przepływ wstrzymaj-zatwierdź-wznów.

Przerwania żądania informacji — gdy agent potrzebuje więcej kontekstu od użytkownika (jak numer zamówienia), wstrzymuje się i pyta. Frontend wyświetla pytanie, użytkownik odpowiada, a wykonanie wznawia się dokładnie tam, gdzie się zatrzymało.

Oba wzorce są strumieniowane jako standardowe zdarzenia AG-UI, więc frontend nie potrzebuje niestandardowej logiki dla każdego agenta — po prostu renderuje to, co przychodzi przez połączenie SSE.

Podłączenie jest zaskakująco proste

Integracja między MAF a AG-UI to jedno wywołanie funkcji:

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 tworzy nowy przepływ pracy dla każdego wątku, więc każda rozmowa otrzymuje izolowany stan. Endpoint automatycznie obsługuje całe “hydrauliczne” SSE. Jeśli już używasz FastAPI (lub możesz dodać go jako lekką warstwę), to właściwie zerowe tarcie.

Moje zdanie

Dla nas, programistów .NET, natychmiastowe pytanie brzmi: “Czy mogę to zrobić w C#?” Agent Framework jest dostępny zarówno dla .NET, jak i Python, a protokół AG-UI jest niezależny od języka (to po prostu SSE). Więc choć ta konkretna demonstracja używa Python i FastAPI, wzorzec przekłada się bezpośrednio. Możesz podpiąć minimalne API ASP.NET Core z endpointami SSE zgodnie z tym samym schematem zdarzeń AG-UI.

Ważniejszy wniosek: interfejsy użytkownika dla wielu agentów stają się pierwszoklasowym zagadnieniem, a nie przemyśleniem. Jeśli budujesz cokolwiek, gdzie agenty wchodzą w interakcje z ludźmi — obsługa klienta, przepływy zatwierdzeń, przetwarzanie dokumentów — ta kombinacja orkiestracji MAF i przejrzystości AG-UI to wzorzec do naśladowania.

Podsumowanie

AG-UI + Microsoft Agent Framework zapewnia to, co najlepsze z obu światów: solidną orkiestrację wieloagentową na backendzie i widoczność w czasie rzeczywistym na frontendzie. Koniec z interakcjami agentów jako czarną skrzynką.

Sprawdź pełny przewodnik i repozytorium protokołu AG-UI, by zagłębić się w temat.

Microsoft Agent Framework osiąga wersję 1.0 — co naprawdę ważne dla programistów .NET

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

Ten post został automatycznie przetłumaczony. Aby przejść do oryginału, kliknij tutaj.

Jeśli śledzisz historię Agent Framework od wczesnych dni Semantic Kernel i AutoGen, ta wiadomość jest znacząca. Microsoft Agent Framework właśnie osiągnął wersję 1.0 — gotowy do produkcji, stabilne API, zobowiązanie do długoterminowego wsparcia. Jest dostępny zarówno dla .NET, jak i Python i naprawdę gotowy na prawdziwe obciążenia.

Pominę hałas ogłoszenia i skupię się na tym, co ważne, jeśli budujesz aplikacje oparte na AI w .NET.

Krótka wersja

Agent Framework 1.0 łączy to, co kiedyś było Semantic Kernel i AutoGen, w jeden otwarty SDK. Jedna abstrakcja agenta. Jeden silnik orkiestracji. Wielu dostawców AI. Jeśli skakałeś między Semantic Kernel dla wzorców enterprise i AutoGen dla przepływów pracy wieloagentowych klasy badawczej, możesz przestać. To jest teraz jeden SDK.

Pierwsze kroki są niemal wstydliwie proste

Oto działający agent w .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."));

To wszystko. Kilka linii i masz agenta AI działającego przeciwko Azure Foundry. Odpowiednik w Python jest równie zwięzły. Dodawaj narzędzia funkcji, rozmowy wieloturowe i streaming w miarę potrzeb — powierzchnia API skaluje się bez dziwactw.

Orkiestracja wieloagentowa — to jest prawdziwa sprawa

Pojedynczy agent jest w porządku dla demonstracji, ale scenariusze produkcyjne zazwyczaj wymagają koordynacji. Agent Framework 1.0 dostarcza przetestowane w boju wzorce orkiestracji prosto z Microsoft Research i AutoGen:

Sekwencyjne — agenty przetwarzają po kolei (autor → recenzent → redaktor)
Współbieżne — rozgałęź do wielu agentów równolegle, zbierz wyniki
Przekazywanie — jeden agent deleguje do innego na podstawie intencji
Czat grupowy — wielu agentów dyskutuje i dochodzi do rozwiązania
Magentic-One — wzorzec wieloagentowy klasy badawczej z MSR

Wszystkie wspierają streaming, punkty kontrolne, zatwierdzenia przez człowieka w pętli oraz wstrzymanie/wznowienie. Część dotycząca punktów kontrolnych jest kluczowa — długo działające przepływy pracy przeżywają ponowne uruchomienie procesu. Dla nas, programistów .NET, którzy budowali trwałe przepływy pracy z Azure Functions, to brzmi znajomo.

Funkcje, które mają największe znaczenie

Oto moja lista tego, co warto znać:

Haki middleware. Wiesz, jak ASP.NET Core ma potoki middleware? Ten sam koncept, ale dla wykonania agenta. Przechwytuj każdy etap — dodawaj bezpieczeństwo treści, logowanie, zasady zgodności — bez dotykania promptów agenta. To właśnie sprawia, że agenty są gotowe na środowisko enterprise.

Podłączalna pamięć. Historia rozmów, trwały stan klucz-wartość, wyszukiwanie wektorowe. Wybierz backend: Foundry Agent Service, Mem0, Redis, Neo4j lub własny. Pamięć to właśnie to, co zmienia bezstanowe wywołanie LLM w agenta, który naprawdę zapamiętuje kontekst.

Deklaratywne agenty YAML. Zdefiniuj instrukcje, narzędzia, pamięć i topologię orkiestracji agenta w wersjonowanych plikach YAML. Ładuj i uruchamiaj jednym wywołaniem API. To zmienia zasady gry dla zespołów, które chcą iterować zachowanie agentów bez ponownego wdrażania kodu.

Wsparcie A2A i MCP. MCP (Model Context Protocol) pozwala agentom dynamicznie odkrywać i wywoływać zewnętrzne narzędzia. A2A (protokół Agent-to-Agent) umożliwia współpracę między różnymi środowiskami uruchomieniowymi — twoje agenty .NET mogą koordynować z agentami działającymi w innych frameworkach. Wsparcie A2A 1.0 pojawi się wkrótce.

Funkcje podglądowe warte obserwowania

Niektóre funkcje zostały dostarczone jako podgląd w 1.0 — działające, ale API może się ewoluować:

DevUI — lokalny debugger w przeglądarce do wizualizacji wykonania agenta, przepływów wiadomości i wywołań narzędzi w czasie rzeczywistym. Pomyśl Application Insights, ale dla rozumowania agenta.
GitHub Copilot SDK i Claude Code SDK — używaj Copilot lub Claude jako narzędzia agenta bezpośrednio z kodu orkiestracji. Skomponuj agenta zdolnego do kodowania obok innych agentów w tym samym przepływie pracy.
Agent Harness — konfigurowalne lokalne środowisko uruchomieniowe dające agentom dostęp do powłoki, systemu plików i pętli wiadomości. Pomyśl agenty kodujące i wzorce automatyzacji.
Skills — pakiety wielokrotnego użytku z możliwościami domeny, które od razu dają agentom ustrukturyzowane umiejętności.

Migracja z Semantic Kernel lub AutoGen

Jeśli masz istniejący kod Semantic Kernel lub AutoGen, dostępne są dedykowane asystenty migracji, które analizują kod i generują plany migracji krok po kroku. Przewodnik migracji z Semantic Kernel i przewodnik migracji z AutoGen prowadzą przez wszystko.

Jeśli korzystałeś z pakietów RC, uaktualnienie do 1.0 to tylko zmiana wersji.

Podsumowanie

Agent Framework 1.0 to kamień milowy produkcji, na który czekały zespoły enterprise. Stabilne API, wsparcie dla wielu dostawców, wzorce orkiestracji działające w skali i ścieżki migracji zarówno z Semantic Kernel, jak i AutoGen.

Framework jest w pełni open source na GitHub, a możesz zacząć już dziś z dotnet add package Microsoft.Agents.AI. Sprawdź przewodnik szybkiego startu i przykłady, by zabrać się do pracy.

Jeśli czekałeś na sygnał “bezpieczne do użycia w produkcji” — to jest właśnie ten moment.

Odpowiedzi w Tle w Microsoft Agent Framework: Koniec z Lękiem Przed Timeoutem

Emiliano Montesdeoca — Thu, 26 Mar 2026 00:00:00 +0000

Ten post został automatycznie przetłumaczony. Aby przejść do oryginału, kliknij tutaj.

Jeśli budowałeś cokolwiek z modelami rozumowania jak o3 lub GPT-5.2, znasz ten ból. Twój agent zaczyna przetwarzać złożone zadanie, klient czeka, a gdzieś między “to jest w porządku” a “czy to się zawiesiło?” połączenie przekracza czas.

Microsoft Agent Framework właśnie dostarczył odpowiedzi w tle — i szczerze mówiąc, to jedna z tych funkcji, która powinna istnieć od pierwszego dnia.

Problem z blokującymi wywołaniami

W tradycyjnym wzorcu żądanie-odpowiedź klient blokuje się do momentu zakończenia przez agenta. Odpowiedzi w tle odwracają to do góry nogami.

Jak działają tokeny kontynuacji

Zamiast blokować, uruchamiasz zadanie agenta i otrzymujesz z powrotem token kontynuacji. Pomyśl o tym jak o numerku w garderob. Przepływ jest prosty:

Wyślij żądanie z AllowBackgroundResponses = true
Jeśli agent obsługuje przetwarzanie w tle, otrzymujesz token kontynuacji
Odpytuj według harmonogramu, aż token wróci jako null

AgentRunOptions options = new()
{
 AllowBackgroundResponses = true
};

AgentSession session = await agent.CreateSessionAsync();
AgentResponse response = await agent.RunAsync(
 "Write a detailed market analysis for the Q4 product launch.", session, options);

while (response.ContinuationToken is not null)
{
 await Task.Delay(TimeSpan.FromSeconds(2));
 options.ContinuationToken = response.ContinuationToken;
 response = await agent.RunAsync(session, options);
}

Console.WriteLine(response.Text);

Kiedy faktycznie tego używać

Złożone zadania rozumowania — wieloetapowe analizy, głębokie badania
Długa generacja treści — szczegółowe raporty, wieloczęściowe dokumenty
Nierezualne sieci — klienci mobilni, wdrożenia brzegowe
Asynchroniczne wzorce UX — prześlij zadanie, zrób coś innego, wróć po wyniki

Sprawdź pełną dokumentację po kompletny opis API.