Advanced AI Agents — Claude Agent SDK, MCP, ו-LangGraph לשיווק

מ-Workflow ל-Agent — מה השתנה ב-2026

בפרק 13 בנית אוטומציה ב-n8n או ב-Claude Code. היא עבדה בצורה לינארית: "כשמגיע ליד חדש → שלח אותו ל-Claude עם פרומפט מוגדר → קבל ניקוד → עדכן שדה ב-CRM → שלח התראה אם ניקוד גבוה". הצעדים ידועים מראש, הסדר קבוע, התוצאה צפויה. זה workflow דטרמיניסטי, והוא מצוין לתהליכים חוזרים ופשוטים שבהם אתה בדיוק יודע מה צריך לקרות ומתי. 80% ממשימות השיווק נופלות בקטגוריה הזו, ו-n8n הוא הכלי הנכון עבורן.

אבל בואו נסתכל על משימה אחרת. נניח שאתה רוצה לבקש: "סקור את 5 המתחרים העיקריים שלנו, מצא על מה הם מדברים החודש, זהה פערים בתוכן שלהם, וכתוב לי דוח עם המלצות". במבט ראשון זה נשמע כמו עוד workflow. אבל תחשוב על זה שנייה: מי הם "5 המתחרים העיקריים"? איך מוצאים "על מה הם מדברים"? איזה נושאים ייחשבו "פערים"? מה המלצה טובה? ברגע שאתה מנסה לתכנת את זה כ-workflow קלאסי, אתה מגלה שאתה חייב לתכנן מראש מאות החלטות: אילו אתרים לסרוק, איך לחלץ נושאים, איך להשוות מוחשי, איך לנסח המלצות. זה ימים של עבודה ועדיין לא גמיש — כל שינוי במתחרים דורש קוד חדש.

Agent אוטונומי פותר את זה אחרת לגמרי. אתה לא מתכנת את הצעדים — אתה נותן מטרה ("סקור מתחרים של [מותג] וכתוב דוח") + כלים ("אתה יכול להשתמש ב-WebSearch, WebFetch, ו-Write") + גבולות ("עד 20 הרצות tool, אסור לכתוב מחוץ לתיקייה X, אסור להשתמש בכלים אחרים") — וה-LLM מתכנן את הצעדים בעצמו. הוא מחליט: "קודם אחפש את המתחרים של המותג ב-Google", "עכשיו אקרא את הדף הראשון של כל אחד", "אני רואה שכולם מדברים על X ועל Y, חסר נושא Z", "אכתוב דוח Markdown".

ההבדל הזה — בין לתכנת כל צעד ל-"להסביר מטרה ולתת כלים" — הוא המהפכה של 2024-2026. Anthropic שחררה את Claude Agent SDK בספטמבר 2025 (שנקרא קודם "Claude Code SDK" והותאם אחרי שהיא הצליחה מאוד ב-development workflows). OpenAI שחררה את Agents SDK במרץ 2025 אחרי תקופת ניסיון עם Swarm. LangChain הוציאה את LangGraph 1.0 באוקטובר 2025 אחרי שנה של בטא. גם גוגל, Meta ואמזון מציעות SDKs משלהן ב-2026. כולם מתכנסים לאותו מודל בסיסי: LLM בלולאה + tools + memory. זה הסטנדרט. אם אתה לא מכיר אותו, אתה פוספסת את הגל השני של המהפכה — הגל שבו AI עובר מ"כלי עזר" ל"עובד אמיתי".

ארבעת המרכיבים של Agent

כל Agent בנוי מ-4 מרכיבים. אם חסר אחד — זה לא Agent, זה בוט רגיל:

3 ה-SDKs של 2026 — Claude, OpenAI, LangGraph

ב-2026 יש שלושה SDK שאתה באמת צריך להכיר. כל אחד עושה את אותו הדבר ברמת הפרינציפ — מריץ LLM בלולאה עם tools — אבל כל אחד עם פילוסופיה שונה:

Claude Agent SDK — הבחירה הראשית שלנו

הספרייה הזו יצאה בספטמבר 2025 (Anthropic שחררה אותה מחדש כ-"Claude Agent SDK" — קודם היא נקראה Claude Code SDK). היא בנויה סביב 4 רעיונות פשוטים: (1) אתה מגדיר system_prompt שמסביר מה ה-Agent אמור לעשות, (2) אתה נותן לו allowed_tools — רשימה מוגבלת של כלים שהוא רשאי להפעיל, (3) אתה קובע permission_mode שקובע אם ה-SDK שואל אותך לפני כל פעולה או מריץ אוטונומית, (4) אתה קורא ל-query() וקורא את הפלט. זה הכל. הספרייה מטפלת מאחורי הקלעים בלולאה של ה-Agent, בניהול ה-context, ב-tool calling ובכל מה שהופך את הבנייה מסיוט של מאות שורות לקובץ של 30-100 שורות.

