Microsoft Agent Framework Alternatives (2026), Compared

The best alternative depends on what you need that Agent Framework doesn't give you, or what you want to avoid. If you want explicit graphs and the largest Python ecosystem, LangGraph. For the least code on OpenAI models, the OpenAI Agents SDK. For typed inputs and outputs, Pydantic AI. On Google Cloud and Gemini, Google ADK. For role-based teams of agents, CrewAI. For retrieval-heavy apps, LlamaIndex. For MCP-first Python agents with approvals, budgets and a runtime for scheduled and event-driven agents, Promptise Foundry.

The effort column is our estimate for a typical Python agent with tools. Tools written as plain functions or served over MCP move with little change; workflows, memory and hosting are what you rewrite.

• Stay on Agent Framework if you are on Azure or .NET. It is Microsoft's supported path, covers Python and .NET, and is the first framework listed for Foundry hosted agents.

• LangGraph also runs in Microsoft Foundry, as a hosted agent. Choosing Foundry doesn't force Agent Framework.

• "Foundry" means two unrelated things. Microsoft Foundry is Azure's AI platform. Promptise Foundry is an open-source Python framework. They share a word, nothing else.

Microsoft Agent Framework is an open-source framework (MIT license) for building agents and multi-agent workflows in Python and .NET, with Go in public preview. Microsoft's overview calls it the direct successor to Semantic Kernel and AutoGen, created by the same teams: it combines AutoGen's agent abstractions with Semantic Kernel's enterprise features (session state, type safety, filters, telemetry) and adds graph-based workflows.

Key facts, from Microsoft's docs and repository:

• Status. Version 1.0 for Python and .NET was released on April 3, 2026, with stable APIs. The Python package agent-framework was at 1.23.0 on October 22, 2026.

• Agents. An Agent wraps a chat client and tools. Model connectors include Microsoft Foundry, Azure OpenAI, OpenAI, Anthropic, Amazon Bedrock, Gemini and Ollama.

• Workflows. Graph-based workflows with checkpointing, plus multi-agent patterns: sequential, concurrent, handoff, group chat and Magentic-One, with human-in-the-loop approvals.

• Tools and protocols. Function tools, MCP tools, and samples for hosting agents over the A2A protocol.

• Context and RAG. Context providers inject memory or retrieved content before a model call; a vector search tool lets the model retrieve on demand, with stores such as in-memory, Azure AI Search, pgvector, Qdrant and Redis.

• Operations. Middleware, OpenTelemetry, declarative YAML agents, a DevUI for local testing, and migration guides from Semantic Kernel and AutoGen.

AutoGen's README now says the project is no longer actively maintained and points new users to Agent Framework; Semantic Kernel's README says it "is now Microsoft Agent Framework". If you are moving off AutoGen, Migrate from AutoGen: Agent Framework, AG2 and More covers that path with code.

Many searches for "Foundry" agents mean Microsoft Foundry. The two products are unrelated:

The distinction that matters is platform versus framework. Microsoft Foundry is where an agent can be hosted, connected to models and tools, and evaluated. Agent Framework, LangGraph and the others are libraries you write the agent with. Microsoft Foundry's Agent Service hosts agents built with several frameworks, so the platform choice and the framework choice are separate decisions.

Yes, as a hosted agent. Microsoft's Foundry Agent Service docs list Agent Framework, LangGraph, the OpenAI Agents SDK and custom code among the frameworks a hosted agent can use. The LangGraph how-to installs langchain-azure-ai[hosting] (1.2.9 or later), wraps a compiled graph in a host server such as ResponsesHostServer(graph) for an OpenAI-compatible responses endpoint, and deploys it with the Azure Developer CLI. With a checkpointer, the graph's state carries across turns; the docs recommend a durable checkpointer in production.

The core of Microsoft's example, condensed (from the official how-to; it needs an Azure project, so it isn't run here). build_chat_model() is a helper defined in the how-to that connects ChatOpenAI to the Foundry project's model deployment with an Entra ID token:

from langchain.agents import create_agent
from langgraph.checkpoint.memory import MemorySaver
from langchain_azure_ai.agents.hosting import ResponsesHostServer

graph = create_agent(build_chat_model(), tools=[], checkpointer=MemorySaver())
ResponsesHostServer(graph).run(port=8088)  # serves POST /responses

