Sub-agents: איך להריץ כמה סוכני Claude Code במקביל

מאת צוות מדיה דיל · 08.08.2026 · AI · 9 דק׳

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

מכירים את הרגע שבו אתם עובדים על פיצ׳ר, ופתאום המסך מתמלא בתוצאות חיפוש, לוגים ארוכים, ופלט טסטים שאתם לא באמת צריכים לזכור עוד חמש דקות? זה בדיוק הרגע שבו Claude Code שולף כלי שהרבה מפתחים לא מנצלים עד הסוף: sub-agents. במקום שסוכן אחד ינסה לעשות הכול בתוך אותה שיחה - לחפש, לקרוא, לכתוב, לבדוק - אפשר לפצל את העבודה בין כמה סוכנים שרצים כל אחד בהקשר (context) משלו, ולתת לסוכן ראשי לתאם ביניהם ולמזג את התוצאה הסופית. זה לא רק עניין של נוחות. זה שינוי אמיתי באיך שפרויקטים גדולים מתנהלים מול Claude Code, ובמאמר הזה נפרק את זה לגורמים: מה זה sub-agent, איך מגדירים אחד בעצמכם, מתי Claude בוחר להאציל משימה לבד ומתי אתם צריכים לבקש את זה מפורשות, ואיך זה נראה בתרחיש עסקי אמיתי.

מה זה בעצם Sub-agent?

Sub-agent הוא עוזר AI מתמחה שמטפל בסוג ספציפי של משימה בתוך סשן של Claude Code. כל sub-agent רץ בחלון context משלו, עם system prompt מותאם, גישה מוגבלת לכלים (tools) והרשאות עצמאיות. כשקלוד נתקל במשימה שמתאימה לתיאור של sub-agent מסוים, הוא מאציל לו את העבודה, הסוכן פועל באופן עצמאי, ומחזיר תוצאה - בלי שכל התהליך שהוביל לתוצאה הזו "מציף" את השיחה הראשית שלכם.

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

Claude Code מגיע עם כמה sub-agents מובנים שקלוד מפעיל אוטומטית לפי הצורך:

• Explore - סוכן קריאה בלבד, מהיר, שמיועד לחיפוש וניתוח קוד. אין לו הרשאות כתיבה או עריכה. קלוד מציין רמת יסודיות כשהוא קורא לו - quick לבדיקה ממוקדת, medium לאיזון, או very thorough לניתוח מקיף.
• Plan - סוכן מחקר שרץ במצב plan mode, אוסף הקשר על הקוד לפני שקלוד מציג תוכנית עבודה. גם הוא read-only.
• General-purpose - סוכן יכולות מלאות למשימות מורכבות ורב-שלביות שדורשות גם חקירה וגם פעולה - כלומר גם קריאה וגם עריכת קבצים.

מעבר לאלה יש עוד כמה sub-agents פנימיים לצרכים ספציפיים (למשל אחד שמופעל כשמריצים את הפקודה statusline, ואחד שעונה על שאלות לגבי Claude Code עצמו) - אלה בדרך כלל מופעלים אוטומטית ואתם לא צריכים לקרוא להם ישירות.

למה בכלל להפריד context בין סוכנים

הסיבה המרכזית להשתמש ב-sub-agents היא שימור context. תארו לעצמכם שאתם מבקשים מקלוד להריץ את כל חבילת הטסטים ולדווח על מה שנכשל. אם זה קורה בתוך השיחה הראשית, כל הפלט הארוך של הטסטים - כולל כל הטסטים שכן עברו - נכנס להיסטוריה שלכם ותופס מקום בחלון ה-context. עם sub-agent, הפלט המסיבי הזה נשאר בתוך ה-context הנפרד של הסוכן, וחוזרת אליכם רק התמצית: אילו טסטים נכשלו ולמה.

אותו עיקרון עובד גם כשרוצים להריץ כמה חקירות מקבילות לגמרי בלי תלות אחת בשנייה. למשל, לבקש לחקור בו זמנית את מודול ה-authentication, את שכבת ה-database ואת ה-API, כל אחד ב-sub-agent נפרד. כל סוכן חוקר את התחום שלו באופן עצמאי, ורק כשכולם מסיימים קלוד מרכיב את הממצאים לכדי תמונה אחת. זה בדיוק המודל שמזכיר "לידר שמנהל צוות": הוא לא צריך לדעת כל שורת קוד שכל אחד מהעובדים קרא, הוא צריך את הסיכום שממנו הוא יכול לקבל החלטה.

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

