Two Frameworks Enter, One Framework Leaves

Microsoft just shipped the Release Candidate for Agent Framework 1.0, and in the process killed both AutoGen and Semantic Kernel. Two of the most popular tools for building agents in the .NET and Python ecosystems — one born in a research lab, the other in an enterprise SDK team — now share a single codebase. Both original repos are in maintenance mode. No new features, just security patches and a gentle push toward migration.

This is the most consequential framework decision in the agent space this year, and most people are treating it as a versioning detail.

#What Actually Got Merged

AutoGen was the research darling. Group chat orchestration, creative multi-agent topologies, the kind of experimental patterns that made for great conference demos. You could throw half a dozen specialized agents into a conversation and watch them negotiate a solution. Powerful, chaotic, and not something you'd put behind a customer-facing API without serious guardrails.

Semantic Kernel was the enterprise workhorse. Session management, telemetry hooks, vector store connectors for Azure AI Search and Cosmos DB, the whole nine yards of production plumbing. Stable, predictable, and frankly boring in the best way possible.

The new unified framework takes AutoGen's orchestration patterns — sequential, concurrent, group chat, handoff — and drops them into Semantic Kernel's production chassis. Pluggable memory backends spanning Redis, Pinecone, Qdrant, and Postgres. OpenTelemetry baked in from day one. Human-in-the-loop approval queues for regulated industries. Checkpointing for long-running workflows so your pipeline can survive a pod restart without losing three hours of accumulated context.

The interesting architectural choice: they split orchestration into two explicit modes. Agent Orchestration handles LLM-driven, open-ended reasoning — the AutoGen lineage. Workflow Orchestration handles deterministic business logic — the Semantic Kernel lineage. Same runtime, different execution models, composable in a single pipeline.

from agent_framework import ChatClientAgent, sequential

agent = AzureOpenAIResponsesClient.as_agent()

workflow = sequential([
    validate_input,       # deterministic step
    agent.reason,         # LLM-driven reasoning
    apply_business_rules, # deterministic again
    agent.summarize,      # LLM-driven output
])

This hybrid is exactly what production systems need. The deployments I've seen fail hardest are the ones that try to make the model handle everything, including the parts that should just be a function call with a switch statement.

#The Consolidation Is Everywhere

Microsoft isn't the only one collapsing layers. Last week, DigitalOcean acquired Katanemo Labs — the team behind Plano, an open-source data plane for agentic applications. Their pitch: a framework-agnostic layer that handles orchestration, safety, and observability regardless of which SDK sits on top. Salman Paracha, Katanemo's CEO, joined as DigitalOcean's SVP of AI.

Two infrastructure moves in the same week, both pointing the same direction. The ecosystem can't sustain a dozen incompatible ways to wire agents together. Here's where the major players stand right now:

Every major vendor wants to own the orchestration layer. Not the model — they know you'll swap models quarterly. The orchestration. Because that's where switching costs compound.

#Orchestration Is the New Middleware Lock-in

Kai Waehner published a sharp analysis this week arguing that agent orchestration is an underappreciated lock-in mechanism. His core point: enterprises obsess over which foundation model to use while sleepwalking into orchestration decisions that are far harder to reverse.

The math backs him up. Swapping GPT-4 for Claude in an API call is a weekend project. Ripping Agentforce's orchestration out of your Salesforce instance after you've built 50 workflows on it? That's a quarter of engineering time, minimum. The orchestration layer touches routing logic, state management, approval flows, observability pipelines — everything that makes your agents actually work rather than just respond.

Microsoft's open-source play helps here, paradoxically. By supporting MCP, A2A, and OpenAPI as first-class protocols, they're betting that openness wins adoption. Whether that bet holds once Azure-specific features start getting preferential treatment in the docs and tooling remains an open question.

#So What Do You Do

If you're currently on AutoGen or Semantic Kernel, start planning migration. Maintenance mode means you're accumulating tech debt with every commit. The RC is stable enough to prototype against, and the GA target was end of Q1 — it's either shipped or shipping any day.

If you're choosing a framework today, the decision isn't really about which SDK has the nicest API surface. It's about which orchestration layer you can leave without rewriting your core logic. Prioritize support for open protocols. Test that you can swap model providers without touching orchestration code. If you can't, you've already made a lock-in decision — you just haven't noticed yet.

If you're building something custom in-house, the Microsoft merger validates a pattern worth stealing regardless of what tools you use: separate your agent orchestration from your workflow orchestration. Don't let the model make decisions that should be hard-coded. Don't hard-code decisions that benefit from reasoning. The boundary between those two modes is your most important architectural decision, and most teams get it wrong by defaulting to "let the LLM figure it out."

The era of picking a framework based on GitHub stars and tutorial vibes is winding down. What matters now is which orchestration layer you're willing to couple your architecture to — and how much of it you can actually take with you when the next consolidation wave hits.