AutoGen, Mastra ו-Emerging Frameworks -- שאר הנוף

סקירה -- למה צריך להכיר את כל הנוף

בפרקים 5-10 עשיתם deep dive לתוך 6 SDKs מרכזיים: Claude Agent SDK, Vercel AI SDK, OpenAI Agents SDK, LangGraph, CrewAI, ו-Google ADK. זה כיסה את הליבה -- אבל השוק של agent frameworks גדול הרבה יותר.

למה זה חשוב? כי הבחירה הנכונה ב-SDK תלויה בהקשר שלכם:

• הצוות שלכם עובד ב-.NET? אף אחד מ-6 ה-SDKs שלמדתם לא מתאים -- תצטרכו את Microsoft Agent Framework
• אתם רוצים לערבב סוכנים מ-frameworks שונים? AG2 הוא היחיד שתומך ב-Universal Interoperability
• אתם TypeScript team שצריכים auth, storage ו-workflows מובנים? Vercel AI SDK הוא library -- Mastra הוא full framework
• אתם Python team שרוצים type safety מקסימלי? Pydantic AI נבנה בדיוק בשביל זה
• אתם חוקרים שרוצים minimal abstraction? Smolagents הוא ~1,000 שורות קוד בלבד

הפרק הזה מכסה את כל חמשת ה-frameworks האלה -- עם קוד לדוגמה, use cases ספציפיים, ו-decision tree שיעזור לכם לבחור. בסוף הפרק תהיה לכם מפה שלמה של שוק ה-agent SDKs ב-2026.

# Python frameworks
pip list | grep -iE "autogen|ag2|pydantic-ai|smolagents|semantic-kernel"

# TypeScript frameworks
npm list -g | grep mastra

Microsoft Agent Framework -- AutoGen + Semantic Kernel

הסיפור: מיזוג שני עולמות

עד 2025, ל-Microsoft היו שני frameworks נפרדים לבניית סוכני AI:

• AutoGen -- יצא מ-Microsoft Research. מתמקד ב-multi-agent conversations, שיחות חופשיות בין סוכנים, מחקר אקדמי
• Semantic Kernel -- ה-SDK הארגוני של Microsoft. Enterprise-grade orchestration, .NET/C# first, אינטגרציה עמוקה עם Azure ו-Microsoft 365

ב-2026, Microsoft מיזגה את שניהם ל-Microsoft Agent Framework. זה לא rebranding -- זה rebuild אמיתי שלוקח את הטוב משני העולמות:

למי זה מתאים?

Microsoft Agent Framework הוא ה-SDK היחיד עם first-class .NET/C# support. אם הארגון שלכם רץ על .NET ו-Azure -- זה הבחירה הטבעית. אבל יש עוד סיבות:

• Enterprise compliance -- שכבות אבטחה, RBAC, audit trails ברמה ארגונית
• Microsoft 365 integration -- סוכנים שעובדים עם Teams, Outlook, SharePoint ישירות
• Azure AI Services -- חיבור native ל-Azure OpenAI, Cognitive Search, ו-Azure AI Studio
• Cross-language -- אותו framework ב-Python וב-.NET, עם interoperability ביניהם

Key Features

• Graph-based workflow engine -- sequential, concurrent, handoff, group chat patterns. דומה ל-LangGraph אבל עם syntax שונה
• Session-based state management -- ניהול state לכל session, עם persistence מובנה
• Type safety ו-middleware pipeline -- middleware שרצה לפני ואחרי כל tool call או agent action
• OpenTelemetry -- tracing מובנה עם OpenTelemetry -- לא vendor-specific כמו LangSmith
• MCP + A2A -- תמיכה בשני הפרוטוקולים הסטנדרטיים
• Durable Agents -- סוכנים ששורדים crashes ו-restarts עם reliable state persistence
• Memory connectors -- חיבור מובנה ל-Pinecone, Qdrant, Azure Cognitive Search

קוד לדוגמה -- סוכן ראשון עם Microsoft Agent Framework (Python)

