Claude Haiku 5.5: העובד הזול שהופך סוכני משנה לברירת מחדל

הכירו את Claude Haiku 5.5, המודל הקטן והמהיר של Anthropic שיצא ב-7 באוקטובר. בעיניי הוא לא עוד "מודל זול" אלא העובד החרוץ שכל מערכת סוכנים חיכתה לו. הוא עולה 10 סנט למיליון טוקנים של קלט ו-50 סנט למיליון טוקנים של פלט, יש לו לראשונה בתולדות Haiku כפתור effort, וב-Hacker News הפוסט על ההשקה טיפס ל-1,049 נקודות ו-489 תגובות. בואו נפרק למה זה מעניין דווקא אנשים שבונים סוכנים, ואיך מחברים אותו כבר היום ל-Claude Code ול-API.

לאורך כל הכתבה נלווה דוגמה אחת: יש לנו ריפו עם 200 קבצי Python, ואנחנו צריכים למצוא בכל אחד מהם קריאות לספרייה פנימית ישנה בשם legacy_client ולהציע תיקון. משימה משעממת, ארוכה ומקבילית לגמרי. בדיוק מה שסוכנים אמורים לעשות בשבילנו.

המצב: כל הסוכנים שלנו רצים על המודל הכי יקר

רוב מי שעובד היום עם Claude Code או עם API מכיר את הדפוס: פותחים סשן על המודל החזק, והוא עושה הכל. מתכנן, קורא קבצים, מחפש, מסכם, כותב קוד. זה עובד מצוין, אבל זה כמו לשלוח את הארכיטקט הראשי של החברה לספור ברגים במחסן. הוא יספור נכון, רק שכל בורג עולה לנו שעת ארכיטקט.

בדוגמה שלנו, רוב העבודה היא קריאה: לפתוח קובץ, לסרוק, לרשום ממצאים. רק החלק האחרון, לאחד 200 ממצאים לתוכנית מיגרציה מסודרת לפי סיכון, באמת דורש שיקול דעת של מודל גדול. ובכל זאת, ברירת המחדל של רובנו היא להריץ את כל השרשרת על אותו מודל.

המענה: מנצח ותזמורת

הדפוס שפותר את זה נקרא orchestrator/worker, ובעברית פשוטה: מנצח ונגנים. orchestrator/worker הוא דפוס עבודה שבו מודל גדול מתכנן ומחלק משימות, וצי של מודלים קטנים וזולים מבצע אותן במקביל, עבור כל מי שמריץ עבודה סוכנית בהיקף. המנצח לא מנגן בעצמו. הוא מחליט מי מנגן מה, מקשיב לתוצאה, ומחבר את הכל ליצירה אחת.

סוכן משנה (subagent) הוא בדיוק הנגן הזה: מופע נפרד של מודל, עם חלון הקשר משלו (כמות הטקסט שהמודל "רואה" בבת אחת), עם סט כלים מוגבל ועם הנחיה אחת ברורה. הוא מקבל משימה, עובד עליה בשקט, ומחזיר למנצח רק סיכום קצר. מסתבר שזה חוסך פעמיים: פעם אחת בכסף, כי הנגן רץ על מודל זול, ופעם שנייה בהקשר, כי כל הקריאה הרועשת של קבצים נשארת אצל הנגן ולא מלכלכת את הראש של המנצח.

בדוגמה שלנו זה נראה כך: המנצח, Opus 5.5, מקבל את המשימה, מחלק את 200 הקבצים ל-50 חבילות של ארבעה קבצים, ושולח כל חבילה ל-Haiku 5.5. כל Haiku מחזיר רשימה קצרה של שורות בעייתיות והצעת תיקון, ו-Opus מאחד את הכל לתוכנית אחת.

המכשול: למה זה לא עבד טוב עד עכשיו