So "LangGraph or Foundry" is a false choice. If your team knows LangGraph and the company runs on Azure, you can keep LangGraph and host it in Foundry. Agent Framework has the deeper Foundry integration (Foundry tools, memory and evaluation, some still in preview), which is a reason to prefer it when Foundry is your platform for the long term.

Choose it when:

• You build in .NET, or in both .NET and Python. No other framework here has first-class .NET support.

• Azure and Microsoft Foundry are your platform. Entra ID, Azure AI Search, Foundry models and hosted agents are first-party integrations.

• You are migrating from Semantic Kernel or AutoGen. Microsoft provides migration guides and the concepts carry over.

• You need graph workflows and multi-agent patterns from one vendor with long-term support.

Look at an alternative when:

• You want a Python-only library with a smaller surface, or one built around typed outputs.

• Your company standardizes on another cloud (Google ADK on Google Cloud).

• You need features around the agent that Agent Framework leaves to you or to Foundry, for example a project runner, cron and webhook triggers, or per-run budgets in a self-hosted runtime.

• You want to avoid anything that pulls you toward one cloud, even optionally.

Start from the shape of your retrieval, not the framework brand:

• Retrieval is the product (search, Q&A over many document types, complex indexing): LlamaIndex, which is built around loaders, indexes and query engines, or LangChain's retrievers and vector store integrations.

• Retrieval is one tool of an agent: any agent framework works, because RAG is then a tool call. Agent Framework has a native vector search tool and context providers; Promptise has RAGPipeline and rag_to_tool(); LangGraph uses LangChain retrievers; Pydantic AI and the OpenAI Agents SDK take a search function as a tool.

• You are on Azure: Agent Framework with Azure AI Search is the shortest path.

A practical way to stay free to switch: keep retrieval in your own function or behind an MCP server, and wrap it as a tool in whichever framework you pick. The example below does exactly that, so the same retrieval code runs in both frameworks. Agentic RAG in Python: Give Your AI Agent a Search Tool goes deeper on retrieval as a tool.

Versions were checked on PyPI on October 23, 2026; each summary comes from the project's own documentation.

LangGraph

LangGraph 1.2.16 is a low-level runtime for stateful agents: you define state, nodes and edges and compile the graph with a checkpointer. It offers durable execution, human-in-the-loop interrupts, short- and long-term memory and streaming, with tracing and deployment through LangSmith. It is the closest match to Agent Framework's workflows, and it runs as a hosted agent in Microsoft Foundry. See LangGraph Alternatives: 7 Options and How to Migrate (2026) for the reverse view.

OpenAI Agents SDK

The OpenAI Agents SDK 0.24.0 is a small library around agents, handoffs, guardrails and sessions, with built-in MCP support, tracing and human-in-the-loop interruptions. Other model providers work through adapters. It is a documented Foundry hosted-agent option too. Pick it for the least code on OpenAI models.

Pydantic AI

Pydantic AI 2.60.0 treats an agent as a typed function: validated dependencies in, validated output out. It supports many providers, has MCP built in, integrates with Temporal, DBOS and Prefect for durable runs, and traces through OpenTelemetry and Logfire. Pick it if your team likes Pydantic and wants errors before runtime.

Google ADK

Google ADK 2.12.0 is a code-first toolkit in Python, TypeScript, Go, Java and Kotlin, with LLM agents, graph workflows, MCP and A2A, built-in evaluation, and deployment to Google Cloud. It works with Gemini and other models. Pick it when your platform is Google Cloud, as you would pick Agent Framework on Azure.

CrewAI

CrewAI 1.15.28 describes agents by role and goal and groups them into crews; Flows add event-driven steps with persisted state, and MCP servers plug into agents. Pick it when your problem maps to a team of roles. CrewAI Alternatives: 7 Options and How to Migrate (2026) covers its limits.

LlamaIndex

LlamaIndex 0.14.25 centers on connecting LLMs to your data: connectors, indexes, vector stores, query and chat engines, plus agents and event-driven workflows. Pick it when retrieval quality is the main problem.

Promptise Foundry

Promptise Foundry 1.7.0, which we make, is an Apache-2.0 Python framework. build_agent() turns MCP servers and @tool functions into an agent, with human approvals, budgets, guardrails, sandboxed code execution and observability. It also includes an MCP server framework, and an Agent Runtime that runs agents on cron, webhook and other triggers with a journal for crash recovery. It builds on LangChain's packages and accepts LangChain chat models, which is how it reaches Azure OpenAI and other providers. Its gaps against Agent Framework: Python only, no A2A protocol support, no managed hosting, RAG through base classes you implement rather than ready-made database connectors, and a smaller community.

