1 
2AI-agenter har gatt fran forskningsdemos till produktionssystem. Over 60% av enterprise AI-tillaampningar forvantas innehalla agentiska komponenter till 2026. Men att bygga agenter fran grunden  -  hantera tool-loopar, state, minne, felhantering och multi-agent-koordinering  -  ar komplext. Det ar dar ramverk kommer in.
3 
4Fyra ramverk dominerar 2026: **LangGraph**, **CrewAI**, **OpenAI Agents SDK** och **Claude Agent SDK**. Varje tar ett fundamentalt annorlunda tillvagagangssatt for samma problem: att ge LLM:er formagan att resonera, planera, anvanda verktyg och samarbeta.
5 
6## I Korthet
7 
8| Aspekt | LangGraph | CrewAI | OpenAI Agents SDK | Claude Agent SDK |
9|--------|-----------|--------|-------------------|-----------------|
10| **Av** | LangChain | CrewAI Inc. | OpenAI | Anthropic |
11| **Arkitektur** | Grafbaserad | Rollbaserad | Handoff-baserad | Autonom loop |
12| **Filosofi** | Maximal kontroll | Teamsamarbete | Minimal abstraktion | Ge agenten en dator |
13| **Sprak** | Python, TypeScript | Python | Python | Python, TypeScript |
14| **Modellstod** | Alla (OpenAI, Claude, lokala) | Alla | Alla (trots namnet) | Endast Claude |
15| **GitHub stars** | ~29k | ~40k | ~21k | ~6k |
16| **Bast for** | Komplexa tillstandshanterade workflows | Multi-agent-specialisering | Routing och triage | Coding och filintensiva uppgifter |
17 
18## LangGraph: Grafbyggaren
19 
20LangGraph modellerar agent-workflows som **riktade cykliska grafer**. Du definierar noder (funktioner som utfor arbete) och kanter (overganger mellan dem, valfritt villkorliga). State floder genom grafen och persisteras via checkpointing.
21 
22Detta ar det mest explicita och kontrollerbara ramverket  -  du kopplar varje steg sjalv.
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### Karnkoncept
35 
36- **StateGraph**: grafdefinitionen med typad state
37- **Nodes**: Python-funktioner som transformerar state
38- **Edges**: kopplingar mellan noder, kan vara villkorliga
39- **Checkpointing**: inbyggd persistens for langvariga workflows
40 
41### Kodexempel
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### Styrkor
79 
80- Detaljerad kontroll over varje steg och overgang
81- Inbyggd checkpointing och human-in-the-loop
82- Full TypeScript-paritet
83- Fungerar med vilken LLM-leverantor som helst
84- Bast for komplexa workflows med villkorlig forgrening och loopar
85 
86### Svagheter
87 
88- Brant inlarningskurva  -  du behover forsta grafteorikoncept
89- Omstandligt for enkla anvandningsfall  -  en enkel agent kraver mer boilerplate an andra ramverk
90- Att debugga graffloden kan vara utmanande utan LangSmith
91 
92### Priser
93 
94Open-source (MIT). LangSmith (hanterad observability-plattform) har betalda nivaer for produktionsovervakning.
95 
96## CrewAI: Teamsammanstallaren
97 
98CrewAI anvander en mansklig metafor: du satter ihop en **crew** av specialiserade agenter, var och en med en **roll**, ett **mal** och en **bakgrundshistoria**. Agenter samarbetar om **uppgifter** med hjalp av **verktyg**, koordinerade av en **process** (sekventiell, hierarkisk eller konsensusbaserad).
99 
100Tank pa det som att anstalla ett team dar varje medlem har en specifik yrkestitel och 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### Karnkoncept
114 
115- **Agent**: en persona med roll, mal, bakgrundshistoria och verktyg
116- **Task**: ett uppdrag med beskrivning, forvantad output och tilldelad agent
117- **Crew**: en grupp agenter som arbetar tillsammans
118- **Process**: exekveringsstrategi (sekventiell, hierarkisk, konsensusbaserad)
119- **Flow**: haendelsedriven orkestreringslagret for att koppla samman flera crews
120 
121### Kodexempel
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### Styrkor
171 
172- Intuitiv rollbaserad abstraktion  -  latt att forsta
173- Over 100 inbyggda tool-integrationer
174- Delat minne over agenter (korttids-, langtids-, entity-minne)
175- Storsta communityn (~40k GitHub stars)
176- Hierarkisk process med en "manager"-agent som delegerar och validerar
177 
178### Svagheter
179 
180- Mindre detaljerad kontroll an LangGraph  -  du definierar roller, inte exakta exekveringsvagar
181- Hierarkisk process kan vara oforutsagbar nar agenter ar oense
182- Att debugga multi-agent-konversationer ar svarare an single-agent-floden
183 
184### Priser
185 
186Open-source-karna (gratis). CrewAI Platform: $99/manad (Teams) till $120k/ar (Enterprise). Priser baserade pa aktiva crews och manatliga exekveringar.
187 
188## OpenAI Agents SDK: Routern
189 
190OpenAI Agents SDK (andlig efterfoljare till Swarm) fokuserar pa **handoffs**  -  agenter som overlamnar konversationer till andra specialiserade agenter. Det ar det mest minimala ramverket: agenter, verktyg, handoffs och guardrails. Det ar allt.
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### Karnkoncept
204 
205- **Agent**: modell + instruktioner + verktyg + handoffs
206- **Handoff**: en overlamning till en annan agent (modellerad som ett verktyg som LLM:en kan anropa)
207- **Guardrail**: indata-/utdatavalidering som kor parallellt med agenten
208- **Runner**: exekverar agent-loopen
209- **Tracing**: inbyggd observability for alla LLM-anrop, verktygsexekveringar och handoffs
210 
211### Kodexempel
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### Styrkor
258 
259- Rent handoff-monster  -  naturligt for routing-/triage-workflows
260- Guardrails kor parallellt med exekvering (fail-fast, inte blockerande)
261- Inbyggd tracing-dashboard for debugging
262- Trots namnet stods aven icke-OpenAI-modeller
263- Minimal abstraktion  -  latt att forsta och utoka
264 
265### Svagheter
266 
267- Mindre mogen state management an LangGraph
268- Ingen inbyggd persistens eller checkpointing
269- Ekosystemet av tredjepartsverktyg ar mindre
270- Handoff-centrerad design kanske inte passar alla arkitekturer
271 
272### Priser
273 
274Open-source (MIT). Du betalar per token for vilken modell du an anvander.
275 
276## Claude Agent SDK: Utvecklaren
277 
278Claude Agent SDK tar ett annorlunda tillvagagangssatt: istallet for att definiera workflows eller roller ger du agenten en **uppsattning verktyg och later den lista ut hur den ska utfora uppgiften**. Den anvander samma autonoma loop som driver Claude Code  -  lasa, agera, verifiera, iterera.
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### Karnkoncept
291 
292- **query()**: huvudingangspunkten som startar agent-loopen
293- **Inbyggda verktyg**: Read, Write, Edit, Bash, Glob, Grep, WebSearch, WebFetch
294- **Anpassade verktyg via MCP**: definiera verktyg som in-process MCP-servrar
295- **Sub-agenter**: specialiserade agenter som den overordnade agenten kan delegera till
296- **Sessions**: behall kontext over flera interaktioner
297 
298### Kodexempel
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### Styrkor
336 
337- Forstklassig MCP-integration  -  anslut till hela MCP-server-ekosystemet
338- Inbyggda verktyg for filoperationer, terminal och webbatkomst
339- Automatisk kontextkomprimering for stora kodbaser
340- Sub-agent-parallellism for komplexa uppgifter
341- Samma motor som Claude Code  -  stridstestad i riktiga utvecklingsworkflows
342 
343### Svagheter
344 
345- Endast Claude-modeller  -  inget multi-provider-stod
346- Nyare ramverk med en mindre community
347- Kraver Node.js-runtime aven for Python SDK
348- Mindre explicit workflowkontroll jamfort med LangGraph
349 
350### Priser
351 
352Open-source. Standard Claude API-tokenpriser. Managed Agents (hostad version): $0,08 per sessionstimme utover tokenkostnader.
353 
354## Nar ska du valja vilket
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### Valj LangGraph om:
371- Du behover exakt kontroll over varje steg i workflowen
372- Ditt anvandningsfall innefattar komplex villkorlig logik och loopar
373- Du vill ha inbyggd persistens och human-in-the-loop-checkpoints
374- Du behover anvanda flera LLM-leverantorer i samma workflow
375 
376### Valj CrewAI om:
377- Du vill ha en intuitiv, rollbaserad abstraktion
378- Din uppgift innefattar flera agenter med olika specialiseringar
379- Du behover agenter som samarbetar och skickar kontext mellan varandra
380- Den storsta communityn och flest inbyggda integrationer ar viktigt for dig
381 
382### Valj OpenAI Agents SDK om:
383- Ditt primara monster ar att routa konversationer till specialister
384- Du behover guardrails som validerar indata/utdata parallellt
385- Du vill ha enklast mojliga abstraktion med minimal boilerplate
386- Inbyggd tracing och observability ar viktigt
387 
388### Valj Claude Agent SDK om:
389- Dina agenter behover lasa, skriva och exekvera kod
390- Du vill ha forstklassig MCP-server-integration
391- Du behover autonoma agenter som itererar och sjalvkorrigerar
392- Du redan anvander Claude och vill ha den djupaste integrationen
393 
394## Kan man kombinera ramverk?
395 
396Ja. Ett vanligt monster ar att anvanda ett ramverk for orkestrering och ett annat for individuella agenter:
397 
398- **LangGraph** for den overgripande workflow-grafen
399- **CrewAI** for en specifik nod som kraver multi-agent-samarbete
400- **Claude Agent SDK** for kodrelaterade deluppgifter via MCP
401- **OpenAI Agents SDK** for kundriktad triage och routing
402 
403Ramverken utesluter inte varandra. Anvand det som passar varje del av ditt system.
404 
405## Slutsats
406 
407Varje ramverk satsar pa en tydlig inriktning:
408 
409- **LangGraph** optimerar for kontroll  -  du bestammer varje overgang
410- **CrewAI** optimerar for samarbete  -  agenter arbetar som ett team
411- **OpenAI Agents SDK** optimerar for enkelhet  -  minimal abstraktion, rena handoffs
412- **Claude Agent SDK** optimerar for autonomi  -  ge det verktyg och lat det arbeta
413 
414Ratt val beror pa din workflow, ditt team och din befintliga stack. Valj det som matchar ditt primara anvandningsfall, lar dig det ordentligt och dra in andra nar du traffar deras styrkor.
415