Agentic AI frameworkok osszehasonlitasa: LangGraph vs CrewAI vs OpenAI Agents SDK vs Claude Agent SDK

Az AI agensek a kutatasi demokbol produkcios rendszerekke fejlodtek. 2026-ra az elorejelzesek szerint a vallalati AI alkalmazasok tobb mint 60%-a tartalmaz majd agens komponenseket. De agenseket a semmibol epiteni - kezelni az eszkozciklusokat, az allapotot, a memoriat, a hibakezelest es a tobbagens-koordinaciot - osszetett feladat. Ezert leteznek a frameworkok.

Negy framework dominnal 2026-ban: LangGraph, CrewAI, OpenAI Agents SDK es Claude Agent SDK. Mindegyik alapvetoen mas megkozelitest alkalmaz ugyanarra a problemara: megadni az LLM-eknek a kepesseget a gondolkodasra, tervezesre, eszkozhasznalatra es egyuttmukodesre.

Attekintes

LangGraph: A grafepito

A LangGraph az agens workflow-kat iranyitott ciklikus grafkent modelezi. Csomopontokat (munkavegzo fuggvenyeket) es eleket (kozottuk levo atmenetek, opcionalisan feltetelesen) hataroz meg. Az allapot vegigfolyik a grafon es checkpointing segitsegevel megorzodik.

Ez a legjobban kifejtett es leginkabb vezerelheto framework - minden lepest te kotogettel ossze.

Alapfogalmak

• StateGraph: a graf definicio tipizalt allapottal
• Nodes: allapotot atalakito Python fuggvenyek
• Edges: csomopontok kozti kapcsolatok, lehetnek feltetelezettek
• Checkpointing: beepitett perzisztencia hosszan futo workflow-khoz

Kodpelda

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?"}]})

Erossegek

• Reszletes kontroll minden lepes es atmenet felett
• Beepitett checkpointing es human-in-the-loop
• Teljes TypeScript paritas
• Barmely LLM szolgaltatoval mukodik
• A legjobb osszetett workflow-khoz felteteles elagazassal es ciklusokkal

Gyengesegek

• Meredek tanulasi gorbe - ertened kell a grafelmelet fogalmait
• Boszavu egyszeru esetekre - egy alap agens tobb boilerplate-et igenyel, mint mas frameworkok
• A graffolyamatok debuggolasa kihivast jelenthet LangSmith nelkul

Arazes

Open-source (MIT). A LangSmith (felugyelt megfigyelehetosegi platform) fizetett szintekkel rendelkezik produkcios monitorozashoz.

CrewAI: A csapatepito

A CrewAI emberi metaforat hasznal: specializalt agensekbol allo legenyseget allitasz ossze, amelyekben mindegyiknek van szerepe, celja es hattertoertenete. Az agensek feladatokon dolgoznak eszkozok segitsegevel, egy folyamat altal koordinalva (szekvencialis, hierarchikus vagy konszenzusos).

Gondolj ra ugy, mint egy csapat felvetele, ahol minden tagnak meghatarozott munkakor es specializacio jut.

Alapfogalmak

• Agent: persona szereppel, cellal, hattertoertenettel es eszkozokkel
• Task: feladat leirassal, elvart kimenettel es hozzarendelt agenssel
• Crew: egyutt dolgozo agensek csoportja
• Process: vegrehajtasi strategia (szekvencialis, hierarchikus, konszenzusos)
• Flow: esemenyvezerelt orkesztracios reteg tobb legenyseget osszekapcsolasahoz

Kodpelda

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)

Erossegek

• Intuitiv szerepalapau absztrakcio - konnyen athato
• Tobb mint 100 beepitett eszkozintegraciohoz
• Megosztott memoria az agensek kozott (rovid tavu, hosszu tavu, entitas)
• A legnagyobb kozosseg (~40k GitHub csillag)
• Hierarchikus folyamat "menedzser" agenssel, aki delegall es validall

Gyengesegek

• Kevesbe reszletes kontroll, mint a LangGraph - szerepeket hatarozol meg, nem pontos vegrehajtasi utvonalakat
• A hierarchikus folyamat kiszamithatatlan lehet, amikor az agensek nem ertenek egyet
• A tobbagens beszelgetesek debuggolasa nehezebb, mint az egyagens folyamatok

Arazes

Open-source mag (ingyenes). CrewAI Platform: 99 $/ho (Teams) es 120 ezer $/ev (Enterprise) kozott. Az arazes az aktiv legenysegtol es a havi vegrehajtasok szamatol fugg.

OpenAI Agents SDK: A router

Az OpenAI Agents SDK (a Swarm szellemi utodja) a kiosztasokra osszpontosit - az agensek mas specializalt agenseknek adjak at a beszelgeteseket. Ez a legminimalisztikusabb framework: agensek, eszkozok, kiosztasok es guardrail-ek. Ennyi.

Alapfogalmak

• Agent: model + utasitasok + eszkozok + kiosztasok
• Handoff: atadasas egy masik agensnek (eszkoznek modelezve, amelyet az LLM meghivhat)
• Guardrail: bemenet/kimenet validacio, ami parhuzamosan fut az agenssel
• Runner: vegrehajtja az agens ciklust
• Tracing: beepitett megfigyelehetoseg minden LLM hivashoz, eszkozhasznalahoz es kiosztashoz

Kodpelda

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

Erossegek