Each cell is from the project's documentation. "Yes" means built in; "via" names the integration the docs describe.

A2A, the agent-to-agent protocol, is documented by Agent Framework, Google ADK, Pydantic AI, CrewAI and LangGraph's Agent Server, not by Promptise. Where others are ahead of Promptise: Agent Framework and Google ADK on languages and their clouds, LangGraph on ecosystem size and graph control, LlamaIndex on retrieval components, and every framework with a managed platform on hosting.

• Python 3.10 or newer (Agent Framework recommends 3.11 or newer) and an OpenAI API key.

• Agent Framework: uv pip install "agent-framework-core==1.23.0" agent-framework-openai python-dotenv. The agent-framework package installs every integration; core plus the OpenAI connector is enough here.

• Promptise: uv pip install "promptise==1.7.0" python-dotenv.

The example answers questions from a small employee handbook. Retrieval is a plain function: embed the passages once, rank them by cosine similarity. Neither framework is involved, which is what keeps it portable:

"""A tiny retrieval index shared by both examples: embed once, search by cosine similarity."""
import math

from openai import OpenAI

DOCS = [
    "Travel: book flights at least 14 days ahead; economy class for trips under 6 hours.",
    "Expenses: submit receipts within 30 days; meals are reimbursed up to 60 EUR per day.",
    "Remote work: up to 3 days a week from home; work abroad needs HR approval first.",
    "Equipment: laptops are replaced every 4 years; request a new one through the IT portal.",
]
_vectors: list[list[float]] = []


def _embed(texts: list[str]) -> list[list[float]]:
    response = OpenAI().embeddings.create(model="text-embedding-3-small", input=texts)
    return [item.embedding for item in response.data]


def search(query: str, k: int = 2) -> list[str]:
    """Return the k handbook passages most similar to the query."""
    if not _vectors:
        _vectors.extend(_embed(DOCS))
    q = _embed([query])[0]

    def cosine(v: list[float]) -> float:
        return sum(a * b for a, b in zip(q, v)) / (math.hypot(*q) * math.hypot(*v))

    ranked = sorted(zip(DOCS, _vectors), key=lambda pair: cosine(pair[1]), reverse=True)
    return [doc for doc, _ in ranked[:k]]

In production you would replace the list with a vector database. The interface stays the same: a query in, passages out.

Agent Framework turns the function into a tool with @tool, and the Agent runs the tool-calling loop:

"""RAG as a tool in Microsoft Agent Framework (agent-framework 1.23.0)."""
import asyncio
import os
from typing import Annotated

from dotenv import load_dotenv
from agent_framework import Agent, tool
from agent_framework.openai import OpenAIChatClient

import handbook

load_dotenv()  # Agent Framework doesn't load .env files on its own


@tool
def search_handbook(query: Annotated[str, "What to look up in the employee handbook"]) -> str:
    """Search the employee handbook."""
    return "\n".join(handbook.search(query))


agent = Agent(
    client=OpenAIChatClient(model="gpt-5-mini", api_key=os.environ["OPENAI_API_KEY"]),
    name="HandbookAgent",
    instructions="Answer from the employee handbook only, in one short sentence.",
    tools=[search_handbook],
)


async def main() -> None:
    result = await agent.run("Can I work from Lisbon for two weeks, and how do I claim my meals there?")
    print(f"Agent: {result}")


asyncio.run(main())

Agent: You may work from Lisbon only with HR approval, and you can claim meals by submitting receipts within 30 days for reimbursement up to 60 EUR per day.

The model called search_handbook and answered from the remote-work and expenses passages. Two details from the docs: Agent Framework doesn't load .env files on its own, and parameter descriptions go in Annotated[...]. On Azure you would swap OpenAIChatClient for FoundryChatClient with a project endpoint and an Azure credential; the agent code stays the same.

Promptise takes the same function through its own @tool decorator, which reads parameter descriptions from the docstring:

"""The same agent in Promptise Foundry (promptise 1.7.0)."""
import asyncio

from dotenv import load_dotenv
from promptise import build_agent, tool

import handbook

load_dotenv()  # OPENAI_API_KEY


@tool
async def search_handbook(query: str) -> str:
    """Search the employee handbook.

    Args:
        query: What to look up in the employee handbook.
    """
    return "\n".join(handbook.search(query))


