LangGraph vs Microsoft Agent Framework vs OpenAI Agents vs Anthropic SDK: The 2026 Pick

Picking an agent framework in 2026 is not the same exercise it was in 2024. Two years ago, the choice was effectively LangChain or write-your-own. Today there are four serious frameworks from four serious providers, plus the model-agnostic open ecosystem. The good news is that all of them work. The harder news is that they have meaningfully different shapes, and picking the wrong one costs you weeks of rework.

I have built production agents in all four. This piece is the comparison I wish I had read before I started.

Why pick a framework at all

You can write an agent without a framework. The simplest agent is a while-loop that calls a model, parses the response, calls a tool, and feeds the result back. For a single-tool agent, that loop is fifty lines.

The reason frameworks exist is that real agents are not single-tool loops. They have multiple tools, branching logic, retries, parallel sub-agents, human-in-the-loop checkpoints, observability, persistent state, and recovery from partial failures. Re-implementing all of that for every project burns months. A good framework gives you those capabilities as defaults and lets you customize the parts you care about.

The task we're going to build in all four

To compare the frameworks fairly, I will show the same simple task in each one: an agent that reads a customer support ticket, classifies it, looks up customer history from a database, and drafts a reply. The actual code is illustrative — exact APIs change every release — but the shape and feel of each framework is what we want to see.

LangGraph: the graph-based heavyweight

LangGraph is built by the LangChain team and treats an agent as an explicit graph. You define nodes (units of work) and edges (transitions). The state of the agent is a typed object that flows through the graph. You can branch, loop, parallelize, and persist state at every step.

from langgraph.graph import StateGraph, END
from typing import TypedDict

class TicketState(TypedDict):
    ticket: str
    category: str
    customer_history: list
    draft_reply: str

def classify(state):
    state["category"] = llm.classify(state["ticket"])
    return state

def lookup_customer(state):
    state["customer_history"] = db.query(state["ticket"]["customer_id"])
    return state

def draft_reply(state):
    state["draft_reply"] = llm.draft(state)
    return state

graph = StateGraph(TicketState)
graph.add_node("classify", classify)
graph.add_node("lookup", lookup_customer)
graph.add_node("draft", draft_reply)
graph.add_edge("classify", "lookup")
graph.add_edge("lookup", "draft")
graph.add_edge("draft", END)
graph.set_entry_point("classify")
app = graph.compile()

What it is good at. Production-grade reliability. Explicit control. Human-in-the-loop checkpoints. Persistence and replay. Observability through LangSmith. If you are running an agent that touches customer money or does anything regulators will audit, LangGraph is the strongest choice.

What it is rough at. The learning curve. The first week of LangGraph is a lot of vocabulary — graphs, channels, reducers, checkpointers. A team that just wants to ship a chatbot will feel slowed down.

Microsoft Agent Framework: the .NET / Azure pick

Microsoft consolidated AutoGen and several internal efforts into the Microsoft Agent Framework, which hit 1.0 in 2026 with strong MCP support. It is Python-and-.NET-first, with deep Azure OpenAI integration and built-in identity, observability, and policy enforcement through Azure.

using Microsoft.AgentFramework;

var agent = new Agent("ticket-handler")
    .WithModel("gpt-5.5")
    .WithTool(ClassifyTool)
    .WithTool(CustomerLookupTool)
    .WithTool(DraftReplyTool)
    .WithSystemPrompt("You handle customer support tickets...")
    .Build();

var result = await agent.RunAsync(new { ticket = incomingTicket });
Console.WriteLine(result.Output);

What it is good at. Enterprise governance. The framework integrates Azure AD identity, Azure Key Vault for secrets, Azure Monitor for telemetry, and Azure Content Safety for guardrails. For a regulated enterprise on Azure, the procurement story writes itself.

What it is rough at. Vendor coupling. The framework runs outside Azure, but every step away from Azure costs you something. Teams that want a multi-cloud or cloud-portable agent should think twice.

I covered the framework's 1.0 release in detail in my Microsoft Agent Framework 1.0 piece — read that for the deeper history and Azure-side trade-offs.

OpenAI Agents SDK: the smoothest beginner path

OpenAI's Agents SDK launched in 2025 and matured through several releases into 2026. The pitch is simplicity: an agent is a model, a system prompt, a list of tools, and a handoff mechanism for sub-agents. The API is small enough to fit on a postcard.

from openai_agents import Agent, function_tool

@function_tool
def classify(ticket: str) -> str:
    return llm_classify(ticket)

@function_tool
def lookup_customer(customer_id: str) -> dict:
    return db.query(customer_id)

