Agentic AI Frameworks Sammenlignet: LangGraph vs CrewAI vs OpenAI Agents SDK vs Claude Agent SDK

AI-agenter er gaaet fra forskningsdemoer til produktionssystemer. Over 60% af enterprise AI-applikationer forventes at indeholde agentiske komponenter inden 2026. Men at bygge agenter fra bunden - haandtere tool-loops, state, hukommelse, fejlhaandtering og multi-agent-koordinering - er komplekst. Det er her frameworks kommer ind i billedet.

Fire frameworks dominerer i 2026: LangGraph, CrewAI, OpenAI Agents SDK og Claude Agent SDK. Hver taeger en fundamentalt anderledes tilgang til det samme problem: at give LLM'er evnen til at raesonnere, planlaegge, bruge vaerktojer og samarbejde.

Overblik

LangGraph: Grafbyggeren

LangGraph modellerer agent-workflows som rettede cykliske grafer. Du definerer noder (funktioner der udfoerer arbejde) og kanter (overgange mellem dem, eventuelt betingede). State flyder gennem grafen og persisteres via checkpointing.

Dette er det mest eksplicitte og kontrollerbare framework - du kobler hvert trin selv.

Kernekoncepter

• StateGraph: grafdefinitionen med typet state
• Nodes: Python-funktioner der transformerer state
• Edges: forbindelser mellem noder, kan vaere betingede
• Checkpointing: indbygget persistens for langvarige workflows

Kodeeksempel

from langgraph.graph import StateGraph, MessagesState, START, END
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o")

def call_agent(state: MessagesState):
    response = llm.invoke(state["messages"])
    return {"messages": [response]}

def should_continue(state: MessagesState):
    last = state["messages"][-1]
    if last.tool_calls:
        return "tools"
    return END

def call_tools(state: MessagesState):
    # Execute tool calls and return results
    results = []
    for tool_call in state["messages"][-1].tool_calls:
        result = execute_tool(tool_call)
        results.append(result)
    return {"messages": results}

graph = StateGraph(MessagesState)
graph.add_node("agent", call_agent)
graph.add_node("tools", call_tools)
graph.add_edge(START, "agent")
graph.add_conditional_edges("agent", should_continue, {"tools": "tools", END: END})
graph.add_edge("tools", "agent")

app = graph.compile()
result = app.invoke({"messages": [{"role": "user", "content": "What's the weather?"}]})

Styrker

• Detaljeret kontrol over hvert trin og overgang
• Indbygget checkpointing og human-in-the-loop
• Fuld TypeScript-paritet
• Fungerer med enhver LLM-udbyder
• Bedst til komplekse workflows med betinget forgrening og loops

Svagheder

• Stejl laeringskurve - du skal forstaa grafteorikoncepter
• Omstaendeligt for simple use cases - en simpel agent kraever mere boilerplate end andre frameworks
• Debugging af grafflows kan vaere udfordrende uden LangSmith

Priser

Open-source (MIT). LangSmith (administreret observability-platform) har betalte niveauer for produktionsovervagning.

CrewAI: Teamsamleren

CrewAI bruger en menneskelig metafor: du sammensaetter et crew af specialiserede agenter, hver med en rolle, et maal og en baggrundshistorie. Agenter samarbejder om opgaver ved hjaelp af vaerktojer, koordineret af en proces (sekventiel, hierarkisk eller konsensusbaseret).

Taenk paa det som at ansaette et team hvor hvert medlem har en specifik jobtitel og specialitet.

Kernekoncepter

• Agent: en persona med rolle, maal, baggrundshistorie og vaerktojer
• Task: en opgave med beskrivelse, forventet output og tildelt agent
• Crew: en gruppe agenter der arbejder sammen
• Process: eksekveringsstrategi (sekventiel, hierarkisk, konsensusbaseret)
• Flow: haendelsesdrevet orkestreringslaag til at forbinde flere crews

Kodeeksempel

from crewai import Agent, Task, Crew, Process

researcher = Agent(
    role="Senior Research Analyst",
    goal="Find comprehensive data about the given topic",
    backstory="You have 10 years of experience in technology research. "
              "You are thorough and always verify facts from multiple sources.",
    tools=[web_search_tool],
    verbose=True,
)

writer = Agent(
    role="Technical Writer",
    goal="Create clear, engaging technical content",
    backstory="You write for a developer audience. "
              "Your articles are practical and include code examples.",
    tools=[file_tool],
    verbose=True,
)