# pip install semantic-kernel  (Microsoft Agent Framework Python package)
import asyncio
from semantic_kernel import Kernel
from semantic_kernel.agents import ChatCompletionAgent
from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion
from semantic_kernel.contents import ChatHistory

async def main():
    # 1. Create kernel -- the orchestration core
    kernel = Kernel()

    # 2. Add AI service (Azure OpenAI or direct OpenAI)
    kernel.add_service(
        AzureChatCompletion(
            deployment_name="gpt-4o",
            endpoint="https://your-resource.openai.azure.com/",
            api_key="your-azure-key"
        )
    )

    # 3. Create agent
    agent = ChatCompletionAgent(
        kernel=kernel,
        name="ResearchAssistant",
        instructions="""You are a research assistant.
        Analyze topics thoroughly and provide structured answers.
        Always cite sources when possible."""
    )

    # 4. Create chat history and run
    history = ChatHistory()
    history.add_user_message("What are the key trends in AI agents for 2026?")

    async for message in agent.invoke(history):
        print(f"{message.name}: {message.content}")

asyncio.run(main())

קוד לדוגמה -- Multi-Agent Group Chat

from semantic_kernel.agents import AgentGroupChat
from semantic_kernel.agents.strategies import (
    SequentialSelectionStrategy,
    DefaultTerminationStrategy
)

async def group_chat_example():
    kernel = Kernel()
    # ... add AI service ...

    # Create specialized agents
    analyst = ChatCompletionAgent(
        kernel=kernel,
        name="Analyst",
        instructions="You analyze data and identify patterns."
    )

    writer = ChatCompletionAgent(
        kernel=kernel,
        name="Writer",
        instructions="You take analysis and write clear reports."
    )

    reviewer = ChatCompletionAgent(
        kernel=kernel,
        name="Reviewer",
        instructions="You review reports for accuracy and clarity."
    )

    # Create group chat with sequential strategy
    chat = AgentGroupChat(
        agents=[analyst, writer, reviewer],
        selection_strategy=SequentialSelectionStrategy(),
        termination_strategy=DefaultTerminationStrategy(
            maximum_iterations=6
        )
    )

    # Run the group chat
    await chat.add_chat_message("Analyze the impact of AI agents on marketing")

    async for message in chat.invoke():
        print(f"[{message.name}]: {message.content[:200]}...")

Adding Tools (Plugins)

from semantic_kernel.functions import kernel_function

class WebSearchPlugin:
    """Plugin for web search capabilities."""

    @kernel_function(
        name="search_web",
        description="Search the web for current information on a topic"
    )
    def search_web(self, query: str) -> str:
        # Your search implementation here
        return f"Search results for: {query}"

    @kernel_function(
        name="get_page_content",
        description="Get the content of a specific web page"
    )
    def get_page_content(self, url: str) -> str:
        # Your page fetching implementation here
        return f"Content from: {url}"

# Add plugin to kernel
kernel.add_plugin(WebSearchPlugin(), plugin_name="web")

# The agent can now use search_web and get_page_content tools

pip install semantic-kernel

from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion

kernel.add_service(
    OpenAIChatCompletion(
        ai_model_id="gpt-4o",
        api_key="your-openai-key"
    )
)

AG2 -- ה-Fork הקהילתי של AutoGen

הסיפור: כשהקהילה לוקחת פיקוד

כש-Microsoft החליטה למזג את AutoGen עם Semantic Kernel, קבוצת מפתחים מהקהילה החליטה ש-AutoGen המקורי שווה שימור. הם עשו fork, שינו את השם ל-AG2 (AutoGen 2), ובנו אותו מחדש מאפס עם כמה עקרונות ברורים:

• Community-governed -- אין vendor יחיד ששולט. Apache 2.0, governance שקוף
• Zero vendor lock-in -- עובד עם כל LLM provider, כל cloud, כל tool
• Universal Framework Interoperability -- ה-USP הייחודי: סוכנים מ-AG2, Google ADK, OpenAI SDK, LangChain -- כולם באותו צוות

