Open Source vs Proprietary AI Agent Frameworks 2026: Complete Guide

Open Source vs Proprietary AI Agent Frameworks 2026: The Real Decision

In short

The 2026 decision is not free vs paid. Every major agent SDK is MIT or Apache 2.0 licensed. The real axis is whether the framework's runtime and orchestration state can operate against multiple model providers, or hard-binds to one vendor's inference API and hosted state. Alice Labs classifies frameworks on both model portability and orchestration portability — both must be portable to count as 'truly open source' for total cost of ownership.

The framing most 2026 buyers still walk into the meeting with — "open source is free and safe, proprietary is paid and risky" — is wrong twice over. Every major agent SDK shipping in 2026 (LangGraph, CrewAI, LlamaIndex, Pydantic AI, OpenAI Agents SDK, Claude Agent SDK, Microsoft Agent Framework, Google ADK) uses MIT or Apache 2.0 for its code. License is table stakes.

The real distinction is whether the framework's runtime and orchestration state can operate against multiple model providers, or whether the happy path hard-binds to one vendor's inference API and hosted state. Kai Waehner's April 2026 enterprise agentic AI landscape report calls this out explicitly: framework license and framework portability are now separate discussions, and buyers who conflate them make expensive single-vendor bets that a permissive license does nothing to reverse.

The stakes are real. A 2026 Zapier survey of enterprise AI leaders found 81% concerned about AI vendor dependency and 74% saying loss of their AI vendor would disrupt or halt operations. Those numbers do not fall because your framework ships under MIT — they fall when your state, telemetry, and orchestration can be re-pointed at a different runtime without a rewrite.

Alice Labs classifies frameworks along two axes when we advise Nordic and EU buyers on 2026 shortlists. Model portability: can the framework route to any provider, or does its abstraction assume one? Orchestration portability: is the graph, handoff, or state model reproducible on another runtime, or is the state store proprietary to the vendor? Both must be portable for us to treat a framework as genuinely open source for TCO accounting.

This is the frame we use throughout the rest of this article, and it lives inside the broader shortlist covered in our best AI agent frameworks 2026 guide.

What Counts as 'Open Source' vs 'Proprietary' in Agent Frameworks

In short

Two categories that matter: (1) open source pure play — LangGraph, CrewAI, LlamaIndex, Pydantic AI — MIT-licensed code, model-agnostic orchestration, no hosted runtime required; (2) vendor-anchored open source — Claude Agent SDK, OpenAI Agents SDK, Google ADK, Microsoft Agent Framework — MIT or Apache 2.0 code, but the happy path targets one vendor's API and hosted runtime. Alice Labs' rule: if the happy path requires one vendor's API, treat it as proprietary for lock-in accounting regardless of license.

The taxonomy that matters in 2026 has two categories, not one. Once you use the wrong category as the top-of-funnel filter, every downstream trade-off analysis drifts.

Open source pure play

LangGraph (MIT, langchain-ai/langgraph), CrewAI (MIT, crewAIInc/crewAI), LlamaIndex (MIT, run-llama/llama_index), and Pydantic AI (MIT, pydantic/pydantic-ai). Code is source-available, orchestration is model-agnostic, and no hosted runtime is required — you can install, run, and observe entirely on customer infrastructure without contacting any vendor. The paid layer (LangSmith, CrewAI Enterprise, LlamaCloud) is optional and outside the framework itself.

Vendor-anchored open source

Claude Agent SDK (MIT code, but use is governed by Anthropic's Commercial Terms of Service and the SDK calls Anthropic's API by default), OpenAI Agents SDK (MIT, but Responses API is the default backend), Google ADK (Apache 2.0, first-class for Gemini and Vertex AI), and Microsoft Agent Framework (MIT, first-class for Azure Foundry). The code carries a permissive license; the runtime carries a vendor.

The gap between these categories is not academic. OpenAI Agents SDK supports 100+ models via LiteLLM and any-llm adapters — the license and the runtime both give you options. Claude Agent SDK cannot be pointed at a non-Anthropic model without forking — the license is permissive, the runtime is not. Same MIT-licensed source; opposite lock-in profile.

