1~
2Agenty 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.
3~
4Cztery 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.
5~
6## W skrocie
7~
8| Aspekt | LangGraph | CrewAI | OpenAI Agents SDK | Claude Agent SDK |
9|--------|-----------|--------|-------------------|-----------------|
10| **Tworca** | LangChain | CrewAI Inc. | OpenAI | Anthropic |
11| **Architektura** | Oparta na grafach | Oparta na rolach | Oparta na przekazywaniu | Autonomiczna petla |
12| **Filozofia** | Maksymalna kontrola | Wspolpraca zespolowa | Minimalna abstrakcja | Daj agentowi komputer |
13| **Jezyki** | Python, TypeScript | Python | Python | Python, TypeScript |
14| **Obsluga modeli** | Dowolne (OpenAI, Claude, lokalne) | Dowolne | Dowolne (pomimo nazwy) | Tylko Claude |
15| **Gwiazdki na GitHub** | ~29k | ~40k | ~21k | ~6k |
16| **Najlepszy do** | Zlozonych stanowych workflow | Specjalizacji wielu agentow | Routingu i triazu | Kodowania i zadan zwiazanych z plikami |
17~
18## LangGraph: Budowniczy grafow
19~
20LangGraph 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.
21~
22To najbardziej jawny i kontrolowalny framework  -  sam podlaczasz kazdy krok.
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### Kluczowe koncepcje
35~
36- **StateGraph**: definicja grafu z typowanym stanem
37- **Nodes**: funkcje Python transformujace stan
38- **Edges**: polaczenia miedzy wezlami, moga byc warunkowe
39- **Checkpointing**: wbudowana trwalosc dla dlugo trwajacych workflow
40~
41### Przyklad kodu
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### Mocne strony
79~
80- Szczegolowa kontrola nad kazdym krokiem i przejsciem
81- Wbudowany checkpointing i human-in-the-loop
82- Pelna zgodnosc z TypeScript
83- Dziala z dowolnym dostawca LLM
84- Najlepszy do zlozonych workflow z warunkowym rozgalezianiem i petlami
85~
86### Slabe strony
87~
88- Stroma krzywa uczenia  -  musisz rozumiec koncepcje teorii grafow
89- Rozwlekly dla prostych przypadkow  -  podstawowy agent wymaga wiecej boilerplate'u niz inne frameworki
90- Debugowanie przeplywow grafowych moze byc trudne bez LangSmith
91~
92### Cennik
93~
94Open-source (MIT). LangSmith (zarzadzana platforma obserwowalnosci) posiada platne plany do monitorowania produkcyjnego.
95~
96## CrewAI: Tworca zespolow
97~
98CrewAI 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).
99~
100Pomysl o tym jak o zatrudnianiu zespolu, w ktorym kazdy czlonek ma okreslone stanowisko i specjalnosc.
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### Kluczowe koncepcje
114~
115- **Agent**: persona z rola, celem, historia i narzedziami
116- **Task**: zadanie z opisem, oczekiwanym wynikiem i przypisanym agentem
117- **Crew**: grupa agentow pracujacych razem
118- **Process**: strategia wykonania (sekwencyjna, hierarchiczna, konsensualna)
119- **Flow**: warstwa orkiestracji sterowana zdarzeniami do laczenia wielu zalog
120~
121### Przyklad kodu
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### Mocne strony
171~
172- Intuicyjna abstrakcja oparta na rolach  -  latwa do zrozumienia
173- Ponad 100 wbudowanych integracji narzedzi
174- Wspoldzielona pamiec miedzy agentami (krotkoterminowa, dlugoterminowa, encji)
175- Najwieksza spolecznosc (~40k gwiazdek na GitHub)
176- Hierarchiczny proces z agentem "menedzerem", ktory deleguje i waliduje
177~
178### Slabe strony
179~
180- Mniejsza szczegolowa kontrola niz LangGraph  -  definiujesz role, a nie dokladne sciezki wykonania
181- Hierarchiczny proces moze byc nieprzewidywalny, gdy agenty sie nie zgadzaja
182- Debugowanie rozmow wielu agentow jest trudniejsze niz przeplywow pojedynczego agenta
183~
184### Cennik
185~
186Open-source (darmowy). CrewAI Platform: 99$/miesiac (Teams) do 120 tys.$/rok (Enterprise). Cennik oparty na aktywnych zalogach i miesiecznych wykonaniach.
187~
188## OpenAI Agents SDK: Router
189~
190OpenAI 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.
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### Kluczowe koncepcje
204~
205- **Agent**: model + instrukcje + narzedzia + przekazywania
206- **Handoff**: przekazanie do innego agenta (modelowane jako narzedzie, ktore LLM moze wywolac)
207- **Guardrail**: walidacja wejscia/wyjscia uruchamiana rownolegle z agentem
208- **Runner**: wykonuje petle agenta
209- **Tracing**: wbudowana obserwowalnosc dla wszystkich wywolan LLM, narzedzi i przekazan
210~
211### Przyklad kodu
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### Mocne strony
258~
259- Przejrzysty wzorzec przekazywan  -  naturalny dla workflow routingu/triazu
260- Guardrails dzialaja rownolegle z wykonaniem (fail-fast, nie blokujace)
261- Wbudowany panel tracing do debugowania
262- Pomimo nazwy, obsluguje modele spoza OpenAI
263- Minimalna abstrakcja  -  latwy do zrozumienia i rozszerzenia
264~
265### Slabe strony
266~
267- Mniej dojrzale zarzadzanie stanem niz LangGraph
268- Brak wbudowanej trwalosci lub checkpointingu
269- Ekosystem narzedzi zewnetrznych jest mniejszy
270- Projekt skupiony na przekazywaniach moze nie pasowac do kazdej architektury
271~
272### Cennik
273~
274Open-source (MIT). Platisz za token za dowolny model, ktorego uzywasz.
275~
276## Claude Agent SDK: Programista
277~
278Claude 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.
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### Kluczowe koncepcje
291~
292- **query()**: glowny punkt wejscia uruchamiajacy petle agenta
293- **Wbudowane narzedzia**: Read, Write, Edit, Bash, Glob, Grep, WebSearch, WebFetch
294- **Niestandardowe narzedzia przez MCP**: definiowanie narzedzi jako serwerow MCP w procesie
295- **Sub-agents**: specjalizowani agenci, do ktorych rodzic moze delegowac
296- **Sessions**: utrzymywanie kontekstu miedzy wieloma interakcjami
297~
298### Przyklad kodu
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### Mocne strony
336~
337- Pierwszorzedna integracja MCP  -  polacz sie z dowolnym ekosystemem serwerow MCP
338- Wbudowane narzedzia do operacji na plikach, terminala i dostepu do sieci
339- Automatyczna kompaktacja kontekstu dla duzych baz kodu
340- Rownolegle sub-agents do zlozonych zadan
341- Ten sam silnik co Claude Code  -  przetestowany w prawdziwych workflow programistycznych
342~
343### Slabe strony
344~
345- Tylko modele Claude  -  brak wsparcia wielu dostawcow
346- Nowszy framework z mniejsza spolecznoscia
347- Wymaga srodowiska Node.js nawet dla Python SDK
348- Mniejsza jawna kontrola workflow w porownaniu z LangGraph
349~
350### Cennik
351~
352Open-source. Standardowe stawki za tokeny Claude API. Managed Agents (wersja hostowana): 0,08$ za godzine sesji plus koszty tokenow.
353~
354## Kiedy wybrac ktory
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### Wybierz LangGraph, jesli:
371- Potrzebujesz precyzyjnej kontroli nad kazdym krokiem workflow
372- Twoj przypadek uzycia obejmuje zlozono logike warunkowa i petle
373- Chcesz wbudowana trwalosc i checkpointy human-in-the-loop
374- Musisz uzywac wielu dostawcow LLM w tym samym workflow
375~
376### Wybierz CrewAI, jesli:
377- Chcesz intuicyjnej abstrakcji opartej na rolach
378- Twoje zadanie obejmuje wielu agentow z odrebnymi specjalnosciami
379- Potrzebujesz, zeby agenty wspolpracowaly i przekazywaly sobie kontekst
380- Cenisz najwieksza spolecznosc i najwiecej wbudowanych integracji
381~
382### Wybierz OpenAI Agents SDK, jesli:
383- Twoj glowny wzorzec to kierowanie rozmow do specjalistow
384- Potrzebujesz guardrails walidujacych wejscie/wyjscie rownolegle
385- Chcesz najprostszej mozliwej abstrakcji z minimalnym boilerplate'em
386- Wbudowany tracing i obserwowalnosc sa wazne
387~
388### Wybierz Claude Agent SDK, jesli:
389- Twoje agenty musza czytac, pisac i wykonywac kod
390- Chcesz pierwszorzednej integracji z serwerami MCP
391- Potrzebujesz autonomicznych agentow, ktore iteruja i samodzielnie sie koryguja
392- Juz uzywasz Claude i chcesz najglebszej integracji
393~
394## Czy mozna laczyc frameworki?
395~
396Tak. Czestym wzorcem jest uzywanie jednego frameworka do orkiestracji i innego do poszczegolnych agentow:
397~
398- **LangGraph** do ogolnego grafu workflow
399- **CrewAI** do konkretnego wezla wymagajacego wspolpracy wielu agentow
400- **Claude Agent SDK** do podzadan zwiazanych z kodowaniem przez MCP
401- **OpenAI Agents SDK** do triazu i routingu po stronie klienta
402~
403Frameworki nie wykluczaja sie wzajemnie. Uzywaj tego, co pasuje do kazdej czesci Twojego systemu.
404~
405## Podsumowanie
406~
407Kazdy framework stawia na cos innego:
408~
409- **LangGraph** optymalizuje pod katem kontroli  -  Ty decydujesz o kazdym przejsciu
410- **CrewAI** optymalizuje pod katem wspolpracy  -  agenty pracuja jako zespol
411- **OpenAI Agents SDK** optymalizuje pod katem prostoty  -  minimalna abstrakcja, przejrzyste przekazywania
412- **Claude Agent SDK** optymalizuje pod katem autonomii  -  daj mu narzedzia i pozwol dzialac
413~
414Wlasciwy 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.
415~