הרעיון לא חדש. הבעיה הייתה שהנגנים היו חלשים מדי. המודל הקודם, Haiku 4.5, היה זול יחסית, אבל במשימות סוכניות אמיתיות הוא נפל. לפי הטבלה שפרסמה Anthropic, Haiku 4.5 קיבל 0% ב-Terminal-Bench 4.0 (בנצ'מרק של עבודה עצמאית בטרמינל) ו-15.7% ב-OSWorld 2.1 (שימוש במחשב כמו בן אדם). כש-Haiku 5.5 מקבל באותם מבחנים 39.2% ו-72.4%, זה כבר לא שדרוג קטן, זו קטגוריה אחרת של עובד.

כדי להיות הוגנים, צריך לשים גם את הצד השני של הטבלה: Sonnet 5.5, שיצא כמה ימים לפני, מקבל 70.6% ב-Terminal-Bench ו-83.9% ב-OSWorld. כלומר Haiku 5.5 לא מחליף את המודלים הגדולים במשימות קוד קשות, והוא גם לא מתיימר לזה. ב-Anthropic עצמם כותבים שהוא "משתלב היטב עם Opus 5.5 ו-Sonnet 5.5 כסוכן משנה בעבודת קוד". שורה תחתונה: נגן מצוין, לא מנצח.

עוד שני דברים שכדאי לדעת לפני שקופצים:

• אותו טקסט, יותר טוקנים. המודל עבר לטוקנייזר (הכלי שחותך טקסט ליחידות שהמודל סופר ומחייב עליהן) של הדור החדש, ולפי התיעוד הרשמי אותו טקסט יוצא בערך 30% יותר טוקנים מאשר ב-Haiku 4.5. מול Opus 5.5 ו-Sonnet 5 ההשוואה הוגנת, כי כולם על אותו טוקנייזר.
• חשיבה מופעלת כברירת מחדל. התשובה יכולה להתחיל בבלוק חשיבה, והחשיבה נספרת בתוך max_tokens. קוד ישן שקורא את הבלוק הראשון כתשובה, או שמגדיר max_tokens קטן מאוד, עלול לקבל תשובה ריקה.

הקטע המדליק: effort, ומלכודת ה-100 אלף

לפי Anthropic, זה "מודל ה-Haiku הראשון עם הגדרת effort מתכווננת". effort הוא פרמטר שקובע כמה עבודה המודל משקיע בתשובה, כולל כמה הוא חושב וכמה קריאות לכלים הוא עושה. תחשבו על זה כמו על מתג של מזגן: Low, Medium, High, ועוד שני מצבים xhigh ו-max. ברירת המחדל ב-Haiku 5.5 היא medium.

ההמלצה בתיעוד ברורה: medium לרוב העבודה, כולל קוד סוכני. low למשימות קצרות, פשוטות ובנפח גבוה. high לעבודת ידע, משימות סוכניות ארוכות והקפדה על הוראות. אבל יש אזהרה שחשוב לקרוא: ב-low, בפרומפטים סוכניים ארוכים, המודל נוטה יותר לדלג על חיפוש, לעצור מוקדם או לוותר על בדיקה. בדוגמה שלנו, Haiku שקורא קובץ אחד ומחזיר רשימה הוא מועמד מושלם ל-low. Haiku שמסתובב בריפו עם כלים ומחפש לבד, עדיף ב-medium.

ועכשיו המלכודת. התמחור של Haiku 5.5 מדורג לפי אורך הפרומפט: עד 100,000 טוקנים בבקשה, 0.10$ קלט ו-0.50$ פלט למיליון. מעל 100,000, כל הבקשה עולה פי חמישה: 0.50$ ו-2.50$. וזה לא רק הקלט: גם הפלט של אותה בקשה מתומחר במחיר הגבוה, וגם טוקנים שנקראים מהקאש נספרים באורך הפרומפט. בדף התמחור מבהירים שכל בקשה מתומחרת בפני עצמה, כך שבלולאה סוכנית, שבה ההיסטוריה נשלחת מחדש בכל סיבוב, הסוכן יכול לחצות את הקו באמצע העבודה בלי ששמנו לב.

בגרף רואים את מחירי הפלט הרשמיים למיליון טוקנים. מתחת ל-100K, Haiku 5.5 עולה 0.50$, פי 20 פחות מ-Sonnet 5 (10$) ופי 40 פחות מ-Opus 5.5 (20$). מעל 100K הוא קופץ ל-2.50$, עדיין זול מ-Haiku 4.5 (5$), אבל פער של פי חמישה בתוך אותו מודל.

בואו נעשה חשבון: כמה עולה הדוגמה שלנו

נניח, לצורך החישוב בלבד, שכל אחת מ-50 המשימות צורכת בסך הכל 40 אלף טוקנים של קלט ו-4,000 טוקנים של פלט (כולל חשיבה), וכל בקשה בודדת נשארת מתחת ל-100K. בנוסף, המנצח על Opus 5.5 קורא את כל הסיכומים וכותב תוכנית: נגיד 150 אלף טוקנים קלט ו-20 אלף פלט. אלו הנחות להמחשה, לא מדידה, והמספרים האמיתיים שלנו ישתנו לפי הקוד, ה-effort ומספר הסיבובים. החשבון עצמו מבוסס על המחירים הרשמיים:

• הכל על Opus 5.5: העובדים צורכים 2 מיליון קלט כפול 4$ ועוד 200 אלף פלט כפול 20$, כלומר 12$, ועוד 1$ למנצח. סך הכל כ-13$.
• עובדים על Sonnet 5, מנצח על Opus 5.5: 4$ ועוד 2$ לעובדים, ועוד 1$. סך הכל כ-7$.
• עובדים על Haiku 5.5, מנצח על Opus 5.5: 0.20$ ועוד 0.10$ לעובדים, ועוד 1$. סך הכל כ-1.30$.

באותה עבודה בדיוק, החלפת הנגנים ל-Haiku 5.5 מורידה את החשבון בערך פי 10, ורוב מה שנשאר הוא המנצח. ועכשיו מלכודת ה-100K במספרים: אם היינו נותנים לכל עובד חבילה גדולה של 120 אלף טוקנים בבקשה אחת, 50 בקשות כאלה היו עולות כ-3.50$. אם מפצלים כל חבילה לשתי בקשות של 60 אלף, אותה כמות קלט עולה כ-0.80$. הלקח: חבילות קטנות, ולא עובד אחד שבולע הכל.

במחשבון אפשר לשחק עם המספרים של הפרויקט שלנו:

איך מחברים את זה היום: Claude Code ו-API

ב-Claude Code, סוכן משנה הוא קובץ Markdown בתיקייה .claude/agents/ בפרויקט (או ~/.claude/agents/ לכל הפרויקטים), עם כותרת YAML. לפי התיעוד הרשמי, שדה model מקבל כינוי כמו haiku או מזהה מלא, ושדה effort מקבל את חמש הרמות. שימו לב לפרט קטן וחשוב: הכינוי haiku מצביע על Haiku 5.5 רק כשמתחברים דרך ה-API של Anthropic. דרך Bedrock, Google Cloud, Foundry או Claude Platform on AWS הוא עדיין מצביע על Haiku 4.5. לכן כאן נכתוב את המזהה המלא:

---
name: legacy-scanner
description: Scans a small batch of Python files for calls to the deprecated legacy_client library and proposes a one-line fix for each. Use for bulk, read-only code audits.
tools: Read, Grep, Glob
model: claude-haiku-5-5
effort: medium
---

You audit Python files for the deprecated `legacy_client` library.
For each file you are given:
1. Find every import or call of `legacy_client`.
2. Report: file path, line number, the call, and a one-line fix using `new_client`.
3. If a file has no usage, report it as CLEAN.
Do not edit files. Return a short Markdown table only.

מרגע שהקובץ בתיקייה, המנצח בסשן הראשי יכול להאציל אליו עבודה לפי התיאור שכתבנו ב-description, או שנבקש במפורש להשתמש בו. ואם רוצים שכל סוכני המשנה ירוצו על Haiku כברירת מחדל, התיעוד מציין את משתנה הסביבה CLAUDE_CODE_SUBAGENT_MODEL. הגדרה בתוך קובץ הסוכן עדיין גוברת עליו.

ב-API הדפוס אותו דפוס, רק שאנחנו כותבים את הלולאה בעצמנו. הקוד הבא סורק כל קובץ עם Haiku 5.5 ב-effort נמוך, במקביל, בודק עם count_tokens שהבקשה לא חוצה את קו ה-100K, ואז מעביר את כל הדוחות ל-Opus 5.5 שיאחד אותם לתוכנית אחת:

import glob
from concurrent.futures import ThreadPoolExecutor

import anthropic

client = anthropic.Anthropic()

WORKER = "claude-haiku-5-5"
ORCHESTRATOR = "claude-opus-5-5"
SYSTEM = (
    "You audit one Python file for the deprecated `legacy_client` library. "
    "List every call with its line number and a one-line fix using `new_client`. "
    "Reply CLEAN if there is none."
)


def text_of(response) -> str:
    # responses can start with a thinking block - select by type, not position
    return "".join(b.text for b in response.content if b.type == "text")


def audit(path: str) -> str:
    source = open(path, encoding="utf-8").read()
    messages = [{"role": "user", "content": f"File: {path}\n\n{source}"}]

    # Haiku 5.5 bills the whole request at the higher rate above 100k prompt tokens
    count = client.messages.count_tokens(model=WORKER, system=SYSTEM, messages=messages)
    if count.input_tokens > 100_000:
        return f"{path}: SKIPPED ({count.input_tokens} tokens) - split this file first"

    response = client.messages.create(
        model=WORKER,
        max_tokens=8000,  # thinking counts toward max_tokens
        system=SYSTEM,
        output_config={"effort": "low"},
        messages=messages,
    )
    return f"### {path}\n{text_of(response)}"


files = sorted(glob.glob("src/**/*.py", recursive=True))
with ThreadPoolExecutor(max_workers=8) as pool:
    reports = list(pool.map(audit, files))

plan = client.messages.create(
    model=ORCHESTRATOR,
    max_tokens=16000,
    output_config={"effort": "high"},
    messages=[{
        "role": "user",
        "content": "Merge these per-file audit reports into one migration plan, "
                   "ordered by risk:\n\n" + "\n\n".join(reports),
    }],
)
print(text_of(plan))

שלושה דברים בקוד ששווה לשים לב אליהם: output_config={"effort": "low"} הוא המקום שבו מגדירים effort, לא פרמטר נפרד. התשובה נאספת לפי סוג הבלוק ולא לפי מיקום, כי היא עלולה להתחיל בבלוק חשיבה. ואין בקוד temperature, כי לפי מדריך המעבר פרמטרי דגימה כמו temperature עלולים להחזיר שגיאה ב-Haiku 5.5.

מסקנה: מתי Haiku, ומתי לא

בעיניי, Haiku 5.5 הוא הרגע שבו "מודל גדול מתכנן, הרבה מודלים קטנים מבצעים" הפך מרעיון יפה בהרצאות לברירת מחדל כלכלית. הנגן סוף סוף מספיק טוב, ומספיק זול, כדי שנריץ עשרות כאלה בלי לחשוב פעמיים. גם הלקוחות של Anthropic מדווחים על זה במילים שלהם: Asana מדברים על מהירות של עד פי 2.5 בכל סיבוב של סוכן, ו-Box על ציון גבוה ב-11 נקודות מ-Haiku 4.5 בערך בחצי מזמן התגובה. אלה דיווחים של לקוחות, לא מדידה עצמאית.

אבל יש גבולות. המודל עדיין רחוק מ-Sonnet 5.5 במשימות קוד קשות וארוכות, אז את ההחלטות הגדולות, הארכיטקטורה והאיחוד הסופי משאירים למנצח. כדאי למדוד את ה-effort על משימות אמיתיות שלנו לפני שמורידים ל-low. חובה לשמור כל בקשה מתחת ל-100K, אחרת החיסכון מתכווץ. ועוד הערה למי שעובד דרך Bedrock: לפי התיעוד, structured outputs לא זמינים שם ל-Haiku 5.5.

שורה תחתונה: בדוגמה שלנו, אותה סריקה של 200 קבצים ירדה מכ-13$ לכ-1.30$, והמודל הגדול התפנה לעשות את מה שהוא באמת טוב בו.

רוצים ללכת עם זה רחוק יותר?

את כל העבודה עם סוכני משנה, effort והחלוקה בין מנצח לנגנים אני מפרק לעומק בקורס Claude Code Mastery באנגלית. מי שמעדיף בעברית, ורוצה להתחיל מ-Claude Desktop, MCP, Skills, סוכנים ואוטומציות, מוזמן לקורס Practical AI with Claude.

את הדמואים והניסויים האלה אני מעלה ל-YouTube ול-LinkedIn, עם עדכונים שוטפים גם ב-X, ב-Instagram וב-TikTok. הקוד שלי פתוח ב-GitHub.

ואני סקרן לשמוע: איזו משימה בפרויקט שלכם הייתם מעבירים ראשונה לצי של סוכני Haiku, ואיזו לעולם לא הייתם נותנים לו לגעת בה?