1~
2AI agents עברו ממדגמי מחקר למערכות production. צפוי שלמעלה מ-60% מיישומי ה-AI הארגוניים יכללו רכיבים agentic עד 2026. אך בניית agents מאפס  -  ניהול tool loops, state, memory, error handling, וקואורדינציה רב-agent-ית  -  היא מורכבת. כאן נכנסים ה-frameworks לתמונה.
3~
4ארבעה frameworks שולטים ב-2026: **LangGraph**, **CrewAI**, **OpenAI Agents SDK**, ו-**Claude Agent SDK**. לכל אחד גישה שונה באופן יסודי לאותה בעיה: לתת ל-LLMs את היכולת להסיק, לתכנן, להשתמש ב-tools, ולשתף פעולה.
5~
6## במבט חטוף
7~
8| היבט | LangGraph | CrewAI | OpenAI Agents SDK | Claude Agent SDK |
9|--------|-----------|--------|-------------------|-----------------|
10| **מאת** | LangChain | CrewAI Inc. | OpenAI | Anthropic |
11| **ארכיטקטורה** | מבוסס graph | מבוסס role | מבוסס handoff | לולאה אוטונומית |
12| **פילוסופיה** | שליטה מקסימלית | שיתוף פעולה צוותי | הפשטה מינימלית | תנו ל-agent מחשב |
13| **שפות** | Python, TypeScript | Python | Python | Python, TypeScript |
14| **תמיכה במודלים** | כל מודל (OpenAI, Claude, מקומי) | כל מודל | כל מודל (למרות השם) | Claude בלבד |
15| **GitHub stars** | ~29k | ~40k | ~21k | ~6k |
16| **מתאים במיוחד ל** | workflows מורכבים עם state | התמחות רב-agent-ית | routing ו-triage | קוד ומשימות עתירות קבצים |
17~
18## LangGraph: בונה ה-Graphs
19~
20LangGraph ממדל agent workflows כ-**graphs מחזוריים מכוונים**. אתם מגדירים nodes (פונקציות שמבצעות עבודה) ו-edges (מעברים ביניהם, אופציונלית מותנים). ה-state זורם דרך ה-graph ונשמר באמצעות checkpointing.
21~
22זהו ה-framework המפורש והשליט ביותר  -  אתם מחווטים כל שלב בעצמכם.
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### מושגי ליבה
35~
36- **StateGraph**: הגדרת ה-graph עם state מטופס
37- **Nodes**: פונקציות Python שמעבירות state
38- **Edges**: חיבורים בין nodes, יכולים להיות מותנים
39- **Checkpointing**: persistence מובנה עבור workflows ארוכים
40~
41### דוגמת קוד
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### חוזקות
79~
80- שליטה עדינה בכל שלב ומעבר
81- checkpointing מובנה ו-human-in-the-loop
82- שוויון מלא ל-TypeScript
83- עובד עם כל ספק LLM
84- מתאים במיוחד ל-workflows מורכבים עם conditional branching ולולאות
85~
86### חולשות
87~
88- עקומת למידה תלולה  -  צריך להבין מושגים של תורת הגרפים
89- מילולי מדי ל-use cases פשוטים  -  agent בסיסי דורש יותר boilerplate מ-frameworks אחרים
90- ניפוי זרימות graph יכול להיות מאתגר ללא LangSmith
91~
92### תמחור
93~
94קוד פתוח (MIT). ל-LangSmith (פלטפורמת observability מנוהלת) יש מסלולים בתשלום לניטור production.
95~
96## CrewAI: מרכיב הצוות
97~
98CrewAI משתמש במטאפורה אנושית: אתם מרכיבים **crew** של agents מומחים, לכל אחד יש **role**, **goal**, ו-**backstory**. ה-agents משתפים פעולה על **tasks** באמצעות **tools**, מתואמים על ידי **process** (sequential, hierarchical, או consensual).
99~
100חשבו על זה כגיוס צוות שבו לכל חבר יש תפקיד והתמחות ספציפיים.
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### מושגי ליבה
114~
115- **Agent**: פרסונה עם role, goal, backstory, ו-tools
116- **Task**: משימה עם תיאור, פלט צפוי, ו-agent מוקצה
117- **Crew**: קבוצה של agents שעובדים יחד
118- **Process**: אסטרטגיית הרצה (sequential, hierarchical, consensual)
119- **Flow**: שכבת אורקסטרציה מבוססת אירועים לחיבור מספר crews
120~
121### דוגמת קוד
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### חוזקות
171~
172- הפשטה אינטואיטיבית מבוססת role  -  קל לחשוב עליה
173- יותר מ-100 אינטגרציות tool מובנות
174- זיכרון משותף בין agents (קצר-טווח, ארוך-טווח, entity)
175- הקהילה הגדולה ביותר (~40k GitHub stars)
176- תהליך hierarchical עם agent "manager" שמאציל ומאמת
177~
178### חולשות
179~
180- פחות שליטה עדינה מ-LangGraph  -  אתם מגדירים roles, לא נתיבי הרצה מדויקים
181- תהליך hierarchical יכול להיות בלתי צפוי כאשר agents לא מסכימים
182- ניפוי שיחות רב-agent-יות קשה יותר מזרימות single-agent
183~
184### תמחור
185~
186ליבת קוד פתוח (חינם). פלטפורמת CrewAI: $99/חודש (Teams) עד $120k/שנה (Enterprise). התמחור מבוסס על live crews והרצות חודשיות.
187~
188## OpenAI Agents SDK: ה-Router
189~
190ה-OpenAI Agents SDK (היורש הרוחני של Swarm) מתמקד ב-**handoffs**  -  agents המעבירים שיחות ל-agents מומחים אחרים. זהו ה-framework המינימלי ביותר: agents, tools, handoffs, ו-guardrails. זה הכל.
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### מושגי ליבה
204~
205- **Agent**: model + הוראות + tools + handoffs
206- **Handoff**: העברה ל-agent אחר (ממודל כ-tool שה-LLM יכול לקרוא לו)
207- **Guardrail**: ולידציית input/output שרצה במקביל ל-agent
208- **Runner**: מריץ את לולאת ה-agent
209- **Tracing**: observability מובנה לכל קריאות ה-LLM, הפעלות tool, ו-handoffs
210~
211### דוגמת קוד
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### חוזקות
258~
259- דפוס handoff נקי  -  טבעי ל-workflows של routing/triage
260- guardrails רצים במקביל להרצה (fail-fast, לא חוסם)
261- dashboard tracing מובנה לניפוי
262- למרות השם, תומך במודלים שאינם OpenAI
263- הפשטה מינימלית  -  קל להבין ולהרחיב
264~
265### חולשות
266~
267- ניהול state פחות בשל מ-LangGraph
268- אין persistence או checkpointing מובנים
269- אקוסיסטם של tools של צד שלישי קטן יותר
270- עיצוב ממוקד handoff עלול שלא להתאים לכל ארכיטקטורה
271~
272### תמחור
273~
274קוד פתוח (MIT). אתם משלמים per-token עבור כל מודל שאתם משתמשים בו.
275~
276## Claude Agent SDK: המפתח
277~
278ה-Claude Agent SDK נוקט גישה שונה: במקום להגדיר workflows או roles, אתם נותנים ל-agent **סט של tools ונותנים לו להבין איך לבצע את המשימה**. הוא משתמש באותה לולאה אוטונומית שמפעילה את Claude Code  -  לקרוא, לפעול, לאמת, לחזור.
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### מושגי ליבה
291~
292- **query()**: נקודת הכניסה הראשית שמתחילה את לולאת ה-agent
293- **Built-in tools**: Read, Write, Edit, Bash, Glob, Grep, WebSearch, WebFetch
294- **Custom tools via MCP**: הגדירו tools כ-MCP servers בתהליך
295- **Sub-agents**: agents מומחים שה-parent יכול להאציל אליהם
296- **Sessions**: שמירה על הקשר בין אינטראקציות מרובות
297~
298### דוגמת קוד
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### חוזקות
336~
337- אינטגרציית MCP ממדרגה ראשונה  -  התחברו לכל אקוסיסטם של MCP server
338- tools מובנים לפעולות קבצים, terminal, וגישת web
339- דחיסת קונטקסט אוטומטית עבור codebases גדולים
340- מקביליות sub-agent למשימות מורכבות
341- אותו מנוע כמו Claude Code  -  נבחן בקרב על workflows אמיתיים של פיתוח
342~
343### חולשות
344~
345- מודלי Claude בלבד  -  אין תמיכה במספר ספקים
346- framework חדש יותר עם קהילה קטנה יותר
347- דורש Node.js runtime גם עבור Python SDK
348- פחות שליטה מפורשת על workflow בהשוואה ל-LangGraph
349~
350### תמחור
351~
352קוד פתוח. תעריפי token סטנדרטיים של Claude API. Managed Agents (גרסה מאוחסנת): $0.08 לשעת session בנוסף לעלויות token.
353~
354## מתי לבחור מה
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### בחרו ב-LangGraph אם:
371- אתם זקוקים לשליטה מדויקת בכל שלב של ה-workflow
372- ה-use case שלכם כולל לוגיקה מותנית מורכבת ולולאות
373- אתם רוצים persistence מובנה ונקודות checkpoint של human-in-the-loop
374- אתם צריכים להשתמש במספר ספקי LLM באותו workflow
375~
376### בחרו ב-CrewAI אם:
377- אתם רוצים הפשטה אינטואיטיבית מבוססת role
378- המשימה שלכם כוללת מספר agents עם התמחויות שונות
379- אתם צריכים agents שישתפו פעולה ויעבירו קונטקסט אחד לשני
380- אתם מעריכים את הקהילה הגדולה ביותר ואת האינטגרציות המובנות הרבות ביותר
381~
382### בחרו ב-OpenAI Agents SDK אם:
383- הדפוס העיקרי שלכם הוא ניתוב שיחות למומחים
384- אתם צריכים guardrails שמאמתים input/output במקביל
385- אתם רוצים את ההפשטה הפשוטה ביותר האפשרית עם מינימום boilerplate
386- tracing ו-observability מובנים חשובים
387~
388### בחרו ב-Claude Agent SDK אם:
389- ה-agents שלכם צריכים לקרוא, לכתוב, ולהריץ קוד
390- אתם רוצים אינטגרציית MCP server ממדרגה ראשונה
391- אתם צריכים agents אוטונומיים שמבצעים איטרציה ומתקנים את עצמם
392- אתם כבר משתמשים ב-Claude ורוצים את האינטגרציה העמוקה ביותר
393~
394## האם אפשר לשלב frameworks?
395~
396כן. דפוס נפוץ הוא שימוש ב-framework אחד לאורקסטרציה ובאחר ל-agents בודדים:
397~
398- **LangGraph** עבור graph ה-workflow הכולל
399- **CrewAI** עבור node ספציפי שדורש שיתוף פעולה רב-agent-י
400- **Claude Agent SDK** עבור תת-משימות הקשורות לקוד באמצעות MCP
401- **OpenAI Agents SDK** עבור triage ו-routing הפונים ללקוח
402~
403ה-frameworks אינם בלעדיים הדדית. השתמשו במה שמתאים לכל חלק במערכת שלכם.
404~
405## סיכום
406~
407כל framework מבצע הימור ברור:
408~
409- **LangGraph** ממוטב לשליטה  -  אתם מחליטים על כל מעבר
410- **CrewAI** ממוטב לשיתוף פעולה  -  agents עובדים כצוות
411- **OpenAI Agents SDK** ממוטב לפשטות  -  הפשטה מינימלית, handoffs נקיים
412- **Claude Agent SDK** ממוטב לאוטונומיה  -  תנו לו tools ותנו לו לעבוד
413~
414הבחירה הנכונה תלויה ב-workflow שלכם, בצוות שלכם, ובסטאק הקיים שלכם. בחרו את זה שמתאים ל-use case העיקרי שלכם, למדו אותו היטב, והביאו אחרים כשאתם מגיעים לנקודת המתיקות שלהם.
415~