research_task = Task(
    description="Research the latest developments in WebAssembly in 2026. "
                "Focus on WASI, Component Model, and production use cases.",
    expected_output="A structured research document with key findings and sources.",
    agent=researcher,
)

writing_task = Task(
    description="Write a blog post based on the research. "
                "Include code examples and Mermaid diagrams.",
    expected_output="A complete blog post in Markdown format.",
    agent=writer,
    context=[research_task],  # Writer receives researcher's output
)

crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task],
    process=Process.sequential,
    verbose=True,
)

result = crew.kickoff()
print(result.raw)

Styrker

• Intuitiv rollebaseret abstraktion - let at forstaa
• Over 100 indbyggede tool-integrationer
• Delt hukommelse paa tvaers af agenter (korttids-, langtids-, entity-hukommelse)
• Stoerste community (~40k GitHub stars)
• Hierarkisk proces med en "manager"-agent der delegerer og validerer

Svagheder

• Mindre detaljeret kontrol end LangGraph - du definerer roller, ikke eksakte eksekveringsstier
• Hierarkisk proces kan vaere uforudsigelig naar agenter er uenige
• Debugging af multi-agent-samtaler er svaerere end single-agent-flows

Priser

Open-source-kerne (gratis). CrewAI Platform: $99/maaned (Teams) til $120k/aar (Enterprise). Priser baseret paa aktive crews og maanedlige eksekveringer.

OpenAI Agents SDK: Routeren

OpenAI Agents SDK (aandelig efterfoelger til Swarm) fokuserer paa handoffs - agenter der overdrager samtaler til andre specialiserede agenter. Det er det mest minimale framework: agenter, vaerktojer, handoffs og guardrails. Det er det hele.

Kernekoncepter

