Porownanie frameworkow Agentic AI: LangGraph vs CrewAI vs OpenAI Agents SDK vs Claude Agent SDK

Agenty AI przeszly od demonstracji badawczych do systemow produkcyjnych. Oczekuje sie, ze ponad 60% korporacyjnych aplikacji AI bedzie zawierac komponenty agentowe do 2026 roku. Ale budowanie agentow od zera - zarzadzanie petlami narzedzi, stanem, pamiecia, obsluga bledow i koordynacja wielu agentow - jest zlozone. Wlasnie dlatego powstaly frameworki.

Cztery frameworki dominuja w 2026 roku: LangGraph, CrewAI, OpenAI Agents SDK i Claude Agent SDK. Kazdy z nich przyjmuje zasadniczo inne podejscie do tego samego problemu: nadania modelom LLM zdolnosci do rozumowania, planowania, uzywania narzedzi i wspolpracy.

W skrocie

LangGraph: Budowniczy grafow

LangGraph modeluje workflow agentow jako skierowane grafy cykliczne. Definiujesz wezly (funkcje wykonujace prace) i krawedzie (przejscia miedzy nimi, opcjonalnie warunkowe). Stan przeplywa przez graf i jest utrwalany poprzez checkpointing.

To najbardziej jawny i kontrolowalny framework - sam podlaczasz kazdy krok.

Kluczowe koncepcje

• StateGraph: definicja grafu z typowanym stanem
• Nodes: funkcje Python transformujace stan
• Edges: polaczenia miedzy wezlami, moga byc warunkowe
• Checkpointing: wbudowana trwalosc dla dlugo trwajacych workflow

Przyklad kodu

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

Mocne strony

• Szczegolowa kontrola nad kazdym krokiem i przejsciem
• Wbudowany checkpointing i human-in-the-loop
• Pelna zgodnosc z TypeScript
• Dziala z dowolnym dostawca LLM
• Najlepszy do zlozonych workflow z warunkowym rozgalezianiem i petlami

Slabe strony

• Stroma krzywa uczenia - musisz rozumiec koncepcje teorii grafow
• Rozwlekly dla prostych przypadkow - podstawowy agent wymaga wiecej boilerplate'u niz inne frameworki
• Debugowanie przeplywow grafowych moze byc trudne bez LangSmith

Cennik

Open-source (MIT). LangSmith (zarzadzana platforma obserwowalnosci) posiada platne plany do monitorowania produkcyjnego.

CrewAI: Tworca zespolow

CrewAI wykorzystuje metafore ludzka: tworzysz zalogo specjalizowanych agentow, z ktorych kazdy ma role, cel i historie. Agenty wspolpracuja nad zadaniami uzywajac narzedzi, koordynowane przez proces (sekwencyjny, hierarchiczny lub konsensualny).

Pomysl o tym jak o zatrudnianiu zespolu, w ktorym kazdy czlonek ma okreslone stanowisko i specjalnosc.

Kluczowe koncepcje

• Agent: persona z rola, celem, historia i narzedziami
• Task: zadanie z opisem, oczekiwanym wynikiem i przypisanym agentem
• Crew: grupa agentow pracujacych razem
• Process: strategia wykonania (sekwencyjna, hierarchiczna, konsensualna)
• Flow: warstwa orkiestracji sterowana zdarzeniami do laczenia wielu zalog

Przyklad kodu

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)

Mocne strony

• Intuicyjna abstrakcja oparta na rolach - latwa do zrozumienia
• Ponad 100 wbudowanych integracji narzedzi
• Wspoldzielona pamiec miedzy agentami (krotkoterminowa, dlugoterminowa, encji)
• Najwieksza spolecznosc (~40k gwiazdek na GitHub)
• Hierarchiczny proces z agentem "menedzerem", ktory deleguje i waliduje

Slabe strony

• Mniejsza szczegolowa kontrola niz LangGraph - definiujesz role, a nie dokladne sciezki wykonania
• Hierarchiczny proces moze byc nieprzewidywalny, gdy agenty sie nie zgadzaja
• Debugowanie rozmow wielu agentow jest trudniejsze niz przeplywow pojedynczego agenta

Cennik

Open-source (darmowy). CrewAI Platform: 99$/miesiac (Teams) do 120 tys.$/rok (Enterprise). Cennik oparty na aktywnych zalogach i miesiecznych wykonaniach.

OpenAI Agents SDK: Router

OpenAI Agents SDK (duchowy nastepca Swarm) skupia sie na przekazywaniu - agenty przekazuja rozmowy innym specjalizowanym agentom. To najbardziej minimalistyczny framework: agenty, narzedzia, przekazywania i guardrails. To wszystko.

Kluczowe koncepcje

• Agent: model + instrukcje + narzedzia + przekazywania
• Handoff: przekazanie do innego agenta (modelowane jako narzedzie, ktore LLM moze wywolac)
• Guardrail: walidacja wejscia/wyjscia uruchamiana rownolegle z agentem
• Runner: wykonuje petle agenta
• Tracing: wbudowana obserwowalnosc dla wszystkich wywolan LLM, narzedzi i przekazan

Przyklad kodu

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

Mocne strony

