What Is Semantic Kernel? The AI Agent Framework Behind AI-103 (2026 Guide)

Update (September 2026): AI-900 and AI-102 retired on June 30, 2026. Their replacements, AI-901 (Azure AI Fundamentals) and AI-103 (Azure AI App and Agent Developer Associate), are the current exams. For the current path, see the AI-103 Study Guide.

Semantic Kernel sits at the heart of Microsoft's modern AI agent stack, and it now powers a significant portion of the AI-103 exam. If you are preparing for AI-103 or building production agents on Azure AI Foundry, understanding Semantic Kernel is no longer optional, it is foundational.

This guide explains what Semantic Kernel is, how it relates to the new Microsoft Agent Framework, where it shows up in AI-103, and how to start using it without getting lost in marketing terminology.

Info

TL;DR: Semantic Kernel is Microsoft's open-source SDK for building AI agents and orchestrating LLM calls, plugins, planners, and memory. In 2026, it merged conceptually with the Microsoft Agent Framework, and it is the recommended SDK for building agents on Azure AI Foundry, the platform tested in AI-103.

What Semantic Kernel actually is

Semantic Kernel is an open-source SDK from Microsoft that lets you wire together large language models, your own functions (called "plugins" or "skills"), memory, and planners into a single agent. Think of it as the connective tissue between an LLM and the rest of your application code.

It is available in three languages:

• C# with the most mature feature surface
• Python which is at near parity with C#
• Java for enterprise JVM stacks

The kernel itself is a lightweight container. You register an LLM service (Azure OpenAI, OpenAI, or any compatible model), attach plugins, and then either invoke functions directly or let an agent decide what to call.

Why Semantic Kernel matters for AI-103

The AI-103 exam, which replaced AI-102 when it retired on June 30, 2026, tests your ability to build agents on Azure AI Foundry. Foundry's Agent Service is conceptually aligned with Semantic Kernel, and Microsoft Learn modules for AI-103 use Semantic Kernel code samples throughout.

Concretely, you can expect AI-103 questions on:

• Registering an Azure OpenAI chat completion service with the kernel
• Creating plugins from native code and from prompt templates
• Function calling and tool selection by the model
• Multi-agent orchestration patterns (sequential, concurrent, group chat, handoff)
• Process Framework for deterministic workflows
• Memory and vector store connectors for retrieval-augmented generation
• Filters and telemetry for production hardening

If you are studying for AI-103, our free AI-103 study guide and cheat sheet maps every learning path to exam domains, and our Azure AI Foundry explainer covers the platform Semantic Kernel runs on.

Semantic Kernel vs Microsoft Agent Framework

This is the single most confusing topic in 2026. Here is the short version.

In late 2025, Microsoft announced that Semantic Kernel and AutoGen were converging into the Microsoft Agent Framework. The Agent Framework is the umbrella brand. Semantic Kernel is the SDK you actually install and write code against. AutoGen patterns for multi-agent conversations were folded in as orchestration primitives.

What this means in practice:

• You still install the semantic-kernel package
• You still create a Kernel and register services
• You now have richer agent abstractions, including ChatCompletionAgent, AzureAIAgent, and OpenAIAssistantAgent
• Multi-agent orchestration is a first-class concept, not a separate library

For the exam, treat them as the same thing. Microsoft Learn uses both names interchangeably in 2026 content.

Core concepts you must know

The Kernel

The kernel is the central object. You build it once, register your AI services and plugins, and then use it everywhere.

from semantic_kernel import Kernel
from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion

kernel = Kernel()
kernel.add_service(AzureChatCompletion(
    deployment_name="gpt-4o",
    endpoint="https://your-foundry.openai.azure.com/",
    api_key="...",
))

Plugins (formerly Skills)

A plugin is a group of functions the model can call. Functions can be native code or prompt templates.

from semantic_kernel.functions import kernel_function

class HotelPlugin:
    @kernel_function(description="Get available rooms for a date range")
    def get_rooms(self, check_in: str, check_out: str) -> str:
        return "Suite 101, Suite 202"

kernel.add_plugin(HotelPlugin(), plugin_name="hotel")

Function calling

When you set function_choice_behavior to Auto, the model decides which plugin functions to call based on the user's request. This is how Semantic Kernel turns an LLM into an agent.

Agents

An agent is a kernel plus an instruction set plus a conversation loop. The simplest is ChatCompletionAgent. For Foundry-hosted agents, use AzureAIAgent, which delegates state and tool execution to the Foundry Agent Service.

Multi-agent orchestration

Four patterns matter for AI-103:

1. Sequential - agents run in a fixed order, each consuming the previous output
2. Concurrent - agents run in parallel and results are aggregated
3. Group chat - agents take turns under a manager that decides who speaks next
4. Handoff - one agent transfers control to a more specialized agent

