The Agentic AI Landscape: A C#/Azure Developer's Field Guide

Part 4 of the "From .NET to AI Engineer" series

The Shift That's Changing Everything

Building Glucoplate, I recently started thinking: "What if an AI agent could handle the entire meal logging workflow?" Not just recognize food from a photo—but check the pantry, suggest recipes based on expiring ingredients, log nutrition, and sync with health apps. All autonomously.

A year ago, that would have required months of custom code. Today, with Azure's agent services and the MCP protocol, it's becoming feasible for a solo developer to build.

We're living through the transition from AI-assisted development to AI-agentic development. Gartner projects that 40% of enterprise applications will embed AI agents by mid-2026, up from less than 5% in early 2025.

This isn't hype. I'm building toward it right now.

Understanding the Landscape

What Makes an Agent "Agentic"?

The term gets thrown around loosely. Here's my working definition:

Chatbot: Responds to queries, stateless, single-turn AI Assistant: Maintains context, can use tools, follows instructions AI Agent: Autonomous goal-pursuit, makes decisions, takes actions, handles failures

The key distinction: agents have agency. They don't just answer questions—they work toward objectives.

Traditional: User asks → AI responds → User acts
Agentic:     User sets goal → Agent plans → Agent acts → Agent validates → Agent reports

The Microsoft Stack (2026)

Microsoft has consolidated their AI offerings. Here's the current landscape:

┌─────────────────────────────────────────────────────────────┐
│                    Microsoft Foundry                         │
│              (formerly Azure AI Foundry)                     │
├─────────────────────────────────────────────────────────────┤
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐      │
│  │ Azure OpenAI │  │  Azure AI    │  │   Foundry    │      │
│  │   Service    │  │   Search     │  │      IQ      │      │
│  └──────────────┘  └──────────────┘  └──────────────┘      │
│                                                              │
│  ┌──────────────────────────────────────────────────────┐  │
│  │           Microsoft Agent Framework                    │  │
│  │  ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐    │  │
│  │  │AutoGen  │ │Semantic │ │ Agent   │ │ A2A     │    │  │
│  │  │         │ │ Kernel  │ │ Service │ │Protocol │    │  │
│  │  └─────────┘ └─────────┘ └─────────┘ └─────────┘    │  │
│  └──────────────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────────────┘

Let me break down what matters for .NET developers:

Microsoft Foundry (Azure AI Foundry Rebranded)

Microsoft Foundry is the unified platform for building AI applications. Think of it as the "IDE" for AI development on Azure.

Key Capabilities:

• Model Catalog: Access to OpenAI, Llama, Mistral, and other models
• Prompt Flow: Visual orchestration for AI workflows
• Evaluations: Built-in testing for AI quality and safety
• Deployments: One-click deployment to Azure endpoints
• Foundry IQ: Enterprise data integration (SharePoint, OneLake, ADLS)

For .NET developers, the SDK integration is seamless:

using Azure.AI.Projects;

var client = new AIProjectClient(
    connectionString,
    new DefaultAzureCredential());

// Create an agent
var agent = await client.CreateAgentAsync(
    model: "gpt-4o",
    name: "support-agent",
    instructions: "You are a helpful customer support agent...",
    tools: new List<ToolDefinition>
    {
        new FunctionToolDefinition("search_knowledge_base", ...),
        new FunctionToolDefinition("create_ticket", ...),
        new FunctionToolDefinition("escalate_to_human", ...)
    });

// Run the agent
var thread = await client.CreateThreadAsync();
await client.CreateMessageAsync(thread.Id, "I can't reset my password");
var run = await client.CreateRunAsync(thread.Id, agent.Id);

Microsoft Agent Framework

The Microsoft Agent Framework (public preview) is the most significant development for .NET agent builders.

It unifies:

• AutoGen: Microsoft Research's multi-agent framework
• Semantic Kernel: The .NET SDK for AI orchestration
• Agent2Agent (A2A): Cross-runtime agent collaboration

Building Agents with Semantic Kernel

If you're a .NET developer, Semantic Kernel is your primary tool:

using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Agents;

// Define the kernel with plugins
var kernel = Kernel.CreateBuilder()
    .AddAzureOpenAIChatCompletion(deployment, endpoint, key)
    .Build();

kernel.ImportPluginFromType<EmailPlugin>();
kernel.ImportPluginFromType<CalendarPlugin>();
kernel.ImportPluginFromType<DatabasePlugin>();

// Create an agent
var agent = new ChatCompletionAgent
{
    Kernel = kernel,
    Name = "SchedulingAssistant",
    Instructions = @"
        You are a scheduling assistant. You can:
        - Query available meeting times
        - Send meeting invitations
        - Check conflicts
        - Reschedule meetings
        Always confirm before taking actions."
};

