Diese Microsoft Agent Framework Anleitung zeigt dir, wie du in fünf Minuten einen lauffähigen KI‑Agenten in Python oder .NET startest. Du nutzt die stabile Release‑Candidate‑Version, erstellst einen Bot in wenigen Zeilen und lernst, zwei Agenten nacheinander zu orchestrieren – mit Streaming und Unterstützung für viele Modellanbieter. Microsoft hat das Agent Framework als Release Candidate für .NET und Python veröffentlicht. Das ist ein wichtiger Schritt hin zur allgemeinen Verfügbarkeit: Die API‑Oberfläche ist stabil, und alle Features für Version 1.0 sind komplett. Das Framework ist der Nachfolger von Semantic Kernel und AutoGen. Es vereint beide Ansätze in einem offenen, einheitlichen Programmiermodell für .NET und Python. In dieser Microsoft Agent Framework Anleitung bekommst du einen klaren Fahrplan: zuerst ein kleiner, hilfreicher Agent in wenigen Zeilen Code, dann ein einfacher Workflow mit zwei spezialisierten Agenten. Du siehst, wie das Framework moderne Orchestrierungsmuster, Streaming und die Anbindung an viele KI‑Dienste bündelt. So kannst du schnell vom ersten Test hin zu robusten Agentensystemen gehen.

Was ist Microsoft Agent Framework?

Microsoft Agent Framework ist ein umfassendes, quelloffenes Gerüst zum Erstellen, Orchestrieren und Bereitstellen von KI‑Agenten. Es baut auf einer gemeinsamen Basis für .NET und Python auf und bringt zentrale Funktionen mit, die in realen Anwendungen sofort helfen. Wichtige Eigenschaften:

• Einfache Agent‑Erstellung – du gehst in wenigen Zeilen von Null zu einem laufenden Agenten.
• Function Tools – Agenten können deinen Code als Tools mit typsicheren Definitionen aufrufen.
• Graph‑basierte Workflows – du komponierst Agenten und Funktionen zu Sequenzen, Parallel‑Schritten, Handoffs und Gruppen‑Chats; inklusive Streaming, Checkpointing und Human‑in‑the‑Loop.
• Multi‑Provider‑Support – funktioniert mit Microsoft Foundry, Azure OpenAI, OpenAI, GitHub Copilot, Anthropic Claude, AWS Bedrock, Ollama und mehr.
• Interoperabilität – unterstützt A2A (Agent‑to‑Agent), AG‑UI und MCP (Model Context Protocol).

Diese Basis schafft eine klare Trennung: Du beschreibst, was der Agent tun soll, und das Framework stellt die Verbindung zu Diensten und Orchestrierungen her. Weil die API jetzt als Release Candidate markiert ist, kannst du mit Stabilität planen und deinen Code auf 1.0 ausrichten.

Microsoft Agent Framework Anleitung: In 5 Minuten zum ersten Agenten

Du willst sofort loslegen? Unten siehst du je ein minimales Beispiel für Python und .NET. In beiden Fällen entsteht ein kleiner Assistent, der auf eine Benutzereingabe reagiert. Mit dieser Microsoft Agent Framework Anleitung richtest du in kurzer Zeit eine funktionsfähige Basis ein.

Python: Ein einfacher Agent

Die Python‑Variante nutzt Azure‑Anmeldeinformationen und erzeugt einen Agenten, der ein Haiku schreibt. Die Pakete stehen auf PyPI bereit.

import asyncio
from agent_framework.azure import AzureOpenAIResponsesClient
from azure.identity import AzureCliCredential


async def main():
 agent = AzureOpenAIResponsesClient(
 credential=AzureCliCredential(),
 ).as_agent(
 name="HaikuBot",
 instructions="You are an upbeat assistant that writes beautifully.",
 )

 print(await agent.run("Write a haiku about Microsoft Agent Framework."))

if __name__ == "__main__":
 asyncio.run(main())

Dieses Beispiel zeigt die Kernidee: Du instanziierst einen Client, wandelst ihn per as_agent in einen Agenten mit Namen und Anweisungen und rufst dann run mit einer Eingabe auf. Das Ergebnis ist eine natürliche Textantwort, die du direkt ausgibst.

.NET: Ein einfacher Agent

Für .NET fügst du zunächst die benötigten Pakete hinzu. Danach erstellst du einen Client, hängst ihn als Agent ein und rufst RunAsync auf. Ersetze im Code den Ressourcennamen und die Deployment‑Bezeichnung wie im Kommentar beschrieben.

dotnet add package Microsoft.Agents.AI.OpenAI --prerelease
dotnet add package Azure.Identity