Alice Labs decision rule: if the framework's happy path requires one vendor's API, treat it as proprietary for lock-in accounting regardless of license. This is the rule we use with every buyer, and it is the rule that keeps procurement conversations honest.

The Open Source Contenders: LangGraph, CrewAI, LlamaIndex, Pydantic AI

In short

Four production-serious open source frameworks compete in 2026. LangGraph (MIT, ~15k+ stars) — graph-based durable execution used in production by Klarna, Replit, and Elastic. CrewAI (MIT, 56.5k stars) — role-based multi-agent crews, claims 65% of Fortune 500 as Basic-tier users. LlamaIndex (MIT, 51.3k stars) — document agents and OCR-heavy retrieval. Pydantic AI (MIT, 19k+ stars) — type-safe agents with dependency injection and durable execution.

These four are the frameworks we most often see reach production in Nordic and EU enterprise deployments in 2026. The community-metrics differences are real, but the technical positioning matters more.

LangGraph

MIT, langchain-ai/langgraph, ~15k+ GitHub stars, 295+ contributors. Graph-based durable execution: nodes are functions or LLM calls, edges are typed transitions, state is a checkpointed TypedDict. First-class human-in-the-loop via interrupt() and Command(resume=...). Production references: Klarna, Replit, Elastic, Uber, LinkedIn, Rippling, Coinbase, NVIDIA. Optional paid layer: LangSmith (observability) and LangGraph Platform ($39/seat/month on the Plus tier).

CrewAI

MIT, crewAIInc/crewAI, 56.5k GitHub stars — the largest agent-framework repo in 2026 by stars. Role-based multi-agent crews plus event-driven flows. CrewAI claims 65% of Fortune 500 as users of the Basic tier. Optional paid layer: CrewAI Enterprise (SSO, RBAC, PII redaction, private VPC deployment). Deep coverage in our CrewAI implementation guide.

LlamaIndex

MIT, run-llama/llama_index, 51.3k stars. Document agents and OCR-heavy retrieval are the sweet spot; the Workflows API extends the framework into agentic orchestration for RAG-shaped agents. Optional paid layer: LlamaCloud for hosted indexing and OCR.

Pydantic AI

MIT, pydantic/pydantic-ai, 19k+ stars. Type-safe agents with dependency injection, structured outputs, MCP support, and durable execution. Positioning: the FastAPI of agent frameworks — Python-idiomatic, testable, and comfortable for teams already invested in Pydantic elsewhere in the stack.

All four are trivially self-hostable. All four are MIT. And all four are portable across model providers — a LangGraph node can call Claude, Gemini, GPT, or an open-weights model on the same graph without a rewrite. This is the property that justifies the "pure play open source" label.

The Proprietary (Vendor-Anchored) Contenders: OpenAI Agents SDK, Claude Agent SDK, MAF, Google ADK

In short

Four vendor-shipped SDKs anchor the 'proprietary in practice' category despite MIT and Apache 2.0 licenses. OpenAI Agents SDK — Responses API by default, 100+ models via LiteLLM. Claude Agent SDK — Python and TypeScript only, same harness as Claude Code, Anthropic API required. Microsoft Agent Framework 1.0 (April 3, 2026) — direct successor to Semantic Kernel and AutoGen. Google ADK — code-first Python/TS/Go/Java/Kotlin, deployment biased to Google Cloud.

These four are the SDKs shipped by the model vendors themselves. All four are MIT or Apache 2.0. All four ship a happy path that assumes their vendor's API and hosted runtime. The differences among them matter because they change which lock-in you accept and which you buy your way out of.

OpenAI Agents SDK

MIT, openai/openai-agents-python. Responses API is the default backend; handoffs, guardrails, sandboxed execution, and MCP support ship in the box. Supports 100+ models via LiteLLM and any-llm adapters — the framework's abstraction is genuinely provider-agnostic even though the docs assume OpenAI first. If OpenAI is your default but you want the escape hatch to Claude for reasoning or Gemini for long context, this SDK gives you the shortest path.

