1~
2Agentii AI au trecut de la demo-uri de cercetare la sisteme in productie. Se estimeaza ca peste 60% din aplicatiile AI de enterprise vor include componente agentice pana in 2026. Dar construirea agentilor de la zero  -  gestionand bucle de tool, stare, memorie, tratarea erorilor si coordonarea multi-agent  -  este complexa. Aici intervin framework-urile.
3~
4Patru framework-uri domina in 2026: **LangGraph**, **CrewAI**, **OpenAI Agents SDK** si **Claude Agent SDK**. Fiecare adopta o abordare fundamental diferita pentru aceeasi problema: a oferi LLM-urilor capacitatea de a rationa, planifica, folosi tool-uri si colabora.
5~
6## Vedere Generala
7~
8| Aspect | LangGraph | CrewAI | OpenAI Agents SDK | Claude Agent SDK |
9|--------|-----------|--------|-------------------|-----------------|
10| **Creat de** | LangChain | CrewAI Inc. | OpenAI | Anthropic |
11| **Arhitectura** | Bazata pe grafuri | Bazata pe roluri | Bazata pe handoff | Bucla autonoma |
12| **Filozofie** | Control maxim | Colaborare de echipa | Abstractie minima | Da agentului un calculator |
13| **Limbaje** | Python, TypeScript | Python | Python | Python, TypeScript |
14| **Suport modele** | Oricare (OpenAI, Claude, local) | Oricare | Oricare (in ciuda numelui) | Doar Claude |
15| **Stele GitHub** | ~29k | ~40k | ~21k | ~6k |
16| **Ideal pentru** | Workflow-uri stateful complexe | Specializare multi-agent | Routing si triage | Coding si sarcini cu fisiere |
17~
18## LangGraph: Constructorul de Grafuri
19~
20LangGraph modeleaza workflow-urile agentilor ca **grafuri ciclice dirijate**. Definesti noduri (functii care fac munca) si muchii (tranzitii intre ele, optional conditionale). Starea curge prin graf si persista prin checkpointing.
21~
22Este cel mai explicit si controlabil framework  -  conectezi fiecare pas manual.
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### Concepte Cheie
35~
36- **StateGraph**: definitia grafului cu stare tipizata
37- **Nodes**: functii Python care transforma starea
38- **Edges**: conexiuni intre noduri, pot fi conditionale
39- **Checkpointing**: persistenta integrata pentru workflow-uri de lunga durata
40~
41### Exemplu de Cod
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### Puncte Forte
79~
80- Control granular asupra fiecarui pas si tranzitii
81- Checkpointing integrat si human-in-the-loop
82- Paritate completa cu TypeScript
83- Functioneaza cu orice furnizor LLM
84- Ideal pentru workflow-uri complexe cu ramificari conditionale si bucle
85~
86### Puncte Slabe
87~
88- Curba de invatare abrupta  -  trebuie sa intelegi concepte de teoria grafurilor
89- Verbos pentru cazuri de utilizare simple  -  un agent de baza necesita mai mult boilerplate decat alte framework-uri
90- Debugging-ul fluxurilor grafului poate fi dificil fara LangSmith
91~
92### Preturi
93~
94Open-source (MIT). LangSmith (platforma de observabilitate gestionata) are planuri platite pentru monitorizare in productie.
95~
96## CrewAI: Asamblorul de Echipe
97~
98CrewAI foloseste o metafora umana: asamblezi un **crew** de agenti specializati, fiecare cu un **rol**, un **obiectiv** si o **poveste**. Agentii colaboreaza pe **sarcini** folosind **tool-uri**, coordonati de un **proces** (secvential, ierarhic sau consensual).
99~
100Gandeste-te la asta ca angajarea unei echipe in care fiecare membru are un titlu si o specialitate specifice.
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### Concepte Cheie
114~
115- **Agent**: un persona cu rol, obiectiv, poveste si tool-uri
116- **Task**: o sarcina cu descriere, output asteptat si agent asignat
117- **Crew**: un grup de agenti care lucreaza impreuna
118- **Process**: strategie de executie (secventiala, ierarhica, consensuala)
119- **Flow**: strat de orchestrare event-driven pentru conectarea mai multor crew-uri
120~
121### Exemplu de Cod
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### Puncte Forte
171~
172- Abstractie bazata pe roluri intuitiva  -  usor de inteles
173- Peste 100 de integrari de tool-uri incorporate
174- Memorie partajata intre agenti (pe termen scurt, pe termen lung, pe entitate)
175- Cea mai mare comunitate (~40k stele GitHub)
176- Proces ierarhic cu un agent "manager" care deleaga si valideaza
177~
178### Puncte Slabe
179~
180- Mai putin control granular decat LangGraph  -  definesti roluri, nu cai de executie exacte
181- Procesul ierarhic poate fi imprevizibil cand agentii nu sunt de acord
182- Debugging-ul conversatiilor multi-agent este mai dificil decat fluxurile cu un singur agent
183~
184### Preturi
185~
186Core open-source (gratuit). CrewAI Platform: $99/luna (Teams) pana la $120k/an (Enterprise). Preturi bazate pe crew-uri active si executii lunare.
187~
188## OpenAI Agents SDK: Routerul
189~
190OpenAI Agents SDK (succesorul spiritual al Swarm) se concentreaza pe **handoff**  -  agenti care transfera conversatii catre alti agenti specializati. Este cel mai minimalist framework: agenti, tool-uri, handoff si guardrail. Atat.
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### Concepte Cheie
204~
205- **Agent**: model + instructiuni + tool-uri + handoff
206- **Handoff**: un transfer catre un alt agent (modelat ca un tool pe care LLM-ul il poate apela)
207- **Guardrail**: validare de intrare/iesire care ruleaza in paralel cu agentul
208- **Runner**: executa bucla agentului
209- **Tracing**: observabilitate integrata pentru toate apelurile LLM, invocarile de tool si handoff-uri
210~
211### Exemplu de Cod
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### Puncte Forte
258~
259- Pattern de handoff curat  -  natural pentru workflow-uri de routing/triage
260- Guardrail-urile ruleaza in paralel cu executia (fail-fast, neblocante)
261- Dashboard de tracing integrat pentru debugging
262- In ciuda numelui, suporta modele non-OpenAI
263- Abstractie minima  -  usor de inteles si de extins
264~
265### Puncte Slabe
266~
267- Gestionarea starii mai putin matura decat LangGraph
268- Fara persistenta sau checkpointing integrate
269- Ecosistemul de tool-uri terte este mai restrans
270- Design-ul centrat pe handoff poate sa nu se potriveasca oricarei arhitecturi
271~
272### Preturi
273~
274Open-source (MIT). Platesti per token in functie de modelul utilizat.
275~
276## Claude Agent SDK: Dezvoltatorul
277~
278Claude Agent SDK adopta o abordare diferita: in loc sa definesti workflow-uri sau roluri, oferi agentului un **set de tool-uri si il lasi sa-si dea seama cum sa realizeze sarcina**. Foloseste aceeasi bucla autonoma care alimenteaza Claude Code  -  citeste, actioneaza, verifica, itereaza.
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### Concepte Cheie
291~
292- **query()**: punctul de intrare principal care porneste bucla agentului
293- **Tool-uri integrate**: Read, Write, Edit, Bash, Glob, Grep, WebSearch, WebFetch
294- **Tool-uri personalizate via MCP**: defineste tool-uri ca servere MCP in-process
295- **Sub-agenti**: agenti specializati catre care parintele poate delega
296- **Sessions**: mentin contextul de-a lungul mai multor interactiuni
297~
298### Exemplu de Cod
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### Puncte Forte
336~
337- Integrare MCP de prima clasa  -  conecteaza-te la orice ecosistem de servere MCP
338- Tool-uri integrate pentru operatiuni cu fisiere, terminal si acces web
339- Compactare automata a contextului pentru baze de cod mari
340- Paralelism al sub-agentilor pentru sarcini complexe
341- Acelasi motor ca Claude Code  -  testat in lupta pe workflow-uri reale de dezvoltare
342~
343### Puncte Slabe
344~
345- Doar modele Claude  -  fara suport multi-furnizor
346- Framework mai nou cu o comunitate mai mica
347- Necesita runtime-ul Node.js chiar si pentru SDK-ul Python
348- Mai putin control explicit al workflow-ului comparativ cu LangGraph
349~
350### Preturi
351~
352Open-source. Tarife standard per token ale API-ului Claude. Managed Agents (versiune gazduita): $0.08 per ora de sesiune pe langa costurile per token.
353~
354## Cand Sa Alegi Care
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### Alege LangGraph daca:
371- Ai nevoie de control precis asupra fiecarui pas al workflow-ului
372- Cazul tau de utilizare implica logica conditionala complexa si bucle
373- Vrei persistenta integrata si checkpoint-uri human-in-the-loop
374- Trebuie sa folosesti mai multi furnizori LLM in acelasi workflow
375~
376### Alege CrewAI daca:
377- Vrei o abstractie intuitiva bazata pe roluri
378- Sarcina ta implica mai multi agenti cu specialitati distincte
379- Ai nevoie ca agentii sa colaboreze si sa-si paseze context intre ei
380- Valorezi cea mai mare comunitate si cele mai multe integrari
381~
382### Alege OpenAI Agents SDK daca:
383- Pattern-ul tau principal este rutarea conversatiilor catre specialisti
384- Ai nevoie de guardrail-uri care valideaza intrarea/iesirea in paralel
385- Vrei abstractia cea mai simpla posibila cu boilerplate minim
386- Tracing-ul si observabilitatea integrate sunt importante
387~
388### Alege Claude Agent SDK daca:
389- Agentii tai trebuie sa citeasca, scrie si execute cod
390- Vrei integrare de prima clasa cu servere MCP
391- Ai nevoie de agenti autonomi care itereaza si se auto-corecteaza
392- Folosesti deja Claude si vrei integrarea cea mai profunda
393~
394## Se Pot Combina Framework-urile?
395~
396Da. Un pattern comun este sa folosesti un framework pentru orchestrare si altul pentru agentii individuali:
397~
398- **LangGraph** pentru graful workflow-ului general
399- **CrewAI** pentru un nod specific care necesita colaborare multi-agent
400- **Claude Agent SDK** pentru sub-sarcini legate de coding via MCP
401- **OpenAI Agents SDK** pentru triage si routing orientat catre client
402~
403Framework-urile nu se exclud reciproc. Foloseste-l pe cel care se potriveste fiecarei parti a sistemului tau.
404~
405## Concluzie
406~
407Fiecare framework face un pariu clar:
408~
409- **LangGraph** optimizeaza pentru control  -  tu decizi fiecare tranzitie
410- **CrewAI** optimizeaza pentru colaborare  -  agentii lucreaza ca o echipa
411- **OpenAI Agents SDK** optimizeaza pentru simplicitate  -  abstractie minima, handoff-uri curate
412- **Claude Agent SDK** optimizeaza pentru autonomie  -  da-i tool-uri si lasa-l sa lucreze
413~
414Alegerea corecta depinde de workflow-ul tau, echipa ta si stack-ul tau existent. Alege-l pe cel care se potriveste cazului tau principal de utilizare, invata-l bine si integreaza-le pe celelalte cand ajungi la punctul lor forte.
415~