using System.ClientModel.Primitives;
using Azure.Identity;
using Microsoft.Agents.AI;
using OpenAI;
using OpenAI.Responses;

// Replace <resource> and gpt-4.1 with your Azure OpenAI resource name and deployment name.
var agent = new OpenAIClient(
 new BearerTokenPolicy(new AzureCliCredential(), "https://ai.azure.com/.default"),
 new OpenAIClientOptions() { Endpoint = new Uri("https://<resource>.openai.azure.com/openai/v1") })
 .GetResponsesClient("gpt-4.1")
 .AsAIAgent(name: "HaikuBot", instructions: "You are an upbeat assistant that writes beautifully.");

Console.WriteLine(await agent.RunAsync("Write a haiku about Microsoft Agent Framework."));

Nach diesem Start kannst du schrittweise mehr hinzufügen: Function Tools, Sitzungen für Multi‑Turn‑Dialoge und Streaming‑Antworten. Das Grundprinzip bleibt gleich: Klare Instruktionen, ein konsistentes Agenten‑Objekt und ein einfacher Aufruf.

Mehrere Agenten orchestrieren

Ein einzelner Agent deckt viele Fälle ab. In echten Anwendungen brauchst du jedoch oft spezialisierte Rollen, die zusammenarbeiten. Das Framework bringt dafür eine Workflow‑Engine mit. Du kannst Agenten in Sequenzen, parallel oder als Handoffs kombinieren. Gruppen‑Chats sind ebenfalls möglich. Streaming ist integriert, damit du Fortschritte in Echtzeit siehst. Die Microsoft Agent Framework Anleitung zeigt auch, wie du einen kurzen, aber aussagekräftigen Workflow baust: Ein Writer verfasst einen Slogan, ein Reviewer gibt kurz Feedback. So entsteht ein Mini‑Prozess, der leicht erweiterbar ist.

Python‑Workflow: Writer → Reviewer

Installiere das Orchestrierungs‑Paket und nutze den SequentialBuilder. Das folgende Beispiel streamt Events, sammelt die Ausgaben und druckt die letzte Ausgabe mit Autorennamen.

pip install agent-framework-orchestrations --pre

import asyncio
from typing import cast

from agent_framework import Message
from agent_framework.azure import AzureOpenAIChatClient
from agent_framework.orchestrations import SequentialBuilder
from azure.identity import AzureCliCredential


async def main() -> None:
 client = AzureOpenAIChatClient(credential=AzureCliCredential())

 writer = client.as_agent(
 instructions="You are a concise copywriter. Provide a single, punchy marketing sentence based on the prompt.",
 name="writer",
 )

 reviewer = client.as_agent(
 instructions="You are a thoughtful reviewer. Give brief feedback on the previous assistant message.",
 name="reviewer",
 )

 # Build sequential workflow: writer -> reviewer
 workflow = SequentialBuilder(participants=[writer, reviewer]).build()

 # Run and collect outputs
 outputs: list[list[Message]] = []
 async for event in workflow.run("Write a tagline for a budget-friendly eBike.", stream=True):
 if event.type == "output":
 outputs.append(cast(list[Message], event.data))

 if outputs:
 for msg in outputs[-1]:
 name = msg.author_name or "user"
 print(f"[{name}]: {msg.text}")


if __name__ == "__main__":
 asyncio.run(main())

Du definierst zwei Agenten mit klaren Instruktionen und verknüpfst sie in einer Sequenz. Der Reviewer reagiert auf die vorherige Antwort. Das ist ein leichtes Muster, das du für mehrstufige Ketten ausbauen kannst.

.NET‑Workflow: Writer → Reviewer

Auch in .NET ist der Aufbau ähnlich. Du nutzt das Workflows‑Paket, erstellst zwei ChatClientAgent‑Instanzen und verbindest sie in einem Sequential‑Workflow. Der Stream liefert Live‑Updates.

dotnet add package Microsoft.Agents.AI.Workflows --prerelease

using System.ClientModel.Primitives;
using Azure.Identity;
using Microsoft.Agents.AI;
using Microsoft.Agents.AI.Workflows;
using Microsoft.Extensions.AI;
using OpenAI;

// Replace <resource> and gpt-4.1 with your Azure OpenAI resource name and deployment name.
var chatClient = new OpenAIClient(
 new BearerTokenPolicy(new AzureCliCredential(), "https://ai.azure.com/.default"),
 new OpenAIClientOptions() { Endpoint = new Uri("https://<resource>.openai.azure.com/openai/v1") })
 .GetChatClient("gpt-4.1")
 .AsIChatClient();

