Agentic AI: from chatbots to autonomous agents

AIAgent agent = chatClient.AsAIAgent(
    name: "CardAssistant",
    instructions: "You help customers with card issues. Ask before doing anything risky.",
    tools: [AIFunctionFactory.Create(GetCardStatus), AIFunctionFactory.Create(BlockCard)]);

AgentSession session = await agent.CreateSessionAsync();
Console.WriteLine(await agent.RunAsync("I lost my card in Bali", session));

Agent Framework is the successor to Semantic Kernel agents and AutoGen. Semantic Kernel still works, but start new agent work on Agent Framework.

public enum Route { Complaint, Faq, Fraud }
public sealed record Classification(Route Route);

// Routing workflow: the code decides the path, the LLM only classifies
var c = (await chat.GetResponseAsync<Classification>($"Classify this message: {message}")).Result;

string reply = c.Route switch
{
    Route.Fraud     => await EscalateToFraudTeamAsync(message),   // no LLM on the risky path
    Route.Complaint => (await complaintsAgent.RunAsync(message)).Text,
    _               => (await faqAgent.RunAsync(message)).Text
};

IChatClient chat = new ChatClientBuilder(inner)
    .UseFunctionInvocation(configure: f => f.MaximumIterationsPerRequest = 8)  // max steps
    .Build();

using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(60));          // max time
ChatResponse r = await chat.GetResponseAsync(goal,
    new ChatOptions { Tools = tools, MaxOutputTokens = 1_000 }, cts.Token);

public sealed class CardTools(ICardApi cards)
{
    [Description("Gets the status of a customer's card by its last 4 digits.")]
    public async Task<string> GetCardStatus([Description("Last 4 digits of the card")] string last4) =>
        last4.Length == 4 ? await cards.GetStatusAsync(last4) : "Error: last4 must be 4 digits";
}

IChatClient chat = new ChatClientBuilder(inner).UseFunctionInvocation().Build();
var cardTools = new CardTools(cardApi);

var options = new ChatOptions { Tools = [AIFunctionFactory.Create(cardTools.GetCardStatus)] };
ChatResponse reply = await chat.GetResponseAsync("Is my card ending 4821 blocked?", options);

The model only sees names, descriptions and parameter schemas, so write them for the model: clear verbs, narrow scope, few parameters.

// Short-term memory: keep the system prompt + the last 20 messages
IChatReducer reducer = new MessageCountingChatReducer(20);
List<ChatMessage> history = [new(ChatRole.System, systemPrompt)];

history.Add(new(ChatRole.User, userInput));
var trimmed = await reducer.ReduceAsync(history, ct);
ChatResponse r = await chat.GetResponseAsync(trimmed, options, ct);
history.AddMessages(r);

All in Microsoft.Agents.AI.Workflows. Tool approvals pause the workflow and surface as events.

AIAgent researcher = chat.AsAIAgent(name: "Researcher", instructions: "Find the relevant policy facts.");
AIAgent writer     = chat.AsAIAgent(name: "Writer",     instructions: "Draft a clear customer reply.");
AIAgent checker    = chat.AsAIAgent(name: "Checker",    instructions: "Check the reply against policy and tone.");

var workflow = AgentWorkflowBuilder.BuildSequential([researcher, writer, checker]);
// Run it with InProcessExecution and read the streamed WorkflowEvents

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddMcpServer()
    .WithHttpTransport()             // streamable HTTP
    .WithToolsFromAssembly();        // finds [McpServerTool] methods

var app = builder.Build();
app.MapMcp("/mcp");                  // add .RequireAuthorization() in real life
app.Run();

[McpServerToolType]
public static class CardTools
{
    [McpServerTool, Description("Gets the status of a card by its last 4 digits.")]
    public static string GetCardStatus(string last4) => $"Card ending {last4} is active.";
}

// Money movement needs a human "yes" before it runs
AITool transfer = new ApprovalRequiredAIFunction(AIFunctionFactory.Create(TransferMoney));
AIAgent agent = chat.AsAIAgent(instructions: "...", tools: [transfer]);

AgentResponse r = await agent.RunAsync("Pay $500 to John", session);
foreach (var request in r.Messages.SelectMany(m => m.Contents).OfType<ToolApprovalRequestContent>())
{
    bool ok = await AskUserAsync(request);      // show what will run, with the arguments
    r = await agent.RunAsync(new ChatMessage(ChatRole.User, [request.CreateResponse(ok)]), session);
}

ApprovalRequiredAIFunction only marks a tool. The agent runtime (Agent Framework) enforces it. If you call IChatClient directly, check approval in your own code. Azure AI Foundry guardrails can also apply Prompt Shields and content filters to a model deployment without code.

IChatClient chat = new ChatClientBuilder(inner)
    .UseFunctionInvocation()
    .UseOpenTelemetry(sourceName: "Bank.Agents")   // GenAI spans: chat, execute_tool, tokens
    .Build();

builder.Services.AddOpenTelemetry()
    .WithTracing(t => t.AddSource("Bank.Agents"))
    .WithMetrics(m => m.AddMeter("Bank.Agents"))
    .UseOtlpExporter();                            // Aspire dashboard / collector