Claude Agent SDK

MIT code plus Anthropic Commercial Terms, anthropics/claude-agent-sdk-python (7.8k stars). Python and TypeScript only. Same agent loop as Claude Code, deepest MCP integration in the market (Anthropic authored MCP), filesystem, bash, web, and subagent primitives out of the box. API-key auth to Anthropic is required — you cannot point the SDK at a non-Anthropic model without forking. Deep coverage in our Claude Agent SDK guide 2026.

Microsoft Agent Framework

MIT, microsoft/agent-framework. Shipped 1.0 on April 3, 2026 as the direct successor to Semantic Kernel and AutoGen, which entered maintenance mode October 2025. Supports Foundry, Anthropic, Azure OpenAI, OpenAI, and Ollama. Python, .NET, and Go bindings. Happy path is Azure Foundry — deploying to non-Azure infrastructure is possible but not the golden path in the docs.

Google ADK

Apache 2.0, google/adk-python. Code-first Python, TypeScript, Go, Java, and Kotlin toolkit. Supports Gemini, Gemma, Claude, OpenAI, Ollama, vLLM, and LiteLLM. The framework itself has no lock-in axis on models, but deployment is optimized for Google Cloud Agent Platform and Vertex AI — the observability and evaluation surfaces assume the Google Cloud console.

Vendor Lock-In: The Four Layers Every Buyer Underestimates

In short

Lock-in in 2026 agent frameworks accumulates in four distinct layers. Model lock-in — the API you call, swappable in hours when the framework abstracts it. Orchestration lock-in — the graph, handoff, and state semantics, a rewrite to swap. State and memory lock-in — session stores, checkpointers, vector stores tied to a hosted service. Governance and evidence lock-in — telemetry, audit trails, and eval fixtures that only exist inside one vendor's console. Kai Waehner (April 2026) calls the fourth the fastest-growing category of AI dependency risk.

Lock-in in agent frameworks is not one thing. It is four layers that accumulate independently, and buyers who account for only the first layer routinely find themselves locked in through the fourth.

1. Model lock-in

The API you call. Swappable in hours if the framework abstracts it (LangGraph, CrewAI, Pydantic AI, MAF, ADK, OpenAI Agents SDK via LiteLLM). Impossible without a fork for Claude Agent SDK. This is the layer buyers look at and often the only layer they weigh.

2. Orchestration lock-in

The graph, handoff, and state semantics your code is written against. Reimplementing 40 nodes with typed edges on a different framework is a rewrite, not a swap. This is the layer buyers under-model most.

3. State and memory lock-in

Session stores, checkpointers, and vector stores tied to a hosted service (LangSmith, AgentCore, Foundry) create durable dependency independent of the framework. Migrating state out is often technically possible but operationally hard — mid-flight sessions do not port cleanly.

4. Governance and evidence lock-in

Telemetry, audit trails, and eval fixtures that only exist inside one vendor's console. Kai Waehner's April 2026 landscape report calls this the fastest-growing category of AI dependency risk, and it is the layer Alice Labs sees regulated EU clients hit last and most painfully. Your evidence for an EU AI Act audit is only as portable as the console it lives in.

The Alice Labs pattern for scoring a framework in an RFP: score each of the four layers separately, weight by how expensive migration would be at that layer, and only then compute a lock-in cost. A framework that is portable at layers 1 and 2 but proprietary at layers 3 and 4 is still locking you in — the money just leaves the room later.

TCO Analysis: What Open Source Actually Costs

In short

Alice Labs' benchmark across 12 production Claude Agent SDK, LangGraph, and CrewAI deployments in 2026: framework license cost is under 2% of TCO. Model tokens are 55-70%, platform engineering 20-30%, observability and eval tooling 5-10%. Open source frameworks are usually paired with a paid platform: LangGraph + LangSmith, CrewAI + CrewAI Enterprise, LlamaIndex + LlamaCloud. Proprietary SDKs bundle observability and hosting into Anthropic Managed Agents, OpenAI's hosted agent runtime, Foundry, or Google Agent Platform.

