# What are Semantic Kernel and Microsoft Agent Framework?

> Semantic Kernel is Microsoft's SDK for AI agents. Microsoft Agent Framework is its successor, merging Semantic Kernel and AutoGen.

Source: https://www.honeyhive.ai/learn/semantic-kernel-framework (updated 2026-10-31)

Semantic Kernel is Microsoft's open-source SDK for building AI agents in C#, Python or Java, and Microsoft Agent Framework is its successor. Microsoft's docs say Agent Framework "is the direct successor, created by the same teams," combining AutoGen's agent abstractions with Semantic Kernel's enterprise features ([overview](https://learn.microsoft.com/en-us/agent-framework/overview/)). The Semantic Kernel README now opens with "Semantic Kernel is now Microsoft Agent Framework" ([GitHub](https://github.com/microsoft/semantic-kernel)). If you are starting a new project, Microsoft's 1.0 announcement says "Now is the time to migrate to Microsoft Agent Framework" ([announcement, April 2026](https://devblogs.microsoft.com/agent-framework/microsoft-agent-framework-version-1-0/)).

## Semantic Kernel in brief

Semantic Kernel describes itself as a "lightweight, open-source development kit" for building [AI agents](/learn/what-are-ai-agents) and plugging models into C#, Python or Java code ([overview](https://learn.microsoft.com/en-us/semantic-kernel/overview/)). Its design has three parts you will meet in any code base:

- The kernel: "a Dependency Injection container that manages all of the services and plugins" ([kernel docs](https://learn.microsoft.com/en-us/semantic-kernel/concepts/kernel)).
- Services: AI services such as chat completion, plus other services like loggers and HTTP clients ([kernel docs](https://learn.microsoft.com/en-us/semantic-kernel/concepts/kernel)).
- Plugins: your existing code, described to the model so it can call it. Semantic Kernel translates the model's request into a function call and passes the result back to the model ([overview](https://learn.microsoft.com/en-us/semantic-kernel/overview/)).

Events and middleware can fire at each step of a prompt invocation, which is where logging and responsible-AI checks go ([kernel docs](https://learn.microsoft.com/en-us/semantic-kernel/concepts/kernel)).

## How the names relate

| Project | What it is | Relationship |
|---|---|---|
| Semantic Kernel | SDK built around a kernel, plugins and connectors | Predecessor; README points to Agent Framework ([GitHub](https://github.com/microsoft/semantic-kernel)) |
| AutoGen | Multi-agent framework from Microsoft Research | Predecessor ([overview](https://learn.microsoft.com/en-us/agent-framework/overview/)) |
| Microsoft Agent Framework | Agents, graph workflows, middleware, sessions | Successor to both, "created by the same teams" ([overview](https://learn.microsoft.com/en-us/agent-framework/overview/)) |

Agent Framework reached 1.0 for .NET and Python in April 2026 with "stable APIs, and a commitment to long-term support" ([announcement](https://devblogs.microsoft.com/agent-framework/microsoft-agent-framework-version-1-0/)). The overview lists .NET, Python and Go, with Go in public preview ([overview](https://learn.microsoft.com/en-us/agent-framework/overview/)). Neither the 1.0 post nor the release-candidate post gives a support timeline for Semantic Kernel or AutoGen ([RC post](https://devblogs.microsoft.com/agent-framework/migrate-your-semantic-kernel-and-autogen-projects-to-microsoft-agent-framework-release-candidate/)).

## What changes when you move

Microsoft's migration guide lists the differences ([guide](https://learn.microsoft.com/en-us/agent-framework/migration-guide/from-semantic-kernel)):

| Area | Semantic Kernel | Agent Framework |
|---|---|---|
| Agent creation | Every agent depends on a `Kernel` | Built from a chat client, for example `as_agent()` |
| Agent classes | `ChatCompletionAgent`, `OpenAIAssistantAgent`, `AzureAIAgent` | One `Agent` (Python) or `ChatClientAgent` (.NET) for chat-client services |
| Tools | Decorate with `@kernel_function`, wrap in a plugin, add to the kernel | Pass plain functions in `tools`; plugins are optional |
| State | Caller creates a thread type | `agent.create_session()` |
| Calling | `invoke`, returns an async iterator | `run`, returns one `AgentResponse` |
| Options | `KernelArguments` with execution settings | Typed `options` dictionary (Python) |
| Python package | `semantic-kernel` | `agent-framework` |

Two details catch people. Agent Framework has no session deletion API, so you track hosted threads yourself and delete them through the provider SDK. And in .NET the namespaces move from `Microsoft.SemanticKernel` to `Microsoft.Agents.AI` ([guide](https://learn.microsoft.com/en-us/agent-framework/migration-guide/from-semantic-kernel)).

Python projects can move in steps: existing Semantic Kernel functions, including vector store search functions, convert with `as_agent_framework_tool()` on `semantic-kernel` 1.38 or later ([guide](https://learn.microsoft.com/en-us/agent-framework/migration-guide/from-semantic-kernel)).

## What Agent Framework adds

- Workflows: functional or graph-based, with human-in-the-loop pauses, checkpoints and resuming, and declarative definitions ([workflows](https://learn.microsoft.com/en-us/agent-framework/workflows/)).
- Orchestrations: sequential, concurrent, handoff, group-chat and Magentic patterns ([workflows](https://learn.microsoft.com/en-us/agent-framework/workflows/)).
- Providers and protocols: Foundry, Azure OpenAI, OpenAI, Anthropic, Amazon Bedrock, Google Gemini and Ollama connectors, plus [MCP](/learn/model-context-protocol) and A2A interoperability, with A2A 1.0 support listed as coming soon ([announcement](https://devblogs.microsoft.com/agent-framework/microsoft-agent-framework-version-1-0/)).
- Middleware for intercepting agent actions, for example content safety filters and logging ([overview](https://learn.microsoft.com/en-us/agent-framework/overview/), [announcement](https://devblogs.microsoft.com/agent-framework/microsoft-agent-framework-version-1-0/)).

## When to use which

The overview gives the agent-or-workflow rule: use an agent when the task is open-ended and needs autonomous tool use, and a workflow when the steps are well defined and order matters. It adds: "If you can write a function to handle the task, do that instead of using an AI agent" ([overview](https://learn.microsoft.com/en-us/agent-framework/overview/)). See [agentic workflows](/learn/agentic-workflow) for the pattern in general.

- New project in the Microsoft stack: Agent Framework, per Microsoft's guidance above.
- Existing Semantic Kernel app that works: you can keep it. The sources read give no retirement date, but the README points to Agent Framework, so plan a move and use the compatibility layer.
- Different ecosystem: [LangGraph](/learn/langgraph-framework), [OpenAI Agents SDK](/learn/openai-agents-sdk-framework) and [Pydantic AI](/learn/pydantic-ai-framework) cover similar ground with their own trade-offs.

## How to test and trace it

Both frameworks emit OpenTelemetry data, so most OTel backends can receive it. Semantic Kernel emits logs, metrics and traces compatible with OpenTelemetry, and notes the GenAI conventions are still experimental ([SK observability](https://learn.microsoft.com/en-us/semantic-kernel/concepts/enterprise-readiness/observability/)). Agent Framework emits spans following the OpenTelemetry GenAI conventions: `invoke_agent`, `chat` and `execute_tool` ([Agent Framework observability](https://learn.microsoft.com/en-us/agent-framework/agents/observability)). Prompts, responses and tool arguments are captured only when you enable sensitive-data capture, which Microsoft says to reserve for development and test ([Agent Framework observability](https://learn.microsoft.com/en-us/agent-framework/agents/observability)).

Spans alone do not say whether an agent is right. For that, run [LLM evaluation](/learn/llm-evaluation) on traced runs, and read [agent observability](/learn/agent-observability) for what to capture.

## Tracing Semantic Kernel in HoneyHive

HoneyHive's integration for Semantic Kernel turns on the framework's native OpenTelemetry diagnostics and adds a provider instrumentor. Install `honeyhive`, `semantic-kernel` and the matching `openinference` instrumentor, set `SEMANTICKERNEL_EXPERIMENTAL_GENAI_ENABLE_OTEL_DIAGNOSTICS` to `true` before other imports, call `HoneyHiveTracer.init()`, then use Semantic Kernel as normal. Agent invocations, kernel function and plugin calls, multi-agent orchestration and LLM calls with token usage are traced. The page lists `semantic-kernel` 1.36.0 as last tested ([integration docs](https://docs.honeyhive.ai/v2/integrations/semantic-kernel)).

HoneyHive's docs index lists no separate Agent Framework page as of October 2026 ([docs index](https://docs.honeyhive.ai/llms.txt)). Setup details for Semantic Kernel are on the [HoneyHive Semantic Kernel integration page](https://docs.honeyhive.ai/v2/integrations/semantic-kernel).

## FAQ

### Is Semantic Kernel deprecated?

Microsoft's docs call Microsoft Agent Framework "the next generation of both Semantic Kernel and AutoGen" ([overview](https://learn.microsoft.com/en-us/agent-framework/overview/)), and the Semantic Kernel README opens with "Semantic Kernel is now Microsoft Agent Framework" ([GitHub](https://github.com/microsoft/semantic-kernel)). No source gives an end-of-life date for Semantic Kernel, so check the repository before you plan around one.

### What is the difference between Semantic Kernel and Microsoft Agent Framework?

Agent Framework drops the central `Kernel` object and plugin wrappers. You build an agent from a chat client and pass plain functions as tools, and it adds graph-based workflows ([migration guide](https://learn.microsoft.com/en-us/agent-framework/migration-guide/from-semantic-kernel)).

### Is Microsoft Agent Framework the same as AutoGen?

No (see [AutoGen](/learn/autogen-framework)). It is the successor to both AutoGen and Semantic Kernel, and its orchestration patterns come from "Microsoft Research and AutoGen" ([1.0 announcement](https://devblogs.microsoft.com/agent-framework/microsoft-agent-framework-version-1-0/)). AutoGen's code is on [GitHub](https://github.com/microsoft/autogen).

### Can I migrate from Semantic Kernel gradually?

In Python, yes. `KernelFunction.as_agent_framework_tool()` turns existing Semantic Kernel functions into Agent Framework tools, and it needs `semantic-kernel` 1.38 or later ([migration guide](https://learn.microsoft.com/en-us/agent-framework/migration-guide/from-semantic-kernel)).