• Przejrzysty wzorzec przekazywan - naturalny dla workflow routingu/triazu
• Guardrails dzialaja rownolegle z wykonaniem (fail-fast, nie blokujace)
• Wbudowany panel tracing do debugowania
• Pomimo nazwy, obsluguje modele spoza OpenAI
• Minimalna abstrakcja - latwy do zrozumienia i rozszerzenia

Slabe strony

• Mniej dojrzale zarzadzanie stanem niz LangGraph
• Brak wbudowanej trwalosci lub checkpointingu
• Ekosystem narzedzi zewnetrznych jest mniejszy
• Projekt skupiony na przekazywaniach moze nie pasowac do kazdej architektury

Cennik

Open-source (MIT). Platisz za token za dowolny model, ktorego uzywasz.

Claude Agent SDK: Programista

Claude Agent SDK przyjmuje inne podejscie: zamiast definiowac workflow lub role, dajesz agentowi zestaw narzedzi i pozwalasz mu samodzielnie wymyslic, jak wykonac zadanie. Uzywa tej samej autonomicznej petli, ktora napedza Claude Code - czytaj, dzialaj, weryfikuj, iteruj.

Kluczowe koncepcje

• query(): glowny punkt wejscia uruchamiajacy petle agenta
• Wbudowane narzedzia: Read, Write, Edit, Bash, Glob, Grep, WebSearch, WebFetch
• Niestandardowe narzedzia przez MCP: definiowanie narzedzi jako serwerow MCP w procesie
• Sub-agents: specjalizowani agenci, do ktorych rodzic moze delegowac
• Sessions: utrzymywanie kontekstu miedzy wieloma interakcjami

Przyklad kodu

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

Mocne strony

• Pierwszorzedna integracja MCP - polacz sie z dowolnym ekosystemem serwerow MCP
• Wbudowane narzedzia do operacji na plikach, terminala i dostepu do sieci
• Automatyczna kompaktacja kontekstu dla duzych baz kodu
• Rownolegle sub-agents do zlozonych zadan
• Ten sam silnik co Claude Code - przetestowany w prawdziwych workflow programistycznych

Slabe strony

• Tylko modele Claude - brak wsparcia wielu dostawcow
• Nowszy framework z mniejsza spolecznoscia
• Wymaga srodowiska Node.js nawet dla Python SDK
• Mniejsza jawna kontrola workflow w porownaniu z LangGraph

Cennik

Open-source. Standardowe stawki za tokeny Claude API. Managed Agents (wersja hostowana): 0,08$ za godzine sesji plus koszty tokenow.

Kiedy wybrac ktory

Wybierz LangGraph, jesli:

• Potrzebujesz precyzyjnej kontroli nad kazdym krokiem workflow
• Twoj przypadek uzycia obejmuje zlozono logike warunkowa i petle
• Chcesz wbudowana trwalosc i checkpointy human-in-the-loop
• Musisz uzywac wielu dostawcow LLM w tym samym workflow

Wybierz CrewAI, jesli:

• Chcesz intuicyjnej abstrakcji opartej na rolach
• Twoje zadanie obejmuje wielu agentow z odrebnymi specjalnosciami
• Potrzebujesz, zeby agenty wspolpracowaly i przekazywaly sobie kontekst
• Cenisz najwieksza spolecznosc i najwiecej wbudowanych integracji

Wybierz OpenAI Agents SDK, jesli:

• Twoj glowny wzorzec to kierowanie rozmow do specjalistow
• Potrzebujesz guardrails walidujacych wejscie/wyjscie rownolegle
• Chcesz najprostszej mozliwej abstrakcji z minimalnym boilerplate'em
• Wbudowany tracing i obserwowalnosc sa wazne

Wybierz Claude Agent SDK, jesli:

• Twoje agenty musza czytac, pisac i wykonywac kod
• Chcesz pierwszorzednej integracji z serwerami MCP
• Potrzebujesz autonomicznych agentow, ktore iteruja i samodzielnie sie koryguja
• Juz uzywasz Claude i chcesz najglebszej integracji

Czy mozna laczyc frameworki?

Tak. Czestym wzorcem jest uzywanie jednego frameworka do orkiestracji i innego do poszczegolnych agentow:

• LangGraph do ogolnego grafu workflow
• CrewAI do konkretnego wezla wymagajacego wspolpracy wielu agentow
• Claude Agent SDK do podzadan zwiazanych z kodowaniem przez MCP
• OpenAI Agents SDK do triazu i routingu po stronie klienta

Frameworki nie wykluczaja sie wzajemnie. Uzywaj tego, co pasuje do kazdej czesci Twojego systemu.

Podsumowanie

Kazdy framework stawia na cos innego:

• LangGraph optymalizuje pod katem kontroli - Ty decydujesz o kazdym przejsciu
• CrewAI optymalizuje pod katem wspolpracy - agenty pracuja jako zespol
• OpenAI Agents SDK optymalizuje pod katem prostoty - minimalna abstrakcja, przejrzyste przekazywania
• Claude Agent SDK optymalizuje pod katem autonomii - daj mu narzedzia i pozwol dzialac

Wlasciwy wybor zalezy od Twojego workflow, Twojego zespolu i istniejacego stosu technologicznego. Wybierz ten, ktory najlepiej pasuje do Twojego glownego przypadku uzycia, naucz sie go dobrze i siegnij po inne, gdy trafisz na ich mocna strone.