The most persistent misconception we see in 2026 procurement is that open source frameworks are free. They are free to install. They are not free to own.

Open source frameworks are nearly always paired with a paid platform. LangGraph is almost always deployed with LangSmith for observability and, in bigger teams, LangGraph Platform for hosted runs. CrewAI's enterprise adopters typically take CrewAI Enterprise for SSO, RBAC, PII redaction, and private VPC deployment. LlamaIndex users routinely adopt LlamaCloud for hosted OCR and indexing.

Proprietary SDKs bundle observability and hosting: Anthropic Managed Agents, OpenAI's hosted agent runtime, Microsoft Foundry, and Google Agent Platform each replace some portion of the platform-engineering spend you would otherwise carry.

Alice Labs benchmarked total cost of ownership across 12 production framework deployments in 2026 — a mix of Claude Agent SDK, LangGraph, and CrewAI, spanning regulated Nordic clients and higher-volume EU deployments. The composition:

TCO composition — Alice Labs 12-deployment benchmark, 2026

Multi-vendor deployments above ~5,000 users are typically cost-justified vs single-vendor once negotiated token rates are factored in — but only if your framework is portable enough to route different workloads to different vendors without a rewrite. This is where model portability (layer 1 lock-in) starts to matter for real money, not just architectural preference.

MCP as the Escape Hatch: Why the Protocol Layer Matters More Than the Framework

In short

Model Context Protocol is an open standard supported across Claude, ChatGPT, VS Code, Cursor, and MCPJam as of the 2026-07-28 spec. Every major framework in this comparison ships first-class MCP support — LangGraph, CrewAI, Pydantic AI, OpenAI Agents SDK, Claude Agent SDK, Microsoft Agent Framework, and Google ADK. MCP servers you own (data connectors, internal tools) are portable across frameworks: a Slack MCP server written for Claude Agent SDK works unchanged under LangGraph. Alice Labs recommends keeping proprietary business logic inside MCP servers and only orchestration inside the framework.

MCP is the highest-leverage portability investment a buyer can make in the 2026 agent stack. It is more portable than the framework, it is more stable than the framework, and it survives framework migrations without a rewrite.

Model Context Protocol is an open standard. As of the 2026-07-28 spec, it is supported in Claude, ChatGPT, VS Code, Cursor, MCPJam, and a growing list of enterprise agent surfaces. Every major framework in this comparison — LangGraph, CrewAI, Pydantic AI, OpenAI Agents SDK, Claude Agent SDK, Microsoft Agent Framework, and Google ADK — ships first-class MCP support. This is a genuine 8-out-of-8 crossover.

The practical consequence is under-appreciated. MCP servers you own — the Slack connector, the Postgres tool, the internal API adapter you wrote for your product — are portable across frameworks. A Slack MCP server written for Claude Agent SDK runs unchanged under LangGraph via langchain-mcp-adapters, unchanged under CrewAI's MCP integration, and unchanged under Google ADK.

Alice Labs' portability recommendation: keep proprietary business logic inside MCP servers, keep only orchestration inside the framework. This way, the framework becomes a swappable layer — you can migrate LangGraph to CrewAI, or Claude Agent SDK to Pydantic AI, without touching your tool integrations. In a stack where layer-1 model lock-in is variable and layer-2 orchestration lock-in is expensive, MCP neutralises much of the risk at the tool boundary.

The one caveat: MCP support depth still varies. Claude Agent SDK has the deepest native MCP surface because Anthropic authored the protocol — runtime add_mcp_server and get_mcp_status APIs, per-subagent tool scoping, and one-line stdio server attach. LangGraph consumes MCP through an adapter. Both work in production; the ceremony delta is a real engineering cost when you are wiring 8+ servers.

When Open Source Wins: The Buyer Situations Where LangGraph, CrewAI, or Pydantic AI Beat Proprietary

In short