היתרונות למשווקים ישראלים: ראשית, היא עובדת מעולה בעברית — Claude Sonnet 4.6 הוא המודל הכי טוב בשפה העברית ב-2026, מבין ניואנסים תרבותיים, מבדיל בין טון פורמלי לסלנג, ויודע לכתוב כמו ישראלי אמיתי ולא כמו תרגום מאנגלית. שנית, המחיר הוגן — $3 ל-input tokens ו-$15 ל-output למיליון tokens במודל Sonnet, ויש גם Haiku הזול יותר למשימות פשוטות ב-$1/$5. שלישית, MCP כבר מובנה בספרייה ללא צורך בהתקנות נוספות. רביעית — והחשוב ביותר לצוות שיווקי — היא תומכת native ב-file tools (Read/Write/Edit) שמאפשרים ל-Agent לקרוא brand guidelines, לעדכן לוחות תוכן, ולשמור דוחות בלי להתחבר ל-API חיצוני. אם אתה מתחיל היום — תתחיל פה. 80% מהמשווקים יגמרו פה וגם לא יצטרכו שום דבר אחר.

דגשים נוספים שכדאי להכיר: הספרייה תומכת ב-subagents — אתה יכול להפעיל Claude אחד "ראשי" שמעביר משימות משנה ל-Claude "משני" עם system prompt שונה (כמו להיות מנהל שמעסיק עצמאיים). בנוסף, יש תמיכה ב-memory בצורה של קבצי markdown שה-Agent קורא אוטומטית בכל ריצה (למשל CLAUDE.md עם brand guidelines), כך שאתה לא צריך לשלוח את אותו הטקסט בכל קריאה. זה חוסך tokens וכסף. לבסוף, הספרייה כוללת streaming — אתה רואה את ה-Agent חושב בזמן אמת, לא חיכיון ארוך ואז "הפתעה". לפי התיעוד הרשמי, זמן ההתחלה לפרויקט הראשון הוא פחות מ-15 דקות.

OpenAI Agents SDK — כשצריך handoffs או voice

OpenAI שחררה את ה-SDK הזה במרץ 2025 והוא החליף את Swarm — פרויקט ניסיוני שהיה להם קודם. החוזקה המובהקת של OpenAI Agents SDK היא handoffs — הרעיון שבו Agent אחד מעביר משימה ל-Agent שני בצורה נקייה, עם העברת קונטקסט אוטומטית. דמיין שירות לקוחות: Agent כללי שעונה על שאלות פשוטות, ומעביר ל-Agent "טכני" שאלות על התקנה, ול-Agent "חיוב" שאלות כספיות. OpenAI עושה את זה עם 3 שורות קוד. בנוסף, ל-SDK יש Guardrails — שכבה שבודקת בקלט ובפלט האם יש תוכן לא רצוי (PII, תוכן לא ראוי, prompt injection attempts) וחוסמת אוטומטית. זו שכבת בטיחות חזקה למי שבונה לקהל הרחב.

יתרון גדול נוסף: OpenAI מציעה מודלי voice ב-API — gpt-4o-realtime — כך שאתה יכול לבנות Agent קולי שעונה לטלפון, מבין דיבור בזמן אמת, ומגיב קולי. זה הכלי האולטימטיבי לשירות לקוחות בעברית דרך טלפון (אם כי איכות ההבנה העברית הקולית עדיין פחות טובה מאנגלית, הפער מצטמצם בכל חודש). גם DALL-E מובנה ב-SDK, כך שאתה יכול להפעיל Agent שמייצר תמונות לפוסטים ב-Instagram כחלק מאותה ריצה.

חסרונות: פחות טובה בעברית כתובה מ-Claude (במיוחד לסגנונות שיווקיים ישראליים אותנטיים), יקרה יותר ל-tokens דומים במודלים המובילים, ועד לאחרונה לא תמכה native ב-MCP — יש adapters אבל החוויה פחות חלקה. אם המשימה שלך דורשת צוות של 3-4 Agents מומחים שצריכים להעביר ביניהם, או אם אתה בונה voice agent — זו הבחירה. אחרת, תישאר עם Claude.

LangGraph — כשהמשימה היא state machine

LangGraph היא גישה אחרת לחלוטין. בעוד Claude ו-OpenAI חושבות על Agent כ"לולאה של LLM עם tools", LangGraph חושבת עליו כ-graph: אוסף של nodes (שלבים) ו-edges (מעברים ביניהם). אתה מצייר את המבנה בקוד — למשל extract_data → analyze → draft → review → publish — ו-LangGraph מריץ אותו. כל node הוא פונקציה Python. כל edge יכול להיות מותנה ("אם state.confidence > 0.8 → publish, אחרת → review"). התוצאה: שליטה מוחלטת על הזרימה, ב-trade-off של קוד קצת יותר ארוך.

