Semantic Kernel vs LangChain comes down to your language and your support plan. Pick LangChain for a new Python or TypeScript agent: it is actively developed, MIT licensed, has the bigger integration catalog, and its agents run on LangGraph when you need durable, controllable workflows. Pick Semantic Kernel only if you already run it in production on .NET or Azure, because Microsoft now calls Microsoft Agent Framework its successor and puts most new features there. If you are a C# shop starting fresh in November 2026, the honest comparison is Agent Framework vs LangChain, not Semantic Kernel vs LangChain.

We checked the Semantic Kernel README, Microsoft's post on Semantic Kernel and Microsoft Agent Framework, the LangChain overview docs and the PyPI release pages for both on November 4, 2026. We also built the same small agent in each one on the box, with fake models and no API key.

Semantic Kernel vs LangChain at a glance

ItemSemantic KernelLangChain
Made byMicrosoftLangChain Inc.
LanguagesC#, Python, JavaPython, JavaScript and TypeScript
Latest release we sawPython 1.46.0 (October 28, 2026), .NET 1.81.0Python 1.4.9 (November 4, 2026)
LicenseMITMIT
Core ideaA Kernel object that holds model services, plugins and filterscreate_agent: model, tools, prompt and middleware
Agent runtimeChatCompletionAgent and other agent typesA compiled LangGraph graph
HooksFunction invocation and prompt filtersMiddleware such as wrap_tool_call
StatusSupported for critical bugs and security fixes; new features go to Agent FrameworkActive development, frequent releases
Best fitExisting .NET and Azure apps already on itNew Python or TypeScript agents

How each framework is built