Open source wins in four buyer situations. Regulated workloads where model routing must be provable and auditable — LangGraph checkpointer plus LangSmith trace is admissible where a hosted vendor loop rarely is. Multi-model production where cost or quality routing matters — Pydantic AI or LangGraph can route Claude, Gemini, and GPT in one graph. On-prem or sovereign cloud deployment for EU AI Act, GDPR, and DORA obligations — CrewAI Enterprise or LangGraph in a customer-owned VPC beats any hosted proprietary runtime. Alice Labs uses LangGraph or CrewAI whenever the client's compliance officer will need to answer 'where does the state live?' with a customer-owned answer.

There are four buyer situations where the open source frameworks reliably win, in our experience across 100+ Alice Labs implementations. The decision framework here is prescriptive, not preference.

Regulated workloads where model routing must be provable and auditable. A LangGraph checkpointer plus a LangSmith trace is admissible in front of an EU AI Act auditor because you can hand over the state and the trace as artefacts you own. A hosted vendor loop is rarely admissible because the auditor's chain-of-custody question leads back to a vendor console you do not control.

Multi-model production where cost or quality routing matters. Pydantic AI or LangGraph can route to Claude for reasoning, Gemini for long context, and GPT for tool use in one graph. This routing is where the 40-60% cost reduction from tier-by-role model choice actually lives — and it is not available inside a single-vendor SDK without operating a parallel non-vendor code path.

On-prem or sovereign cloud deployment for EU AI Act, GDPR, and DORA compliance. CrewAI Enterprise deployed in a customer-owned VPC or LangGraph deployed on customer infrastructure beats any hosted proprietary runtime for regulated workloads where data residency and processor definitions matter.

Nordic and EU enterprises where Alice Labs works. Our rule of thumb: we use LangGraph or CrewAI whenever the client's compliance officer will need to answer "where does the state live?" with a customer-owned answer. That single question resolves probably 70% of framework choices for regulated buyers.

For deeper context on how compliance shapes framework choice, our EU AI Act compliance checklist for 2026 walks the full audit surface for high-risk deployments.

When Proprietary Wins: The Buyer Situations Where Claude Agent SDK, OpenAI Agents SDK, MAF, or ADK Beat Open Source

In short

Proprietary wins in four buyer situations. Coding and computer-use agents with deep OS access — Claude Agent SDK ships filesystem, bash, web, and subagent primitives that take months to replicate on LangGraph. Voice, realtime, and lightweight conversational handoffs — OpenAI Agents SDK's handoff and guardrail model is the shortest path to production. Existing Microsoft or Google shops with sunk cost in Azure Foundry or Vertex AI — MAF and ADK reduce integration cost more than the lock-in premium. Alice Labs uses Claude Agent SDK for internal engineering agents where Anthropic's coding-model quality is the differentiator.

The comparison is only real if it recognises where proprietary wins. Four buyer situations where the vendor-anchored SDKs reliably beat open source pure play — this is not open source advocacy in disguise.

Coding and computer-use agents with deep OS access. Claude Agent SDK ships with filesystem, bash, web, and subagent primitives that would take months to replicate on LangGraph. The same harness that powers Claude Code powers your production agent — feature parity is effectively guaranteed on each release. For a coding agent with a Claude commitment already made at procurement, the SDK is the shortest path and it is not close.

Voice, realtime, and lightweight conversational handoffs. OpenAI Agents SDK's handoff plus guardrail model is the shortest path to production for a realtime conversational agent. If the workload is voice or chat and the vendor is already OpenAI, the ceremony saving over LangGraph is real.

Existing Microsoft or Google shops with sunk cost in Azure Foundry or Vertex AI. MAF and ADK reduce integration cost more than the lock-in premium for buyers who already procured the vendor. In these situations, lock-in is not a technical decision — it is already made at the procurement layer, and the framework choice is about developer velocity, not portability.

Alice Labs' internal engineering agents. We use Claude Agent SDK for our own internal engineering agents where Anthropic's model quality on code is the differentiator and portability is not a stated requirement. Different rule for different buyer — the same firm can (and should) use different frameworks for different workloads.