החוזקה האמיתית של LangGraph — הסיבה שבגללה היא קיימת — היא human-in-the-loop. אתה יכול לעצור את ה-Agent באמצע ריצה (interrupt), להציג state למשתמש, לחכות לאישור/עריכה, ולהמשיך. זה הכלי הכי חזק ב-2026 לכל workflow שדורש "AI מכין את העבודה, אדם מאשר". דוגמאות: מייל שיוצא ללקוח חשוב, פוסט סושיאל שמפרסם מטעם המותג, החלטה על הוצאה מעל סכום מסוים. בלי human-in-the-loop, אתה בונה Agent מסוכן. עם human-in-the-loop, אתה בונה כלי עזר שמכפיל את התפוקה שלך.

יתרון גדול נוסף: time-travel debugging. LangGraph שומר את כל ה-state בכל צעד (אם אתה מחבר checkpointer). אם משהו נשבר — אתה יכול לחזור אחורה לצעד 3, לשנות פרמטר, ולהפעיל מחדש מהנקודה הזו במקום להריץ הכל מהתחלה. זה חוסך זמן ו-tokens במיוחד ב-debugging של Agents מורכבים. LangGraph 1.0 יצאה באוקטובר 2025 ומאז היא התבגרה משמעותית. ה-SDK תומך גם ב-LangSmith — פלטפורמה של LangChain ל-observability של Agents שנותנת trace מפורט של כל קריאה.

MCP — הפרוטוקול שהפך הכל לסטנדרט

בלי להבין מה זה MCP (Model Context Protocol) — לא תבין למה בניית Agents בשנת 2026 קלה פי 10 מ-2023. MCP הוא פרוטוקול פתוח שאנתרופיק פרסמה בנובמבר 2024, ובמהלך 2025 הוא הפך ל"USB-C של AI" — הסטנדרט שכולם משתמשים בו. לפני MCP, בכל פעם שרצית לחבר כלי חיצוני ל-LLM היית כותב קוד custom: פונקציה Python שמתחברת ל-API, פורמטר שמחזיר את הנתונים בצורה שה-LLM יבין, error handling, retry logic, ועוד. בכל פעם מחדש. אם עברת מ-OpenAI ל-Claude — היית צריך לכתוב הכל שוב. MCP פתר את זה: כתוב MCP server פעם אחת, והוא עובד עם כל LLM שתומך ב-MCP (Claude, GPT, Gemini, ועוד). זה כמו שברגע שיש USB-C, כל מטען עובד עם כל מכשיר. לפני זה, כל יצרן היה עושה חיבור משלו.

עד סוף 2025, כל ה-LLMs המרכזיים אימצו MCP. OpenAI הוסיפה תמיכה native ב-GPT-5 ואילך, Google הוסיפה בגרסת Gemini 2.5, ו-Anthropic שם זה כבר מ-Claude 3.5 Sonnet. זה אומר שאם אתה בונה MCP server היום, הוא יעבוד לנצח, בכל פלטפורמה, בלי לשנות שורה. זה ההבטחה — והיא מתגשמת בפועל.

מה MCP נותן לך בפועל

• Tools: פונקציות שה-Agent יכול להפעיל (web_search, send_email, query_db)
• Resources: מסמכים/קבצים שה-Agent יכול לקרוא (PDF, דוחות, brand guidelines)
• Prompts: תבניות פרומפטים שנטענות דינמית

MCP servers מוכנים שכל משווק צריך להכיר

רשימה מלאה נמצאת ב-github.com/modelcontextprotocol/servers. ב-2026 יש מעל 500 MCP servers פומביים. רובם open source וחינמיים לשימוש — אתה רק משלם על API keys של השירותים עצמם (אם יש).

הבניה הראשונה — Research Agent ב-80 שורות

הגענו לחלק הכייפי. נבנה Research Agent עובד שמקבל שם מותג, סורק 5 מתחרים ישראליים, ומחזיר דוח Markdown. נעשה זאת עם Claude Agent SDK + MCP fetch tool. עלות משוערת לריצה: $0.05-0.15 (5-15 אגורות ₪).

לפני שניגש לקוד — רגע של הכנה מנטלית. זה יהיה הקובץ הראשון שאתה באמת בונה בפרק הזה, והוא יהיה ה-baseline שלך לעוד חודשים קדימה. הקפד לעשות את זה בסביבה נקייה, בלי קבצים אחרים שמסיחים, בלי browser tabs מיותרים. 30-45 דקות של ריכוז ישלמו לך את עצמם באלפי שעות של יכולת.

שלב 1 — התקנה

פתח terminal (על macOS/Linux: Terminal. על Windows: PowerShell או WSL). צור תיקיה חדשה, והתקן את ה-SDK. הקפד ליצור virtual environment כדי שהתלויות של הפרויקט הזה לא יתנגשו עם פרויקטים אחרים שלך. ב-macOS/Linux/WSL:

mkdir marketing-agents
cd marketing-agents
python3 -m venv venv
source venv/bin/activate  # Windows: venv\Scripts\activate
pip install claude-agent-sdk anthropic

