1 
2AI-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.
3 
4Fire 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.
5 
6## Overblik
7 
8| Aspekt | LangGraph | CrewAI | OpenAI Agents SDK | Claude Agent SDK |
9|--------|-----------|--------|-------------------|-----------------|
10| **Af** | LangChain | CrewAI Inc. | OpenAI | Anthropic |
11| **Arkitektur** | Grafbaseret | Rollebaseret | Handoff-baseret | Autonom loop |
12| **Filosofi** | Maksimal kontrol | Teamsamarbejde | Minimal abstraktion | Giv agenten en computer |
13| **Sprog** | Python, TypeScript | Python | Python | Python, TypeScript |
14| **Modelsupport** | Alle (OpenAI, Claude, lokale) | Alle | Alle (trods navnet) | Kun Claude |
15| **GitHub stars** | ~29k | ~40k | ~21k | ~6k |
16| **Bedst til** | Komplekse stateful workflows | Multi-agent-specialisering | Routing og triage | Coding og filintensive opgaver |
17 
18## LangGraph: Grafbyggeren
19 
20LangGraph 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.
21 
22Dette er det mest eksplicitte og kontrollerbare framework  -  du kobler hvert trin selv.
23 
24```mermaid
25graph LR
26    Start --> Router[Router Node]
27    Router -->|needs research| Research[Research Node]
28    Router -->|needs code| Code[Code Node]
29    Research --> Synthesize[Synthesize Node]
30    Code --> Synthesize
31    Synthesize --> End
32```
33 
34### Kernekoncepter
35 
36- **StateGraph**: grafdefinitionen med typet state
37- **Nodes**: Python-funktioner der transformerer state
38- **Edges**: forbindelser mellem noder, kan vaere betingede
39- **Checkpointing**: indbygget persistens for langvarige workflows
40 
41### Kodeeksempel
42 
43```python
44from langgraph.graph import StateGraph, MessagesState, START, END
45from langchain_openai import ChatOpenAI
46 
47llm = ChatOpenAI(model="gpt-4o")
48 
49def call_agent(state: MessagesState):
50    response = llm.invoke(state["messages"])
51    return {"messages": [response]}
52 
53def should_continue(state: MessagesState):
54    last = state["messages"][-1]
55    if last.tool_calls:
56        return "tools"
57    return END
58 
59def call_tools(state: MessagesState):
60    # Execute tool calls and return results
61    results = []
62    for tool_call in state["messages"][-1].tool_calls:
63        result = execute_tool(tool_call)
64        results.append(result)
65    return {"messages": results}
66 
67graph = StateGraph(MessagesState)
68graph.add_node("agent", call_agent)
69graph.add_node("tools", call_tools)
70graph.add_edge(START, "agent")
71graph.add_conditional_edges("agent", should_continue, {"tools": "tools", END: END})
72graph.add_edge("tools", "agent")
73 
74app = graph.compile()
75result = app.invoke({"messages": [{"role": "user", "content": "What's the weather?"}]})
76```
77 
78### Styrker
79 
80- Detaljeret kontrol over hvert trin og overgang
81- Indbygget checkpointing og human-in-the-loop
82- Fuld TypeScript-paritet
83- Fungerer med enhver LLM-udbyder
84- Bedst til komplekse workflows med betinget forgrening og loops
85 
86### Svagheder
87 
88- Stejl laeringskurve  -  du skal forstaa grafteorikoncepter
89- Omstaendeligt for simple use cases  -  en simpel agent kraever mere boilerplate end andre frameworks
90- Debugging af grafflows kan vaere udfordrende uden LangSmith
91 
92### Priser
93 
94Open-source (MIT). LangSmith (administreret observability-platform) har betalte niveauer for produktionsovervagning.
95 
96## CrewAI: Teamsamleren
97 
98CrewAI 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).
99 
100Taenk paa det som at ansaette et team hvor hvert medlem har en specifik jobtitel og specialitet.
101 
102```mermaid
103graph TD
104    Crew[Crew Manager] --> R[Researcher\nRole: Find data\nTools: WebSearch]
105    Crew --> W[Writer\nRole: Write content\nTools: FileWrite]
106    Crew --> E[Editor\nRole: Review quality\nTools: FileRead]
107    R --> Task1[Research Task]
108    W --> Task2[Writing Task]
109    E --> Task3[Review Task]
110    Task1 --> Task2 --> Task3
111```
112 
113### Kernekoncepter
114 
115- **Agent**: en persona med rolle, maal, baggrundshistorie og vaerktojer
116- **Task**: en opgave med beskrivelse, forventet output og tildelt agent
117- **Crew**: en gruppe agenter der arbejder sammen
118- **Process**: eksekveringsstrategi (sekventiel, hierarkisk, konsensusbaseret)
119- **Flow**: haendelsesdrevet orkestreringslaag til at forbinde flere crews
120 
121### Kodeeksempel
122 
123```python
124from crewai import Agent, Task, Crew, Process
125 
126researcher = Agent(
127    role="Senior Research Analyst",
128    goal="Find comprehensive data about the given topic",
129    backstory="You have 10 years of experience in technology research. "
130              "You are thorough and always verify facts from multiple sources.",
131    tools=[web_search_tool],
132    verbose=True,
133)
134 
135writer = Agent(
136    role="Technical Writer",
137    goal="Create clear, engaging technical content",
138    backstory="You write for a developer audience. "
139              "Your articles are practical and include code examples.",
140    tools=[file_tool],
141    verbose=True,
142)
143 
144research_task = Task(
145    description="Research the latest developments in WebAssembly in 2026. "
146                "Focus on WASI, Component Model, and production use cases.",
147    expected_output="A structured research document with key findings and sources.",
148    agent=researcher,
149)
150 
151writing_task = Task(
152    description="Write a blog post based on the research. "
153                "Include code examples and Mermaid diagrams.",
154    expected_output="A complete blog post in Markdown format.",
155    agent=writer,
156    context=[research_task],  # Writer receives researcher's output
157)
158 
159crew = Crew(
160    agents=[researcher, writer],
161    tasks=[research_task, writing_task],
162    process=Process.sequential,
163    verbose=True,
164)
165 
166result = crew.kickoff()
167print(result.raw)
168```
169 
170### Styrker
171 
172- Intuitiv rollebaseret abstraktion  -  let at forstaa
173- Over 100 indbyggede tool-integrationer
174- Delt hukommelse paa tvaers af agenter (korttids-, langtids-, entity-hukommelse)
175- Stoerste community (~40k GitHub stars)
176- Hierarkisk proces med en "manager"-agent der delegerer og validerer
177 
178### Svagheder
179 
180- Mindre detaljeret kontrol end LangGraph  -  du definerer roller, ikke eksakte eksekveringsstier
181- Hierarkisk proces kan vaere uforudsigelig naar agenter er uenige
182- Debugging af multi-agent-samtaler er svaerere end single-agent-flows
183 
184### Priser
185 
186Open-source-kerne (gratis). CrewAI Platform: $99/maaned (Teams) til $120k/aar (Enterprise). Priser baseret paa aktive crews og maanedlige eksekveringer.
187 
188## OpenAI Agents SDK: Routeren
189 
190OpenAI 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.
191 
192```mermaid
193graph LR
194    User --> Triage[Triage Agent]
195    Triage -->|billing question| Billing[Billing Agent]
196    Triage -->|refund request| Refund[Refund Agent]
197    Triage -->|technical issue| Support[Support Agent]
198    Billing --> Response[Response]
199    Refund --> Response
200    Support --> Response
201```
202 
203### Kernekoncepter
204 
205- **Agent**: model + instruktioner + vaerktojer + handoffs
206- **Handoff**: en overdragelse til en anden agent (modelleret som et vaerktoej som LLM'en kan kalde)
207- **Guardrail**: input-/outputvalidering der koerer parallelt med agenten
208- **Runner**: eksekverer agent-loopen
209- **Tracing**: indbygget observability for alle LLM-kald, vaerktoejesekekveringer og handoffs
210 
211### Kodeeksempel
212 
213```python
214from agents import Agent, Runner, handoff, InputGuardrail, GuardrailFunctionOutput
215from pydantic import BaseModel
216 
217class SafetyCheck(BaseModel):
218    is_safe: bool
219    reason: str
220 
221async def content_safety(ctx, agent, input_text):
222    result = await Runner.run(
223        Agent(name="Safety", instructions="Check if input is safe. No PII."),
224        input_text,
225        context=ctx,
226    )
227    output = SafetyCheck.model_validate_json(result.final_output)
228    return GuardrailFunctionOutput(
229        output_info=output, tripwire_triggered=not output.is_safe
230    )
231 
232billing_agent = Agent(
233    name="Billing Agent",
234    instructions="You handle billing inquiries. Be precise with numbers.",
235    tools=[lookup_invoice, process_payment],
236)
237 
238refund_agent = Agent(
239    name="Refund Agent",
240    instructions="You process refund requests. Always verify the order first.",
241    tools=[lookup_order, issue_refund],
242)
243 
244triage_agent = Agent(
245    name="Triage Agent",
246    instructions="Route the customer to the right specialist. "
247                 "Ask clarifying questions if needed.",
248    handoffs=[billing_agent, refund_agent],
249    input_guardrails=[InputGuardrail(guardrail_function=content_safety)],
250)
251 
252result = await Runner.run(triage_agent, "I need a refund for order #4521")
253print(result.final_output)
254# The triage agent routes to refund_agent, which processes the refund
255```
256 
257### Styrker
258 
259- Rent handoff-moenster  -  naturligt for routing-/triage-workflows
260- Guardrails koerer parallelt med eksekvering (fail-fast, ikke blokerende)
261- Indbygget tracing-dashboard til debugging
262- Trods navnet understoettes ogsaa ikke-OpenAI-modeller
263- Minimal abstraktion  -  let at forstaa og udvide
264 
265### Svagheder
266 
267- Mindre modent state management end LangGraph
268- Ingen indbygget persistens eller checkpointing
269- Oekosystemet af tredjepartsvaerktojer er mindre
270- Handoff-centreret design passer maaske ikke til enhver arkitektur
271 
272### Priser
273 
274Open-source (MIT). Du betaler per token for den model du bruger.
275 
276## Claude Agent SDK: Udvikleren
277 
278Claude 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.
279 
280```mermaid
281graph TD
282    Prompt[User Prompt] --> Loop[Autonomous Agent Loop]
283    Loop --> Reason[Reason about next step]
284    Reason --> Act[Execute tool]
285    Act --> Verify[Check result]
286    Verify -->|not done| Loop
287    Verify -->|done| Output[Final output]
288```
289 
290### Kernekoncepter
291 
292- **query()**: hovedindgangspunktet der starter agent-loopen
293- **Indbyggede vaerktojer**: Read, Write, Edit, Bash, Glob, Grep, WebSearch, WebFetch
294- **Brugerdefinerede vaerktojer via MCP**: definer vaerktojer som in-process MCP-servere
295- **Sub-agenter**: specialiserede agenter som den overordnede agent kan delegere til
296- **Sessions**: bevar kontekst paa tvaers af flere interaktioner
297 
298### Kodeeksempel
299 
300```typescript
301import { tool, createSdkMcpServer, query } from "@anthropic-ai/claude-agent-sdk";
302import { z } from "zod";
303 
304const searchDocs = tool(
305  "search_docs",
306  "Search the internal documentation for relevant information",
307  { query: z.string().describe("Search query") },
308  async ({ query }) => {
309    const results = await vectorStore.similaritySearch(query, 5);
310    return {
311      content: [{ type: "text", text: results.map(r => r.pageContent).join("\n\n") }],
312    };
313  }
314);
315 
316const docsServer = createSdkMcpServer({
317  name: "docs",
318  version: "1.0.0",
319  tools: [searchDocs],
320});
321 
322for await (const message of query({
323  prompt: "Find how authentication works in our system and write a summary",
324  options: {
325    mcpServers: { docs: docsServer },
326    allowedTools: ["Read", "Glob", "Grep", "mcp__docs__search_docs"],
327  },
328})) {
329  if (message.type === "result" && message.subtype === "success") {
330    console.log(message.result);
331  }
332}
333```
334 
335### Styrker
336 
337- Foersteklasses MCP-integration  -  forbind til hele MCP-server-oekosystemet
338- Indbyggede vaerktojer til filoperationer, terminal og webadgang
339- Automatisk kontekstkomprimering for store kodebaser
340- Sub-agent-parallelisme til komplekse opgaver
341- Samme motor som Claude Code  -  kamptestet i rigtige udviklingsworkflows
342 
343### Svagheder
344 
345- Kun Claude-modeller  -  ingen multi-provider-understoettelse
346- Nyere framework med et mindre community
347- Kraever Node.js-runtime ogsaa for Python SDK
348- Mindre eksplicit workflowkontrol sammenlignet med LangGraph
349 
350### Priser
351 
352Open-source. Standard Claude API-tokenpriser. Managed Agents (hostet version): $0,08 per sessionstime ud over tokenomkostninger.
353 
354## Hvornaar skal du vaelge hvilket
355 
356```mermaid
357graph TD
358    Start{What's your priority?}
359    Start -->|Full control over workflow| LG[LangGraph]
360    Start -->|Multi-agent collaboration| CA[CrewAI]
361    Start -->|Routing and triage| OA[OpenAI Agents SDK]
362    Start -->|Coding and file automation| CS[Claude Agent SDK]
363 
364    LG --> LGU[Complex stateful workflows\nConditional branching\nHuman-in-the-loop]
365    CA --> CAU[Team of specialized agents\nResearch + writing pipelines\nContent generation]
366    OA --> OAU[Customer service routing\nMulti-step handoffs\nInput validation]
367    CS --> CSU[Code generation and review\nFile-heavy automation\nMCP tool ecosystem]
368```
369 
370### Vaelg LangGraph hvis:
371- Du har brug for praecis kontrol over hvert trin i workflowen
372- Dit use case indebaerer kompleks betinget logik og loops
373- Du vil have indbygget persistens og human-in-the-loop-checkpoints
374- Du skal bruge flere LLM-udbydere i den samme workflow
375 
376### Vaelg CrewAI hvis:
377- Du vil have en intuitiv, rollebaseret abstraktion
378- Din opgave indebaerer flere agenter med forskellige specialiseringer
379- Du har brug for agenter der samarbejder og sender kontekst videre til hinanden
380- Det stoerste community og flest indbyggede integrationer er vigtigt for dig
381 
382### Vaelg OpenAI Agents SDK hvis:
383- Dit primaere moenster er at route samtaler til specialister
384- Du har brug for guardrails der validerer input/output parallelt
385- Du vil have den enklest mulige abstraktion med minimal boilerplate
386- Indbygget tracing og observability er vigtigt
387 
388### Vaelg Claude Agent SDK hvis:
389- Dine agenter skal laese, skrive og eksekvere kode
390- Du vil have foersteklasses MCP-server-integration
391- Du har brug for autonome agenter der itererer og selvkorrigerer
392- Du allerede bruger Claude og vil have den dybeste integration
393 
394## Kan man kombinere frameworks?
395 
396Ja. Et almindeligt moenster er at bruge et framework til orkestrering og et andet til individuelle agenter:
397 
398- **LangGraph** til den overordnede workflow-graf
399- **CrewAI** til en specifik node der kraever multi-agent-samarbejde
400- **Claude Agent SDK** til koderelaterede delopgaver via MCP
401- **OpenAI Agents SDK** til kundevendt triage og routing
402 
403Frameworks udelukker ikke hinanden. Brug det der passer til hver del af dit system.
404 
405## Konklusion
406 
407Hvert framework satser paa en klar retning:
408 
409- **LangGraph** optimerer for kontrol  -  du bestemmer hver overgang
410- **CrewAI** optimerer for samarbejde  -  agenter arbejder som et team
411- **OpenAI Agents SDK** optimerer for enkelhed  -  minimal abstraktion, rene handoffs
412- **Claude Agent SDK** optimerer for autonomi  -  giv det vaerktojer og lad det arbejde
413 
414Det 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.
415