זו נקודה שלרוב מתעלמים ממנה: מה קורה כשצריך לשלב סוכנים שנבנו ב-frameworks שונים? בעולם אמיתי, צוות אחד בנה עם LangGraph, צוות שני עם Google ADK, וצוות שלישי עם Claude SDK. AG2 מאפשר לחבר את כולם.

Key Features

• MemoryStream -- pub/sub event bus שמאפשר concurrent state isolation. כל סוכן רואה רק את ה-events שרלוונטיים לו -- בלי race conditions
• Streaming & Event-driven architecture -- לא polling, אלא event-based. מתאים למערכות real-time
• Multi-provider LLM support -- OpenAI, Anthropic, Google, local models -- כולם באותו agent
• Dependency injection ו-typed tools -- ארכיטקטורה נקייה עם DI pattern מובנה
• First-class testing -- TestConfig ו-TestClient מובנים -- agent testing בלי mock ידני
• MCP + A2A -- תמיכה בשני הפרוטוקולים

קוד לדוגמה -- AG2 Basic Agent

# pip install ag2
from ag2 import ConversableAgent, config_list_from_json

# Load LLM config
config_list = config_list_from_json("OAI_CONFIG_LIST")

# Create an assistant agent
assistant = ConversableAgent(
    name="research_assistant",
    system_message="""You are a helpful research assistant.
    When asked to research a topic, break it down into subtopics,
    find key facts, and present a structured summary.""",
    llm_config={"config_list": config_list},
)

# Create a user proxy agent (represents the human)
user_proxy = ConversableAgent(
    name="user",
    human_input_mode="NEVER",  # Automatic mode
    max_consecutive_auto_reply=3,
    code_execution_config=False,
)

# Start conversation
result = user_proxy.initiate_chat(
    assistant,
    message="Research the current state of AI agent frameworks in 2026"
)

print(result.summary)

קוד לדוגמה -- Universal Framework Interoperability

from ag2 import ConversableAgent
from ag2.interop import GoogleADKAdapter, OpenAIAdapter

# Wrap a Google ADK agent
adk_agent = GoogleADKAdapter(
    adk_agent=your_existing_adk_agent,
    name="google_specialist"
)

# Wrap an OpenAI agent
openai_agent = OpenAIAdapter(
    openai_agent=your_existing_openai_agent,
    name="openai_specialist"
)

# Native AG2 agent
ag2_coordinator = ConversableAgent(
    name="coordinator",
    system_message="You coordinate between specialist agents.",
    llm_config={"config_list": config_list},
)

# All three can now talk to each other!
# AG2, Google ADK, and OpenAI agents in one conversation
result = ag2_coordinator.initiate_chat(
    adk_agent,
    message="Analyze this data using your multimodal capabilities"
)

pip install ag2

Mastra -- TypeScript-Native Full-Stack Agents

הפרשנות: אם Vercel AI SDK הוא library, Mastra הוא framework

בפרק 6 למדתם את Vercel AI SDK -- ספריית TypeScript מצוינת לבניית סוכנים. אבל Vercel AI SDK הוא library: הוא נותן לכם primitives (generateText, streamText, tools) ומשאיר לכם לבנות את ה-auth, storage, workflows, ו-deployment.

Mastra הוא framework -- batteries included:

מי משתמש ב-Mastra?

PayPal, Adobe, Elastic, Docker. 19.4K GitHub stars, 300K+ weekly npm downloads. Built by the ex-Gatsby team (YC W25). זה לא toy project -- זה framework שחברות Fortune 500 משתמשות בו בפרודקשן.

Key Features

• 40+ model providers -- OpenAI, Anthropic, Google, Mistral, Cohere, local models... כולם עם API אחיד
• AgentFSFilesystem -- persistent file storage לסוכנים. מבוסס Turso/SQLite. הסוכן יכול לקרוא ולכתוב קבצים -- ולזכור אותם בין sessions
• End-to-end auth ו-RBAC -- authentication ו-authorization מובנים. מגדירים roles ו-permissions ישירות ב-framework
• Workflow path tracking -- מעקב אוטומטי אחרי כל נתיב בתוך workflow. מצוין ל-debugging ו-audit
• Concurrent-safe snapshots -- snapshots של agent state שבטוחים ל-concurrency. חשוב כש-100 users משתמשים באותו agent

