TL;DR: הסמכת Claude Certified Architect מגדירה 5 תחומי ליבה קריטיים לבניית אגנטים יציבים: Agentic Loop עם stop_reason (27% מהבחינה), Sub-Agent Orchestration עם Coordinator Pattern (18%), הפרדה חדה בין Prompts ל-Hooks (20%), Tool Description Optimization להפחתת misrouting, וניהול Context Window למניעת Lost in the Middle. הבנת ההבדלים בין best-effort ל-100% enforcement היא קריטית למניעת כשלים עסקיים.
- 12% כשלים בזיהוי לקוחות מתרחשים כאשר מסתמכים על Prompts במקום Hooks לאימות פעולות פיננסיות
- 27% מהבחינה מוקדשים לארכיטקטורת Agentic Loop, כולל שימוש נכון בשדה stop_reason במקום ניתוח טקסט
- 40% הראשונים של חלון ההקשר (system prompt, claude.md) והסוף מקבלים משקל גבוה, בעוד האמצע הופך fuzzy
- 3-4 ניסיונות כושלים של בחירת כלי לא נכון מתרחשים כאשר Tool Descriptions חסרים negative instructions ברורים
Anthropic השיקה תוכנית הסמכה חדשה לארכיטקטים של Claude Code: בחינת pass/fail רשמית המבוססת על 5 תחומי ליבה. הצעד מסמן מעבר מכלי שיחה ל-infrastructure-grade agent platform. החברה מתמודדת עם מתח מובנה: מצד אחד, היא צריכה לאפשר גמישות מקסימלית למפתחים. מצד שני, היא חייבת למנוע כשלים קריטיים בסביבות ייצור. צוותי DevOps מדווחים על misrouting תכוף של כלים. מהנדסי אבטחה מזהים פערים ב-enforcement של כללי compliance. ארכיטקטים מתקשים עם Lost in the Middle logic בחלונות הקשר גדולים.
המתח הזה מתבטא בבירור בחומר הבחינה. יעקב אברהמוב מנתח 40 עמודי מדריך הבחינה ומזהה דפוס ברור: Anthropic מבחינה בין best-effort patterns (Prompts) ל-guaranteed enforcement (Hooks). הניתוח שלנו מראה שהבנת ההבחנה הזו היא קריטית. 12% כשלים בוידוא לקוחות לפני החזרים כספיים אינם מקובלים בסביבות ייצור. המדריך מציג 5 עקרונות מתקדמים שמטפלים בפערים האלה ישירות.
איך לבנות Agentic Loop יעיל עם Claude Code?
לולאת Agent יעילה נבנית על בדיקה קפדנית של שדה stop_reason בכל תגובה מהמודל – כאשר הערך הוא tool_use המערכת ממשיכה לפעול, וכאשר הערך הוא end_turn התהליך מסתיים. שיטה זו מבטיחה אמינות של 100% לעומת ניתוח טקסט שמתקלקל באופן עקבי.
הלב הפועם של כל מערכת אוטונומית ב-Claude Code הוא מנגנון הלולאה האג'נטית. בין אם אתם משתמשים ב-SDK של Anthropic או במסגרת עבודה מתקדמת יותר, התהליך זהה: המערכת שולחת בקשה ל-Claude, מקבלת תגובה, ובודקת את שדה stop_reason. כאשר הערך הוא tool_use, המערכת מבצעת את הפעולה הנדרשת (קריאת קובץ, הרצת פקודה, הפעלת sub-agent), מזינה את התוצאה חזרה, והתהליך חוזר על עצמו. כאשר הערך הוא end_turn – המשימה הושלמה.
יעקב אברהמוב מדגיש בניתוח שלנו שלוש טעויות קריטיות שמארגונים עושים בבניית לולאות אג'נטיות. הראשונה: חיפוש ביטויים כמו "I'm done" או "task complete" בתוכן התגובה. שיטה זו נכשלת באופן עקבי כי Claude עשוי להשתמש בביטויים דומים בהקשרים שונים לחלוטין. השנייה: הגדרת מגבלות קשיחות כמו "עצור אחרי 10 לולאות". הבעיה המהותית כאן היא שעומק המשימה לא ידוע מראש – משימה לגיטימית עשויה לדרוש 11 או 15 צעדים, וחיתוך מלאכותי יקטע עבודה תקינה. השלישית: ניסיון לפרש את תוכן התשובה במקום לבדוק את השדה הייעודי.
כל פעולה שהמודל מבצע – קריאת קובץ, הרצת פקודה, יצירת sub-agent – עוברת דרך מנגנון הלולאה הזה. הבנת הדפוס הזה חיונית לבניית ארכיטקטורה מתקדמת. כאשר Claude צריך לטפל במשימות מורכבות כמו מחקר רב-ממדי או עיבוד פרויקט גדול, אין צורך לשלוח agent אחד לעשות הכול. במקום זאת, agent מרכזי מפרק את המשימה, מעביר חלקים ל-agents מתמחים, ומאחד את התוצאות בסוף.
נקודה קריטית שמדריך הבחינה מדגיש: כל sub-agent פועל בחלון הקשר נפרד משלו, ללא תקשורת ישירה עם agents אחרים. Sub-agent A לא יודע מה Sub-agent B עשה – כל המידע מתאחד רק ב-agent המרכזי בסוף התהליך. התכונה החדשה Agent Teams נועדה לפתור בעיה זו על ידי מתן "תיבת דואר" לכל agent, שמאפשרת תיאום ישיר ביניהם.
Practical Application: בפעם הבאה שאתם בונים לולאת agent, התחילו בלוגיקה פשוטה: בדקו את stop_reason בכל תגובה, הימנעו ממגבלות קשיחות, והשתמשו ב-sub-agents רק כשהמשימה באמת מורכבת מספיק להצדיק את העלות בטוקנים.
מתי כדאי להשתמש ב-Sub-Agents במקום Agent יחיד?
Sub-agents מומלצים כאשר משימה מחייבת מחקר ממספר זוויות או עיבוד פרויקט מורכב, כאשר agent מרכזי מפצל משימות ל-agents מתמחים שפועלים בחלונות הקשר נפרדים ללא תקשורת בינהם, ומרכז את התוצאות בסוף.
הארכיטקטורה של sub-agents פועלת על עיקרון פשוט: agent ראשי אחד מתפקד כמתאם, מפרק משימות גדולות לחלקים קטנים יותר, ומעביר כל חלק ל-agent מתמחה. כל sub-agent פועל בעולם משלו עם חלון הקשר נפרד, משתמש בכלים ספציפיים, ומחזיר תוצאות ל-agent הראשי שמרכז את הממצאים.
כפי שיעקב אברהמוב מציין בניתוח שלנו, ההבדל הקריטי בין sub-agents לבין Agent Teams החדש יותר הוא שב-sub-agents אין תקשורת ישירה בין האגנטים. Sub-agent A לא יודע מה עשה Sub-agent B. התקשורת זורמת רק דרך ה-agent המרכזי, שמתפקד כמנהל צוות שאוסף דיווחים ומסכם אותם.
התרחיש האופטימלי לשימוש ב-Sub-Agents
דוגמה מעשית: מחקר על השפעת AI על יצירת תוכן. במקום agent יחיד שמנסה לכסות הכל, ה-agent הראשי יוצר שלושה sub-agents מקבילים:
- Sub-agent 1: מתמחה בתוכן וידאו (כלים: חיפוש ברשת, ניתוח מגמות)
- Sub-agent 2: מתמחה בתוכן כתוב (כלים: ניתוח טקסט, מחקר ספרות)
- Sub-agent 3: מתמחה בתוכן אודיו (כלים: ניתוח פלטפורמות, מחקר טכנולוגיות)
כל agent עובד בעצמאות, משתמש בכלים שלו, וצורך את ה-tokens שלו. בסוף, ה-agent הראשי מקבל שלושה סיכומים נקודתיים ומייצר סינתזה אחת מקיפה.
Anti-Pattern קריטי: ה-Coordinator הצר מדי
הטעות הנפוצה ביותר בעבודה עם sub-agents היא coordinator שמפרק משימות צר מדי. לדוגמה: בקשה למחקר "AI in creative industries" עלולה להוביל ל-coordinator שיוצר משימות רק על אמנות ויזואלית – עיצוב גרפי, צילום, אמנות דיגיטלית – אבל מפספס לחלוטין מוזיקה, כתיבה, קולנוע ועיצוב משחקים.
הבעיה אינה ב-sub-agents עצמם. הם ביצעו את העבודה בצורה מושלמת. הבעיה היא ב-coordinator שהגדיר את ה-scope בצורה שגויה. זה כמו מנהל גרוע לצוות מעולה.
| הגישה המקובלת | הפרספקטיבה של [email protected] |
|---|---|
| מתן checklist מפורט ל-coordinator עם משימות צרות מראש | מתן יעדים רחבים שמאפשרים ל-sub-agents לפרק משימות עצמאית |
| ניהול מיקרו של כל צעד בתהליך | אונבורדינג של agent עם מטרות ברורות ואמון לביצוע עצמאי |
| הגדרת כלים ספציפיים לכל sub-agent מראש | מתן גישה לכלים רלוונטיים ומתן חופש בחירה בהתאם למשימה |
| בדיקת תוצאות רק בסוף התהליך | מעקב אחר תהליך הפירוק של ה-coordinator לפני הפעלת sub-agents |
הפתרון: יעדים רחבים במקום Checklists צרים
במקום לתת ל-coordinator רשימת משימות מוגדרת מראש, תנו לו מטרות כלליות ותנו ל-sub-agents את החופש לפרק את המשימות בעצמם. זה לא אומר לוותר על שליטה – זה אומר לתת מסגרת ברורה ולאפשר גמישות בביצוע.
דוגמה לפרומפט אופטימלי:
"אני רוצה שתחקור את ההשפעה של AI על יצירת תוכן על ידי הפעלת שלושה sub-agents במקביל. Sub-agent ראשון יחקור איך AI משנה יצירת תוכן וידאו. Sub-agent שני יחקור איך AI משנה יצירת תוכן כתוב. Sub-agent שלישי יחקור איך AI משנה יצירת תוכן אודיו. כל sub-agent צריך לחפש ברשת ולהחזיר סיכום בן שלושה bullets."
שימו לב: הפרומפט לא מגדיר איך לחפש, אילו כלים להשתמש, או איזה סדר לפעול. הוא נותן assignment ברור ומאפשר ביצוע עצמאי. זה כמו לגייס עובד, לעשות לו אונבורדינג טוב, ואז לתת לו משימה ולסמוך עליו שיבצע אותה.
מתי לא להשתמש ב-Sub-Agents
לא כל משימה מצדיקה פיצול ל-sub-agents. אם המשימה פשוטה, ברורה, ונוגעת לקובץ בודד או לתהליך ליניארי – agent יחיד יהיה יעיל יותר. Sub-agents מתאימים למשימות שדורשות:
- מחקר ממספר זוויות: נושאים שדורשים גישות שונות או מקורות מידע מגוונים
- עיבוד מקבילי: משימות שניתן לבצע בו-זמנית ללא תלות אחת בשנייה
- התמחות בכלים: כאשר כל חלק במשימה דורש כלים או מיומנויות שונות
- ניהול context נפרד: כאשר רוצים לשמור על העבודה המבולגנת של מחקר מחוץ לשיחה הראשית
Practical Application: לפני שמפעילים sub-agents, שאלו את עצמכם: האם המשימה באמת דורשת מספר זוויות התקפה? אם התשובה כן, תנו ל-coordinator יעדים רחבים ותנו ל-sub-agents לפרק את המשימות בעצמם בהתבסס על המטרות הכלליות.
מה ההבדל בין Prompts ל-Hooks ב-Claude Code?
Prompts הם הצעות עם 90-99% הצלחה המתאימות לעיצוב וסגנון, בעוד Hooks הם חוקים עם 100% אכיפה שחוסמים פיזית ביצוע פעולות עד עמידה בתנאי מוגדר מראש. ההבדל הקריטי: Prompt יכול להיכשל, Hook לא יאפשר את הפעולה מלכתחילה.
כאשר אנתרופיק פרסמה את מדריך הסמכת Claude Architect, נקודה אחת בלטה מעל כולן: 12% מהמקרים בהם סוכן AI דילג על אימות לקוח לפני ביצוע החזר כספי. זה לא באג טכני, זו תוצאה ישירה של שימוש לא נכון ב-Prompts במקום ב-Hooks.
Prompts פועלים כהמלצות. כאשר אתם כותבים "תמיד אמת את פרטי הלקוח לפני החזר כספי", Claude מבין את הכוונה ומבצע אותה ברוב המקרים. אבל "רוב המקרים" זה לא מספיק כשמדובר בכסף אמיתי. במחקר הפנימי של אנתרופיק, מערכות שהסתמכו על Prompts לאימות לקוחות הפנו החזרים ללקוחות שגויים ב-12% מהפעמים. עבור חברה שמעבדת 10,000 החזרים בחודש, זה 1,200 טעויות פוטנציאליות.
איך Hooks חוסמים כשלים במקור
Hook הוא סקריפט אוטומטי שרץ לפני או אחרי שהסוכן מנסה לבצע פעולה. ההבדל המהותי: Hook יכול לחסום פיזית את ביצוע הפעולה אם תנאי מסוים לא מתקיים. במקרה של החזר כספי, Hook יכול לאכוף:
- חסימת פונקציית process_refund עד שהפונקציה get_customer תופעל תחילה
- בדיקת קיום customer_id בזיכרון הפעיל של השיחה
- דרישת אישור אנושי עבור סכומים מעל סף מוגדר
כאשר Hook פעיל, הפעולה פשוט לא יכולה להתבצע. זה לא עניין של דיוק או הסתברות, זה 100% אכיפה. יעקב אברהמוב מציין בניתוח שלנו: "החברות שעברו מ-Prompts ל-Hooks בתהליכי החזרים ראו ירידה של 100% בטעויות זיהוי לקוח, לא כי ה-AI השתפר, אלא כי הוא פשוט לא יכול לטעות יותר."
כלל הזהב: מתי להשתמש בכל אחד
| תחום | כלי מומלץ | סיבה |
|---|---|---|
| Compliance ורגולציה | Hooks בלבד | אפס סובלנות לטעויות משפטיות |
| פעולות פיננסיות | Hooks בלבד | כל טעות = הפסד כספי מיידי |
| אבטחת מידע | Hooks בלבד | דליפת נתונים בודדת = אסון |
| סגנון כתיבה | Prompts | 90% דיוק מספיק, אין סיכון עסקי |
| עיצוב ממשק | Prompts | העדפות אסתטיות, לא קריטיות |
| פורמט פלט | Prompts | ניתן לתקן בקלות אם נדרש |
המדריך של אנתרופיק מציג דוגמה מעשית: אם אתם רוצים ש-Claude ישתמש בטון רשמי במיילים, Prompt יעשה עבודה מצוינת. אבל אם אתם רוצים למנוע ממנו לשלוח מייל בכלל ללא אישור מנהל, רק Hook יבטיח זאת.
הטעות הנפוצה: "אשפר את ה-Prompt"
כמנכ"ל Prompt Advisors, יעקב אברהמוב ראה תופעה חוזרת: חברות שחוו כשלים ב-5-10% מהמקרים השקיעו שבועות בשיפור ניסוחי Prompts. התוצאה? שיפור ל-96-97% הצלחה, אבל אף פעם לא 100%. הסיבה פשוטה: מודלי שפה הם מערכות הסתברותיות. הם לא מבצעים לוגיקה דטרמיניסטית.
מעל 1,000 איטרציות או 5,000 שאילתות, אפילו שיעור כשל של 1% הופך למשמעותי. עבור מערכת שמעבדת 100,000 פעולות בחודש, זה 1,000 כשלים פוטנציאליים. Hooks מבטלים את הבעיה הזו לחלוטין.
Practical Application: סקרו את כל התהליכים האוטומטיים שלכם ושאלו: "מה הסיכון אם הפעולה הזו תכשל פעם אחת?" אם התשובה כוללת הפסד כספי, חשיפה משפטית או פגיעה באבטחה, החליפו מיד את ה-Prompt ב-Hook. התחילו עם הפעולות הקריטיות ביותר והתקדמו כלפי מטה.
איך למנוע מ-Claude Code לבחור בכלי הלא נכון?
תיאורים מעורפלים של כלים גורמים ל-Claude לבחור בכלי הלא נכון ב-12% מהמקרים. הפתרון: הוספת 'Do NOT use when…' לכל כלי, לא רק 'Use when…' – גישה שמפחיתה בזבוז tokens ומגדירה גבולות ברורים בין כלים דומים.
כאשר Claude מקבל גישה למספר כלים עם תיאורים מעורפלים, הוא מתחיל לנחש. במקרה של שני כלים כמו get_customer ו-lookup_order, שניהם עוסקים באחזור מידע על לקוחות והזמנות, Claude עלול לבחור בכלי הלא נכון. התוצאה? 12% מהמקרים מסתיימים בזיהוי שגוי של חשבונות, החזרים כספיים ללקוחות הלא נכונים, ובעיות תפעוליות שעלולות לעלות כסף אמיתי.
כפי שמציין יעקב אברהמוב בניתוח שלנו: "רוב המפתחים מתארים רק מתי להשתמש בכלי, אבל לא מתי להימנע ממנו. זה כמו לתת לעובד חדש הרשאות לכל המערכות ביום הראשון ולקוות שהוא יבחר נכון."
השיטה המתקדמת: גבולות שליליים
במקום להסתפק בתיאור חיובי של הכלי, הוסף סעיף 'Do NOT use when…' לכל כלי. זה יוצר גבולות ברורים ומונע חפיפה בין כלים דומים:
- get_customer: Use when you need customer ID and profile data. Do NOT use when you have an order number – use lookup_order instead.
- lookup_order: Use when you have an order number and need shipping status. Do NOT use for general customer information – use get_customer instead.
הגישה הזו מגדירה לא רק מה הכלי עושה, אלא גם מה הוא לא אמור לעשות. Claude לומד את הגבולות בין הכלים ומפחית את הסיכוי לבחירה שגויה.
המחיר הנסתר: בזבוז Tokens
גם כאשר Claude מגיע לתוצאה הנכונה בסופו של דבר, הדרך לשם עלולה להיות יקרה. Agent עם תיאורי כלים מעורפלים עשוי לנסות 3-4 ניסיונות כושלים לפני שהוא מוצא את הכלי הנכון. כל ניסיון כזה צורך tokens, מאט את התהליך, ומייקר את העלות התפעולית.
תיאור מדויק של כלים מפחית את ה-waste הזה באופן דרמטי. במקום לראות את Claude מנסה כלי אחר כלי בתקווה למצוא את הנכון, הוא בוחר את הכלי המתאים מהניסיון הראשון. זה לא רק חוסך כסף – זה גם משפר את חוויית המשתמש ומקצר זמני תגובה.
Practical Application: עבור על כל הכלים שהגדרת ל-Claude והוסף סעיף 'Do NOT use when…' לכל אחד. התמקד במקרים שבהם יש חפיפה פוטנציאלית עם כלים אחרים במערכת.
Context Window Management: מניעת 'Lost in the Middle' באמצעות key fact pinning וטכניקות trimming
כאשר אתם מעבירים מידע ל-Claude, המודל קורא את 40% הראשונים של חלון ההקשר בדיוק גבוה במיוחד. זה כולל את ה-system prompt, ההודעות הראשונות, וקובץ ה-claude.md שנטען אוטומטית. באותה מידה, Claude מפגין recency bias חזק לקראת סוף החלון. אבל המידע באמצע? הוא הופך מטושטש. זה מה שמכונה "Lost in the Middle" – תופעה שבה נתונים קריטיים שקבורים בחלק האמצעי של ההקשר פשוט נעלמים מהזיכרון האפקטיבי של המודל.
הבעיה מחמירה עם כל שימוש בכלי. כל פעם ש-Claude מפעיל tool, התוצאה מתווספת לאזור האמצע הזה. לקוח יכול לחזור עם 40 שדות כשאתם צריכים רק חמישה. כל שדה מיותר דוחף את המידע החשוב עמוק יותר לאזור המטושטש.
שלוש שיטות מוכחות לפתרון
שיטה 1: Key Fact Summary Block
במקום לתת ל-Claude לחפור דרך הקשר ארוך, תקבעו את העובדות הקריטיות בראש השיחה. צרו בלוק סיכום שמכיל רק את הנתונים החיוניים ביותר – מזהה לקוח, סטטוס הזמנה, פרטי תשלום. זה מבטיח ש-Claude רואה אותם בכל פעם, ללא קשר לאורך השיחה.
שיטה 2: Trimming של Metadata מיותר
כלים מחזירים לעיתים קרובות מטא-דאטה מסורבל שלא מקדם שום דבר. במקום לשמור את כל 40 השדות שחזרו מה-API, תחתכו אותם לחמישה שבאמת משנים. זה שומר על חלון ההקשר רזה ומיועל.
שיטה 3: Delegation ל-Sub-Agents
כשיש לכם משימה מורכבת, אל תדחסו הכול לסוכן אחד. השתמשו ב-sub-agents שכל אחד מהם עובד בחלון הקשר מבודד משלו. כל הפלט המבולגן נשאר אצלם – אתם מקבלים רק סיכום נקי. זה כמו לשלוח מישהו לחדר אחר לעשות מחקר ולהביא רק את המסקנות.
Anti-Pattern: ההמשך האינסופי
טעות נפוצה: להמשיך שיחה ב-context window של 1M טוקנים עם עשרות tool calls ו-pivots בשיחה. גם אם יש לכם את כל המקום בעולם, זה לא אומר שכדאי להשתמש בו. כל קריאת כלי, כל ניסיון שנכשל, כל פיבוט בשיחה – הכול מזהם את ההקשר.
הפתרון? התחילו session חדש עם סיכום מזוקק. במקום לדחוף את Claude דרך מיליון טוקנים של היסטוריה, תסכמו את הממצאים המרכזיים בכמה פסקאות וכתבו אותם ב-session נקי. זה נותן ל-Claude התחלה טרייה עם כל המידע הרלוונטי, ללא הרעש.
כדי לבדוק מה בדיוק נמצא בזיכרון של Claude בנקודת זמן מסוימת, הקלידו /memory בטרמינל. זה יראה לכם את project memory, את ה-claude.md, ואת תיקיית ה-automemory עם כל מה שהמודל זוכר מה-session הנוכחי.
Practical Application: לפני שאתם מתחילים משימה מורכבת עם Claude, הגדירו key fact block בראש השיחה עם 3-5 עובדות קריטיות בלבד. אם השיחה עוברת 15 tool calls, פתחו session חדש עם סיכום במקום להמשיך באותה שיחה.
שאלות נפוצות
מה ההבדל בין Prompts ל-Hooks ב-Claude Code?
Prompts הם הצעות עם 90-99% הצלחה המתאימות לעיצוב וסגנון, בעוד Hooks הם חוקים עם 100% אכיפה שחוסמים פיזית ביצוע פעולות עד עמידה בתנאי מוגדר מראש. במחקר של אנתרופיק, מערכות שהסתמכו על Prompts לאימות לקוחות הפנו החזרים ללקוחות שגויים ב-12% מהפעמים, בעוד Hooks חוסמים את הפעולה לחלוטין עד לאימות. ההבדל הקריטי: Prompt יכול להיכשל, Hook לא יאפשר את הפעולה מלכתחילה.
איך לבנות Agentic Loop יעיל עם Claude Code?
לולאת Agent יעילה נבנית על בדיקה קפדנית של שדה stop_reason בכל תגובה מהמודל, כאשר הערך tool_use המערכת ממשיכה לפעול, וכאשר הערך end_turn התהליך מסתיים. שיטה זו מבטיחה אמינות של 100% לעומת ניתוח טקסט שמתקלקל באופן עקבי. 27% מבחינת Claude Certified Architect מוקדשים לארכיטקטורת Agentic Loop, כולל שימוש נכון ב-stop_reason במקום פרשנות טקסט.
מתי כדאי להשתמש ב-Sub-Agents במקום Agent יחיד?
Sub-agents מומלצים כאשר משימה מחייבת מחקר ממספר זוויות או עיבוד פרויקט מורכב, כאשר agent מרכזי מפצל משימות ל-agents מתמחים שפועלים בחלונות הקשר נפרדים ללא תקשורת בינהם. כל sub-agent פועל בעולם משלו עם חלון הקשר נפרד, משתמש בכלים ספציפיים, ומחזיר תוצאות ל-agent הראשי שמרכז את הממצאים. אם המשימה פשוטה, ברורה, ונוגעת לקובץ בודד או לתהליך ליניארי, agent יחיד יהיה יעיל יותר.
מה זה Coordinator Pattern ב-Sub-Agent Orchestration?
Coordinator Pattern הוא ארכיטקטורה שבה agent ראשי אחד מתפקד כמתאם, מפרק משימות גדולות לחלקים קטנים יותר, ומעביר כל חלק ל-agent מתמחה. הטעות הנפוצה ביותר היא coordinator שמפרק משימות צר מדי, למשל בקשה למחקר על AI in creative industries שיוצר משימות רק על אמנות ויזואלית אבל מפספס מוזיקה, כתיבה וקולנוע. הפתרון הוא לתת ל-coordinator יעדים רחבים במקום checklists צרים ולאפשר ל-sub-agents לפרק את המשימות בעצמם.
איך למנוע Lost in the Middle בחלון הקשר של Claude?
40% הראשונים של חלון ההקשר (system prompt, claude.md) והסוף מקבלים משקל גבוה, בעוד האמצע הופך fuzzy ונתונים חשובים עלולים להיאבד. הפתרון הוא key fact pinning וטכניקות trimming שמבטיחות שמידע קריטי נשאר באזורים בעלי משקל גבוה. ניהול Context Window נכון הוא אחד מ-5 תחומי הליבה בבחינת Claude Certified Architect למניעת כשלים בזיהוי מידע חיוני.