• Agent: model + instruktioner + vaerktojer + handoffs
• Handoff: en overdragelse til en anden agent (modelleret som et vaerktoej som LLM'en kan kalde)
• Guardrail: input-/outputvalidering der koerer parallelt med agenten
• Runner: eksekverer agent-loopen
• Tracing: indbygget observability for alle LLM-kald, vaerktoejesekekveringer og handoffs

Kodeeksempel

from agents import Agent, Runner, handoff, InputGuardrail, GuardrailFunctionOutput
from pydantic import BaseModel

class SafetyCheck(BaseModel):
    is_safe: bool
    reason: str

async def content_safety(ctx, agent, input_text):
    result = await Runner.run(
        Agent(name="Safety", instructions="Check if input is safe. No PII."),
        input_text,
        context=ctx,
    )
    output = SafetyCheck.model_validate_json(result.final_output)
    return GuardrailFunctionOutput(
        output_info=output, tripwire_triggered=not output.is_safe
    )

billing_agent = Agent(
    name="Billing Agent",
    instructions="You handle billing inquiries. Be precise with numbers.",
    tools=[lookup_invoice, process_payment],
)

refund_agent = Agent(
    name="Refund Agent",
    instructions="You process refund requests. Always verify the order first.",
    tools=[lookup_order, issue_refund],
)

triage_agent = Agent(
    name="Triage Agent",
    instructions="Route the customer to the right specialist. "
                 "Ask clarifying questions if needed.",
    handoffs=[billing_agent, refund_agent],
    input_guardrails=[InputGuardrail(guardrail_function=content_safety)],
)

result = await Runner.run(triage_agent, "I need a refund for order #4521")
print(result.final_output)
# The triage agent routes to refund_agent, which processes the refund

Styrker

• Rent handoff-moenster - naturligt for routing-/triage-workflows
• Guardrails koerer parallelt med eksekvering (fail-fast, ikke blokerende)
• Indbygget tracing-dashboard til debugging
• Trods navnet understoettes ogsaa ikke-OpenAI-modeller
• Minimal abstraktion - let at forstaa og udvide

Svagheder

• Mindre modent state management end LangGraph
• Ingen indbygget persistens eller checkpointing
• Oekosystemet af tredjepartsvaerktojer er mindre
• Handoff-centreret design passer maaske ikke til enhver arkitektur

Priser

Open-source (MIT). Du betaler per token for den model du bruger.

Claude Agent SDK: Udvikleren

Claude Agent SDK taeger en anderledes tilgang: i stedet for at definere workflows eller roller giver du agenten et saet vaerktojer og lader den finde ud af hvordan opgaven skal loeses. Den bruger den samme autonome loop der driver Claude Code - laese, handle, verificere, iterere.

Kernekoncepter

• query(): hovedindgangspunktet der starter agent-loopen
• Indbyggede vaerktojer: Read, Write, Edit, Bash, Glob, Grep, WebSearch, WebFetch
• Brugerdefinerede vaerktojer via MCP: definer vaerktojer som in-process MCP-servere
• Sub-agenter: specialiserede agenter som den overordnede agent kan delegere til
• Sessions: bevar kontekst paa tvaers af flere interaktioner

Kodeeksempel

import { tool, createSdkMcpServer, query } from "@anthropic-ai/claude-agent-sdk";
import { z } from "zod";

const searchDocs = tool(
  "search_docs",
  "Search the internal documentation for relevant information",
  { query: z.string().describe("Search query") },
  async ({ query }) => {
    const results = await vectorStore.similaritySearch(query, 5);
    return {
      content: [{ type: "text", text: results.map(r => r.pageContent).join("\n\n") }],
    };
  }
);

const docsServer = createSdkMcpServer({
  name: "docs",
  version: "1.0.0",
  tools: [searchDocs],
});

for await (const message of query({
  prompt: "Find how authentication works in our system and write a summary",
  options: {
    mcpServers: { docs: docsServer },
    allowedTools: ["Read", "Glob", "Grep", "mcp__docs__search_docs"],
  },
})) {
  if (message.type === "result" && message.subtype === "success") {
    console.log(message.result);
  }
}

Styrker

• Foersteklasses MCP-integration - forbind til hele MCP-server-oekosystemet
• Indbyggede vaerktojer til filoperationer, terminal og webadgang
• Automatisk kontekstkomprimering for store kodebaser
• Sub-agent-parallelisme til komplekse opgaver
• Samme motor som Claude Code - kamptestet i rigtige udviklingsworkflows

Svagheder

• Kun Claude-modeller - ingen multi-provider-understoettelse
• Nyere framework med et mindre community
• Kraever Node.js-runtime ogsaa for Python SDK
• Mindre eksplicit workflowkontrol sammenlignet med LangGraph

Priser

Open-source. Standard Claude API-tokenpriser. Managed Agents (hostet version): $0,08 per sessionstime ud over tokenomkostninger.

Hvornaar skal du vaelge hvilket

Vaelg LangGraph hvis:

• Du har brug for praecis kontrol over hvert trin i workflowen
• Dit use case indebaerer kompleks betinget logik og loops
• Du vil have indbygget persistens og human-in-the-loop-checkpoints
• Du skal bruge flere LLM-udbydere i den samme workflow

Vaelg CrewAI hvis:

• Du vil have en intuitiv, rollebaseret abstraktion
• Din opgave indebaerer flere agenter med forskellige specialiseringer
• Du har brug for agenter der samarbejder og sender kontekst videre til hinanden
• Det stoerste community og flest indbyggede integrationer er vigtigt for dig

Vaelg OpenAI Agents SDK hvis:

• Dit primaere moenster er at route samtaler til specialister
• Du har brug for guardrails der validerer input/output parallelt
• Du vil have den enklest mulige abstraktion med minimal boilerplate
• Indbygget tracing og observability er vigtigt

Vaelg Claude Agent SDK hvis:

• Dine agenter skal laese, skrive og eksekvere kode
• Du vil have foersteklasses MCP-server-integration
• Du har brug for autonome agenter der itererer og selvkorrigerer
• Du allerede bruger Claude og vil have den dybeste integration

Kan man kombinere frameworks?

Ja. Et almindeligt moenster er at bruge et framework til orkestrering og et andet til individuelle agenter:

• LangGraph til den overordnede workflow-graf
• CrewAI til en specifik node der kraever multi-agent-samarbejde
• Claude Agent SDK til koderelaterede delopgaver via MCP
• OpenAI Agents SDK til kundevendt triage og routing

Frameworks udelukker ikke hinanden. Brug det der passer til hver del af dit system.

Konklusion

Hvert framework satser paa en klar retning:

• LangGraph optimerer for kontrol - du bestemmer hver overgang
• CrewAI optimerer for samarbejde - agenter arbejder som et team
• OpenAI Agents SDK optimerer for enkelhed - minimal abstraktion, rene handoffs
• Claude Agent SDK optimerer for autonomi - giv det vaerktojer og lad det arbejde

Det rigtige valg afhaenger af din workflow, dit team og din eksisterende stack. Vaelg det der matcher dit primaere use case, laer det godt at kende og traek andre ind naar du rammer deres styrker.