LangChain vs LlamaIndex vs Semantic Kernel (2026)

The real selection problem

Most comparison posts present feature tables. They list API surface, supported models, and quickstart complexity. That is useful for orientation but dangerous as a decision artifact. The real selection problem is not which framework has more features. It is which framework fails in a way your team can handle.

LangChain, LlamaIndex, and Semantic Kernel are not interchangeable. They solve different primary problems because they start from different design philosophies.

LangChain is integration-first. It gives you the broadest set of model providers, tool connectors, and community packages. You can swap providers and assemble agent logic quickly. The cost appears later when abstraction layers interact in unexpected ways under retry pressure.

LlamaIndex is data-first. Its center of gravity is indexing, retrieval, and query pipelines. Agent capabilities have matured, but the framework rewards teams whose core product value comes from getting the right context to the model at the right time.

Semantic Kernel is enterprise-SDK-first. It models everything as a kernel with services and plugins. Multi-language support across C#, Python, and Java gives enterprise teams SDK consistency that other frameworks do not offer. The tradeoff is a smaller community and a Python SDK that lags behind C#.

The design philosophy determines what breaks in production. Integration-first frameworks struggle when abstraction complexity compounds. Data-first frameworks carry overhead when retrieval is not central. Enterprise-SDK frameworks trade community velocity for structural discipline. Knowing where each one bends under pressure matters more than counting features.

What top sources miss

We reviewed three top-ranking comparison articles before writing. They cover API surface well. They miss production failure modes and governance gaps consistently.

The pattern is consistent: good orientation, weak on what happens when agents execute side effects in production without policy gates. This article fills that gap with failure mode analysis, current metrics, and governance integration patterns.

2026 framework snapshot

Table data uses current GitHub API and PyPIStats snapshots from April 2026. Community size is not a direct proxy for runtime quality, but it helps estimate ecosystem velocity and troubleshooting surface area.

LangChain dominates in raw adoption. Its PyPI download count is roughly 22x LlamaIndex and 82x Semantic Kernel. That gap reflects ecosystem breadth and early-mover advantage, not quality ranking.

Feature comparison matrix

This matrix focuses on framework-native capabilities. A partial mark means the feature exists but needs custom engineering for strong reliability, operator control, or enterprise policy requirements.

The row that matters most is "Built-in policy enforcement." All three frameworks show "Not native." None of them evaluates policy before a tool call executes. If your agent can write to production databases, trigger deployments, or send emails, the framework will not stop it. You need an external governance layer.

LangChain: integration-first agent composition

# pip install -U langchain "langchain[anthropic]" langgraph-checkpoint-postgres
from langchain.agents import create_agent
from langgraph.checkpoint.postgres import PostgresSaver


def get_ticket_status(ticket_id: str) -> str:
    return f"ticket {ticket_id} is in progress"


def escalate_ticket(ticket_id: str, reason: str) -> str:
    return f"ticket {ticket_id} escalated: {reason}"


DB_URI = "postgresql://postgres:postgres@localhost:5442/postgres?sslmode=disable"

with PostgresSaver.from_conn_string(DB_URI) as checkpointer:
    checkpointer.setup()
    agent = create_agent(
        model="claude-sonnet-4-6",
        tools=[get_ticket_status, escalate_ticket],
        system_prompt="You are an ops assistant. Check status before escalating.",
        checkpointer=checkpointer,
    )

    result = agent.invoke(
        {"messages": [{"role": "user", "content": "Status for INC-1042"}]},
        {"configurable": {"thread_id": "inc-1042"}},
    )
    print(result)

LlamaIndex: data-first agent pipelines

# pip install -U llama-index
from llama_index.core.agent.workflow import AgentWorkflow, FunctionAgent


def search_docs(topic: str) -> str:
    """Search internal documentation for a topic."""
    return f"Found 3 relevant documents about {topic}"


def write_summary(notes: str) -> str:
    """Produce a concise summary from research notes."""
    return f"Summary: {notes}"


research_agent = FunctionAgent(
    name="ResearchAgent",
    description="Collect context from documentation",
    system_prompt="Gather technical facts and handoff to WriteAgent",
    tools=[search_docs],
)

write_agent = FunctionAgent(
    name="WriteAgent",
    description="Create concise summary",
    system_prompt="Write final summary from research notes",
    tools=[write_summary],
)

workflow = AgentWorkflow(
    agents=[research_agent, write_agent],
    root_agent="ResearchAgent",
    initial_state={"notes": ""},
)

# in async context:
# response = await workflow.run(user_msg="Summarize the Q1 incident trends")