@function_tool
def draft_reply(ticket: str, history: dict) -> str:
    return llm_draft(ticket, history)

agent = Agent(
    name="ticket-handler",
    instructions="Classify the ticket, look up customer history, and draft a reply.",
    tools=[classify, lookup_customer, draft_reply],
    model="gpt-5.5",
)

result = agent.run({"ticket": incoming_ticket})
print(result.output)

What it is good at. Fast onboarding. A first agent in twenty minutes. Built-in multi-agent handoffs, structured outputs, computer-use tools, and the deepest GPT-5.5 integration. If you want a working agent before the week is out, this is the path.

What it is rough at. Production discipline. The simplicity that makes day one fast also means you have to add observability, persistence, and retry policy yourself. For a serious production agent you will reach for additional tooling.

Anthropic Agent SDK: minimal and Claude-native

Anthropic's official Agent SDK (built on top of the broader Anthropic SDK) is the youngest of the four. It is also the smallest. The whole framework is a thin layer that turns a Claude model, a tool list, and a goal into an agentic loop. It inherits Claude Opus 4.7's 1M-token context, which means an agent can hold a much larger working memory than its peers.

from anthropic import Anthropic
from anthropic.tools import tool

client = Anthropic()

@tool
def classify(ticket: str) -> str:
    return llm_classify(ticket)

@tool
def lookup_customer(customer_id: str) -> dict:
    return db.query(customer_id)

@tool
def draft_reply(ticket: str, history: dict) -> str:
    return llm_draft(ticket, history)

response = client.agents.run(
    model="claude-opus-4-7",
    instructions="Classify, look up history, draft reply.",
    tools=[classify, lookup_customer, draft_reply],
    input={"ticket": incoming_ticket},
)
print(response.output)

What it is good at. Long context. Claude voice consistency. The cleanest minimal API of the four. Excellent tool-use accuracy. Native MCP support so any MCP server you build is callable.

What it is rough at. Multi-agent orchestration. The SDK is honest about what it is — a single-agent loop done well. If you need a graph of cooperating agents, you will reach for LangGraph or build orchestration yourself.

Side-by-side comparison

Here is the short summary I keep on a sticky note.

• Best for production reliability: LangGraph > Microsoft > Anthropic > OpenAI.
• Best for fastest first agent: OpenAI > Anthropic > Microsoft > LangGraph.
• Best for enterprise / Azure shops: Microsoft > LangGraph > OpenAI > Anthropic.
• Best for long-context single-agent work: Anthropic > LangGraph > OpenAI > Microsoft.
• Best for multi-agent orchestration: LangGraph > Microsoft > OpenAI > Anthropic.
• Best for model flexibility: LangGraph > Microsoft > OpenAI > Anthropic.
• Best for community + examples: LangGraph > OpenAI > Microsoft > Anthropic.

Which one to pick

Here is the honest decision tree I use when a team asks me.

If you are a solo developer or small team shipping your first agent in a week, use the OpenAI Agents SDK or the Anthropic Agent SDK. Pick whichever model you already prefer. You will learn the agent-loop mental model fastest.

If you are a .NET shop on Azure, use the Microsoft Agent Framework. The procurement story, the identity story, and the observability story are already done for you.

If you are building an agent that touches money, healthcare records, or anything a regulator will inspect, use LangGraph. The explicit graph and persistence model is what regulators will want to see.

If you are building a single-agent system that needs a huge working memory — read this entire codebase, read this entire research library — and produce one careful output, use the Anthropic Agent SDK with Claude Opus 4.7's 1M-token context.

If you do not know which one fits yet, spend a Saturday rebuilding the same toy task in two of them. The framework whose code you find more pleasant after four hours is your right answer. Taste matters.

Common questions

Should I learn LangChain first? LangChain is still useful as a tool library, but for agent orchestration in 2026, LangGraph has eclipsed it. If you are starting from zero, learn LangGraph directly.

What about Anthropic's Claude Code as a framework? Claude Code is a coding agent — a turnkey product, not a framework you build with. It uses the Anthropic SDK under the hood. If you want to build something like Claude Code, the Anthropic Agent SDK is the starting point. See my Claude Opus 4.7 piece for context.

How do these compare on cost? Token costs are mostly a function of the underlying model, not the framework. LangGraph and Microsoft are model-agnostic; you pick the model and pay that provider's rates. OpenAI Agents and the Anthropic SDK lean toward their own models. The framework overhead is usually noise compared to the underlying model spend.

Can I use these for non-coding agents? Yes. All four are general agent frameworks. The customer-support example above is non-coding. Coding agents (Claude Code, Cursor, Aider) are a specific application of the same pattern.