יתרון נוסף שקשור לזה הוא אכיפת מגבלות: אפשר להגביל בדיוק אילו כלים sub-agent מסוים מורשה להשתמש בהם. סוכן שתפקידו לקרוא קוד ולנתח אותו לא צריך גישה ל-Write או ל-Edit, וכך גם אם הוא "יטעה", הוא פיזית לא יכול לשנות קבצים. זה מנגנון בטיחות אמיתי, לא רק המלצה.

איך מגדירים Sub-agent מותאם אישית

Sub-agents מוגדרים כקבצי Markdown עם YAML frontmatter. יש כמה מיקומים אפשריים, שקובעים למי ה-sub-agent זמין:

• .claude/agents/ - סוכני פרויקט, ספציפיים לקודבייס אחד. כדאי להכניס לגיט כדי שכל הצוות ישתמש בהם ויוכל לשפר אותם ביחד.
• ~/.claude/agents/ - סוכנים אישיים שזמינים בכל הפרויקטים שלכם במחשב.
• בנוסף יש אפשרות להגדיר סוכנים דרך flag בשורת הפקודה לשימוש חד-פעמי בסשן, וגם דרך plugins להפצה רחבה יותר.

מבנה הקובץ פשוט: frontmatter ב-YAML, ואחריו גוף הטקסט שמהווה את ה-system prompt של הסוכן. השדות היחידים שחובה למלא הם name ו-description. הנה דוגמה בסיסית לקובץ בשם .claude/agents/code-reviewer.md: בחלק ה-frontmatter מגדירים name: code-reviewer, description: Reviews code for quality and best practices, tools: Read, Glob, Grep, ו-model: sonnet. ואחרי הקווים המפרידים בא גוף ה-prompt עצמו, למשל: "You are a code reviewer. When invoked, analyze the code and provide specific, actionable feedback on quality, security, and best practices."

כמה שדות שכדאי להכיר מעבר לבסיס:

• description - השדה הכי חשוב מבחינת ההאצלה האוטומטית. Claude משתמש בו כדי להחליט מתי לפנות לסוכן הזה, ולכן כדאי לכתוב תיאור ברור וממוקד. אם רוצים שקלוד יאציל לסוכן ביוזמתו, אפשר לכלול בתיאור ניסוח כמו "use proactively".
• tools - רשימת הכלים שהסוכן רשאי להשתמש בהם. אם משמיטים את השדה, הסוכן יורש את כל הכלים הזמינים ל-sub-agents. יש גם שדה disallowedTools שפועל כרשימה שחורה ומאפשר לרשת הכול חוץ מכלים ספציפיים.
• model - איזה מודל ירוץ: sonnet, opus, haiku, fable, מזהה מודל מלא, או inherit (ברירת המחדל, כלומר אותו מודל שהשיחה הראשית משתמשת בו). זו דרך מצוינת לחסוך בעלויות - למשל להריץ סוכני חיפוש פשוטים על Haiku.
• skills - שדה ל"טעינה מראש" (preload) של סקילים לתוך ה-context של הסוכן כבר בהפעלה, כך שהתוכן המלא שלהם זמין לו מהרגע הראשון ולא רק דרך גילוי עצמי במהלך העבודה.
• mcpServers - מאפשר לחשוף לסוכן שרתי MCP ספציפיים, כולל הגדרה מוטמעת שמתחברת רק בזמן ריצת הסוכן ומתנתקת בסיומו - שימושי כשרוצים לשמור על השיחה הראשית "נקייה" מתיאורי כלים שאינם רלוונטיים לה.
• permissionMode - קובע איך הסוכן מתמודד עם בקשות הרשאה (default, acceptEdits, dontAsk, bypassPermissions, plan ועוד).
• memory - מאפשר לסוכן זיכרון מתמשך שנשמר גם בין שיחות, ברמת user, project או local, כך שהוא יכול לצבור ידע לאורך זמן - למשל דפוסים חוזרים או החלטות ארכיטקטורה.
• background - האם הסוכן ירוץ תמיד ברקע.
• isolation: worktree - נותן לסוכן עותק מבודד של המאגר בעזרת git worktree, כדי שהוא לא יתנגש עם מה שקורה בסביבת העבודה הראשית.

