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~