Skip to main content

Semantic Kernel: Enterprise Agent Framework for .NET, Python, and Java

Full framework comparison: Guide to choosing a framework

What Is Semantic Kernel​

Semantic Kernel is an open‑source SDK from Microsoft that enables developers to build AI‑driven applications and agents by integrating Large Language Models (LLMs) with conventional programming languages. It provides a lightweight, model‑agnostic orchestration layer that sits between your enterprise logic and AI services, handling the complexities of prompt management, function calling, memory, and planning while allowing you to focus on building valuable applications.

Think of Semantic Kernel as the foundation for Microsoft Copilots. It’s the same technology Microsoft uses internally to power products like Microsoft 365 Copilot, and now it’s available to you as an open‑source SDK under the MIT License.

# Python example
import semantic_kernel as sk
from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion

kernel = sk.Kernel()

# Add an AI service connector
kernel.add_service(AzureChatCompletion(
    deployment_name="gpt-4o",
    endpoint="https://your-resource.openai.azure.com/",
    api_key="your-api-key"
))

# Register a plugin
kernel.add_plugin(
    plugins.core_plugins.TimePlugin(),
    plugin_name="time"
)

# Invoke the kernel
result = await kernel.invoke(
    kernel.plugins["time"].functions["today"],
    input="What day is it?"
)
print(result)  # "Saturday"

Semantic Kernel’s purpose is threefold: to abstract away the underlying LLMs, APIs, and tooling; to handle complex implementations in a generic, reusable way; and to make it easy to integrate your own content, code, and enterprise services. As of April 2026, the project has accumulated over 27,500 stars on GitHub and is widely adopted across Fortune 500 enterprises.

Why Semantic Kernel Was Created​

Before Semantic Kernel (2022–2023), enterprise developers faced a fragmented AI landscape. Integrating LLMs into production applications meant:

  • Writing custom glue code to connect your application to OpenAI, Azure OpenAI, or Hugging Face—each with different APIs, authentication patterns, and error handling.
  • Reinventing orchestration – Building systems to chain prompts, call functions, manage memory, and handle failures from scratch.
  • No reusable abstractions – Every team built their own plugins, prompt templates, and memory components, leading to duplicated effort and inconsistent quality.
  • Poor integration with existing code – LLM capabilities felt like an isolated island, not a natural extension of your .NET, Python, or Java application logic.

Microsoft built Semantic Kernel to address these challenges in a systematic, enterprise‑grade way. The framework is designed around a simple philosophy: make AI accessible to every developer, regardless of their machine learning expertise.

What Semantic Kernel provides that earlier approaches lacked:

  • A unified kernel abstraction – The Kernel coordinates all AI services, plugins, and memory components.
  • Plugin‑based extensibility – Reusable, composable units of functionality that can be native code, prompt templates, or imported from OpenAPI.
  • Model‑agnostic connectors – Switch between OpenAI, Azure OpenAI, Anthropic, Google Gemini, and local models with configuration changes.
  • Native planning capabilities – Planners that use LLMs to automatically compose sequences of plugin calls to achieve user goals.
  • First‑class memory – Vector database integrations for retrieval‑augmented generation (RAG) and long‑term context.

Key Features of Semantic Kernel​

FeatureDescription
KernelThe central orchestrator that manages AI services, plugins, memory, and execution flow
PluginsReusable units of functionality (native code, semantic prompts, or OpenAPI imports)
AI Service ConnectorsUnified interfaces to OpenAI, Azure OpenAI, Anthropic, Google Gemini, Hugging Face, Ollama, and more
FunctionsIndividual operations within plugins – can be native code or prompt‑based
Memory & ConnectorsVector database integrations (Azure Cognitive Search, Chroma, Qdrant, Weaviate) for RAG
PlannersLLM‑powered components that decompose user requests into sequences of plugin calls
AgentsBuilt on the kernel, agents can be single‑purpose, multi‑step, or collaborative
FiltersMiddleware‑style interceptors for telemetry, logging, validation, and cross‑cutting concerns
MCP SupportNative support for Model Context Protocol (MCP) servers as tool providers
Multi‑LanguageFirst‑class support for C# (.NET), Python, and Java with consistent abstractions

Semantic Kernel's architecture is modular – you can use individual components (connectors, plugins, planners) independently, or combine them for full orchestration.

How Semantic Kernel Works​