• Tiszta kiosztas minta - termeszetes routing/triazs workflow-khoz
• A guardrail-ek parhuzamosan futnak a vegrehajtassal (fail-fast, nem blokkolnak)
• Beepitett tracing felulet a debuggolashoz
• A neve ellenere nem OpenAI modelleket is tamogat
• Minimalis absztrakcio - konnyen ertheto es bovitheto

Gyengesegek

• Kevesbe erett allapotkezeles, mint a LangGraph
• Nincs beepitett perzisztencia vagy checkpointing
• A harmadik feles eszkozok okoszisztemaja kisebb
• A kiosztas-kozpontu tervezes nem minden architekturaba illik

Arazes

Open-source (MIT). Tokenenkent fizetsz barmelyik hasznalt modellert.

Claude Agent SDK: A fejleszto

A Claude Agent SDK mas megkozelitest kinal: ahelyett, hogy workflow-kat vagy szerepeket hataroznall meg, az agensnek eszkozok keszletet adod es hagyod, hogy maga talaja ki, hogyan hajtsa vegre a feladatot. Ugyanazt az autonom ciklust hasznalja, ami a Claude Code-ot is hajtja - olvas, cselekszik, ellenoriz, iteral.

Alapfogalmak

• query(): a fo belepesi pont, ami elinditja az agens ciklust
• Beepitett eszkozok: Read, Write, Edit, Bash, Glob, Grep, WebSearch, WebFetch
• Egyedi eszkozok MCP-n keresztul: eszkozok definialaasa in-process MCP serverkenek
• Sub-agents: specializalt agensek, akiknek a szulo delegalhat
• Sessions: kontextus fenntartasa tobb interakcion at

Kodpelda

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);
  }
}

Erossegek

• Elsoosztayu MCP integracio - csatlakozas barmely MCP szerver okoszisztemaahoz
• Beepitett eszkozok fajlmuveletekhez, terminalhoz es webelesreshez
• Automatikus kontextus kompakcio nagy kodbazisokhoz
• Parhuzamos sub-agent-ek osszetett feladatokhoz
• Ugyanaz a motor, mint a Claude Code - valos fejlesztesi workflow-kon tesztelt

Gyengesegek

• Csak Claude modellek - nincs tobbszolgaltatoi tamogatas
• Ujabb framework kisebb kozosseggel
• Node.js kornyezet szukseges meg a Python SDK-hoz is
• Kevesbe explicit workflow kontroll a LangGraph-hoz kepest

Arazes

Open-source. Standard Claude API token diszabasok. Managed Agents (hosztolt verzio): 0,08 $ munkamenetorankeent a token koltsegek mellett.

Mikor melyiket valasszuk

Valaszd a LangGraph-ot, ha:

• Pontos kontrollra van szukseged a workflow minden lepesenel
• A felhasznalasi eseted osszetett felteteles logikat es ciklusokat foglal magaban
• Beepitett perzisztenciat es human-in-the-loop checkpoint-okat akarsz
• Tobb LLM szolgaltatot kell hasznalnod ugyanabban a workflow-ban

Valaszd a CrewAI-t, ha:

• Intuitiv, szerepalapau absztrakciot szeretnel
• A feladatod tobb, kulonbozo specializaciooju agenst igenyel
• Szukseged van ra, hogy az agensek egyuttmukedjenek es kontextust adjanak at egymasnak
• A legnagyobb kozosseget es a legtobb beepitett integraciot ertekeled

Valaszd az OpenAI Agents SDK-t, ha:

• Az elsodleges mintad beszelgetesek iranyitasa szakertokhoz
• Parhuzamosan validalo guardrail-ekre van szukseged bemenethez/kimenethez
• A leheto legegyszerubb absztrakciot akarod minimalis boilerplate-tel
• A beepitett tracing es megfigyelehetoseg fontos

Valaszd a Claude Agent SDK-t, ha:

• Az agenseidnek kodot kell olvasniuk, irniuk es futtatniuk
• Elsoosztayu MCP szerver integraciot szeretnel
• Autonom agensekre van szukseged, amelyek iteralnak es onkorrigalnak
• Mar hasznalod a Claude-ot es a legmelyebb integraciot szeretned

Kombinalhatok a frameworkok?

Igen. Egy gyakori minta az, hogy az egyik frameworkot az orkesztraciora, a masikat az egyes agensekre hasznaljuk:

• LangGraph az egesz workflow grafhoz
• CrewAI egy adott csomoponthoz, ami tobbagens egyuttmukoedest igenyel
• Claude Agent SDK kodolassal kapcsolatos alfeladatokhoz MCP-n keresztul
• OpenAI Agents SDK ugyfeloldali triazs es routing celokra

A frameworkok nem zarjak ki egymast. Hasznald azt, ami az adott reszhez a legjobban illik.

Osszefoglalas

Minden framework egy vilagos iranyba tett:

• LangGraph a kontrollra optimalizal - te dontesz minden atmeenetrol
• CrewAI az egyuttmukodesre optimalizal - az agensek csapatkent dolgoznak
• OpenAI Agents SDK az egyszeerusegre optimalizal - minimalis absztrakcio, tiszta kiosztasok
• Claude Agent SDK az autonomiara optimalizal - add meg az eszkozokat es hagyd dolgozni

A helyes valasztas a workflow-dtol, a csapatodtol es a meglevo technologiai stacktol fugg. Valaszd azt, ami a fo felhasznalasi esetedhez illik, tanold meg alaposan, es huzd be a toobbieket, amikor azok erossegi teruleteere kersz.