ChatClientAgent writer = new(chatClient,
 "You are a concise copywriter. Provide a single, punchy marketing sentence based on the prompt.",
 "writer");

ChatClientAgent reviewer = new(chatClient,
 "You are a thoughtful reviewer. Give brief feedback on the previous assistant message.",
 "reviewer");

// Build sequential workflow: writer -> reviewer
Workflow workflow = AgentWorkflowBuilder.BuildSequential(writer, reviewer);

List<ChatMessage> messages = [new(ChatRole.User, "Write a tagline for a budget-friendly eBike.")];

await using StreamingRun run = await InProcessExecution.StreamAsync(workflow, messages);

await run.TrySendMessageAsync(new TurnToken(emitEvents: true));
await foreach (WorkflowEvent evt in run.WatchStreamAsync())
{
 if (evt is AgentResponseUpdateEvent e)
 {
 Console.Write(e.Update.Text);
 }
}

So kombinierst du fokussierte Rollen in einem klaren Ablauf. Du kannst die Muster um parallele Schritte, Team‑Chats oder Handoffs erweitern. Checkpointing und Human‑in‑the‑Loop helfen, lange Prozesse stabil und nachvollziehbar zu halten.

Interoperabilität und Modellanbieter

Das Framework passt sich an deine Infrastruktur an. Du kannst zwischen Diensten wechseln oder mehrere Provider mischen. Die Interoperabilität macht es einfacher, bestehende Systeme einzubinden. Unterstützte Modell‑ und Dienstanbieter:

• Microsoft Foundry
• Azure OpenAI und OpenAI
• GitHub Copilot
• Anthropic Claude
• AWS Bedrock
• Ollama
• und weitere

Unterstützte Standards:

• A2A (Agent‑to‑Agent)
• AG‑UI
• MCP (Model Context Protocol)

Durch diese Standards sprechen Agenten und Tools eine gemeinsame Sprache. Das vereinfacht die Zusammenarbeit von Komponenten, auch wenn sie aus verschiedenen Quellen stammen.

Migration von Semantic Kernel und AutoGen

Wenn du bereits mit Semantic Kernel oder AutoGen gearbeitet hast, ist der Umstieg der logische nächste Schritt. Das Agent Framework vereint die Stärken beider Projekte in einem konsistenten Modell. Es gibt ausführliche Migrationsleitfäden, die dir beim Transfer helfen. So kannst du vorhandene Ideen und Muster schnell ins neue Framework bringen und davon profitieren, dass die Release‑Candidate‑API stabil ist.

Release Candidate heute, GA bald: Was bedeutet das?

Release Candidate heißt: Die API‑Fläche ist stabil, und die Features, die mit 1.0 ausgeliefert werden, sind vorhanden. Du kannst also jetzt starten und mit einer hohen Planungssicherheit entwickeln. Die nächste Stufe ist die allgemeine Verfügbarkeit (GA). Das Team bittet ausdrücklich um Feedback, damit die letzten Schritte zur 1.0 sitzen. Du kannst Rückmeldungen über GitHub‑Discussions geben oder dich auf Discord austauschen. Die offizielle Dokumentation liegt auf Microsoft Learn. Beispiele findest du im GitHub‑Repository. Die Pakete bekommst du über NuGet (.NET) und PyPI (Python). Der Weg von der Idee zur Lösung ist kurz:

• Starte mit einem kleinen Agenten in Python oder .NET.
• Füge Function Tools, Sitzungen und Streaming hinzu.
• Baue Workflows mit mehreren Agenten: sequenziell, parallel, Handoff oder Gruppen‑Chat.
• Nutze mehrere Modellanbieter und halte dir mit offenen Standards die Tür für Integrationen offen.

Zum Schluss noch ein praktischer Tipp: Halte die Instruktionen deiner Agenten präzise und kurz. Baue Rollen, die klar umrissene Aufgaben haben. So kannst du Workflows sauber komponieren und bekommst reproduzierbare Ergebnisse. Mit der stabilen Release‑Candidate‑API kannst du diese Bausteine jetzt belastbar einsetzen. Mit dieser Microsoft Agent Framework Anleitung hast du gesehen, wie du in wenigen Minuten einen Agenten anlegst und einen kleinen Workflow aufsetzt. Teste die Beispiele, probiere die Orchestrierungsmuster aus und gib Feedback auf GitHub oder Discord. So hilfst du mit, die 1.0‑Version zu finalisieren – und du kommst schneller zu robusten Agentensystemen, die auf vielen Diensten laufen.

(Source: https://devblogs.microsoft.com/foundry/microsoft-agent-framework-reaches-release-candidate/)

For more news: Click Here

FAQ