Process Framework

Process Framework is the deterministic counterpart to planners. You define steps, transitions, and events explicitly. Use it when you need guaranteed execution order, for example in compliance, finance, or healthcare workflows where audit trails matter.

Memory and vector stores

Semantic Kernel ships with connectors for Azure AI Search, Azure Cosmos DB for NoSQL, Qdrant, Redis, and others. The unified VectorStore abstraction means you can swap backends without rewriting your retrieval code, which is exactly the kind of question the exam likes to ask.

A minimal end-to-end example

Here is a complete Python agent that uses a plugin and Azure OpenAI.

import asyncio
from semantic_kernel import Kernel
from semantic_kernel.agents import ChatCompletionAgent
from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion
from semantic_kernel.connectors.ai.function_choice_behavior import FunctionChoiceBehavior
from semantic_kernel.functions import kernel_function

class WeatherPlugin:
    @kernel_function(description="Get current weather for a city")
    def get_weather(self, city: str) -> str:
        return f"It is 22C and sunny in {city}"

async def main():
    kernel = Kernel()
    kernel.add_service(AzureChatCompletion(
        deployment_name="gpt-4o",
        endpoint="https://your-foundry.openai.azure.com/",
        api_key="...",
    ))
    kernel.add_plugin(WeatherPlugin(), plugin_name="weather")

    agent = ChatCompletionAgent(
        kernel=kernel,
        name="TravelAssistant",
        instructions="Help users plan trips. Use tools when needed.",
        function_choice_behavior=FunctionChoiceBehavior.Auto(),
    )

    async for response in agent.invoke("What is the weather in Lisbon?"):
        print(response.content)

asyncio.run(main())

That is a complete agent in roughly thirty lines. The same pattern in C# is nearly identical.

When to use Semantic Kernel vs the Foundry Agent Service directly

A common exam-style question. Use this rule:

• Use the Foundry Agent Service when you want Microsoft to manage state, threads, tool execution, and content safety for you. Good for chat surfaces and copilot-style apps.
• Use Semantic Kernel directly when you need fine-grained control over orchestration, custom planners, deterministic processes, or hybrid local plus cloud execution.
• Use both by wrapping Foundry agents with AzureAIAgent inside a Semantic Kernel multi-agent orchestration. This is the recommended pattern for complex 2026 architectures.

Production checklist

Before you ship an agent built on Semantic Kernel, verify:

1. Filters are in place for prompt injection and PII redaction
2. Telemetry is wired to Application Insights via OpenTelemetry
3. Retry policies cover transient 429 and 503 responses from the model endpoint
4. Token usage is tracked per session for cost attribution
5. System prompts are versioned and stored separately from code
6. Evaluation runs are automated against a regression set in Foundry

These are exactly the operational topics AI-103 emphasises beyond AI-102.

How to study Semantic Kernel for AI-103

A focused four-week plan:

1. Week 1 - Install the SDK, build a kernel, register Azure OpenAI, create a native plugin, and call it with function calling enabled.
2. Week 2 - Build a ChatCompletionAgent, then an AzureAIAgent. Compare state handling.
3. Week 3 - Implement two multi-agent patterns (sequential and group chat), then build one Process Framework workflow.
4. Week 4 - Add vector store retrieval, filters, telemetry, and a basic evaluator. Do practice questions.

Pair this with our AI-103 practice questions and the hands-on labs argument for why typing real code beats reading slides.

Get the free AI-103 study materials

If you are serious about AI-103, start with our free resources:

• The full AI-103 study guide and cheat sheet covering all four official learning paths
• The Azure AI Foundry deep dive
• AI-103 scenario-based practice questions

These three together give you a free, structured runway from "what is Semantic Kernel" to exam-ready in roughly six weeks of focused study.

FAQ

Q: Is Semantic Kernel free? A: Yes, the SDK is open source under MIT. You only pay for the LLM and Azure resources you call from it.

Q: Do I need C# to use Semantic Kernel? A: No, Semantic Kernel supports C#, Python, and Java, with the most mature feature parity across C# and Python.

Q: What is the difference between a Planner and Process Framework in Semantic Kernel? A: A Planner uses the AI model to decide step order at runtime, which is flexible but non-deterministic. Process Framework is a structured workflow engine where steps and transitions are defined explicitly, giving guaranteed execution order, essential for compliance and audit-heavy workflows.

Q: Is Semantic Kernel the same as the Microsoft Agent Framework? A: In 2026, yes for practical purposes. The Microsoft Agent Framework is the umbrella brand that unifies Semantic Kernel and AutoGen patterns. The package you install is still semantic-kernel.

Q: Will AI-103 test Semantic Kernel code? A: Yes. Expect to read short code snippets and identify the correct API call, plugin registration, agent type, or orchestration pattern. Memorise the package names and the four multi-agent patterns.