Semantic Kernel puts one object at the center. You create a Kernel, add a chat service to it (OpenAI, Azure OpenAI, Ollama and others), and register plugins, which are classes whose methods carry a @kernel_function decorator (or a [KernelFunction] attribute in C#). An agent such as ChatCompletionAgent takes that kernel, and the model can call any registered function when you turn on automatic function calling. Cross cutting logic, such as logging or blocking a call, goes into filters that wrap each function invocation.

LangChain removed most of its old chain classes when it reached 1.0. Today its main entry point is create_agent, which the docs describe as a minimal, configurable agent harness: you pass a model, a list of tools and a system prompt, then shape behavior with middleware. Under the hood, create_agent returns a compiled LangGraph graph, so features like checkpointers, streaming and interrupts for human approval come from LangGraph. The langchain package on PyPI now lists langgraph as a direct dependency.

The practical difference: Semantic Kernel organizes code around the kernel and its plugins, which feels familiar to .NET developers used to dependency injection. LangChain organizes code around an agent loop and a graph, which makes it easier to drop down a level into LangGraph when the loop is not enough. Our LangChain vs LangGraph guide covers that second step in detail.

What we tested

We wrote the same agent in both: a support assistant with one tool, order_status, and a scripted model that first asks for the tool and then answers with its result. Both ran in one Python 3.13 venv with Semantic Kernel 1.46.0 and LangChain 1.4.9.

The Semantic Kernel version used a plugin class with a @kernel_function method, a ChatCompletionAgent with FunctionChoiceBehavior.Auto(), and an auto function invocation filter that recorded each call. It printed Answer: Order A17 shipped Nov 3, and the filter saw Orders-order_status, the plugin name and function name joined together. We did not find a fake chat model in the Semantic Kernel package, so we subclassed ChatCompletionClientBase ourselves (about 15 lines). Our first filter used different parameter names and failed: Semantic Kernel passes the filter arguments by the names context and next, so they must be spelled exactly that way.

The LangChain version used a @tool function, create_agent with GenericFakeChatModel from langchain_core, a wrap_tool_call middleware that recorded each call, and an InMemorySaver checkpointer keyed by a thread id. It printed the same answer, the middleware saw order_status, and the returned agent type was CompiledStateGraph, which confirms the LangGraph runtime.

What this does not show: model quality, speed, token cost or behavior with a real provider. Both tests used fake models on purpose. We also did not run any C# or Java code.

# Semantic Kernel: tools are plugin methods on a kernel
class OrderPlugin:
    @kernel_function(description="Get the shipping status of an order")
    def order_status(self, order_id: str) -> str:
        return f"Order {order_id} shipped Nov 3"

kernel.add_plugin(OrderPlugin(), plugin_name="Orders")
agent = ChatCompletionAgent(kernel=kernel, name="support", instructions="help",
    arguments=KernelArguments(settings=PromptExecutionSettings(
        function_choice_behavior=FunctionChoiceBehavior.Auto())))

# LangChain: tools are passed straight to the agent
@tool
def order_status(order_id: str) -> str:
    """Get the shipping status of an order."""
    return f"Order {order_id} shipped Nov 3"

agent = create_agent(model, tools=[order_status], system_prompt="help",
    middleware=[log_tool_calls], checkpointer=InMemorySaver())

Support status: is Semantic Kernel still a safe bet?

This is the question that decides most comparisons now. The top of the Semantic Kernel README says Semantic Kernel "is now Microsoft Agent Framework" and calls Agent Framework its successor. Agent Framework reached version 1.0 for .NET and Python in April 2026, according to the Agent Framework 1.0 announcement.

Microsoft's own FAQ says it will keep supporting Semantic Kernel 1.x, fixing critical bugs and security issues, for at least one year after Agent Framework became generally available, and that most new features will be built for Agent Framework. With 1.0 shipping in April 2026, that window runs to at least April 2027. Semantic Kernel still gets releases (Python 1.46.0 came out October 28, 2026), so it is not abandoned. It is in a slow lane.

LangChain has no such cloud over it. The langchain and langchain-core packages both had new releases on the day we checked, and the GitHub repository is MIT licensed and active. So if long term momentum matters to you, LangChain is the lower risk choice today, and Agent Framework is the lower risk choice inside Microsoft's stack.

Semantic Kernel vs LangChain vs LangGraph

LangGraph is LangChain's lower level orchestration library: you define state, nodes and edges, and you get durable execution with checkpoints. Semantic Kernel had a Process Framework for structured business workflows, but Microsoft's graph based workflow engine, with checkpointing and pause and resume, now lives in Agent Framework. If your real need is a long running workflow that must survive restarts and wait for a human, compare LangGraph with Agent Framework workflows. Semantic Kernel alone is the weaker option there. Our LangGraph vs CrewAI vs OpenAI Agents SDK comparison shows how LangGraph stacks up against other orchestration choices.

Semantic Kernel vs AutoGen vs LangChain

AutoGen was Microsoft's research framework for multi agent conversations. Its repository is now archived, and Microsoft advises against using it for new production work. The multi agent patterns it introduced (group chat, handoff, Magentic-One) moved into Agent Framework alongside Semantic Kernel's enterprise features such as sessions, middleware and telemetry. So the three way choice from 2024 has collapsed: AutoGen is out, Semantic Kernel is in maintenance, and the live options are LangChain (with LangGraph) or Agent Framework. See our AutoGen tool page for its history.

Semantic Kernel vs Agent Framework

Agent Framework is built by the same team, and Microsoft's FAQ tells developers to think of it as Semantic Kernel v2.0. The biggest change in the Semantic Kernel migration guide is that the Kernel goes away: an agent wraps a chat client directly, tools are plain functions passed at creation, and the agent creates its own session instead of you building a thread object by hand. For the full migration and successor comparison (when to stay on SK, when to move, and a tested Agent Framework run), read Semantic Kernel vs Agent Framework.

When to choose Semantic Kernel

  • You have a working Semantic Kernel app in production and no feature you need is missing. Keep it, watch the support window, and plan the move to Agent Framework for your next feature cycle.
  • Your team writes Java, where LangChain has no official library (Semantic Kernel has a separate Java repository).
  • You depend on Azure services such as Azure OpenAI or Azure AI Search and want first party connectors. Agent Framework also ships first party connectors for Microsoft Foundry and Azure OpenAI, so this is not unique to Semantic Kernel.

When to choose LangChain

  • You are starting a new agent in Python or TypeScript.
  • You want a large set of model and tool integrations and community examples, such as our guides on using LangChain with Ollama and using Tavily in LangChain.
  • You expect to need durable workflows, human approval or multi agent graphs later, since LangGraph is already underneath.
  • You want to stay model neutral and avoid tying the code to one cloud.

For a wider view of Python options, including CrewAI, Agno and Pydantic AI, read our best AI agent framework for Python roundup.

FAQ

Is Semantic Kernel better than LangChain?

Not for most new projects in 2026. Semantic Kernel is solid for .NET teams already using it, but Microsoft now steers new work to Agent Framework. LangChain is more active, works in Python and TypeScript, and has LangGraph underneath for complex flows. Semantic Kernel still wins if you need Java or have a large existing Semantic Kernel codebase.

Is Semantic Kernel dead?

No. It still ships releases, and Microsoft has committed to critical bug and security fixes for at least a year after Agent Framework's general availability in April 2026. But most new features go to Agent Framework, so treat Semantic Kernel as a maintained 1.x line rather than the future.

Can I use Semantic Kernel and LangChain together?

You can, but there is rarely a reason. Both can call the same models and the same MCP servers, so a common pattern is to expose shared tools as an MCP server and let each app use its own framework. See what MCP is for how that works.

Is Semantic Kernel free?

Yes. Semantic Kernel is open source under the MIT license, as is LangChain. You pay only for the models and cloud services you call. LangChain's optional LangSmith platform for tracing and deployment has its own pricing.

Does LangChain work with C#?

There is no official LangChain library for C# or .NET. The official libraries are Python and JavaScript or TypeScript. C# developers usually choose Semantic Kernel or, for new work, Microsoft Agent Framework.