קוד לדוגמה -- Mastra Agent

// npm install mastra @mastra/core
import { Agent, createTool } from "@mastra/core";
import { z } from "zod";

// Define a tool with Zod schema
const searchTool = createTool({
  id: "search",
  description: "Search for information on the web",
  inputSchema: z.object({
    query: z.string().describe("The search query"),
    maxResults: z.number().default(5).describe("Max results to return"),
  }),
  execute: async ({ context }) => {
    // Your search implementation
    const results = await performSearch(context.query, context.maxResults);
    return { results };
  },
});

// Create an agent
const researchAgent = new Agent({
  name: "Research Agent",
  instructions: `You are a research agent that helps users find information.
    Use the search tool to find relevant data, then summarize your findings.
    Always provide sources.`,
  model: {
    provider: "ANTHROPIC",
    name: "claude-sonnet-4-5-20250514",
  },
  tools: { search: searchTool },
});

// Run the agent
const response = await researchAgent.generate(
  "What are the latest trends in AI agents?"
);
console.log(response.text);

קוד לדוגמה -- Mastra Workflows

import { Workflow, Step } from "@mastra/core";
import { z } from "zod";

const researchWorkflow = new Workflow({
  name: "research-pipeline",
  triggerSchema: z.object({
    topic: z.string(),
    depth: z.enum(["shallow", "deep"]).default("shallow"),
  }),
});

// Step 1: Search
const searchStep = new Step({
  id: "search",
  execute: async ({ context }) => {
    const results = await searchTool.execute({
      context: { query: context.triggerData.topic, maxResults: 10 }
    });
    return { searchResults: results };
  },
});

// Step 2: Analyze with agent
const analyzeStep = new Step({
  id: "analyze",
  execute: async ({ context }) => {
    const response = await researchAgent.generate(
      `Analyze these search results: ${JSON.stringify(context.searchResults)}`
    );
    return { analysis: response.text };
  },
});

// Step 3: Generate report
const reportStep = new Step({
  id: "report",
  execute: async ({ context }) => {
    const response = await researchAgent.generate(
      `Write a structured report based on: ${context.analysis}`
    );
    return { report: response.text };
  },
});

// Connect steps
researchWorkflow
  .step(searchStep)
  .then(analyzeStep)
  .then(reportStep)
  .commit();

// Run workflow
const result = await researchWorkflow.execute({
  triggerData: { topic: "AI agents in marketing", depth: "deep" }
});

npm install mastra @mastra/core

Pydantic AI -- Type-Safe Python Agents

הפילוסופיה: אם אתם אוהבים Pydantic, תאהבו את זה

Pydantic הוא ה-data validation library הכי פופולרי ב-Python. הוא בבסיס של FastAPI, LangChain, ו-90%+ מהפרויקטים הרציניים ב-Python. Pydantic AI מביא את אותה פילוסופיה -- type safety, validation, clear errors -- לעולם ה-agents.

למה type safety חשוב לסוכנים? כי סוכנים נכשלים בדרכים מפתיעות:

• Tool שמקבל string במקום int -- ה-LLM לא תמיד מבין
• Output שאמור להיות JSON אבל חוזר כ-free text
• Dependencies שחסרות ב-runtime אבל לא ב-development
• State corruption כש-agent רץ במקביל

Pydantic AI תופס את כל השגיאות האלה בזמן פיתוח -- לא בפרודקשן.

Key Features

• Full type safety -- כל tool input, output, ו-dependency מוגדרים עם types. MyPy/Pyright תופסים שגיאות
• Durable execution -- הסוכן שורד API failures ו-restarts. נבנה מהיסוד עם reliability
• MCP + A2A integration -- תמיכה בשני הפרוטוקולים
• Every model/provider -- OpenAI, Anthropic, Google, Mistral, Groq, local models -- כולם
• Streaming event-based -- streaming שמבוסס על events, לא chunks
• Logfire integration -- observability native מ-Pydantic. Dashboard מובנה
• Dependency injection -- clean DI pattern ל-tools ו-agent dependencies

