Contents
- Verdict
- What is Microsoft Semantic Kernel?
- Best for, and not for
- Strengths and limits
- Pricing
- What people actually build with Semantic Kernel
- What Semantic Kernel actually costs at small-business volume
- The gotcha: the free framework leads somewhere that does not publish prices
- What breaks in production, and how you find out
- What it connects to that you already run
- Semantic Kernel alternatives: what to pick instead, and when
- Migration and lock-in: can you get your work out?
- FAQ
Semantic Kernel is not dead and it is not where Microsoft is going. Both statements are true and the second matters more. The repository is genuinely active: roughly 28,400 stars, pushed 5 August 2026, with .NET 1.79.0 version work landing that day. But Microsoft's own documentation now calls the Microsoft Agent Framework the direct successor to both Semantic Kernel and AutoGen, created by the same teams, and publishes a migration guide toward it. Java is effectively stranded, with the last tagged Java release in May 2025. The framework is free; the Azure services Microsoft would rather you use are not, and Foundry Agent Service's pricing page renders its rates as dashes.
What is Microsoft Semantic Kernel?
Semantic Kernel is Microsoft's open-source SDK for integrating LLMs into applications, with a kernel-and-plugins model, planners, and agent abstractions, and it is notable as the main first-class option for .NET and Java teams. In 2026 Microsoft shipped the Microsoft Agent Framework 1.0, which merges Semantic Kernel and AutoGen into a single successor SDK, positioning Semantic Kernel itself in maintenance mode for new agent work. It remains widely deployed in enterprises, especially those already on Azure.
Best for
Enterprise .NET and Java teams, especially on Azure, who want a Microsoft-supported path for LLM features and agents.
Not for
Anyone starting a greenfield agent project today, on Microsoft's own advice. Its documentation names the Agent Framework the direct successor and ships you a migration guide, so choosing Semantic Kernel now means adopting the thing you will be migrating off.
Strengths
- Still genuinely maintained, not abandoned: repository pushed 5 August 2026 with 22 commits in the preceding month, and .NET package version work landing that same day
- First-class C# support, which remains rare. For a .NET shop it avoids standing up a second language and a second deployment pipeline for one agent
- Enterprise application patterns are native rather than retrofitted: dependency injection, tracing and logging, filters and structured configuration
- The plugin model exposes existing application services as agent tools, so your order lookup service becomes a tool without a new integration layer
- Deep Azure OpenAI integration means the model sits inside a contract, a region and a data residency posture your organisation already negotiated
- Microsoft publishes an explicit, detailed migration guide to the Agent Framework covering namespaces, agent creation, tools, streaming and dependency injection
- KernelFunction instances convert to Agent Framework tools via as_agent_framework_tool from semantic-kernel 1.38 onward, so migration can be gradual rather than a rewrite
Limitations
- Microsoft's own docs describe the Agent Framework as the direct successor to Semantic Kernel and AutoGen, which makes new adoption a decision to migrate later
- Java has effectively stalled. The last tagged Java release was java-1.4.4-RC1 in May 2025, over a year before we checked, while .NET and Python shipped in July 2026
- The Microsoft Learn introduction page still carries a 2023 authoring date and a 2024 update stamp, with no mention of the Agent Framework at all, so the entry point to the docs is stale
- Release cadence has slowed relative to the successor: python-1.44.0 and dotnet-1.78.0 both landed on 7 July 2026, a month before we checked
- Considerably more ceremony than the successor. Migration docs show a plugin needing a KernelFunction attribute, a plugin wrapper, a kernel and a kernel handoff, where Agent Framework takes the function directly
- The commercial destination has no published prices. Foundry Agent Service rates for hosted agents and every built-in tool were rendered as dashes on 6 August 2026
- Developer-only, and specifically for developers embedding AI into an application rather than building a standalone automation
Microsoft Semantic Kernel pricing
Semantic Kernel is MIT licensed and free, so there is no framework billing unit at all. Your costs are model tokens from whichever provider you connect, most commonly Azure OpenAI, plus hosting, which may be nothing extra if the agent runs inside an application you already deploy. The commercial gravity is Azure. If you follow Microsoft's recommended path toward the Agent Framework and Foundry Agent Service, the billing units multiply: hosted agents bill by vCPU-hour and GiB-hour, file search bills per GB of vector storage per day, code interpreter bills per session and web search bills per 1,000 transactions. Checking that pricing page on 6 August 2026, every one of those rates was displayed as a placeholder dash rather than a number.
| Plan | Price | What you get |
|---|---|---|
| Semantic Kernel SDK | $0 | MIT licence. C#, Python and Java, though Java parity has lapsed badly. No fee, seats or execution meter |
| Microsoft Agent Framework | $0 | Also free. The stated direct successor to Semantic Kernel and AutoGen, supporting .NET, Python and Go, with Go in public preview |
| Model tokens | Provider rates | Azure OpenAI, OpenAI, Anthropic, Ollama and others. Billed by the provider, not by Microsoft's framework layer |
| Foundry Agent Service (hosted agents) | Not published | Billed by vCPU-hour and GiB-hour. The Azure pricing page displayed both rates as a dash rather than a figure when we checked on 6 August 2026 |
| Foundry built-in tools | Not published | File search per GB of vector storage per day with 1GB free, code interpreter per session, web search per 1,000 transactions. All shown as dashes on the pricing page |
| Agent Pre-Purchase Plan | 5-15% discount | Buy Agent Commit Units upfront on a 1-year metered plan for a stated 5% to 15% discount off rates that are not themselves published |
Pricing reflects public plans as of August 6, 2026 and can change. Check Microsoft Semantic Kernel for the latest.
What people actually build with Semantic Kernel
Semantic Kernel's defining use case is not a standalone agent. It is AI inside software your company already ships, which is why almost every good example below starts with an application that existed before anyone mentioned agents.
AI inside an application you already run
An assistant embedded in an existing line-of-business .NET application. A user asks a question in the app's own interface, and the agent answers it by calling the application's existing services as plugins: the order lookup service, the stock check, the customer record. This is the use case Semantic Kernel was built for and the one where it genuinely beats every alternative, because those services already exist, already run under your authentication, and already appear in your tracing and logging. You are exposing them to a language model, not integrating two systems.
Document and email drafting inside a Microsoft-centric business. A request arrives, the agent gathers context from SharePoint and the CRM through plugins, drafts a quote or a response using the corporate template, and posts it to a Teams channel for a human approval step before sending. Nothing here leaves the tenancy, which is usually the actual requirement when a regulated business asks about AI. For anything simpler than this, Microsoft Copilot Studio or Microsoft Power Automate will get there faster without any code.
Auditable back-office processes
Back-office reconciliation with filters as the audit trail. A nightly job compares two systems, and every model call and function invocation passes through a filter that logs what was requested, what was returned and how long it took. That filter mechanism is a real advantage: it gives you interception points for logging, approval and safety without restructuring the agent, and it is the reason this framework survives a compliance review more comfortably than a lighter one.
A tool layer that outlives the framework. Because plugins are ordinary application services with an attribute, and because KernelFunction instances convert to Agent Framework tools with as_agent_framework_tool from semantic-kernel 1.38 onward, teams increasingly build the tool layer first and treat the orchestration framework as replaceable. Given the successor situation, that is the most sensible posture available.
Where it is genuinely wrong
A quick standalone automation, and a greenfield project of any size. For the first, the ceremony is disproportionate: the migration guide shows the contrast bluntly, with a plugin needing an attribute, a wrapper class, a kernel and a kernel handoff where the successor takes the function directly. For the second, Microsoft's own documentation points you elsewhere, and there is no argument for deliberately starting on the framework that has a published migration guide away from it.
And a Java project, which is the sharpest warning on this page. The three-language claim is still in the marketing; the release record has not supported it since May 2025.
Bottom line: Semantic Kernel earns its place when the agent belongs inside a .NET application you already deploy, and almost nowhere else in 2026.
What Semantic Kernel actually costs at small-business volume
The SDK is free under MIT and so is the Agent Framework. Neither charges a licence, a seat or an execution fee, so at the framework layer Microsoft takes nothing. Your entire bill is model tokens plus wherever the agent runs, and for a .NET shop that second number is frequently zero.
| Line item | Self-hosted in your app | Foundry Agent Service |
|---|---|---|
| Framework licence | $0 (MIT) | $0 (MIT) |
| Model tokens | ~$1 budget tier, ~$27 frontier | Same, billed via Azure |
| Compute | $0 if it runs in an app you already deploy | vCPU-hour and GiB-hour, rates not published |
| Vector storage for file search | Your own store, your own cost | Per GB per day, rate not published, 1GB free |
| Code interpreter | Not applicable | Per session, rate not published |
| Web search | Your own provider | Per 1,000 transactions, rate not published |
| Forecastable in advance? | Yes, to the dollar | No, requires a sales quote |
The self-hosted path is one of the cheapest here
On our standard reference workload, an inbox triage agent handling 1,000 items a month at roughly 3,000 input and 400 output tokens per run, that is 3 million input and 400,000 output tokens a month. A budget-tier model puts you around a dollar; a frontier model around twenty-seven. Hosting is frequently zero marginal cost, which is the underrated part: if the agent lives inside an application you already deploy, there is no new server, no new pipeline and no new thing to patch. For a .NET shop that saving is larger than the token bill.
Azure OpenAI rather than direct provider APIs changes the procurement story more than the arithmetic. Rates and model availability differ from the direct route and Azure availability sometimes trails, but the model sits inside an enterprise agreement, a region and a compliance posture you already negotiated. For a regulated business that is worth real money in avoided procurement work. For a business with no Azure relationship it is a reason to go direct instead.
The managed path is not forecastable from public information
If you follow Microsoft's direction toward Foundry Agent Service, the billing units multiply into vCPU-hours and GiB-hours for hosted agents, per GB per day for file search vector storage, per session for code interpreter and per 1,000 transactions for web search. We checked that pricing page on 6 August 2026 and every rate displayed as a dash. There is a Pre-Purchase Plan offering 5% to 15% off Agent Commit Units, which is a discount expressed against figures you cannot read. Compare that with what an equivalent outcome costs as a done-for-you build, where the number is fixed in writing before anything starts.
Bottom line: Self-hosted inside an application you already deploy, a Semantic Kernel agent costs about $1 to $27 a month in tokens and nothing else; on Foundry Agent Service the cost cannot be calculated from public information at all.
The gotcha: the free framework leads somewhere that does not publish prices
There is no gotcha in Semantic Kernel's own pricing, because there is no pricing. MIT licence, no meter, nothing owed. The gotcha is directional: the free SDK is the on-ramp to a managed service whose rates Microsoft does not publish, and the path from one to the other is signposted in Microsoft's own documentation.
We looked at the Foundry Agent Service pricing page on 6 August 2026 expecting the usual enterprise vagueness and found something more literal. The page has the table. It names the units correctly: hosted agents billed by vCPU-hour and by GiB-hour, file search billed per GB of vector storage per day with 1GB free, code interpreter billed per session, web search and custom search billed per 1,000 transactions. And in the place where each rate should be, it prints a dash. The page also notes that actual pricing may vary depending on the type of agreement entered with Microsoft, and directs you to contact an Azure sales specialist.
The Agent Pre-Purchase Plan makes the shape of this clearer rather than better. It offers a 5% to 15% discount for buying Agent Commit Units upfront on a one-year metered plan. A percentage discount is only meaningful against a base rate, and the base rate is a dash. You are being offered a saving on a number you have to phone someone to learn, and committing for a year to get it.
None of this makes Semantic Kernel a bad choice, because you are not obliged to end up on Foundry. Self-host the agent inside your own application, point it at Azure OpenAI or any other provider, and your costs stay entirely in published token rates. The trap is only for the team that builds a proof of concept on the free SDK, follows the documentation's gravity toward hosted agents, and discovers at deployment time that the production cost model was never public. Decide self-hosting or managed before you build, not after.
Bottom line: Foundry Agent Service's pricing page names every billing unit correctly and prints a dash where each rate should be, so the managed Microsoft path cannot be budgeted without a sales call.
What breaks in production, and how you find out
Nothing here breaks in a novel way. What is unusual about Semantic Kernel in 2026 is that the biggest operational risks are documentation and language support rather than code, and those are the ones an evaluation checklist will miss.
| Signal | Semantic Kernel | Microsoft Agent Framework |
|---|---|---|
| Stars | ~28,400 | ~12,600 |
| Open issues | 257 | Not compared |
| Last push | 5 August 2026 | 5 August 2026 |
| Latest .NET release | dotnet-1.78.0, 7 July 2026 | Shipping under Microsoft.Agents.AI |
| Latest Python release | python-1.44.0, 7 July 2026 | agent-framework package |
| Latest Java release | java-1.4.4-RC1, 6 May 2025 | No Java support listed |
| Go support | None | Public preview |
| Microsoft's own framing | Pioneered the concepts | The direct successor |
Version churn and stale documentation
Microsoft's agent framework strategy has been reorganised more than once, and it has happened again: the Agent Framework is now the stated successor to both Semantic Kernel and AutoGen. That does not break your running application, but it does mean the documentation, the community answers and the examples you find are increasingly written for a different framework. Pin your version, and check which framework any solution you find is actually written against before you spend an afternoon on it.
Stale documentation is a live problem right now and it is worth checking yourself. The Microsoft Learn introduction to Semantic Kernel carries a 2023 authoring date and a 2024 update stamp, and makes no mention of the Agent Framework at all. Someone arriving at the official entry point to the docs in August 2026 would have no idea a successor exists. The migration guide is excellent and it is two clicks away from a page that does not link the reader to the news.
Java, rate limits and the ordinary failures
Java is where a team gets genuinely stranded. The three-language claim is still on the overview page, but the semantic-kernel-java repository's last tagged release was java-1.4.4-RC1 in May 2025, while .NET and Python both shipped in July 2026, and the successor framework lists .NET, Python and Go with no Java at all. If Java is your stack, verify support directly before you build anything you cannot afford to rewrite.
Azure OpenAI rate limiting catches multi-agent designs faster than people expect. A fan-out pattern where several agents work in parallel will hit deployment quota well before it hits any framework limit, and the symptom is throttling under load rather than a clean error in testing. Test at realistic concurrency, not one request at a time.
Beyond that, the ordinary agent failures apply and the framework gives you unusually good places to catch them. Unbounded loops need explicit step limits. Tool calls with subtly wrong arguments need validation before they reach a real system. Silent failure needs a heartbeat. The filter mechanism is the right hook for all three, it costs little to add at the start, and retrofitting it after an incident is the expensive path.
Bottom line: The two Semantic Kernel risks a code review will not catch are a docs entry point that has not mentioned the successor framework since 2024, and a Java SDK with no tagged release since May 2025.
What it connects to that you already run
The plugin model is the integration story and it is genuinely different from everything else in this directory. Instead of a catalogue of connectors to third-party SaaS, Semantic Kernel exposes your own application's existing services as functions the model can call, using descriptions the model reads to decide when to invoke them. For a company that already runs software, this is the most direct route available: your order lookup becomes an agent tool without a new integration layer, running under the same authentication, the same logging and the same deployment as everything else.
Azure is the natural surrounding ecosystem. Azure OpenAI for models inside your existing agreement and region, Azure AI Search for retrieval, and the vector store connectors that Semantic Kernel maintains, which include Azure AI Search alongside third-party stores such as Qdrant and Pinecone. If your data and identity are already in Azure, the integration work is mostly configuration.
OpenAPI support is the quiet advantage. Semantic Kernel consumes OpenAPI specifications the same way Microsoft 365 Copilot does, which means any internal service with a spec can become an agent capability without bespoke wrapper code, and the same extension can be shared with other developers in your organisation. For a company with a well-specified internal API estate, that turns integration into a much shorter job.
Model providers beyond Microsoft are supported but less first-class, and it is fair to say the gravity pulls toward OpenAI and Azure OpenAI. The successor framework broadens this noticeably, listing Microsoft Foundry, Anthropic, Azure OpenAI, OpenAI and Ollama among its providers. If provider flexibility matters to you, that is another point in favour of building new work on the successor rather than here.
Bottom line: Semantic Kernel does not give you SaaS connectors; it turns the services your own application already exposes into agent tools, which for a .NET business is worth more.
Semantic Kernel alternatives: what to pick instead, and when
The first alternative to consider is Microsoft's own successor, which is unusual and is the honest starting point. Beyond that, the decision splits on language and on whether you want to write code at all.
| Option | Billing unit | Cost at reference workload | Suits | Does better than Semantic Kernel |
|---|---|---|---|---|
| Semantic Kernel | Model tokens only | ~$1-$27 tokens, often $0 hosting | Existing .NET apps already using it | Nothing it does the successor does not do better |
| Microsoft Agent Framework | Model tokens only | ~$1-$27 tokens plus hosting | New Microsoft-stack agent projects | Simpler API, graph workflows, Go preview, active investment |
| Microsoft AutoGen | Model tokens only | Higher: conversation multiplies calls | Nothing new. Its README declares maintenance mode | Nothing. It is explicitly frozen and community managed |
| Microsoft Copilot Studio | Per message or capacity pack | Published Microsoft plan pricing | Microsoft 365 businesses without developers | A non-developer can ship an agent in a day |
| Microsoft Power Automate | Per user or per flow | Published Microsoft plan pricing | Rule-based Microsoft workflows | Hundreds of connectors and no code required |
| LangGraph | Model tokens only | ~$1-$27 tokens plus hosting | Python teams wanting explicit control flow | Mature graph state, checkpoints and approvals |
| Pydantic AI | Model tokens only | ~$1-$27 tokens, free observability | Python teams with no Microsoft attachment | Validated typed output and free full tracing |
When to pick the alternative outright
Pick the Microsoft Agent Framework for anything new on the Microsoft stack. This is not a close call and it is Microsoft's own position: their docs call it the direct successor to both Semantic Kernel and AutoGen, built by the same teams, and it adds graph-based workflows with checkpointing plus a Harness for long multi-step tasks. It supports .NET, Python and Go, with Go in public preview.
Do not pick Microsoft AutoGen for anything new, and this is the least ambiguous statement on the page. Its own README carries a maintenance-mode banner reading, verbatim, that AutoGen is now in maintenance mode, will not receive new features or enhancements and is community managed going forward, directing new users to the Agent Framework instead. Its repository was last pushed on 15 April 2026, nearly four months before we checked. Semantic Kernel carries no such banner and is still being committed to, which is a real and meaningful difference between the two halves of the consolidation.
Pick Microsoft Copilot Studio if the people who need the agent are not developers and your business already runs Microsoft 365, because it will produce a working assistant in a day and Semantic Kernel will take a fortnight. Pick Microsoft Power Automate if the process is mostly rules and connectors with one AI step, which describes far more real work than people admit.
Pick LangGraph or Pydantic AI if you write Python and have no Microsoft attachment, because you avoid inheriting a framework that already has a published migration guide away from it, and both have better momentum right now.
Stay with Semantic Kernel in exactly one situation: you already have a working Semantic Kernel application, it does what it should, and the migration is not worth doing this quarter. That is a perfectly good reason. Adopting it fresh is not.
Bottom line: The strongest Semantic Kernel alternative is Microsoft's own Agent Framework, which its documentation calls the direct successor, so new Microsoft-stack projects should start there rather than here.
Migration and lock-in: can you get your work out?
Commercially there is no lock-in at all. MIT licence, no fee, no seats, no meter, and your plugins are ordinary application services that would still compile if you deleted the framework. Microsoft has no leverage over you through Semantic Kernel itself.
The migration everyone will eventually face is to the Agent Framework, and Microsoft has done unusually good work making it survivable. The published guide walks through it concretely: namespaces move to Microsoft.Agents.AI in .NET or agent_framework in Python, agent creation collapses from building a kernel and attaching an agent into a single AsAIAgent or as_agent call, threads become sessions the agent creates for you, and the family of service-specific agent classes consolidates into one. Tool registration in particular gets much shorter, dropping the attribute, the plugin wrapper and the kernel entirely.
The detail that makes this genuinely incremental rather than a rewrite is the compatibility layer. From semantic-kernel version 1.38 onward, existing KernelFunction instances convert into Agent Framework tools through as_agent_framework_tool, including functions built from prompt templates and search functions created from vector store collections. So you can move the agent loop across while your entire tool layer stays where it is, and migrate the tools later or never. Very few framework transitions offer that.
The stickier dependency is Azure, and it is a soft one. If your models, your search index and your identity are all in Azure, then leaving is a project regardless of which framework sits on top. Keep your model calls behind a thin interface of your own so switching providers is configuration rather than code, and that dependency stays manageable.
The clear-eyed summary: the framework is free and portable, the successor migration is documented and partially automated, and the thing most likely to trap you is not Semantic Kernel at all but a managed Foundry deployment whose costs you agreed to without seeing a public rate card. That is the locked in risk worth naming, and it is avoidable by choosing self-hosting.
The Microsoft consolidation: what it means if you are starting a project today
Microsoft has folded two frameworks into one, and Semantic Kernel is one of the two. Checked against Microsoft Learn on 6 August 2026, the migration guide index publishes exactly this list: migrating from Semantic Kernel, migrating from AutoGen, and an A2A SDK v1 migration. Two of the three are Microsoft's own previous agent frameworks. The Agent Framework overview states that it is the direct successor to both, created by the same teams, combining AutoGen's abstractions for single and multi-agent patterns with Semantic Kernel's enterprise features, and adding graph-based workflows for explicit multi-agent orchestration.
The two halves are not in the same condition and it matters which one you are looking at. AutoGen has formally stopped: its README carries a maintenance-mode banner stating verbatim that it will not receive new features or enhancements and is community managed going forward, and its repository was last pushed on 15 April 2026. Semantic Kernel has no such banner, was pushed on 5 August 2026, and shipped .NET and Python releases on 7 July 2026. So Semantic Kernel is superseded, not frozen. AutoGen is frozen.
The plain answer to whether you should start a new project on Semantic Kernel today is no, and the reason is not quality. It is that Microsoft has published a migration guide pointing away from it, put the new capabilities including graph workflows, the Harness and Go support into the successor, and named that successor in its own documentation. Choosing Semantic Kernel now is choosing to do a migration later that you could simply not do. The exception is a team already deep in a working Semantic Kernel application, where continuing is sensible and the migration can wait for a quarter when it is worth the disruption.
One practical note for anyone in that position: the compatibility layer means the migration does not have to be a single event. Move the agent loop when you have time, keep your tools where they are, and treat the two as separate pieces of work.
Bottom line: As of 6 August 2026 Semantic Kernel is superseded but still maintained, with a Microsoft-published migration guide pointing to the Agent Framework, so existing apps should stay and new projects should start on the successor.
Microsoft Semantic Kernel FAQ
Is Semantic Kernel deprecated in 2026?
Not deprecated, but superseded, and Microsoft says so itself. The Agent Framework documentation states plainly that it is the direct successor to both Semantic Kernel and AutoGen, created by the same teams, and Microsoft publishes a detailed migration guide from Semantic Kernel covering namespaces, agent creation, tool registration and dependency injection. Meanwhile the repository is still active, pushed 5 August 2026. So it works, it is supported, and it is not where new investment is going. Treat it as a maintained legacy rather than a dead project.
Should we start a new project on Semantic Kernel or Agent Framework?
Agent Framework, on Microsoft's own framing. It combines AutoGen's agent abstractions with Semantic Kernel's enterprise features and adds graph-based workflows with checkpointing and human in the loop support, plus a Harness for long multi-step tasks. Its repository had around 12,600 stars and was pushed 5 August 2026 when we checked. Starting new work on Semantic Kernel means adopting a framework you already have a migration guide for, which is a strange position to enter deliberately.
Is Semantic Kernel still maintained?
Yes, on the evidence rather than the assurance. Checking the GitHub API on 6 August 2026: the repository was pushed on 5 August, 22 commits landed in the preceding month, and .NET package version 1.79.0 work went in on 5 August. The most recent tagged releases were python-1.44.0 and dotnet-1.78.0, both on 7 July 2026. That is real maintenance, though at a slower cadence than the successor project. What is not maintained is Java, where the last tagged release was in May 2025.
Does Semantic Kernel support Java properly?
Not any more, and this is the clearest honest warning on the page. Semantic Kernel is marketed as C#, Python and Java, but the semantic-kernel-java repository's last tagged release was java-1.4.4-RC1 in May 2025, with 1.4.3 before it in February 2025. That is over a year of no tagged release while .NET and Python both shipped in July 2026. If you are a Java shop evaluating this on the strength of the three-language claim, verify current Java support directly before committing, because the release record does not support it.
What does Semantic Kernel cost?
The SDK is free under the MIT licence with no fee, seats or execution meter, and the Microsoft Agent Framework is free too. Your bill is model tokens from whichever provider you connect plus hosting, which may be zero extra if the agent lives inside an application you already deploy. On our reference workload of 1,000 inbox triage runs a month at roughly 3,000 input and 400 output tokens, that is around a dollar on a budget model and around twenty-seven on a frontier model. The framework adds nothing to either.
What does Azure AI Foundry Agent Service cost?
Microsoft does not publish the rates. Checking the Foundry Agent Service pricing page on 6 August 2026, hosted agents are billed by vCPU-hour and GiB-hour and both figures render as a dash. File search shows a dash per GB of vector storage per day with 1GB free, code interpreter a dash per session, and web search a dash per 1,000 transactions. There is an Agent Pre-Purchase Plan offering a stated 5% to 15% discount on Agent Commit Units, which is a discount on numbers you cannot see. Get a quote before designing around it.
How hard is migrating to the Agent Framework?
Structural but well documented. Namespaces change, agent creation collapses from a kernel-plus-agent dance into a single AsAIAgent or as_agent call, threads become sessions the agent creates for you, and the many agent classes consolidate into one. Tool registration gets markedly simpler: no KernelFunction attribute, no plugin wrapper, no kernel. Usefully, existing KernelFunction instances convert with as_agent_framework_tool from semantic-kernel 1.38 onward, so you can migrate the agent loop first and keep your tools, which makes it incremental rather than a rewrite.
Semantic Kernel or Pydantic AI?
This is decided by your existing stack, not by features. If you write C# and the agent belongs inside an application you already deploy, the Microsoft path avoids a second language, a second pipeline and a second thing to patch, and that saving recurs forever. If you write Python and have no Microsoft attachment, Pydantic AI is smaller, faster moving and has a better observability story, and you avoid inheriting a framework with a published successor. Neither is a bad tool. The wrong answer is picking one against your team's actual language.
Can you build this into our existing .NET application?
Yes, and embedding into software you already run is usually cheaper and more maintainable than a separate service, because it inherits your deployment, monitoring and authentication instead of needing its own. Given Microsoft's stated direction we would normally build new work on the Agent Framework rather than Semantic Kernel, and say so plainly in the scope. We start with a free automation audit, build with step limits, logging and approval gates on anything consequential, and hand over code and documentation you own outright plus a recurring plain-language report of what ran and what needs attention.
Looking at alternatives? The honest answer on Semantic Kernel in 2026 is a timing answer rather than a quality one. It is well built, genuinely maintained, and for a .NET team the C# support is worth real money against the alternative of running a Python service nobody owns. But Microsoft has named a successor, written the migration guide and put its Go and Harness work there instead, so adopting Semantic Kernel today is choosing the framework you will migrate off rather than the one you will migrate to. Where the Microsoft stack beats us outright is the existing .NET application: embedding an agent in software you already deploy is cheaper than anything we could build alongside it. Where we help is the business with the process and no application to embed anything into. See the Autonoly review.