async def main() -> None:
    agent = await build_agent(
        model="openai:gpt-5-mini",
        instructions="Answer from the employee handbook only, in one short sentence.",
        extra_tools=[search_handbook],
    )
    result = await agent.ainvoke({"messages": [{"role": "user", "content":
        "Can I work from Lisbon for two weeks, and how do I claim my meals there?"}]})
    print(f"Agent: {result['messages'][-1].content}")
    await agent.shutdown()


asyncio.run(main())

Agent: You can work from Lisbon only with HR approval (remote work is limited to up to three days per week), and you can claim meals by submitting receipts within 30 days for reimbursement up to €60 per day.

Same retrieval, same answer, about the same amount of code. The difference shows up around the agent: in Promptise the next steps are serving search_handbook from an MCP server, adding an approval to a write tool, or putting the agent in a runtime process with a cron trigger and a budget. In Agent Framework the next steps are workflows, Foundry tools and hosted agents. Choose by which of those you need.

servers={...}

• Hosting decides more than the framework. If you will run on Microsoft Foundry, check that your framework is a supported hosted-agent option and what it gets (tools, memory, evaluation) there. Self-hosting means you own scaling, secrets and upgrades.

• Keep tools portable. Plain functions and MCP servers move between frameworks; tools that depend on framework classes don't.

• Pin versions. Agent Framework ships releases weekly, and several alternatives are pre-1.0 or move fast. Pin and upgrade on purpose.

• Trace from day one. Agent Framework, Pydantic AI and Google ADK emit OpenTelemetry; LangGraph uses LangSmith; Promptise has its own observability and exporters. Decide where traces go before production.

• Check data handling. A managed platform keeps prompts and traces in its own services; read its data controls before sending customer data.

• Versions move weekly. Every version in this guide is from October 23, 2026; check PyPI before you decide.

• The comparison table is from docs, not benchmarks. It says what each framework offers, not how well it performs on your workload.

• The examples cover one agent with one tool. Workflows, multi-agent patterns and hosting differ much more than single agents do.

• Promptise is compared by the team that makes it. We have tried to state its gaps plainly; check the claims against each project's docs.

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

Agent Framework is the successor to Semantic Kernel and AutoGen, built by the same teams. It keeps Semantic Kernel's enterprise features, adds AutoGen's multi-agent abstractions and graph-based workflows, and is where Microsoft's agent development now happens. Semantic Kernel's README points to Agent Framework, and Microsoft publishes migration guides.

Is LangGraph there in Microsoft Foundry?

Yes. Foundry Agent Service runs hosted agents built with LangGraph, Agent Framework, the OpenAI Agents SDK and custom code. For LangGraph, you install langchain-azure-ai[hosting], wrap the compiled graph in a host server and deploy with the Azure Developer CLI. Use a durable checkpointer so conversations keep their state.

Is Promptise Foundry related to Microsoft Foundry?

No. Microsoft Foundry is Microsoft's Azure platform for models and agents, formerly Azure AI Foundry. Promptise Foundry is an open-source Python framework from Promptise for building and running agents on your own infrastructure. A Promptise agent can use Azure OpenAI models through a LangChain chat model, but the two products are unrelated.

Which AI framework is best to get started with RAG in Python?

If retrieval is the core of your app, start with LlamaIndex or LangChain's retrievers. If retrieval is one tool of an agent, any agent framework works: write retrieval as a plain function and wrap it as a tool. On Azure, Agent Framework's vector search tool with Azure AI Search is the shortest path.

Should I use Microsoft Agent Framework or LangGraph?

Agent Framework if you build in .NET, standardize on Azure and Foundry, or are migrating from Semantic Kernel or AutoGen. LangGraph if your team is Python-first, wants explicit graphs and the LangChain ecosystem, or deploys outside Azure. Both run as hosted agents in Microsoft Foundry.

Does Promptise support .NET or A2A?

No. Promptise Foundry is Python only and doesn't implement the A2A protocol; its agents talk to each other through its own cross-agent calls and the runtime's event triggers. If you need .NET or A2A, Agent Framework or Google ADK are better fits.

• Migrate from AutoGen: Agent Framework, AG2 and More ports an AutoGen team to Agent Framework and Promptise.

• Best AI Agent Frameworks (2026): Python Options Compared builds the same agent in nine frameworks.

• LangChain Alternatives: 11 Agent Frameworks Compared (2026) for the LangChain view.

• What Is an AI Agent Framework? When You Need One explains what a framework replaces.

• What Is Agentic RAG? How It Differs from Classic RAG for retrieval design.