Orchestrating Intelligent Agents with Semantic Kernel and .NET 11

Active Task Execution

The industry is moving past bots that simply summarize data. Organizations need agents that reason, plan, and execute. This shift to active task execution is Agentic Orchestration.

Critical Blockers in Agentic Systems

Building autonomous AI that uses tools and makes decisions is difficult. Developers often face these challenges:

• Tool Call Hallucinations: The LLM suggests tools that don't exist or uses incorrect parameters.
• State Management: Tracking conversation context and tool outputs across multi-step workflows.
• Integration Complexity: Connecting modern LLMs to legacy ERP, CRM, or custom databases.
• Governance and Oversight: Preventing destructive actions without human approval.

Brittle prompt engineering and complex conditional logic often fail when the underlying model changes. A robust framework is required to manage this complexity.

Semantic Kernel and .NET 11

Semantic Kernel (SK) is the leading orchestrator for AI agents. With .NET 11, the ecosystem provides a stable foundation for enterprise deployment.

1. The AI Operating System

Semantic Kernel standardizes how agents interact with the world:

• Plugins: C# functions the agent can call. SK maps LLM intent to code execution.
• Agents: Specialized entities with distinct instructions and toolsets.
• Memory: Interfaces for vector databases to store and retrieve domain knowledge.

2. .NET 11 Foundations

The latest .NET release provides the primitives required for high-performance AI:

• Microsoft.Extensions.AI: A unified abstraction layer. You can swap models (OpenAI, Mistral, Llama) without changing business logic.
• Native AOT: Reduces startup times and memory footprint, which is essential for serverless environments like Azure Container Apps.
• Tensor Primitives: Hardware acceleration for vector operations, speeding up local RAG and Small Language Model (SLM) execution.

Multi-Agent Workflows

This example shows a specialized Inventory Agent using a custom plugin to check stock. It uses the latest .NET 11 patterns and Semantic Kernel abstractions.

using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Agents;
using Microsoft.SemanticKernel.ChatCompletion;
using Microsoft.Extensions.AI;

// 1. Initialize the Kernel with .NET 11's unified AI abstractions
var builder = Kernel.CreateBuilder();

// Use the new unified Microsoft.Extensions.AI abstractions
builder.AddAzureOpenAIChatCompletion(
    deploymentName: "gpt-5-preview",
    endpoint: "https://your-resource.openai.azure.com/",
    apiKey: "your-key"
);

// 2. Register business logic as a Plugin
// This allows the LLM to 'discover' and 'call' your C# code
builder.Plugins.AddFromType<InventoryPlugin>("InventoryService");

var kernel = builder.Build();

// 3. Define the specialized Inventory Agent
ChatCompletionAgent inventoryAgent = new()
{
    Name = "InventoryExpert",
    Instructions = "You are a logistics specialist. Use the InventoryService to check stock. " +
                   "Always provide specific numbers and professional recommendations.",
    Kernel = kernel,
    Arguments = new KernelArguments(new PromptExecutionSettings 
    { 
        // Automatic function calling tells the LLM it can use registered plugins
        FunctionChoiceBehavior = FunctionChoiceBehavior.Auto() 
    })
};

// 4. Execute the agentic workflow
ChatHistory history = new();
history.AddUserMessage("Check the stock for 'SolarController-X1' and tell me if I should reorder.");

await foreach (var message in inventoryAgent.InvokeAsync(history))
{
    Console.WriteLine($"[{message.AuthorName ?? message.Role.ToString()}] {message.Content}");
}

// --- Supporting Plugin ---
public class InventoryPlugin
{
    [KernelFunction]
    [Description("Gets current stock levels and lead times for a specific SKU")]
    public string GetStockStatus(string sku) 
    {
        // Real-world: This would call your ERP or SQL Database
        if (sku == "SolarController-X1")
            return "Current Stock: 12 units. Lead time: 14 days. Minimum threshold: 15 units.";
        
        return "SKU not found.";
    }
}

Managing Agentic Risks

Autonomous systems introduce specific risks that require mitigation:

• Recursion and Token Burn: Agents can enter infinite loops without explicit MaxIterations or cost-monitoring middleware.
• Security Boundaries: Destructive actions (deleting records, sending emails) must require human-in-the-loop approval.
• Nondeterministic Behavior: Probabilistic tool selection makes unit testing difficult. Robust telemetry is required to track every decision step.
• Indirect Prompt Injection: Untrusted user input can manipulate tool parameters if not properly sanitized.

Active Agents

The transition from passive RAG to active agents is a fundamental shift in software development. By using Semantic Kernel on .NET 11, teams can build systems that reason and act on real-world business processes.