קוד לדוגמה -- Pydantic AI Agent

# pip install pydantic-ai
from pydantic_ai import Agent
from pydantic import BaseModel

# Define structured output
class ResearchReport(BaseModel):
    title: str
    summary: str
    key_findings: list[str]
    confidence: float  # 0.0 to 1.0
    sources: list[str]

# Create agent with typed output
research_agent = Agent(
    "anthropic:claude-sonnet-4-5-20250514",
    result_type=ResearchReport,  # Enforced output type!
    system_prompt="""You are a research agent.
    Always provide structured research reports with
    clear findings, confidence levels, and sources.""",
)

# Run -- result is guaranteed to be ResearchReport
result = research_agent.run_sync(
    "Research the impact of AI agents on digital marketing in 2026"
)

# Type-safe access -- IDE autocomplete works!
print(f"Title: {result.data.title}")
print(f"Confidence: {result.data.confidence:.0%}")
for finding in result.data.key_findings:
    print(f"  - {finding}")

קוד לדוגמה -- Pydantic AI with Tools and Dependencies

from pydantic_ai import Agent, RunContext
from dataclasses import dataclass
import httpx

# Define dependencies -- injected at runtime
@dataclass
class SearchDeps:
    api_key: str
    http_client: httpx.AsyncClient
    max_results: int = 10

# Create agent with dependency type
search_agent = Agent(
    "openai:gpt-4o",
    deps_type=SearchDeps,  # Type-safe dependencies!
    system_prompt="You search the web and summarize findings.",
)

# Define typed tool
@search_agent.tool
async def search_web(
    ctx: RunContext[SearchDeps],  # Type-safe context!
    query: str,
    num_results: int = 5
) -> str:
    """Search the web for information."""
    # ctx.deps is typed as SearchDeps -- autocomplete works!
    response = await ctx.deps.http_client.get(
        "https://api.search.com/search",
        params={"q": query, "n": min(num_results, ctx.deps.max_results)},
        headers={"Authorization": f"Bearer {ctx.deps.api_key}"}
    )
    return response.text

# Run with injected dependencies
async with httpx.AsyncClient() as client:
    deps = SearchDeps(api_key="your-key", http_client=client)
    result = await search_agent.run(
        "Find recent news about AI agents",
        deps=deps
    )
    print(result.data)

pip install pydantic-ai

Smolagents -- Minimal Agents מ-Hugging Face

הפילוסופיה: פחות קוד, יותר שקיפות

Smolagents הוא ההפך מ-enterprise framework. בעוד Microsoft Agent Framework ו-LangGraph מציעים אלפי שורות קוד עם abstractions מורכבים, Smolagents הוא ~1,000 שורות של core code. ה-source code קריא כולו ביום אחד.

אבל הייחוד האמיתי הוא CodeAgent:

Key Features

• ~1,000 שורות core code -- קריא, debuggable, מינימלי
• CodeAgent -- כותב Python code להפעלת tools, לא JSON
• ToolCallingAgent -- גם תומך ב-traditional tool calling
• Sandboxed execution -- Modal, E2B, Docker -- הקוד רץ ב-sandbox מאובטח
• Hub integration -- שיתוף agents ו-tools ב-Hugging Face Hub
• Open-source models -- עובד מצוין עם Llama, Mistral, וכל model שרץ על HF

קוד לדוגמה -- Smolagents CodeAgent

# pip install smolagents
from smolagents import CodeAgent, tool, HfApiModel

# Define a tool
@tool
def get_weather(city: str) -> str:
    """Get the current weather for a city.

    Args:
        city: The city name to check weather for.
    """
    # Your weather API call here
    return f"Weather in {city}: 22°C, sunny"

@tool
def translate(text: str, target_language: str) -> str:
    """Translate text to a target language.

    Args:
        text: The text to translate.
        target_language: The target language code (e.g., 'he', 'en', 'fr').
    """
    # Your translation API call here
    return f"[Translated to {target_language}]: {text}"

