What is Semantic Kernel in .NET and How to Build an AI Agent with C#

Artificial Intelligence is rapidly transforming how modern applications are built. Instead of just writing static logic, developers can now create intelligent systems that can understand, reason, and act. One of the most powerful tools for this in the .NET ecosystem is Semantic Kernel.

Semantic Kernel is an open-source SDK by Microsoft that helps developers integrate Large Language Models (LLMs) like OpenAI into their applications. It allows you to build AI agents that can perform tasks, automate workflows, and make decisions using natural language.

In this guide, we will understand what Semantic Kernel is, how it works, and how you can build your own AI agent using C# in a simple and practical way.

What is Semantic Kernel?

Semantic Kernel is a lightweight SDK that acts as a bridge between your C# application and AI models.

Instead of directly calling APIs again and again, Semantic Kernel provides a structured way to:

• Connect to AI models (OpenAI / Azure OpenAI)

• Create reusable AI functions (called skills or plugins)

• Combine AI + traditional code logic

• Build intelligent workflows

In simple words, Semantic Kernel helps you mix "AI thinking" with "normal programming logic."

Key Concepts of Semantic Kernel

To understand Semantic Kernel properly, you need to know a few core concepts.

1. Kernel

The Kernel is the central engine.

It manages:

• AI service connections

• Plugins (functions)

• Execution flow

Think of it as the brain of your AI application.

2. Plugins (Skills)

Plugins are reusable functions.

They can be:

• Native functions (written in C#)

• Semantic functions (prompt-based AI functions)

Example:

• Summarize text

• Translate language

• Generate email

3. Prompts

Prompts define how the AI should behave.

Example:

"Summarize this text in 3 lines"

Semantic Kernel allows you to manage prompts cleanly instead of hardcoding them everywhere.

4. Memory

Memory allows your AI agent to remember past interactions.

This is useful for:

• Chatbots

• Personalized recommendations

• Context-aware responses

5. Planner (AI Agent Brain)

Planner is what makes your app an AI agent.

It decides:

• What steps to take

• Which function to call

• In what order

This enables automation without hardcoding every step.

Why Use Semantic Kernel in .NET?

Here are some strong reasons:

• Clean architecture for AI integration

• Reusable AI components

• Supports OpenAI and Azure OpenAI

• Easy to combine with existing .NET apps

• Helps build AI agents instead of simple API calls

Step-by-Step: Build an AI Agent Using Semantic Kernel in C#

Now let’s build a simple AI agent step by step.

Step 1: Create a .NET Project

dotnet new console -n SemanticKernelDemo
cd SemanticKernelDemo

Step 2: Install Semantic Kernel Package

dotnet add package Microsoft.SemanticKernel

Step 3: Configure OpenAI or Azure OpenAI

Add your API key in appsettings.json:

{
  "OpenAI": {
    "ApiKey": "your-api-key",
    "Model": "gpt-4o-mini"
  }
}

Step 4: Initialize the Kernel

using Microsoft.SemanticKernel;

var builder = Kernel.CreateBuilder();

builder.AddOpenAIChatCompletion(
    modelId: "gpt-4o-mini",
    apiKey: "your-api-key"
);

var kernel = builder.Build();

This connects your application with the AI model.

Step 5: Create a Simple AI Function (Prompt-Based)

var prompt = "Summarize the following text in simple words: {{$input}}";

var summarizeFunction = kernel.CreateFunctionFromPrompt(prompt);

var result = await kernel.InvokeAsync(summarizeFunction, new()
{
    ["input"] = "Artificial Intelligence is transforming the world..."
});

Console.WriteLine(result);

This is your first semantic function.

Step 6: Create a Native Plugin (C# Function)

public class MathPlugin
{
    public int Add(int a, int b)
    {
        return a + b;
    }
}

Register it:

kernel.Plugins.AddFromType<MathPlugin>();

Now your AI agent can use real C# logic.

Step 7: Build an AI Agent with Planner

Planner allows the AI to decide actions automatically.

using Microsoft.SemanticKernel.Planning;

var planner = new FunctionCallingStepwisePlanner();

var goal = "Summarize a paragraph and then translate it into Hindi";

var plan = await planner.CreatePlanAsync(kernel, goal);

var result = await planner.ExecuteAsync(kernel, plan);

Console.WriteLine(result);

Now your system behaves like an AI agent instead of a simple function.

Step 8: Add Memory (Optional but Powerful)

builder.Services.AddSingleton<IMemoryStore, VolatileMemoryStore>();

Memory helps your agent remember previous conversations.

Step 9: Real-World Example: AI Assistant

Let’s combine everything.

Use case:

• User asks a question

• AI answers

• AI can summarize or translate

Console.WriteLine("Ask something:");
var input = Console.ReadLine();

var response = await kernel.InvokePromptAsync(input);

Console.WriteLine(response);

This creates a simple AI assistant.

Best Practices for Semantic Kernel

• Keep prompts clear and specific

• Avoid very long inputs (token limits)

• Use plugins for reusable logic

• Secure API keys using environment variables

• Add logging and error handling

Difference Between Traditional Code vs AI Agent

Feature	Traditional Code	AI Agent (Semantic Kernel)
Logic	Fixed	Dynamic
Decision Making	Manual	AI-driven
Flexibility	Low	High
Automation	Limited	Advanced

Real-World Use Cases

You can build:

• AI Chatbot

• Smart email generator

• Document summarizer

• Personal assistant

• Workflow automation system

Conclusion

Semantic Kernel is a powerful tool for .NET developers who want to build intelligent AI applications. Instead of writing complex logic manually, you can let AI handle reasoning and decision-making.

By combining prompts, plugins, memory, and planners, you can build full AI agents using C# in a clean and scalable way.

Start with small experiments, then gradually build advanced AI-powered systems that can automate real-world tasks efficiently.