For the head-to-head between the two most common vendor-anchored contenders and LangGraph, see our LangGraph vs Claude Agent SDK 2026 comparison.

The Semantic Kernel / AutoGen Case Study: What Vendor-Anchored Open Source Looks Like When It Breaks

In short

Microsoft moved Semantic Kernel and AutoGen into maintenance mode in October 2025; the last feature release was September 2025. Microsoft Agent Framework 1.0 shipped April 3, 2026 as the direct successor, requiring migration from both prior frameworks. AutoGen users must budget for Q3 2026 API deprecations; Semantic Kernel session and telemetry patterns carry over but the API surface is new. Lesson: MIT license did not prevent a forced migration when the vendor changed direction. Framework longevity is a governance question, not a license question.

The Semantic Kernel and AutoGen story is the cautionary tale for anyone who thinks a permissive license inoculates them against vendor decisions. Both frameworks were MIT licensed. Both are now on a forced migration path.

Microsoft moved Semantic Kernel and AutoGen into maintenance mode in October 2025. The last feature release was September 2025. In practice, both frameworks became closed to new capability development while the vendor invested elsewhere.

Microsoft Agent Framework 1.0 shipped April 3, 2026 as the direct successor to both prior frameworks. Existing users of Semantic Kernel and AutoGen must migrate — the successor is MIT-licensed and open source, but the API surface is different and the migration is real work. AutoGen users must budget for Q3 2026 API deprecations. Semantic Kernel session and telemetry patterns carry over conceptually, but the API surface is new.

The lesson is not that Microsoft did anything wrong — the migration path is reasonable and the successor is a better framework. The lesson is that MIT license did not prevent a forced migration when the vendor changed direction. Framework longevity is a governance question — how the vendor manages the project, how open the roadmap is, how many independent contributors carry it forward — not a license question.

For frameworks anchored to a single vendor, this pattern will recur. It is not a statement about Microsoft; it is a statement about vendor-anchored open source as a category. LangGraph 1.0 shipping in October 2025 was a similar kind of milestone with similar migration pressure — but LangGraph's independent-contributor base (295+ contributors) provides a governance signal that is different in kind from single-vendor project management.

Feature-by-Feature Comparison Matrix (2026)

In short

Durable execution and checkpointing ship in LangGraph, Pydantic AI, MAF, ADK, and Claude Agent SDK sessions. First-class multi-model support is native in LangGraph, CrewAI, Pydantic AI, MAF (5 providers), ADK (6+ providers), and OpenAI Agents SDK (100+ via adapters). MCP support is universal across all eight frameworks as of August 2026. Language coverage is widest in Google ADK (Python, TS, Go, Java, Kotlin), followed by MAF (Python, .NET, Go).

The compact scan across all eight frameworks. This is the table Alice Labs starts every RFP shortlist with, and the one we recommend buyers reproduce in their own spreadsheets.

Feature matrix — 8 major agent frameworks, August 2026

Three signals worth flagging inside the matrix. Durable execution now ships in five of eight frameworks — this used to be LangGraph's differentiator and no longer is. Multi-model is native in six of eight, and the two exceptions (Claude Agent SDK, OpenAI's default backend) are exactly where the vendor lock-in lives. MCP is universal — this is the biggest cross-framework standardisation event of 2026 and the reason MCP portability outranks framework portability in our recommendation.

Migration Cost: Moving Between Frameworks in Practice

In short

Alice Labs measured three production migrations in 2026: AutoGen to MAF took ~120 engineering hours for a 12-agent system, with state and telemetry requiring rewrites. CrewAI to LangGraph took ~200 hours because role and task abstractions did not translate cleanly to graph nodes. OpenAI Agents SDK to Claude Agent SDK took ~80 hours if the agent was already OS-native, and larger if handoff chains had to be flattened. Migration cost is the number to price against lock-in — if migration is under 200 hours, layer-2 orchestration lock-in is manageable.