אם התקבלה שגיאה "command not found" — אין לך Python מותקן, חזור לדרישות קדם והתקן מ-python.org.

מה עשית כאן: venv הוא סביבה מבודדת של Python — כל package שתתקין יישמר רק בתיקייה הזו ולא ישפיע על פרויקטים אחרים. זה best practice קריטי, אל תדלג עליו. pip install claude-agent-sdk anthropic מוריד את שתי הספריות: ה-SDK עצמו וה-client הבסיסי של Anthropic (שה-SDK משתמש בו מאחורי הקלעים).

שלב 2 — הגדרת API key

היכנס ל-console.anthropic.com, התחבר, ולחץ על API Keys ואז Create Key. תן לו שם שתזכור (למשל "marketing-agents-dev"). העתק את הערך שמופיע — הוא נראה כמו sk-ant-api03-... ואורכו כ-100 תווים. שמור אותו מיד במקום בטוח כי לא תוכל לראות אותו שוב (רק ליצור חדש ולמחוק את הקודם). אני ממליץ על password manager, לא על קובץ טקסט. ב-terminal:

export ANTHROPIC_API_KEY="sk-ant-api03-..."
# Windows PowerShell:
# $env:ANTHROPIC_API_KEY="sk-ant-api03-..."

הערה חשובה: export מגדיר את המשתנה רק לחלון ה-terminal הנוכחי. אם תסגור ותפתח חדש — הוא יעלם. כדי לשמור אותו קבוע, הוסף את השורה ל-~/.bashrc או ~/.zshrc (לפי ה-shell שלך). ב-Windows, ב-PowerShell, השתמש ב-[System.Environment]::SetEnvironmentVariable("ANTHROPIC_API_KEY", "sk-ant-...", "User") לשמירה קבועה.

שלב 3 — הקוד

צור קובץ חדש בשם research_agent.py בתיקיית הפרויקט שלך והעתק את הקוד הבא. כל שורה מוסברת בתגובה, ואני מציע שתקרא את ההערות לפני ההרצה — זה הבסיס להבנת כל ה-Agents שתבנה בעתיד:

# research_agent.py — Competitor Research Agent
# Built with Claude Agent SDK + MCP fetch tool
import asyncio
import os
from claude_agent_sdk import query, ClaudeAgentOptions

# --- 1. Define the Agent's role and constraints ---
SYSTEM_PROMPT = """
You are a Competitive Research Agent for Israeli marketing teams.
Your job: given a brand name, research 5 competitors in the same niche,
identify what topics they are talking about THIS MONTH, and produce a
Markdown report in HEBREW.

Rules:
- Search the web using the fetch tool
- Read at least 2 pages per competitor
- For each competitor: name, URL, main topics (3 bullets), tone
- End with: "Content Gap Analysis" — 3 topics they ALL miss
- Cite sources with full URLs
- Write the final report in Hebrew, technical terms in English
- Do NOT invent data. If you cannot find something, say so explicitly
"""

# --- 2. Configure the Agent ---
options = ClaudeAgentOptions(
    system_prompt=SYSTEM_PROMPT,
    model="claude-sonnet-4-6",
    allowed_tools=["WebFetch", "WebSearch", "Write"],
    permission_mode="acceptEdits",  # auto-approve file writes
    max_turns=20,  # safety cap — stop after 20 loop iterations
)

# --- 3. Main function ---
async def research_competitors(brand_name: str) -> str:
    task = f"""
    Research the top 5 Israeli competitors of {brand_name}.
    Focus on content published in the last 30 days.
    Save the final report to competitors-report.md.
    """
    result_text = ""
    async for message in query(prompt=task, options=options):
        if hasattr(message, "content"):
            for block in message.content:
                if hasattr(block, "text"):
                    print(block.text)
                    result_text += block.text
    return result_text

# --- 4. Run it ---
if __name__ == "__main__":
    brand = input("Enter brand name: ")
    report = asyncio.run(research_competitors(brand))
    print("\n--- DONE ---")
    print(f"Report saved to: competitors-report.md")

שלב 4 — הרצה

ב-terminal (עם ה-venv פעיל):

python research_agent.py

הזן שם מותג (למשל: "Wolt Israel" או שם החברה שלך). תראה את ה-Agent עובד — הוא יקרא לכלי WebSearch, יקבל תוצאות, יקרא דפים עם WebFetch, יסכם, וישמור competitors-report.md. הרצה טיפוסית: 30-90 שניות, עלות $0.05-0.15.

בניית MCP Tool משלך — Web Search ישראלי

ה-Agent שלך עובד, אבל הכלי WebSearch שלו הוא generic. בואו נבנה MCP tool משלנו — Israeli Search — שמחפש ספציפית במקורות ישראליים (Ynet, Globes, Calcalist, TheMarker). זה הדגמה איך מרחיבים Agent עם כלי custom.

הרעיון של MCP tool