# Create CodeAgent -- it writes Python to use tools!
agent = CodeAgent(
    tools=[get_weather, translate],
    model=HfApiModel("Qwen/Qwen2.5-72B-Instruct"),
    # Or use OpenAI/Anthropic:
    # model=OpenAIServerModel("gpt-4o")
)

# Run -- the agent will write Python code like:
# weather = get_weather("Tel Aviv")
# translated = translate(weather, "he")
result = agent.run(
    "What's the weather in Tel Aviv? Translate the answer to Hebrew."
)
print(result)

מה הסוכן באמת עושה?

כשאתם מריצים את ה-CodeAgent, הוא כותב קוד Python אמיתי. בדוגמה למעלה, ה-LLM יחזיר משהו כזה:

# Code generated by the LLM:
weather_info = get_weather("Tel Aviv")
print(f"Original: {weather_info}")

translated = translate(weather_info, "he")
print(f"Hebrew: {translated}")

final_answer(translated)

שימו לב: הסוכן לא החזיר JSON tool call -- הוא כתב תוכנית Python שמשתמשת ב-tools כפונקציות רגילות. זו ה-paradigm shift של CodeAgent.

pip install smolagents

טבלת השוואה מלאה -- כל 11 ה-SDKs

אחרי 10 פרקים של deep dives, הנה הטבלה המלאה. זו טבלת ההשוואה הכי מקיפה שתמצאו -- כל 11 ה-SDKs, כל feature חשוב:

SDK Selection Decision Tree

בחירה לפי גודל צוות וארגון

מגמות התכנסות -- לאן השוק הולך

שוק ה-agent SDKs משתנה מהר. אבל יש מגמות ברורות שמשפיעות על כל הבחירות:

מגמה 1: Graph-Based Orchestration הופך לסטנדרט

LangGraph הוביל את המגמה, ועכשיו כולם מתכנסים על graphs:

• LangGraph -- graphs מהיום הראשון
• Google ADK 2.0 -- הוסיפו SequentialAgent, ParallelAgent, LoopAgent
• Microsoft Agent Framework -- graph-based workflow engine
• Mastra -- workflow steps עם DAG (Directed Acyclic Graph)

מה זה אומר עבורכם: למדו "לחשוב בגרפים" -- nodes, edges, conditional routing. זה הדפוס שישלוט ב-2026-2027.

מגמה 2: MCP + A2A כ-Open Standards

שני הפרוטוקולים עברו ל-Linux Foundation -- ה-organization שמנהל את Linux, Kubernetes, ו-Node.js:

• MCP (Model Context Protocol) -- agent-to-tool communication. כל 11 ה-SDKs תומכים
• A2A (Agent-to-Agent) -- agent-to-agent communication. Google ADK, Microsoft, AG2, Pydantic AI תומכים. השאר יעקבו

מה זה אומר עבורכם: בנו tools כ-MCP servers -- הם יעבדו עם כל SDK. זו ההשקעה הכי בטוחה שתוכלו לעשות.

מגמה 3: TypeScript הופך ל-First-Class Citizen

עד 2025, רוב ה-agent SDKs היו Python-first. ב-2026 המצב השתנה:

• Vercel AI SDK -- TypeScript-only מהיום הראשון
• Mastra -- TypeScript-only, full framework
• Google ADK -- TypeScript support נוסף
• OpenAI Agents SDK -- TypeScript SDK added
• Claude Agent SDK -- TypeScript SDK added

מה זה אומר עבורכם: TypeScript כבר לא "האופציה השנייה". אם אתם TypeScript devs -- יש לכם ecosystem מלא.

מגמה 4: Durable Execution הופך ל-Table Stakes

Agents שרצים 10+ דקות חייבים לשרוד crashes. מי שכבר תומך:

• LangGraph -- checkpointing (MemorySaver, SQLite, PostgreSQL)
• Pydantic AI -- durable execution native
• Microsoft Agent Framework -- Durable Agents
• Vercel AI SDK -- via Vercel infrastructure
• Mastra -- concurrent-safe snapshots

