Microsoft’s Semantic Kernel

Semantic Kernel is the open-source kit with which Microsoft drops an AI model inside your C#, Python or Java application and lets it call your own code. The central piece, the kernel, acts as the middleman: it receives the model’s request, runs the right function and returns the result. In this guide you will see what the kernel, plugins and functions are, how its agent framework works, how it fits across the three languages, and why in 2026 its official successor is Microsoft Agent Framework. The same explanation is available in Spanish.

Key takeaways

• Semantic Kernel is a lightweight, open-source Microsoft SDK for building AI agents and integrating models into C#, Python and Java, with a 1.0+ commitment to no breaking changes.
• The kernel is a container that gathers the AI services and the plugins; it translates the model’s request into a real call to a function in your code and passes the result back.
• Its agent framework ships ready-made types such as ChatCompletionAgent, AzureAIAgent and OpenAIAssistantAgent, plus orchestration classes to coordinate several agents.
• It exists in all three languages: semantic-kernel 1.44.0 in Python (3.10+), Microsoft.SemanticKernel 1.78.0 in .NET (over 14 million NuGet downloads) and a Java edition on JDK 17+. The repository sits near 28,300 stars.
• In April 2026 Microsoft shipped Microsoft Agent Framework, which merges Semantic Kernel and AutoGen: it is the recommended successor, though Semantic Kernel will keep getting critical fixes for at least one more year.

What is Semantic Kernel and where does it stand in 2026?

Semantic Kernel is, per the official documentation, "a lightweight, open-source development kit that lets you easily build AI agents and integrate the latest AI models into your C#, Python, or Java codebase". It works as a middleware layer between your application and the model: when the model decides it needs to run an action, Semantic Kernel translates that decision into a call to your function and returns the result to the model. Microsoft and several Fortune 500 companies use it because it is modular, observable and stable.

The fact that changes everything in 2026 is the consolidation. On 3 April 2026 Microsoft released Microsoft Agent Framework 1.0, a framework that unifies Semantic Kernel and AutoGen into a single SDK with stable APIs and long-term support. Its product lead describes it as "the successor to Semantic Kernel for building AI agents", and the team informally calls it "Semantic Kernel v2.0, because it is built by the same people". It is their single recommendation for new projects.

That does not mean Semantic Kernel vanishes overnight. Microsoft committed to maintaining it and fixing critical and security bugs for at least one year after Agent Framework’s release, that is, through roughly April 2027. If you already run a Semantic Kernel project in production, it remains a solid base; if you start from scratch, it is worth looking at its successor first. To build agents today it also competes with LangGraph and CrewAI.

What are the kernel, plugins and functions?

The name says it: the kernel is the heart of the framework. It is a dependency-injection container that gathers two things, the services (chat models, embedding models and so on) and the plugins. When a request comes in, the kernel picks the service, lets the model reason and, if the model asks to run something, locates the function and invokes it. It is the same mechanism Microsoft 365 Copilot uses under the hood.

A plugin is simply a group of related functions. A function can be native (ordinary code you decorate to expose it to the model) or a prompt function (a text template that calls the model). By describing your code with types and descriptions, the model learns when and how to call it, without you writing the routing. Semantic Kernel also imports external APIs from OpenAPI specifications, so a function can wrap an existing web service.

Here is a minimal native plugin in Python: a class with a decorated function the model can invoke by its name and description.

from semantic_kernel.functions import kernel_function

class WeatherPlugin:
    @kernel_function(description="Returns the current weather for a city.")
    def get_weather(self, city: str) -> str:
        return f"It is 22 degrees and clear in {city}."

You register that plugin on the kernel with kernel.add_plugin(WeatherPlugin(), "weather") and, from then on, any agent built on that kernel can ask for the weather without you writing the "if the user asks about the weather, call…" logic. That is the promise of well-integrated function calling.

How does its agent framework work?

On top of the kernel, Semantic Kernel added the Agent Framework, a layer for creating agents with the same patterns as the core. An agent here is an entity that receives messages, reasons with a model, calls tools and produces answers, and several agents can collaborate in one workflow. The framework ships ready-made types depending on where the model comes from: ChatCompletionAgent (over any chat service), OpenAIAssistantAgent (over OpenAI’s Assistants API), AzureAIAgent and OpenAIResponsesAgent.

A minimal chat agent in Python is a few lines: you pick the service, give it a name and instructions and run it.

import asyncio
from semantic_kernel.agents import ChatCompletionAgent
from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion

agent = ChatCompletionAgent(
    service=OpenAIChatCompletion(ai_model_id="gpt-4o-mini"),
    name="Assistant",
    instructions="You are a clear, concise assistant.",
)

async def main():
    reply = await agent.get_response(messages="Write a haiku about recursion.")
    print(reply.content)

asyncio.run(main())

To coordinate several, the framework includes orchestration classes (for example a group chat where agents take turns according to a selection strategy). That is where Semantic Kernel overlapped with AutoGen, and exactly why Microsoft ended up merging the two. If your agent needs standardised external tools, it fits with the Model Context Protocol (MCP).

How does it fit across .NET, Python and Java?

Semantic Kernel’s big edge over many rivals is that it genuinely exists in three languages, not just Python. The mid-2026 numbers confirm it:

The .NET package has over 14 million NuGet downloads, and both the Python 1.44.0 and .NET 1.78.0 releases shipped on the same day, 7 July 2026, which shows the publishing cadence. The Java edition is built from its own repository (semantic-kernel-java) and trails a step behind on features, but it shares the concepts: kernel, plugins, functions and agents. Installation in Python is a single command:

python -m venv .venv && source .venv/bin/activate
pip install semantic-kernel

That cross-language parity is the main reason to pick Semantic Kernel in a company already living in the .NET or Java ecosystem, where Python-centric alternatives fit worse.

How does it differ from AutoGen?

For a while Microsoft kept two agent frameworks at once, and that was confusing. AutoGen started at Microsoft Research as an experimental framework for conversations among several agents: it moved fast, explored new orchestration patterns and was aimed at research. Semantic Kernel, by contrast, was the production-ready option: stable, multi-language and committed to not breaking compatibility. Their territories increasingly overlapped.

The fix was to unite them. Microsoft Agent Framework takes the enterprise foundation of Semantic Kernel and the multi-agent orchestrations of AutoGen and fuses them into a single SDK, with native MCP and agent-to-agent (A2A) protocol support and connectors for six providers (Azure OpenAI, OpenAI, Anthropic, Amazon Bedrock, Google Gemini and Ollama, the engine that runs language models on your own machine without a cloud API).

In practice: if you hesitate between Semantic Kernel and AutoGen for something new, the official answer is not to pick either on its own, but to use Microsoft Agent Framework, which inherits the best of both.

Frequently asked questions

Is Semantic Kernel obsolete because of Microsoft Agent Framework?

Not exactly. Microsoft Agent Framework is the recommended successor for new projects since April 2026, but Semantic Kernel enters maintenance mode, not abandonment: it will keep getting critical and security fixes for at least one year after Agent Framework’s release. If you already have code in production, you do not have to migrate overnight; if you are starting today, it is more sensible to build directly on the successor.

Do I need an OpenAI key to use it?

No. Semantic Kernel is provider-agnostic: besides OpenAI and Azure OpenAI, it connects to other services and to models you run on your own machine with Ollama. You swap the kernel’s service without touching your plugins or agents, so you can prototype with a powerful model and then move part of the work to a local or cheaper one.

How does it differ from LangChain or CrewAI?

Semantic Kernel is a Microsoft SDK with real parity across C#, Python and Java and a strong enterprise focus (telemetry, filters, compatibility commitment). LangChain and CrewAI are Python-centric projects with huge communities and more experimentation. The choice usually depends on your ecosystem: if you live in .NET or Java, Semantic Kernel (or now Agent Framework) fits better.

Conclusion

Semantic Kernel solved one concrete problem well: bringing an AI model to the centre of a C#, Python or Java application and letting it call your code through a kernel that orchestrates plugins and functions, with the stability an enterprise needs. Its agent framework and cross-language parity made it popular, up to the repository’s 28,300 stars. In 2026 its story enters a new phase: Microsoft Agent Framework picks up its baton and AutoGen’s. The natural next step is to decide by your case: keep what already works in Semantic Kernel, or build the new on its successor and explore the multi-agent patterns that are now unified.

Sources: [1] Semantic Kernel, official documentation on Microsoft Learn^[1], [2] microsoft/semantic-kernel repository on GitHub^[2], [3] semantic-kernel package on PyPI^[3], [4] Microsoft.SemanticKernel package on NuGet^[4], [5] Semantic Kernel and Microsoft Agent Framework, official blog^[5].

Sources

1. Semantic Kernel, official documentation on Microsoft Learn
2. microsoft/semantic-kernel repository on GitHub
3. semantic-kernel package on PyPI
4. Microsoft.SemanticKernel package on NuGet
5. Semantic Kernel and Microsoft Agent Framework, official blog

Route: Frameworks to Build AI Agents