MCP tool בצורתו הפשוטה ביותר הוא פונקציה Python עם decorator. ה-SDK מסריק פונקציות שסומנו ב-@tool, מזהה את ה-docstring וה-type hints, וממיר אותן ל-schema שה-LLM יודע להפעיל. ברגע שה-LLM רואה את הכלי ברשימת ה-tools שלו, הוא יכול לקרוא לו בדיוק כמו לכל כלי built-in — עם הפרמטרים הנכונים, לקבל את התשובה, ולהמשיך בלולאה. הקסם הגדול הוא שאתה לא כותב את ה-parsing של קריאות הכלי או את ההחזרה של תוצאות — ה-SDK עושה את זה.

יש שני סוגי MCP servers: (א) in-process — פונקציות Python שרצות באותו תהליך כמו ה-Agent, כמו בדוגמה שלנו. מהיר, פשוט, אבל ספציפי לשפה. (ב) stdio servers — תוכנית חיצונית שמתקשרת עם ה-Agent דרך stdin/stdout. יכולה להיות כתובה בכל שפה, רצה ב-process נפרד, אפשר לשתף בין פרויקטים. זה המודל של רוב ה-MCP servers הפומביים ב-GitHub. להתחלה — in-process מספיק, ורק כשתרצה לחשוף את הכלי ליוזרים אחרים או לפרויקטים אחרים תעבור ל-stdio.

הקוד — israeli_search.py

# israeli_search.py — Custom MCP tool for Israeli media search
from claude_agent_sdk import tool, create_sdk_mcp_server
import httpx

ISRAELI_DOMAINS = [
    "ynet.co.il", "globes.co.il", "calcalist.co.il",
    "themarker.com", "mako.co.il", "geektime.co.il"
]

@tool(
    name="israeli_search",
    description="Search only within trusted Israeli news and tech media. "
                "Use this instead of generic WebSearch when the topic is "
                "specific to the Israeli market.",
    input_schema={"query": str, "max_results": int}
)
async def israeli_search(args):
    q = args["query"]
    max_n = args.get("max_results", 5)
    site_filter = " OR ".join(f"site:{d}" for d in ISRAELI_DOMAINS)
    full_query = f"{q} ({site_filter})"
    # Call your search API of choice here (Brave, SerpAPI, etc.)
    # For demo: return a stub
    return {
        "content": [{
            "type": "text",
            "text": f"Search query executed: {full_query}\n"
                    f"(Connect real search API for live results)"
        }]
    }

# Expose as MCP server
israeli_mcp = create_sdk_mcp_server(
    name="israeli-search-server",
    version="1.0.0",
    tools=[israeli_search]
)

חיבור ל-Research Agent

עכשיו ערוך את research_agent.py והוסף:

from israeli_search import israeli_mcp

options = ClaudeAgentOptions(
    system_prompt=SYSTEM_PROMPT,
    model="claude-sonnet-4-6",
    allowed_tools=[
        "WebFetch", "WebSearch", "Write",
        "mcp__israeli-search-server__israeli_search"  # new tool
    ],
    mcp_servers={"israeli-search-server": israeli_mcp},
    permission_mode="acceptEdits",
    max_turns=20,
)

עדכן את ה-SYSTEM_PROMPT להורות ל-Agent: "For Israeli market queries, prefer israeli_search over WebSearch". הרץ שוב. עכשיו יש לך Agent עם כלי custom שאתה בנית.

Content Scheduler Agent — תכנון שבוע של פוסטים

Agent שני בפרק. המטרה שלו: לקבל נושא שבועי וקהל יעד מוגדר, ולהחזיר לוח זמנים של 7 ימים עם פוסטים מותאמים לכל פלטפורמה (LinkedIn, Instagram, Facebook). כל פוסט עם טקסט בעברית שמותאם לטון של הפלטפורמה, רשימת hashtag-ים רלוונטיים, והצעת תמונה שתשלים את המסר. זה אחד מה-use cases הכי שימושיים למשווקים — כי תכנון תוכן שבועי לוקח בדרך כלל חצי יום עבודה, וה-Agent יכול להקטין את זה ל-20 דקות של אישורים.

למה לא לעשות את זה עם workflow רגיל של n8n או Zapier? אפשר, אבל חסר משהו מהותי: התאמה בין-פלטפורמית. פוסט טוב ב-LinkedIn הוא לא אותו פוסט ב-Instagram. LinkedIn אוהב מקצועיות ותובנות, Instagram אוהב תמציתיות ויזואליות, Facebook אוהב סטוריטלינג ורגש. Agent חכם צריך "להבין" את הנושא ואז לנסח גרסאות שונות — לא רק לקצר טקסט. זו משימה של שיפוט, לא של תהליך מוגדר, ולכן Agent עושה זאת טוב יותר מ-workflow.

מבנה ה-Agent

כאן נשתמש ב-LangGraph במקום ב-Claude Agent SDK — כי יש לנו workflow עם human-in-the-loop: אחרי שה-Agent מייצר טיוטה, אתה רוצה לאשר/לערוך לפני שהוא עובר ל-generator של hashtag-ים. LangGraph עושה את זה טבעי.