שווה לשים לב לשני עקרונות שמופיעים בבירור בתיעוד: הסוכן מקבל רק את ה-system prompt שלו ופרטי סביבה בסיסיים (לא את כל ה-system prompt של Claude Code), וכל הפעלה של sub-agent פותחת חלון context חדש לגמרי - הוא לא רואה את היסטוריית השיחה שלכם, לא את הסקילים שכבר הופעלו ולא את הקבצים שכבר נקראו במסגרת השיחה הראשית. קלוד מרכיב הודעת משימה (task message) שמסכמת עבור הסוכן מה נדרש ממנו, וזה מה שהסוכן מקבל כנקודת פתיחה.

מתי Claude מאציל לבד, ומתי אתם קוראים לזה ישירות

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

כשההאצלה האוטומטית לא מספיקה, או שאתם רוצים לוודא בוודאות שסוכן ספציפי ירוץ, יש כמה דרכים לבקש את זה ישירות:

• שפה טבעית - פשוט לציין את שם הסוכן בבקשה, למשל "תשתמש בסוכן code-reviewer כדי לבדוק את השינויים האחרונים". קלוד עדיין מחליט אם להאציל בפועל.
• אזכור מפורש (@-mention) - הקלדת @ ובחירת הסוכן מתוך רשימת ההשלמה האוטומטית, בדיוק כמו שמאזכרים קובץ. זה מבטיח שהסוכן הספציפי הזה ירוץ, ולא משהו אחר שקלוד יבחר.
• ברירת מחדל לכל הסשן - אפשר להריץ סשן שלם עם flag שהופך sub-agent מסוים לסוכן הראשי של השיחה כולה, כך שה-system prompt, מגבלות הכלים והמודל שלו חלים על כל הסשן.

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

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

תרחיש עסקי אמיתי: פיצ׳ר עם באג-אנד, פרונט ובדיקות

נניח שאתם סוכנות שמפתחת פיצ׳ר Checkout חדש ללקוח מסחר אלקטרוני. המשימה כוללת שינוי ב-API של התשלומים, עדכון קומפוננטת React בצד הלקוח, ובדיקת רגרסיה על כל תהליך הרכישה. אם תבקשו מקלוד לעשות את כל זה ב"שיחה אחת שטוחה", אתם צפויים לראות: לוגים של הרצת השרת המקומי, פלט מלא של חבילת הטסטים, קטעי קוד שנקראו רק כדי להבין הקשר ולא באמת רלוונטיים להמשך - וכל זה נשאר ב-context ומקטין את מרחב החשיבה הזמין להמשך העבודה.

גישה מבוססת sub-agents נראית אחרת: מבקשים מקלוד לחקור את שכבת ה-API והלוגיקה העסקית של התשלומים ב-sub-agent אחד, את הקומפוננטה ב-React ואת ניהול ה-state בעוד אחד, ואת חבילת הטסטים הקיימת - כולל אילו טסטים כבר מכסים את התהליך הזה - בשלישי. שלושת הסוכנים חוקרים במקביל, כל אחד בתחום שלו, ומחזירים ממצא ממוקד: "ה-endpoint הרלוונטי הוא X, הוא כבר תומך בפרמטר Y", "הקומפוננטה מנהלת state מקומי ולא גלובלי, צריך התאמה", "יש שני טסטים קיימים שיישברו אם משנים את החתימה של הפונקציה". רק אחרי זה קלוד עצמו, בשיחה הראשית, מרכיב תוכנית מימוש מבוססת שלושת הדוחות האלה - ומכאן ממשיך לכתוב את הקוד בפועל.

ואפשר להרחיב את זה. אם יש לכם sub-agent קבוע בשם code-reviewer שמוגדר ב-.claude/agents/ ונטען לגיט, כל מפתח בצוות שיריץ Claude Code בפרויקט הזה יקבל אותה חוויית בדיקת קוד עקבית - אותם קריטריונים, אותה רמת יסודיות. זה בדיוק ההבדל בין "לבקש מ-AI לבדוק קוד" באופן אקראי לבין תהליך עבודה מתועד ומשוכפל, שדומה יותר לתהליך CI קבוע מאשר לשיחה חד-פעמית. אפשר גם לשרשר sub-agents אחד אחרי השני - למשל קודם code-reviewer שמאתר בעיות ביצועים, ואז optimizer שמתקן אותן על סמך הממצאים - כשכל סוכן מקבל מקלוד רק את מה שרלוונטי מהשלב הקודם.