Execution flow at a glance:

  1. Build the Kernel – You create and configure a Kernel instance with AI service connectors, plugins, memory connectors, and optional filters.
  2. Register plugins – Plugins can be native code functions (C#, Python, or Java), semantic prompt templates, or imported from OpenAPI specifications.
  3. Invoke functions – You can invoke a specific function directly, or use a planner to let the LLM determine which functions to call and in what order.
  4. The Kernel orchestrates – The Kernel handles service selection, function execution, result aggregation, and telemetry via OpenTelemetry.
  5. Result returned – The final output flows back to your application, with filters capturing logs, metrics, and traces along the way.

The Kernel is the central piece – it holds everything together. Every Semantic Kernel application begins by building a Kernel instance that serves as the coordination hub for all AI operations.

Core Concepts​

Kernel​

The Kernel is the core orchestrator. It manages AI service connectors, plugins, memory connectors, filters, and execution flow. Think of it as the “brain” that coordinates everything.

from semantic_kernel import Kernel

kernel = Kernel()

The Kernel is lightweight and designed for dependency injection scenarios. In production applications, you typically create a single Kernel instance at startup and reuse it.

Plugins​

Plugins are containers for functions. A plugin represents a cohesive set of related capabilities – for example, a TimePlugin with functions like Today(), Date(), and TimeOfDay(). Plugins can be:

  • Native plugins – Functions written in your language (C#, Python, Java) that execute existing business logic. The @kernel_function decorator exposes them to the Kernel.
  • Semantic plugins – Prompt‑based functions that leverage LLM capabilities directly, defined with YAML or JSON prompt templates.
  • OpenAPI plugins – Imported API definitions, allowing the Kernel to call external REST services.
from semantic_kernel.functions import kernel_function

class WeatherPlugin:
    @kernel_function(description="Get current weather for a location")
    def get_weather(self, location: str) -> str:
        return f"Weather in {location}: 72°F, sunny"

kernel.add_plugin(WeatherPlugin(), plugin_name="weather")

Functions​

A function is a single unit of work. The Kernel can invoke functions directly, or planners can compose multiple functions to achieve a goal.

Native function example (Python):

@kernel_function(description="Multiply two numbers")
def multiply(self, a: float, b: float) -> float:
    return a * b

Semantic function example (YAML prompt template):

name: Summarize
template: |
  Summarize the following text in 3 bullet points:
  {{$input}}
template_format: semantic-kernel

AI Services​

AI service connectors provide a unified interface to various LLM providers. The Kernel uses these connectors to make model calls.

from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion
from semantic_kernel.connectors.ai.anthropic import AnthropicChatCompletion

# Switch providers with a single line change
kernel.add_service(OpenAIChatCompletion(service_id="gpt", model="gpt-4o"))
# kernel.add_service(AnthropicChatCompletion(service_id="claude", model="claude-3-5-sonnet"))

Supported providers include OpenAI, Azure OpenAI, Anthropic Claude, Google Gemini, Amazon Bedrock, Hugging Face, and local models via Ollama or LMStudio.

Memory & Connectors​

Semantic Kernel provides vector memory connectors that enable Retrieval‑Augmented Generation (RAG). The Memory abstraction allows you to store, index, and search text embeddings against vector databases, giving your agents long‑term context and factual grounding.

from semantic_kernel.connectors.memory.azure_cognitive_search import AzureCognitiveSearchMemoryStore

memory_store = AzureCognitiveSearchMemoryStore(endpoint, api_key)
kernel.add_memory_store(memory_store)
await kernel.memory.save_information("docs", id="doc1", text="Important policy...")

Supported vector stores include Azure AI Search, Chroma, Qdrant, Weaviate, PostgreSQL with pgvector, and others.

Filters​

Filters are middleware‑style interceptors that run before and after Kernel operations. They’re perfect for logging, telemetry, validation, and cross‑cutting concerns.

from semantic_kernel.filters import FunctionInvocationContext

async def logging_filter(context: FunctionInvocationContext, next):
    print(f"Calling: {context.function.name}")
    await next(context)
    print(f"Completed: {context.function.name}")

kernel.add_filter("function_invocation", logging_filter)

Planners​

Planners are LLM‑powered components that decompose complex user requests into sequences of plugin calls. The planner examines the available plugins and functions, then generates a plan (a sequence of steps) to accomplish the user’s goal. This is what distinguishes Semantic Kernel from simple function‑calling – the ability to combine multiple plugins dynamically, without the developer pre‑defining every possible sequence.

from semantic_kernel.planners import StepwisePlanner

planner = StepwisePlanner(kernel, "Execute the user's request using available plugins")
plan = await planner.create_plan("I need to know the current time and then search for news")
result = await plan.invoke()

Semantic Kernel includes built‑in planners (Stepwise, Handlebars) and supports custom planners.

Semantic Kernel Ecosystem​

LLM Providers. Semantic Kernel supports OpenAI, Azure OpenAI, Anthropic Claude, Google Gemini, Amazon Bedrock, Hugging Face, Mistral AI, Ollama, LMStudio, and any OpenAI‑compatible endpoint.

Plugins & Functions. The plugin ecosystem is extensive – you can use built‑in plugins from Microsoft (time, file, math, conversation), community plugins, OpenAPI imports from thousands of APIs, or write your own native functions.

Memory Stores. Supported vector databases include Azure AI Search, Chroma, Qdrant, Weaviate, Pinecone, Milvus, PostgreSQL with pgvector, and SQLite with vector extensions.

MCP Integration. Semantic Kernel has native support for MCP servers as tool providers. An MCP server can be connected at runtime – the Kernel automatically discovers available tools and exposes them as KernelFunction instances.

Observability. OpenTelemetry is built‑in. Exports to Azure Monitor, Application Insights, Jaeger, Datadog, and any OTLP collector.

Enterprise Authentication. Entra ID (formerly Azure Active Directory) and managed identity are supported across all three languages.

Multi‑Language Support​

Semantic Kernel’s distinguishing feature is consistent, first‑class support for three languages: C# (.NET), Python, and Java. The same abstractions (Kernel, plugins, functions, memory, planners) work across all three, with API symmetry maintained between releases.

LanguageStatusLatest VersionPackage
C# (.NET)Production (GA)1.74.0 (NuGet)Microsoft.SemanticKernel
PythonProduction (GA)1.41.0 (PyPI)semantic-kernel
JavaProduction (GA)1.0.0 (Maven)com.microsoft.semantic-kernel

This multi‑language support is critical for enterprises with polyglot teams, legacy .NET systems, or Java‑based data platforms. You can write plugins in one language and call them from another (via REST or Kernel-as‑a‑Service patterns), though the primary use case is consistent development across your entire stack.

Key differences across languages:

  • C# has the most mature implementation, being Microsoft’s primary language.
  • Python has strong community support and is popular for prototyping and AI research.
  • Java has reached 1.0 GA and is production‑ready for enterprise Java applications.

When to Use Semantic Kernel​

Semantic Kernel is designed for enterprise applications where integration with existing systems, security, compliance, and multiple language support are priorities.

Enterprise AI Assistants (Copilots)​

You need to build an internal copilot that can query your company’s databases, ticketing systems, and knowledge bases. Semantic Kernel’s plugin architecture lets you wrap existing APIs as plugins, and the Kernel handles orchestration, authentication, and telemetry.

Internal Knowledge Systems with RAG​

Your organization has thousands of internal documents, policies, and FAQs. Using Semantic Kernel’s memory connectors, you can build a RAG system that retrieves relevant context from vectorised documents and passes it to the LLM for accurate, citation‑backed answers.

Workflow Automation with Planning​

You have a set of existing APIs (CRM, ERP, HR systems) and you want agents that can understand natural language requests (“Escalate this ticket to the manager and email the customer”) and automatically execute the necessary API calls. Semantic Kernel’s planners can decompose the request and orchestrate the required plugin calls – no hard‑coded workflow needed.

AI‑Powered Business Applications​

You’re building a vertical SaaS application (loan processing, claims management, supply chain optimisation) and you want to embed AI capabilities without rewriting your entire stack. Semantic Kernel integrates seamlessly into existing .NET, Python, or Java applications.

Agent Platforms with Multi‑Language Requirements​

Your team includes .NET backend developers, Python data scientists, and Java engineers. Semantic Kernel provides a consistent abstraction across all three languages – everyone works with the same concepts (Kernel, plugins, functions).

Regulated Industries (Finance, Healthcare, Government)​

Azure compliance (SOC, HIPAA, FedRAMP), managed identity, private networking, and audit logging are baked into Semantic Kernel’s Azure integrations. Planners and filters give you control and visibility into every AI decision step.

When Not to Use Semantic Kernel​

Small personal projects or rapid prototypes. For a simple assistant with one model and a few tools, Semantic Kernel’s abstractions add overhead. Use OpenAI Agents SDK for minimal loops, or CrewAI for simple role‑based tasks.

Lightweight chatbots with no existing enterprise systems. If you just need a conversational chatbot with no integration to internal APIs, databases, or authentication, Semantic Kernel is overbuilt. Start with the OpenAI SDK.

When you’re already deeply invested in LangGraph’s graph paradigm. If your workflow naturally maps to explicit state graphs with conditional edges, cycles, and checkpoints, LangGraph is a better fit. Semantic Kernel’s planner approach is powerful but less fine‑grained.

When you need free‑form multi‑agent conversation. For scenarios where agents need to debate, negotiate, or brainstorm in an open‑ended conversation (not structured handoffs), Microsoft Agent Framework (the successor to AutoGen) is more appropriate.

When you’re starting fresh in 2026 with no existing Semantic Kernel codebase. Microsoft has announced that Semantic Kernel and AutoGen have moved to maintenance mode as of late 2025 / early 2026. All new feature development is now focused on Microsoft Agent Framework (MAF), which unifies Semantic Kernel’s enterprise capabilities with AutoGen’s multi‑agent orchestration. For new greenfield projects, Microsoft recommends starting with MAF, not Semantic Kernel.

Semantic Kernel in 2026: Maintenance Mode and the Microsoft Agent Framework​

Semantic Kernel entered maintenance mode in late 2025 / early 2026. The framework is stable, production‑ready, and will continue to receive bug fixes and security patches for the foreseeable future, but Microsoft has stopped adding new features.

On October 1, 2025, Microsoft announced the Microsoft Agent Framework (MAF), a new open‑source project merging Semantic Kernel (enterprise orchestration) with AutoGen (multi‑agent conversation). In April 2026, MAF reached version 1.0 GA with long‑term support (LTS).

What this means for developers:

  • If you have an existing Semantic Kernel codebase: Your applications continue to work. The SDK remains available, and critical patches will be issued for the foreseeable future. However, no new features will be added to Semantic Kernel itself.

  • If you are starting a new project in 2026: Microsoft recommends the Microsoft Agent Framework (MAF) for greenfield builds. MAF preserves Semantic Kernel’s kernel and plugin model as its foundation layer, then adds a unified API for single and multi‑agent systems.

  • Migration path: Microsoft provides migration guides from Semantic Kernel to MAF – the changes are incremental, primarily around namespace updates and simplified agent creation.

The good news: If you learn Semantic Kernel today, you’re learning the foundation of the Microsoft Agent Framework. The Kernel, plugin model, connectors, and filters survive intact in MAF. The investment is not wasted.

Semantic Kernel Learning Path​

The handbook provides structured learning paths for building production AI agents with Semantic Kernel – and by extension, the Microsoft Agent Framework.

Core Concepts​

/frameworks/semantic-kernel/core-concepts/

Learn:

  • Building and configuring the Kernel
  • AI service connectors and service selection
  • Function types: Native vs. Semantic
  • Filters and middleware

Plugins​

/frameworks/semantic-kernel/plugins/

Learn:

  • Creating native plugins with @kernel_function
  • Writing semantic plugins with YAML prompt templates
  • Importing plugins from OpenAPI specifications
  • Plugin composition and reuse patterns

Planners​

/frameworks/semantic-kernel/planners/

Learn:

  • Stepwise Planner for sequential task decomposition
  • Handlebars Planner for complex plans
  • Creating custom planners
  • Planner patterns and best practices

Memory & Connectors​

/frameworks/semantic-kernel/memory-connectors/

Learn:

  • Memory abstractions (semantic, long‑term, entity)
  • Vector database connectors (Azure Cognitive Search, Chroma, Qdrant, pgvector)
  • Retrieval‑augmented generation (RAG) patterns
  • Information indexing and search

Production​

/frameworks/semantic-kernel/production/

Learn:

  • OpenTelemetry telemetry and diagnostics
  • Enterprise authentication (Entra ID, managed identity)
  • Deployment patterns (Azure Container Apps, Functions)
  • Error handling, retries, and resilience

Semantic Kernel vs Other Frameworks​

FrameworkPrimary ModelBest ForLanguage Support2026 Status
Semantic KernelPlugin‑based kernel with plannersEnterprise .NET/Java, integration with existing systemsC#, Python, JavaMaintenance mode (→ MAF)
LangGraphGraph‑based state machinesComplex workflows with branching and cyclesPythonActive
CrewAIRole‑based crewsStructured multi‑agent handoffsPythonActive
OpenAI Agents SDKSingle‑agent loop with handoffsLightweight assistants, OpenAI‑nativePython, TypeScriptActive
Microsoft Agent FrameworkUnified orchestrationEnterprise multi‑agent, graph + conversation + planningC#, PythonActive (successor)

Semantic Kernel vs LangGraph​

LangGraph provides explicit state graphs – you define nodes, edges, conditionals, and cycles. Semantic Kernel uses planners to dynamically compose sequences of function calls based on LLM decisions.

  • Choose Semantic Kernel / MAF when you have existing enterprise APIs and want the system to automatically compose them to achieve user goals. The planner approach is more flexible and less code than writing explicit graphs.

  • Choose LangGraph when you need fine‑grained control over branching, loops, checkpoints, and persistence – and when the workflow is predetermined enough to encode as a graph.

Semantic Kernel vs CrewAI​

CrewAI organises agents into fixed roles with sequential task handoffs (researcher → writer → editor). Semantic Kernel treats everything as functions in the Kernel; agents are lightweight and built on top.

  • Choose Semantic Kernel / MAF when you’re building enterprise applications where the same Kernel powers multiple agents, plugins are shared, and you need enterprise telemetry, authentication, and connectors.

  • Choose CrewAI when you need a fast, role‑based multi‑agent system and your enterprise constraints are minimal – or when your team prefers the role mental model over the plugin model.

Semantic Kernel vs OpenAI Agents SDK​

OpenAI Agents SDK is a minimalist loop for OpenAI‑first agents, with built‑in tracing and handoffs. Semantic Kernel is a full‑featured enterprise platform with plugins, memory, planners, and multi‑language support.

  • Choose Semantic Kernel / MAF when you’re building applications that need to integrate deeply with .NET, Java, or Azure – and you want planning, RAG, and enterprise telemetry.

  • Choose OpenAI SDK when you’re building lightweight assistants with OpenAI, you don’t need planning, and you don’t have enterprise constraints.

Semantic Kernel vs Microsoft Agent Framework​

MAF is the successor to Semantic Kernel. The two are not directly compared in production – MAF inherits Semantic Kernel’s kernel and plugin model as its foundation layer, then adds a unified agent abstraction, graph‑based workflows, and native MCP/A2A protocol support. Moving forward, new projects should use MAF, not Semantic Kernel.

Common Semantic Kernel Use Cases​

Enterprise Knowledge Assistant​

An agent that queries internal documents, wikis, and databases using RAG. The Kernel holds memory connectors for vectorised knowledge bases; agents retrieve relevant documents and answer questions with citations. Filters capture telemetry, and Entra ID handles authentication.

Internal Copilot for ERP/CRM​

A copilot embedded into your company’s ERP system. Users type natural language commands like “Show me all pending invoices from last month.” The planner decomposes the request, calls the appropriate plugin (e.g., querying a SQL database via a native function), and returns the result.

Customer Support Automation​

An agent that answers customer questions by combining knowledge‑base retrieval (memory), ticketing system updates (native plugins), and email notifications (OpenAPI plugin). The Kernel orchestrates all steps, and telemetry tracks which queries the agent can’t answer for human review.

Multi‑System Workflow Orchestration​

A workflow that involves CRM, billing, and shipping systems. User says: “Refund order 12345 and notify the customer.” The planner identifies the sequence: query order status (CRM plugin), initiate refund (billing plugin), send email (communication plugin). All steps are logged and audited via OpenTelemetry.

AI‑Powered Document Processing​

A document processing pipeline for loan applications, insurance claims, or contracts. Plugins extract text, summarise, classify, and update case management systems. The Kernel provides consistent error handling and retries across all steps.

Common Beginner Mistakes​

Overengineering Simple Projects​

Semantic Kernel is powerful, but that power comes with complexity. Using it for a single get_weather agent adds dependency weight and learning overhead.

Recommendation: Match the framework to the problem. Use Semantic Kernel when you need plugins, memory, planners, or enterprise telemetry. Use OpenAI SDK or a direct API call for trivial examples.

Ignoring Plugin Reuse​

Developers often write custom code for tasks that already have built‑in or community plugins (time, file, math, conversation). This wastes time and duplicates functionality.

Recommendation: Explore the built‑in plugins (TimePlugin, FileIOPlugin, ConversationSummaryPlugin) and the community ecosystem before writing custom plugins.

Poor Connector Strategy​

Hard‑coding AI service configurations and not abstracting the selection logic makes switching providers or models difficult.

Recommendation: Use dependency injection and configuration files to define service connectors. Build a factory that selects the appropriate connector based on environment.

Mixing Business Logic and Prompts​

Embedding complex business rules directly into prompt templates makes them impossible to test, version, or reuse.

Recommendation: Keep prompts minimal – move business logic into native plugins where it can be unit‑tested and debugged with standard tools.

Neglecting Security Requirements​

In production, LLM calls need auditing, PII detection, and access control. Semantic Kernel filters are often overlooked.

Recommendation: Use filters to add authentication checks, PII redaction, and telemetry at the Kernel level – consistently applied to every function call.

Best Practices Overview​

Keep plugins focused and reusable. Each plugin should address a single capability. The WeatherPlugin gets weather; EmailPlugin sends emails; TimePlugin handles dates. Compose them in the Kernel or planner.

Separate AI logic from business logic. Use native plugins for deterministic operations (database queries, calculations) and semantic functions for LLM‑powered reasoning. This makes your system testable and debuggable.

Always configure telemetry from day one. Enable OpenTelemetry early in development. Seeing the complete flow – plugins called, prompts invoked, decisions made – saves hours of debugging.

Use filters for cross‑cutting concerns. Filters handle logging, authentication, validation, and retries consistently across all Kernel operations. Don’t duplicate these concerns in every function.

Plan for provider abstraction. Program to the IChatCompletionService interface, not to a specific client. This lets you switch between OpenAI, Azure OpenAI, or Anthropic with configuration changes.

For new projects, start with MAF. If you’re building an enterprise agent from scratch in 2026, begin with Microsoft Agent Framework. Semantic Kernel remains a solid learning foundation, but MAF is the active development target.

FAQ​

1. What is Semantic Kernel?​

Semantic Kernel is Microsoft’s open‑source SDK for building AI agents and integrating LLMs into applications. It provides a kernel‑centric abstraction with plugins, memory, planners, and connectors for C#, Python, and Java.

2. Is Semantic Kernel open source?​

Yes, Semantic Kernel is licensed under the MIT License. The source code is available on GitHub at microsoft/semantic-kernel.

3. Does Semantic Kernel support Java?​

Yes. Semantic Kernel Java reached version 1.0 (GA) and is production‑ready for enterprise Java applications, available via Maven.

4. Does Semantic Kernel support Python?​

Yes. The Python SDK (version 1.41.0 as of March 2026) is production‑ready and widely used, available via pip install semantic-kernel.

5. Does Semantic Kernel support .NET / C#?​

Yes. C# is the primary language, with mature NuGet packages (Microsoft.SemanticKernel). Version 1.74.0 is available as of early 2026.

6. Is Semantic Kernel suitable for enterprises?​

Yes. Semantic Kernel is used internally at Microsoft to power Copilot products and adopted across Fortune 500 enterprises for production AI workloads. Features like Entra ID, OpenTelemetry, and Azure integration make it enterprise‑ready.

7. Does Semantic Kernel support MCP (Model Context Protocol)?​

Yes. Semantic Kernel has native support for MCP servers as tool providers. MCP server tools can be dynamically discovered, exposed as KernelFunction instances, and invoked by agents. Microsoft also provides step‑by‑step guidance on integrating MCP tools with Semantic Kernel.

8. What is the difference between Semantic Kernel and Microsoft Agent Framework (MAF)?​

Semantic Kernel entered maintenance mode in 2026. MAF is the new unified framework that merges Semantic Kernel (kernel, plugins, connectors) with AutoGen (multi‑agent orchestration). MAF is the recommended starting point for new projects. Learn MAF from the official documentation.

9. How do I migrate from Semantic Kernel to MAF?​

Microsoft provides migration guides covering namespace updates, agent creation simplification, and thread/session management. See the official Semantic Kernel to Microsoft Agent Framework Migration Guide for details.

10. What are planners in Semantic Kernel?​

Planners are LLM‑powered components that decompose complex user requests into sequences of plugin calls. They allow agents to dynamically compose workflows without hard‑coding every possible path. Built‑in planners include Stepwise Planner and Handlebars Planner.

11. Does Semantic Kernel support RAG?​

Yes. Semantic Kernel includes memory connectors for vector databases (Azure Cognitive Search, Chroma, Qdrant, Weaviate, pgvector). You can store embeddings, search with semantic similarity, and use the retrieved context in prompts.

12. Can I use local LLMs with Semantic Kernel?​

Yes. Semantic Kernel supports Ollama and LMStudio for local model execution, plus any OpenAI‑compatible endpoint. This is useful for development, edge deployments, and scenarios where data cannot leave the premises.

13. What are filters in Semantic Kernel?​

Filters are middleware‑style interceptors that run before and after Kernel operations (function invocation, prompt rendering, etc.). They’re ideal for telemetry, logging, authentication, and validation – all applied consistently across the Kernel.

14. When should I choose Semantic Kernel over LangGraph?​

Choose Semantic Kernel when you have existing enterprise APIs and want LLM‑powered planning to automatically compose them, or when you need .NET or Java support. Choose LangGraph when you need fine‑grained state graph control, cycles, checkpoints, and your workflow is graph‑shaped.

15. Is Semantic Kernel still actively developed in 2026?​

No. Semantic Kernel entered maintenance mode in late 2025 / early 2026. It receives bug fixes and security patches, but no new feature development. Active development continues on Microsoft Agent Framework.

16. Should I start a new project with Semantic Kernel in 2026?​

For most new projects, Microsoft recommends starting with Microsoft Agent Framework. However, if you are maintaining an existing Semantic Kernel codebase, you can continue with confidence – it remains stable and supported.

17. Does Semantic Kernel have a visual designer or UI?​

Semantic Kernel does not include a visual designer. MAF includes tools for visual orchestration, but Semantic Kernel itself is strictly a code‑first SDK.

18. What types of plugins exist?​

Three types: Native plugins (code functions in C#, Python, Java), Semantic plugins (prompt templates defined in YAML), and OpenAPI plugins (imported from OpenAPI specifications). All appear as functions to the Kernel.

19. How do Semantic Kernel agents compare to AutoGen agents?​

Semantic Kernel agents are built on the Kernel with plugins and memory. AutoGen agents are conversational. The two are merged in Microsoft Agent Framework – MAF provides both patterns. For existing Semantic Kernel agent code, migrate to MAF via Microsoft’s migration guide.

20. Can Semantic Kernel work with Azure OpenAI on private networks?​

Yes. Semantic Kernel supports Azure OpenAI with private endpoints, managed identity, and Azure AD authentication – fully compatible with enterprise networking and compliance requirements.

Conclusion​

Semantic Kernel is Microsoft’s enterprise‑grade SDK for building AI agents and integrating LLMs into production applications. Its kernel‑centric abstraction, plugin architecture, planners, memory connectors, and multi‑language support (C#, Python, Java) make it a powerful choice for developers building on .NET, Azure, or polyglot stacks.

In 2026, Semantic Kernel has entered maintenance mode, with all new development focused on Microsoft Agent Framework (MAF). For existing Semantic Kernel users, your applications remain stable and supported. For new projects, Microsoft recommends starting with MAF – but the investment in learning Semantic Kernel translates directly to MAF, as the kernel and plugin model survive as the foundation.

Core strengths to remember:

  • Enterprise‑grade – Built-in telemetry, authentication, compliance, and Azure integration.
  • Plugin‑first architecture – Reusable, composable units of functionality.
  • Planning – LLM‑powered planners that automatically compose workflows.
  • Multi‑language – C#, Python, and Java with consistent abstractions.
  • MCP support – Native integration with Model Context Protocol servers.

If you are an existing Semantic Kernel user, your production applications continue to work. Plan to evaluate migration to MAF for new feature development.

If you are starting fresh in 2026, begin with the Microsoft Agent Framework guide. The patterns you learn there (kernel, plugins, memory, telemetry) will reflect Semantic Kernel’s best practices while adding unified agent orchestration and multi‑agent conversation.

Continue your learning:

Compare Semantic Kernel with other frameworks:

Additional resources:

Last updated: June 2026