# content_scheduler.py — LangGraph content planner with approval
from langgraph.graph import StateGraph, END
from langgraph.checkpoint.memory import MemorySaver
from langchain_anthropic import ChatAnthropic
from typing import TypedDict, List

class ContentState(TypedDict):
    topic: str
    audience: str
    drafts: List[dict]
    approved: bool
    final_schedule: List[dict]

llm = ChatAnthropic(model="claude-sonnet-4-6")

def draft_posts(state: ContentState):
    prompt = f"""
    Topic: {state['topic']}
    Audience: {state['audience']}
    Create 7 social media posts (one per day) for LinkedIn + Instagram + Facebook.
    Each post: platform, day, text (Hebrew), hashtags, image_prompt.
    Return as JSON array.
    """
    response = llm.invoke(prompt)
    # parse JSON from response (simplified)
    state["drafts"] = parse_json(response.content)
    return state

def human_review(state: ContentState):
    # LangGraph interrupt for human approval
    print("Drafts ready for review:")
    for d in state["drafts"]:
        print(d)
    approval = input("Approve all? (y/n): ")
    state["approved"] = (approval.lower() == "y")
    return state

def finalize(state: ContentState):
    if state["approved"]:
        state["final_schedule"] = state["drafts"]
    return state

# Build the graph
workflow = StateGraph(ContentState)
workflow.add_node("draft", draft_posts)
workflow.add_node("review", human_review)
workflow.add_node("finalize", finalize)
workflow.set_entry_point("draft")
workflow.add_edge("draft", "review")
workflow.add_edge("review", "finalize")
workflow.add_edge("finalize", END)

app = workflow.compile(checkpointer=MemorySaver())

# Run it
initial = {
    "topic": "השקת גרסה חדשה של המוצר",
    "audience": "מנהלי שיווק בחברות B2B ישראליות",
    "drafts": [], "approved": False, "final_schedule": []
}
result = app.invoke(initial, config={"configurable": {"thread_id": "1"}})
print(result["final_schedule"])

Customer-Success Agent — קריאת טיקטים ותגובות

Agent שלישי ומשימה שלישית. הפעם נשתמש ב-Claude Agent SDK (כי זה Agent יחיד, לא צוות) עם זיכרון ארוך-טווח. המטרה: לקרוא את כל הטיקטים של השבוע (מ-CSV, מ-Intercom, או מ-Zendesk), לזהות דפוסים, ולנסח תגובות בסגנון המותג שלך. מה שמייחד את ה-Agent הזה ביחס לשני הראשונים: הוא עובד על טקסט אנושי לא מובנה. לקוחות כותבים ביד, לפעמים עם שגיאות כתיב, לפעמים עם אימוג'ים, לפעמים בתסכול. ה-Agent צריך להבין את הכוונה, לא רק את המילים.

שלושה כללים חשובים ליישום Customer-Success Agent: (1) Draft-only בחודש הראשון — אל תעז להפעיל auto-send עד שראית לפחות 100 תגובות ידנית ואישרת שהן טובות. (2) Brand tone קריטי — ה-Agent הזה מדבר בשמך. אם הטון לא נכון, לקוחות ירגישו. הקדש זמן לכתיבת BRAND_TONE מדויק. (3) Escalation חובה — קבע רף ברור: תלונות קשות, בקשות החזר מעל סכום מסוים, שמות של לקוחות VIP — כל אלה תמיד עוברים לאדם. אל תנסה לחסוך בזה.

קוד בסיסי

# customer_agent.py — Customer-Success Agent with memory
import asyncio, csv
from claude_agent_sdk import query, ClaudeAgentOptions

BRAND_TONE = """
Brand: [YourBrand]
Tone: warm, direct, Israeli. No corporate-speak.
Use "את/אתה" (not "כבוד הלקוח").
Apologize sincerely when we're at fault. Never defensive.
Always offer a concrete next step.
Max 4 lines per response.
"""

SYSTEM_PROMPT = f"""
You are the Customer-Success Agent for [YourBrand].
Read incoming support tickets and draft response suggestions.
{BRAND_TONE}
For each ticket: (1) classify urgency (high/medium/low),
(2) identify category, (3) draft a response in Hebrew,
(4) flag if escalation to human is needed.
Output: JSON array with fields ticket_id, urgency, category, draft, escalate.
"""

options = ClaudeAgentOptions(
    system_prompt=SYSTEM_PROMPT,
    model="claude-sonnet-4-6",
    allowed_tools=["Read", "Write"],
    permission_mode="acceptEdits",
    max_turns=15,
)

async def process_tickets(csv_path: str):
    # load tickets
    with open(csv_path) as f:
        tickets = list(csv.DictReader(f))
    task = f"Here are {len(tickets)} tickets: {tickets}\n\nProcess them per the rules."
    async for msg in query(prompt=task, options=options):
        if hasattr(msg, "content"):
            for b in msg.content:
                if hasattr(b, "text"):
                    print(b.text)