נקודה שחשוב להכיר לפני שקופצים על זה בכל משימה: אם השלבים חולקים הרבה context משותף, או אם המשימה דורשת דיאלוג הלוך ושוב עם עידון הדרגתי, או שמדובר בשינוי קטן וממוקד - נשארים בשיחה הראשית. sub-agents מרוויחים הכי הרבה כשהעבודה עצמאית, מייצרת הרבה "רעש" שלא צריך לחזור אליכם, ואפשר לסכם אותה בבירור בסוף.

שאלות נפוצות

מה ההבדל בין sub-agent לבין skill?

Skill הוא פרומפט או תהליך עבודה שניתן לשימוש חוזר ורץ בתוך ה-context של השיחה הראשית עצמה. sub-agent, לעומת זאת, רץ בחלון context מבודד משלו, ומחזיר לשיחה הראשית רק תוצאה מסוכמת. אם רוצים context מבודד לחלוטין - זה sub-agent. אם רוצים פרומפט חוזר שמשפיע ישירות על השיחה הנוכחית בלי לפצל context - זה skill. חשוב לדעת: יש שילוב אפשרי בין השניים, כשמגדירים ב-sub-agent שדה skills לטעינה מראש של תוכן סקיל לתוך ההקשר שלו.

איך יודעים אם sub-agent רץ בחזית או ברקע, ואיך משנים את זה?

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

האם אפשר להגביל לגמרי אילו כלים sub-agent מסוים רשאי להשתמש בהם?

כן, וזה בדיוק אחד היתרונות המרכזיים. השדה tools בפרונטמטר פועל כרשימה לבנה - רק מה שרשום שם זמין לסוכן. השדה disallowedTools פועל הפוך, כרשימה שחורה שמסירה כלים ספציפיים מתוך המאגר שהסוכן יורש. אפשר גם לחסום גישה לכלי MCP שלמים לפי שם השרת. זה מאפשר, למשל, ליצור סוכן קריאה בלבד שפיזית לא יכול לערוך או לכתוב קבצים.

האם sub-agent "רואה" את מה שקרה קודם בשיחה הראשית?

לא, וזה בדיוק חלק מהרעיון. כל הפעלה של sub-agent פותחת context חדש ונקי לחלוטין - הוא לא רואה את היסטוריית השיחה, את הקבצים שכבר נקראו או את הסקילים שכבר הופעלו בשיחה הראשית. הוא מקבל רק את ה-system prompt שלו, הודעת המשימה שקלוד ניסח עבורו, וקבצי הגדרות פרויקט רלוונטיים. זה מה שמאפשר לו לשמור על context "נקי" ומרוכז במשימה שלו בלבד.

אפשר לגדל צוות שלם של סוכנים מותאמים אישית לפרויקט אחד?

כן. אפשר להגדיר כמה קבצי sub-agent שונים תחת .claude/agents/, כל אחד עם תיאור, כלים ומודל משלו, ולהכניס אותם לגיט כך שכל הצוות עובד עם אותה חלוקת תפקידים - למשל סוכן ל-code review, סוכן לבדיקות, וסוכן שמתמחה בשכבת ה-database. קלוד יכול גם לתאם ביניהם באופן אוטומטי לפי הצורך, ואפשר גם לשרשר אותם ביודעין - קודם אחד, ואז את התוצאה שלו מעבירים לשני.

יש הגבלה על כמה sub-agents אפשר להריץ בו-זמנית?

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

Sub-agents הם אחד הכלים שבאמת משנים איך פרויקט טכני גדול מתנהל מול Claude Code - מהקטנת רעש בשיחה הראשית ועד חלוקת עבודה אמיתית בין "מומחים" עם הרשאות מבוקרות. אם אתם רוצים להטמיע את זה נכון בתהליכי הפיתוח של הצוות שלכם, ולא רק להתנסות פעם אחת ולשכוח - אנחנו במדיה דיל בונים תשתיות Claude Code מותאמות לסוכנויות ולצוותי פיתוח, כולל sub-agents מוגדרים לפי צרכי הפרויקט הספציפי שלכם. מוזמנים לדבר איתנו בוואטסאפ.

תגיות: Claude Code · sub-agents · סוכני AI · אוטומציה לפיתוח · context window · AI לסוכנויות · פיתוח תוכנה עם AI

← חזרה לבלוג · צור קשר