מה זה אומר עבורכם: אם הסוכנים שלכם רצים יותר מדקה -- durable execution הוא must-have, לא nice-to-have.

מגמה 5: Consolidation -- השוק מתאחד

Microsoft מיזגה AutoGen + Semantic Kernel. LangChain ו-LangGraph מתקרבים. זה לא מקרי -- שוק עם 11 SDKs לא יישאר כך. תוך 18 חודשים צפו:

• 3-4 SDKs "גדולים" (LangGraph, OpenAI, Google ADK, Microsoft)
• 2-3 SDKs "מתמחים" (Mastra ב-TS, Pydantic AI ב-type-safe, AG2 ב-interop)
• כמה שייעלמו או ייבלעו

מה זה אומר עבורכם: הימרו על open standards (MCP, A2A) ו-frameworks עם community חזקה. אם framework קטן ייעלם -- ה-tools שלכם (MCP servers) ימשיכו לעבוד.

הקשר ישראלי -- SDKs באקוסיסטם הישראלי

האקוסיסטם הישראלי של AI agents מתפתח מהר. הנה מה שרלוונטי:

סטארטאפים ישראליים

• רוב הסטארטאפים משתמשים ב-Python SDKs (LangGraph, OpenAI SDK, Claude SDK) -- ה-default בתעשייה
• Full-stack startups שבונים SaaS -- Vercel AI SDK או Mastra (TypeScript-native stack: Next.js + Vercel)
• AI-first startups שמוכרים agents כמוצר -- LangGraph (scalability, LangSmith) או CrewAI (speed to market)

ארגונים גדולים

• בנקים וביטוח (הפניקס, לאומי, הראל) -- LangGraph או Microsoft Agent Framework (compliance, audit)
• חברות טכנולוגיה (Check Point, CyberArk, Monday.com) -- בדרך כלל Claude SDK או OpenAI SDK לפרויקטים פנימיים
• Microsoft houses (ארגונים שרצים על .NET + Azure) -- Microsoft Agent Framework הוא הבחירה הטבעית

Community ישראלי

• AI Agent meetups בתל אביב -- 2-3 בחודש, עם demos חיים של frameworks שונים
• Innovation Authority -- תכניות תמיכה לסטארטאפים שבונים agents (ניתן לקבל מענקים)
• Military-to-civilian tech transfer -- טכנולוגיות multi-agent מ-8200 ומערכות צבאיות שעוברות לשוק האזרחי

טעויות נפוצות -- ואיך להימנע מהן

תרגילים

צ'קליסט -- סיכום פרק 11

• מבין/ה את הסיפור של Microsoft Agent Framework -- מיזוג AutoGen + Semantic Kernel, .NET first-class
• יודע/ת להגדיר ChatCompletionAgent ו-AgentGroupChat עם Microsoft Agent Framework
• מבין/ה מה AG2 ולמה הקהילה עשתה fork -- community governance, zero vendor lock-in
• יודע/ת מהו Universal Framework Interoperability של AG2 ומתי זה קריטי
• מבין/ה את ההבדל בין Vercel AI SDK (library) ל-Mastra (framework) -- auth, storage, workflows
• יודע/ת לבנות סוכן עם Mastra -- Agent, createTool, Workflow
• מבין/ה את הפילוסופיה של Pydantic AI -- type safety, durable execution, dependency injection
• יודע/ת להגדיר result_type ו-deps_type ב-Pydantic AI agent
• מבין/ה את ה-CodeAgent paradigm של Smolagents -- Python code במקום JSON tool calls
• יודע/ת להשתמש ב-SDK Selection Decision Tree לפי שפה, cloud, ו-use case
• מבין/ה את 5 מגמות ההתכנסות: graphs, MCP+A2A, TypeScript, durable execution, consolidation
• יודע/ת לבחור SDK לפי גודל צוות: solo, startup, mid-size, enterprise
• מכיר/ה את הנוף הישראלי של SDKs -- סטארטאפים, ארגונים, community
• בנית סוכן עם לפחות 2 frameworks מהפרק הזה
• עניתי על 4 מתוך 5 שאלות ב"בדוק את עצמך"