if __name__ == "__main__":
    asyncio.run(process_tickets("tickets.csv"))

קובץ tickets.csv לדוגמה

ticket_id,customer_name,subject,body
T1001,דנה לוי,"בעיה בחיוב","חויבתי פעמיים החודש, תוכלו לבדוק?"
T1002,יוסי כהן,"תודה","רק רציתי להגיד שהמוצר מעולה"
T1003,מיכל שטרן,"המוצר לא עובד","קניתי לפני שבוע וזה לא מתחבר לוויפי"

בטיחות, הרשאות ועלויות — לפני שמריצים לבד

Agent שרץ ללא גבולות הוא סכנה. לא בגלל ש-Claude זדוני — אלא כי LLMs טועים, ו-Agent שיכול לכתוב קבצים + לגשת לאינטרנט + לקרוא ל-APIs יכול לבצע טעות יקרה במהירות. הפרק הזה הוא רשימת ההגנות שאתה חייב להגדיר לפני שאתה משאיר Agent לרוץ בלילה.

שכבות בטיחות של Claude Agent SDK

חישוב עלות חודשית — דוגמה

Multi-agent orchestration — מתי להוסיף Agent שני

אחרי שבנית Agent אחד ונוח לך איתו — השלב הבא הוא צוות. המלצה פרקטית: אל תעבור ל-multi-agent עד שיש לך Agent אחד שעובד שבועיים רצוף בלי התערבות. זו לא המלצה שרירותית — זו תוצאה של ניסיון. משווקים שממהרים לבנות "צוות של 5 Agents" ביום הראשון מגלים שהם לא יכולים לאבחן מי מהם שגה כשיש בעיה, ושהעלות מטפסת פי 5 במקום פי 1.5. התחל באחד, תבין את הבעיות שלו, תקן אותן, ורק אז הוסף שני.

דפוסים לצוותי Agents שכדאי להכיר: (1) Pipeline — Agent A → B → C, כל אחד עושה צעד ומעביר. פשוט ואמין. (2) Hub and spoke — Orchestrator מרכזי שמחלק משימות ל-Agents מומחים ומאחד תוצאות. זו הגישה של Claude Agent SDK עם Task tool. (3) Peer review — Agent A כותב, Agent B בודק, Agent C מאשר. מצוין לאיכות אבל יקר. (4) Hierarchical — Manager Agent מתכנן, ו-Worker Agents מבצעים. הכי חזק אבל דורש LangGraph.

ל-OpenAI Agents SDK יש מודל "handoffs" שעושה את זה נקי — Agent אחד מעביר את העבודה לשני כשהוא רואה שהמשימה מחוץ לתחומו. LangGraph עושה את זה עם nodes מפורשים. Claude Agent SDK עושה את זה עם subagents (Task tool) — ה-Agent הראשי יכול להפעיל subagent עם system prompt שונה ולקבל תוצאה מרוכזת.

Observability — איך רואים מה ה-Agent באמת עושה

Agent שרץ ב-production הוא black box אלא אם אתה מוסיף שכבת observability. שלוש אפשרויות ב-2026:

• LangSmith (LangChain) — הכלי הבשל ביותר. מראה traces מלאים של כל קריאה, tokens, latency, ותוצאות של כל tool call. $39/חודש לתוכנית Team. עובד גם עם Claude Agent SDK וגם עם LangGraph
• Anthropic Console Traces — בנוי ל-Claude Agent SDK. חינמי, מספיק להתחלה. חסר features מתקדמים
• OpenTelemetry + Honeycomb — למי שרוצה לבנות מערכת monitoring מאוחדת עם שאר התשתית. מורכב יותר אבל הכי גמיש

המלצה למשווקים: התחל עם Anthropic Console Traces (חינם), ואחרי חודש-חודשיים כשיש לך נפח אמיתי, שדרג ל-LangSmith. אל תחכה עם זה עד שיש בעיה — בלי traces, אבחון בעיה ב-Agent לוקח שעות במקום דקות.

מקרי בוחן מייצגים — איך Agents משמשים בתעשייה

דוגמה 1 — סטארטאפ B2B SaaS ישראלי: צוות שיווק של 3 אנשים הפעיל Research Agent שבועי שסורק 10 מתחרים. לפני ה-Agent, זה היה לוקח 4-6 שעות של עובד ידני בשבוע. אחרי — 20 דקות בחינת דוח. חיסכון: כ-20 שעות לחודש = 3,000-6,000 ש"ח. עלות ה-Agent: $8-12/חודש. ROI: פי 40.

דוגמה 2 — חנות אונליין לתחום ה-beauty: הפעילו Customer-Success Agent שעונה ל-60% מהטיקטים ב-draft mode. נציגים אנושיים מאשרים ושולחים. זמן תגובה ממוצע ירד מ-4 שעות ל-22 דקות. שביעות רצון לקוחות עלתה ב-18%. עלות: ~$40/חודש ל-2,000 טיקטים. חיסכון מוערך: 1.5 משרת נציג חלקית.