// Agent execution with automatic tool calling
var response = await agent.InvokeAsync(
    "Schedule a 1-hour meeting with the engineering team next Tuesday");

Multi-Agent Orchestration

The real power comes from combining agents:

// Define specialized agents
var researchAgent = new ChatCompletionAgent
{
    Name = "Researcher",
    Instructions = "You research topics and gather information..."
};

var writerAgent = new ChatCompletionAgent
{
    Name = "Writer",
    Instructions = "You write clear, engaging content..."
};

var reviewerAgent = new ChatCompletionAgent
{
    Name = "Reviewer",
    Instructions = "You review content for accuracy and quality..."
};

// Create a group chat for collaboration
var groupChat = new AgentGroupChat(researchAgent, writerAgent, reviewerAgent)
{
    ExecutionSettings = new()
    {
        TerminationStrategy = new MaxIterationTerminationStrategy(10),
        SelectionStrategy = new RoundRobinSelectionStrategy()
    }
};

// Run the multi-agent workflow
await foreach (var message in groupChat.InvokeAsync(
    "Write a technical blog post about MCP servers"))
{
    Console.WriteLine($"{message.AuthorName}: {message.Content}");
}

Foundry IQ: Enterprise Data Access

One of the biggest challenges in enterprise AI is data access. Foundry IQ solves this:

• Unified data layer across SharePoint, OneLake, ADLS, and web
• Governed by Purview: Respects existing data permissions
• No data movement: Queries in place, doesn't copy data

This means your agents can safely access enterprise data without complex ETL pipelines.

Azure AI Agent Service

For production deployment, Azure AI Agent Service provides:

• Managed hosting for agents
• Built-in durability for long-running tasks
• Observability and tracing
• Compliance controls

Tens of thousands of organizations are using it since public preview in late 2024.

Real-World Architecture: Support Ticket Agent

Here's an architecture I'm currently implementing:

┌─────────────────────────────────────────────────────────────┐
│                    Azure API Management                      │
└─────────────────────────┬───────────────────────────────────┘
                          │
┌─────────────────────────▼───────────────────────────────────┐
│               Azure AI Agent Service                         │
│  ┌─────────────────────────────────────────────────────┐   │
│  │              Support Orchestrator Agent               │   │
│  └─────────────────────────────────────────────────────┘   │
│        │              │              │              │       │
│        ▼              ▼              ▼              ▼       │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐  │
│  │ Triage   │  │ Knowledge│  │  Ticket  │  │ Escalate │  │
│  │  Agent   │  │  Agent   │  │  Agent   │  │  Agent   │  │
│  └──────────┘  └──────────┘  └──────────┘  └──────────┘  │
└─────────────────────────────────────────────────────────────┘
        │              │              │              │
        ▼              ▼              ▼              ▼
  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐
  │ Sentiment│  │  Azure   │  │  Azure   │  │  Slack   │
  │ Analysis │  │ AI Search│  │  DevOps  │  │   API    │
  └──────────┘  └──────────┘  └──────────┘  └──────────┘

Flow:

1. Customer submits support request
2. Triage Agent analyzes urgency and category
3. Knowledge Agent searches for relevant documentation
4. If solvable: Respond with solution
5. If not: Ticket Agent creates work item
6. If urgent: Escalate Agent notifies on-call via Slack

Questions Worth Considering

As I've been learning about agentic AI, these are the questions that helped me understand the "why" behind the technology:

How would you design an AI agent for a specific task?

The framework I use:

1. Define the goal and success criteria
2. Identify required tools/capabilities
3. Determine if single or multi-agent
4. Address failure modes and escalation
5. Consider observability and compliance

What's the difference between AutoGen and Semantic Kernel?

• AutoGen: Research-focused, Python-first, complex multi-agent patterns
• Semantic Kernel: Production-focused, .NET-first, enterprise integration
• They're converging under Microsoft Agent Framework

How do you handle hallucinations in production agents?

This is critical for any real-world deployment:

1. RAG for grounding responses in real data
2. Confirmation steps before taking actions
3. Human-in-the-loop for high-stakes decisions
4. Comprehensive logging for audit trails
5. Confidence thresholds for automated responses

---

Key Takeaways

• Agentic AI is the next major shift—40% of enterprise apps will embed agents by mid-2026
• Microsoft Foundry + Agent Framework is the Azure stack for building agents
• Semantic Kernel is the primary .NET SDK for agent development
• Multi-agent systems are replacing monolithic AI applications
• Security, observability, and governance are critical concerns

---

Final post in the series: How I'm bridging my .NET/Azure experience into the AI engineer role—specific skills, learning paths, and career strategies.