AutoGen Agents

.NET agent implementations and specialized components

Pre-built agent implementations and specialized components for common use cases.

AI Agents

InferenceAgent<T>

Base class for agents using Microsoft.Extensions.AI for chat completion.

using Microsoft.AutoGen.Agents;
using Microsoft.AutoGen.Contracts;
using Microsoft.AutoGen.Core;
using Microsoft.Extensions.AI;

public class MyAIAgent : InferenceAgent<MyMessage>
{
    public MyAIAgent(
        AgentId id,
        IAgentRuntime runtime,
        string name,
        ILogger<InferenceAgent<MyMessage>>? logger,
        IChatClient client)
        : base(id, runtime, name, logger, client)
    {
    }

    public async Task<ChatResponse> GenerateResponseAsync(
        IList<ChatMessage> messages,
        ChatOptions? options = null)
    {
        return await ChatClient.GetResponseAsync(messages, options);
    }
}

T · type parameter · required

Message type (must implement IMessage)

id · AgentId · required

Agent identifier

runtime · IAgentRuntime · required

Runtime environment

name · string · required

Agent name

logger · ILogger?

Optional logger

client · IChatClient · required

Chat client from Microsoft.Extensions.AI

Properties

ChatClient · IChatClient

Gets the chat client for inference

Methods

CompleteAsync · Task<ChatResponse>

Generate a chat completion

var response = await CompleteAsync(
    chatMessages: messages,
    options: new ChatOptions
    {
        Temperature = 0.7f,
        MaxTokens = 1000
    }
);

chatMessages · IList<ChatMessage> · required

Conversation messages

options · ChatOptions?

Generation options

cancellationToken · CancellationToken

Cancellation token

CompleteStreamingAsync · IAsyncEnumerable<ChatResponseUpdate>

Stream chat completion chunks

await foreach (var update in CompleteStreamingAsync(messages))
{
    Console.Write(update.Content);
}

I/O Agents

IProcessIO

Interface for process I/O operations.

using Microsoft.AutoGen.Agents;

public interface IProcessIO
{
    Task WriteAsync(string content);
    Task<string> ReadAsync();
}

WriteAsync · Task

Write content to output

content · string · required

Content to write

ReadAsync · Task<string>

Read input from user or process

IHandleConsole

Interface for console interaction agents.

using Microsoft.AutoGen.Agents;

public class ConsoleAgent : BaseAgent, IHandleConsole
{
    public async ValueTask HandleConsoleInputAsync(
        string input,
        MessageContext context)
    {
        // Process console input
        await WriteToConsoleAsync($"Received: {input}");
    }

    public async Task WriteToConsoleAsync(string message)
    {
        Console.WriteLine(message);
    }
}

IHandleFileIO

Interface for file I/O operations.

using Microsoft.AutoGen.Agents;

public class FileAgent : BaseAgent, IHandleFileIO
{
    public async ValueTask<string> ReadFileAsync(
        string filePath,
        MessageContext context)
    {
        return await File.ReadAllTextAsync(filePath);
    }

    public async ValueTask WriteFileAsync(
        string filePath,
        string content,
        MessageContext context)
    {
        await File.WriteAllTextAsync(filePath, content);
    }
}

ReadFileAsync · ValueTask<string>

Read file contents

filePath · string · required

Path to file

WriteFileAsync · ValueTask

Write content to file

filePath · string · required

Path to file

content · string · required

Content to write

Agent Chat (Teams)

TeamState

State management for agent teams.

using Microsoft.AutoGen.AgentChat;

public class TeamState
{
    public List<Message> History { get; set; } = new();
    public Dictionary<string, object> SharedContext { get; set; } = new();
    public string CurrentSpeaker { get; set; } = string.Empty;
}

History · List<Message>

Conversation history

SharedContext · Dictionary<string, object>

Shared context between agents

CurrentSpeaker · string

Current active agent

Termination Conditions

MaxMessageTermination

Terminate after maximum messages.

using Microsoft.AutoGen.AgentChat.Terminations;

var termination = new MaxMessageTermination(maxMessages: 20);

maxMessages · int · required

Maximum number of messages

TextMessageTermination

Terminate on specific text pattern.

var termination = new TextMessageTermination("TERMINATE");

pattern · string · required

Text pattern to match

TextMentionTermination

Terminate when text mentions specific content.

var termination = new TextMentionTermination("@done");

TimeoutTermination

Terminate after time limit.

var termination = new TimeoutTermination(
    timeout: TimeSpan.FromMinutes(5)
);

timeout · TimeSpan · required

Maximum execution time

TokenUsageTermination

Terminate after token budget.

var termination = new TokenUsageTermination(maxTokens: 10000);

maxTokens · int · required

Maximum tokens to consume

StopMessageTermination

Terminate on stop message.

var termination = new StopMessageTermination();

SourceMatchTermination

Terminate when message source matches.

var termination = new SourceMatchTermination("supervisor");

HandoffTermination

Terminate on agent handoff.

var termination = new HandoffTermination();

FunctionCallTermination

Terminate on specific function call.

var termination = new FunctionCallTermination("complete_task");

ExternalTermination

Terminate based on external signal.

var cts = new CancellationTokenSource();
var termination = new ExternalTermination(cts.Token);

// Trigger termination
cts.Cancel();

Agent Host

Host

Application host for running agent systems.

using Microsoft.AutoGen.AgentHost;

public class Program
{
    public static async Task Main(string[] args)
    {
        var builder = Host.CreateApplicationBuilder(args);

        // Configure services
        builder.Services.AddSingleton<IAgentRuntime, InProcessRuntime>();
        builder.Services.AddTransient<WorkerAgent>();

        var host = builder.Build();
        await host.RunAsync();
    }
}

Example: Complete AI Agent

using Microsoft.AutoGen.Agents;
using Microsoft.AutoGen.Contracts;
using Microsoft.AutoGen.Core;
using Microsoft.Extensions.AI;
using Microsoft.Extensions.Logging;
using Google.Protobuf;

public class TaskMessage : IMessage
{
    public string Content { get; set; } = string.Empty;
    // IMessage implementation...
}

public class AssistantAgent : InferenceAgent<TaskMessage>
{
    public AssistantAgent(
        AgentId id,
        IAgentRuntime runtime,
        IChatClient chatClient,
        ILogger<InferenceAgent<TaskMessage>> logger)
        : base(id, runtime, "Assistant", logger, chatClient)
    {
    }

    public async ValueTask<object?> HandleAsync(
        TaskMessage message,
        MessageContext context)
    {
        var messages = new List<ChatMessage>
        {
            new ChatMessage(ChatRole.System, "You are a helpful assistant."),
            new ChatMessage(ChatRole.User, message.Content)
        };

        var response = await ChatClient.GetResponseAsync(
            messages,
            new ChatOptions
            {
                Temperature = 0.7f,
                MaxTokens = 1000
            });

        return new TaskMessage { Content = response.Content };
    }
}

// Usage
var runtime = new InProcessRuntime();

await runtime.RegisterAgentFactoryAsync(
    new AgentType("assistant"),
    async (id, rt) => new AssistantAgent(
        id,
        rt,
        chatClient,
        logger)
);

var response = await runtime.SendMessageAsync(
    new TaskMessage { Content = "Write a poem" },
    new AgentId("assistant", "default")
);

See Also

• Microsoft.AutoGen.Core - Core runtime and contracts
• Microsoft.AutoGen.Extensions - Extensions and integrations