דוגמה 3 — סוכנות שיווק דיגיטלית: בנתה Content Scheduler Agent שמכין 5 לוחות שבועיים מקבילים עבור 5 לקוחות שונים. כל Agent עם brand guidelines נפרד. העלות הכוללת: $25/חודש. החיסכון: Content Manager עבר מ-80% זמן על תכנון ל-80% על אסטרטגיה, והסוכנות יכולה עכשיו לנהל 7 לקוחות במקום 5 עם אותו מספר אנשים.

דוגמה 4 — יבואן מוצרי טכנולוגיה: בנה Pipeline Agent שלוקח RSS feeds של יצרני מותגים בחו"ל, מתרגם עדכונים לעברית, ומפרסם ב-LinkedIn של החברה. אוטונומי לחלוטין (עם spending cap של $20). התוצאה: 40 פוסטים חודשיים בלי מגע יד אדם. Engagement ממוצע דומה לפוסטים ידניים.

מה הדוגמאות מלמדות: (א) ROI מטורף כמעט תמיד, במיוחד על משימות שהיו לוקחות שעות אנושיות. (ב) מתחילים עם draft mode, לא auto-send. (ג) spending cap חיוני. (ד) תחזוקה שבועית קצרה אבל חובה.

שגרת עבודה ו-Work Routine

Agent שלא מתוחזק הופך לזבל תוך חודש. ה-SDKs מתפתחים, המודלים משתפרים, וה-prompts שעבדו באוגוסט לא בהכרח עובדים בנובמבר. להלן שגרת עבודה שמחזיקה צוות Agents בחיים:

סיכום וצ'קליסט

בנית מערכת אמיתית של Agents שיווקיים. לא "בוטים" — Agents שמחליטים, משתמשים בכלים, זוכרים, ומחזירים תוצרים. הגעת לרמה שרוב המשווקים בישראל עוד לא הגיעו אליה. עובדה זו לבדה היא יתרון תחרותי משמעותי — אתה עכשיו יכול לעשות ביום מה שלצוות הצמוד אליך ייקח שבוע. הפרק הבא יארגן הכל לתוכנית פעולה של 90 יום — מתי להפעיל מה, באיזה סדר, ועם אילו מדדים כך שתוכל להציג את ההשפעה של Agents להנהלה בצורה מקצועית.

שלוש טעויות שראיתי שיווקאים עושים אחרי פרק כזה

טעות #1 — "אני אבנה 10 Agents השבוע": התלהבות טבעית אחרי שרואים את הראשון עובד, אבל קטסטרופלית לתחזוקה. בחודש הראשון תבנה Agent אחד ותפעיל אותו. בחודש השני תוסיף Agent שני רק אחרי שהראשון רץ שבועיים בלי התערבות. בחודש השלישי — שלישי. זה הקצב הבריא. שיווקאים שממהרים יותר מזה מגיעים לנקודה שבה אף Agent לא עובד טוב כי אין זמן לתחזק את כולם.

טעות #2 — "LLMs יחליפו את האינטואיציה שלי": LLMs יודעים לעבד כמויות עצומות של מידע ולזהות דפוסים, אבל אין להם גישה להקשר העסקי הפנימי שלך — למה הלקוח הזה מיוחד, מה ההבטחה האמיתית של המותג, מה המדיניות ברגעי משבר. ה-Agent צריך להיות מגביר של השיפוט שלך, לא תחליף. תמיד השאר נקודות של שיפוט אנושי, במיוחד במצבים חדשים או רגישים.

טעות #3 — "חסכתי שעות, אבל איך אני מוכיח את זה?": בלי מדידה, החיסכון לא קיים בעיני ההנהלה. מה-הרגע הראשון — מדוד 3 מטריקות: (א) שעות אנושיות שחסכת לכל Agent לשבוע, (ב) עלות Agent לחודש בשקלים, (ג) יחס ROI (חיסכון בש"ח ÷ עלות בש"ח). רשום את זה בגיליון, הצג להנהלה כל חודש. זו הדרך היחידה לקבל אישור לפרויקטים גדולים יותר.

הדבר האחרון שאני רוצה להגיד: Agents הם לא מטרה — הם כלי. המטרה היא שיווק טוב יותר: מסרים מדויקים יותר לקהלים רלוונטיים יותר בזמנים נכונים יותר. אם Agent עוזר לך להגיע לשם — מעולה. אם Agent הופך למטרה בפני עצמה ואתה מוצא את עצמך מתחזק טכנולוגיה במקום ליצור ערך ללקוחות — עצור, קח צעד אחורה, ותשאל את עצמך מה באמת מזיז את המחט. Agents הם מכפיל כוח. מי שידע להשתמש בהם נכון — מכפיל תוצאות. מי שיתפתה בצד הטכנולוגי לבד — מבזבז זמן.