Lock-in is real only in proportion to the cost of leaving. Alice Labs measured three production migrations in 2026, and the numbers are worth quoting because they substantially outperform what most 2024-era comparison articles suggest.

Alice Labs 2026 framework migrations — measured engineering hours

The most expensive migration was CrewAI to LangGraph, because CrewAI's role and task abstractions did not translate cleanly to graph nodes — the mental model change was as much of the cost as the code change. The cheapest was OpenAI Agents SDK to Claude Agent SDK, because both share an agent-loop mental model and MCP was already the tool boundary.

Rule we use in RFPs: if the projected migration cost is under 200 engineering hours, layer-2 orchestration lock-in is manageable and should not dominate the framework decision. Above 200 hours, orchestration lock-in becomes a first-class procurement variable and should be scored explicitly.

For a step-by-step example of one such migration, our LangGraph guide 2026 and the LangGraph vs Claude Agent SDK head-to-head walk the migration patterns we use in production.

Alice Labs Recommendation Framework: Which Framework for Which Buyer

In short

Regulated Nordic and EU enterprises with EU AI Act obligations: LangGraph or CrewAI, self-hosted, MCP-first. Fast-moving startups building coding or computer-use agents: Claude Agent SDK, accept the Anthropic dependency, extract business logic to MCP servers. Enterprise Microsoft shops: MAF, but keep orchestration graphs portable and treat Foundry as an execution target rather than a data lock-in. Consumer voice and chat: OpenAI Agents SDK for realtime; route to Claude via LiteLLM where reasoning matters. Alice Labs default for a greenfield agent build in 2026: LangGraph with Anthropic model, self-hosted checkpointer, MCP-first tool boundary — highest portability, lowest lock-in, production-proven at Klarna and Replit.

This is the recommendation matrix Alice Labs uses in Nordic and EU RFPs. It is not a preference — it is the pattern we have arrived at after 100+ implementations, and it maps buyer situations to framework choices with high accuracy.

Alice Labs framework recommendation by buyer situation, 2026

Alice Labs default recommendation for a greenfield agent build in 2026: LangGraph with an Anthropic model, self-hosted checkpointer, and MCP-first tool boundary. Highest portability, lowest lock-in, production-proven at Klarna and Replit, with an escape hatch to any of the other seven frameworks via MCP. This is the configuration we recommend more often than any other in Nordic RFPs.

A minimal example of the shape:

# LangGraph + Anthropic + MCP — the Alice Labs 2026 default
from typing import TypedDict
from langgraph.graph import StateGraph, START, END
from langgraph.checkpoint.postgres import PostgresSaver
from langchain_anthropic import ChatAnthropic
from langchain_mcp_adapters.client import MultiServerMCPClient

class State(TypedDict):
    query: str
    plan: str
    result: str

# MCP servers own the tool boundary — portable across frameworks
mcp = MultiServerMCPClient({
    "github": {"command": "npx", "args": ["-y", "@modelcontextprotocol/server-github"]},
    "postgres": {"command": "npx", "args": ["-y", "@modelcontextprotocol/server-postgres"]},
})
tools = mcp.get_tools()

model = ChatAnthropic(model="claude-sonnet-5").bind_tools(tools)

def plan(state: State) -> State:
    return {**state, "plan": model.invoke(state["query"]).content}

def execute(state: State) -> State:
    return {**state, "result": model.invoke(state["plan"]).content}

graph = StateGraph(State)
graph.add_node("plan", plan)
graph.add_node("execute", execute)
graph.add_edge(START, "plan")
graph.add_edge("plan", "execute")
graph.add_edge("execute", END)

# Self-hosted Postgres checkpointer — state stays inside customer VPC
app = graph.compile(checkpointer=PostgresSaver.from_conn_string(POSTGRES_URL))

Every property that matters in a regulated Nordic RFP is customer-owned: the graph, the state store, and the tool boundary. The model is swappable via ChatAnthropic → ChatOpenAI or ChatGoogleGenerativeAI with no other code changes. If the vendor changes direction, the migration cost is hours, not weeks.