Semantic Kernel: enterprise SDK discipline

# pip install -U semantic-kernel
from semantic_kernel import Kernel
from semantic_kernel.agents import ChatCompletionAgent
from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion
from semantic_kernel.functions import kernel_function


class TicketPlugin:
    @kernel_function(description="Get current ticket status")
    def get_status(self, ticket_id: str) -> str:
        return f"Ticket {ticket_id}: in progress, assigned to on-call"

    @kernel_function(description="Escalate ticket with reason")
    def escalate(self, ticket_id: str, reason: str) -> str:
        return f"Ticket {ticket_id} escalated: {reason}"


kernel = Kernel()
kernel.add_service(AzureChatCompletion(service_id="ops-service"))
kernel.add_plugin(TicketPlugin(), plugin_name="tickets")

agent = ChatCompletionAgent(
    kernel=kernel,
    name="OpsAssistant",
    instructions="Check ticket status before escalating. Explain decisions clearly.",
)

# in async context:
# response = await agent.get_response(messages="What is the status of INC-2048?")
# print(response)

What actually breaks in production

This is the section most comparison articles skip. Feature tables tell you what a framework can do. Failure mode tables tell you what happens when things go wrong. In production, things go wrong every day.

We tested six failure scenarios across all three frameworks. The results show that governance gaps are shared across all three. The framework choice affects how failures manifest, not whether they occur.

The common thread is clear. All three frameworks assume that side effects are safe to execute once the model decides to execute them. None evaluates a policy before dispatch. None requires approval for high-risk operations by default. None provides a structured audit trail without custom integration work.

This is not a framework defect. These tools are designed for agent behavior, not governance. But the gap means that every production deployment on any of these three frameworks needs an external governance layer if agents can affect real systems.

When to use which

If your team needs a concrete recommendation this week, use this decision flow. It is intentionally blunt. The goal is to reduce architecture indecision and force explicit tradeoffs.

For broader framework coverage including CrewAI and AutoGen, see the 6-framework comparison and CrewAI vs AutoGen deep dive.

Why all three need a governance layer

The feature matrix makes it clear: none of these frameworks includes pre-dispatch policy enforcement. LangChain offers HITL interrupts through LangGraph, but they are optional graph nodes, not mandatory gates. LlamaIndex and Semantic Kernel provide callback hooks and telemetry, but neither evaluates whether an action should be allowed before it executes.

In production, this gap creates a specific failure pattern. The model decides to call a tool. The tool executes immediately. The side effect (a database write, an API call, a deployment trigger) happens before any policy evaluation occurs. If the action was risky, you find out after the damage.

A governance layer sits between the framework and tool execution. It intercepts the proposed action, evaluates it against a policy bundle, and returns one of four decisions: allow, deny, require approval, or allow with constraints. This pattern is framework-agnostic. The same governance endpoint works with LangChain, LlamaIndex, Semantic Kernel, or any other framework that executes tool calls.

# Framework-agnostic pre-dispatch governance pattern
# Works with LangChain, LlamaIndex, or Semantic Kernel

import httpx


def governed_tool_call(action: str, params: dict, context: dict) -> dict:
    """Check policy before executing any side-effecting tool call."""

    decision = httpx.post(
        "http://control-plane:8080/api/v1/evaluate",
        json={
            "action": action,
            "params": params,
            "agent_id": context["agent_id"],
            "labels": context.get("labels", []),
        },
    ).json()

    if decision["result"] == "deny":
        return {"status": "blocked", "reason": decision["reason"]}

    if decision["result"] == "require_approval":
        return {"status": "pending_approval", "approval_id": decision["approval_id"]}

    # decision["result"] == "allow"
    return execute_tool(action, params)


def execute_tool(action: str, params: dict) -> dict:
    # Actual tool execution happens here
    return {"status": "executed", "action": action}

Cordum implements this pattern as an Agent Control Plane with a Safety Kernel that evaluates policy before dispatch, supports explicit approval-required states, and records an audit timeline for every governed action. It is additive to any framework, not a replacement for agent logic.

FAQ

Next step

Pick one framework this week based on the decision tree. Run a bounded pilot with one real workflow. Inject failures: tool timeouts, crash recovery, token budget tests. Then add governance gates before any side-effecting action hits production.

• -Read: 6-Framework Comparison (LangChain, CrewAI, AutoGen, LlamaIndex, Semantic Kernel)
• -Read: CrewAI vs AutoGen Deep Dive
• -Read: AI Agent Security Best Practices
• -Compare AI Governance Platforms
• -AI Agent Orchestration Control Plane
• -Cordum Product Overview