📘 תיעוד 38

תזמור תתי-סוכנים בהיקף נרחב באמצעות תהליכי עבודה דינמיים

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

הערה: תהליכי עבודה דינמיים זמינים בכל התוכניות בתשלום, עם גישה ל-API של Anthropic, וכן ב-Amazon Bedrock, ב-Agent Platform של Google Cloud, וב-Microsoft Foundry. בתוכנית Pro, הפעל אותם משורת Dynamic workflows ב-/config.

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

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

#מתי להשתמש בתהליך עבודה

תתי-סוכנים (subagents), מיומנויות (skills), צוותי סוכנים (agent teams) ותהליכי עבודה (workflows) יכולים כולם להריץ משימה מרובת שלבים. ההבדל הוא מי מחזיק בתוכנית:

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

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

#הרצת תהליך עבודה מובנה

הדרך המהירה ביותר לראות תהליך עבודה בפעולה היא להריץ את /deep-research, תהליך העבודה המובנה ש-Claude Code כולל לצורך חקירת שאלה על פני מקורות רבים. תראה סוכנים עובדים דרך סדרה של שלבים ברקע בזמן שההפעלה שלך נשארת פנויה, ותקבל דוח אחד בסיום במקום תמליל של צעד אחר צעד.

1. הרצת תהליך העבודה: הרץ את /deep-research עם שאלה שברצונך לחקור. הוא מפיץ חיפושים ברשת על פני כמה זוויות, מביא ומצליב את המקורות שהוא מוצא, ומסנתז דוח עם ציטוטים.

/deep-research What changed in the Node.js permission model between v20 and v22?

2. אישור תהליכי עבודה: Claude Code שואל האם לאפשר את תהליך העבודה. בחר ב-Yes כדי להמשיך. הבקשה המדויקת תלויה במצב ההרשאות שלך. ראה אישור התוכנית לפני שהיא רצה עבור האפשרויות לכל מצב.

3. מעקב אחר ההתקדמות: הריצה מתחילה ברקע. הרץ את /workflows, השתמש במקשי החצים כדי לבחור את הריצה, ולחץ על Enter כדי לפתוח את תצוגת ההתקדמות שלה:

/workflows

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

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

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

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

כדי להריץ תהליך עבודה עבור משימה משלך, בקש מ-Claude לכתוב אחד, ולאחר שריצה מבצעת את מה שרצית תוכל לשמור אותה כפקודה משלך.

#תהליכי עבודה מובנים

Claude Code כולל את /deep-research כתהליך עבודה מובנה:

הפקודה /deep-research רצה רק כאשר אתה מפעיל אותה.

תהליכי עבודה שאתה שומר בעצמך הופכים לפקודות באותו אופן ומופיעים בהשלמה האוטומטית של / לצד הפקודות המובנות.

#מעקב אחר הריצה

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

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

#לבקש מ-Claude לכתוב תהליך עבודה

באפשרותך לבקש מ-Claude לכתוב תהליך עבודה עבור המשימה שלך בשתי דרכים:

• בקש תהליך עבודה בהנחיה שלך, במילים שלך או על ידי הכללת מילת המפתח ultracode, ו-Claude יכתוב אחד עבור המשימה.
• תן ל-Claude להחליט באמצעות ultracode: הגדר /effort ultracode ו-Claude יתכנן תהליך עבודה עבור כל משימה מהותית בהפעלה.

באפשרותך גם להריץ פקודת תהליך עבודה שכבר קיימת: תהליך עבודה מובנה כמו /deep-research, או תהליך עבודה ששמרת.

#בקשת תהליך עבודה בהנחיה שלך

כדי להריץ משימה בודדת כתהליך עבודה מבלי לשנות את רמת המאמץ של ההפעלה, כלול את מילת המפתח ultracode בהנחיה שלך. בקשה במילים שלך, למשל "use a workflow" או "run a workflow", פועלת גם כן: Claude מתייחס לבקשה ישירה כאותה הסכמה להצטרפות.

ultracode: audit every API endpoint under src/routes/ for missing auth checks

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

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

#ביטול או כיבוי מילת המפתח

אם לא התכוונת להפעיל תהליך עבודה, לחץ על Option+W ב-macOS או על Alt+W ב-Windows וב-Linux כדי לבטל את ההדגשה עבור הנחיה זו, או לחץ על Backspace כאשר הסמן נמצא מיד לאחר מילת המפתח המודגשת. כדי למנוע ממילת המפתח לפעול בכלל, כבה את Ultracode keyword trigger ב-/config.

#היכן מילת המפתח עובדת

מילת המפתח מהווה הסכמה להצטרפות רק בהנחיה שאתה מקליד בעצמך: בשורת הפקודה האינטראקטיבית, בחלונית של הרחבת ה-IDE, בלקוח של Remote Control, או ביישום של Agent SDK שמחתים את קלט המקלדת שלך בשדה origin כ-{ kind: "human" }. היא אינה מפעילה תהליך עבודה כאשר היא מגיעה להפעלה בדרך אחרת:

• הנחיה שמועברת עם -p
• הנחיה שיישום Agent SDK שולח מבלי להחתים אותה כקלט אנושי
• הנחיה של משימה מתוזמנת
• מטען של webhook או הערה ב-pull request שמועברים לתוך השיחה

הערה: לפני גרסה v2.1.210, מילת המפתח הפעילה תהליך עבודה גם מכל אחד מהנתיבים הללו, כולל מטען של webhook או הערה ב-pull request שהועברו לתוך השיחה.

#לתת ל-Claude להחליט באמצעות ultracode

ultracode היא הגדרה ב-Claude Code המשלבת מאמץ חשיבה ברמת xhigh עם תזמור אוטומטי של תהליכי עבודה. כאשר היא מופעלת, Claude מתכנן תהליך עבודה עבור כל משימה מהותית במקום להמתין שתבקש.

/effort ultracode

כדי להתחיל הפעלה שבה ultracode כבר מופעל, הפעל באמצעות claude --effort ultracode. דורש את Claude Code בגרסה v2.1.203 ואילך.

כדי להפעיל אותה בזמן בחירת מודל, העבר את מחוון המאמץ בבורר של /model אל ultracode באמצעות מקשי החצים. הסעיף התאמת רמת המאמץ מפרט את הדרכים שמפעילות את ultracode.

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

הפקודה /effort ultracode תקפה להפעלה הנוכחית. כדי שכל הפעלה תתחיל עם הגדרה זו, קבע את ההגדרה ultracode. חזור אחורה באמצעות /effort high כאשר אתה חוזר לעבודה שגרתית. ההגדרה זמינה במודלים התומכים במאמץ xhigh, במודלים אחרים התפריט /effort אינו מציע אותה.

#אישור התוכנית לפני שהיא רצה

בממשק שורת הפקודה (CLI), הבקשה שמופיעה לפני כל ריצה מציגה את השלבים המתוכננים ואת האפשרויות הבאות:

• Yes, run it: התחלת הריצה
• Yes, and don't ask again for <name> in <path>: התחלה, ודילוג על בקשה זו עבור תהליך עבודה זה בפרויקט זה מעתה ואילך. Claude Code מציע אפשרות זו כאשר אתה מריץ לפי שם תהליך עבודה מובנה, שמור או כזה ששייך לתוסף, ולא עבור סקריפט ש-Claude כתב עבור המשימה הנוכחית.
• View raw script: קריאת הסקריפט לפני שמחליטים
• No: ביטול

המקש Ctrl+G פותח את הסקריפט בעורך שלך. המקש Tab מאפשר לך להתאים את ההנחיה לפני שהריצה מתחילה.

השאלה אם תראה בקשה זו תלויה במצב ההרשאות שלך:

ב-claude -p וב-Agent SDK, Claude Code לעולם אינו מציג בקשה זו. הוא מעביר את קריאת הכלי Workflow דרך אותה הערכת הרשאות כמו שאר ההפעלה, כך שכללי דחייה, כללי שאלה ומצב dontAsk חלים על ההפעלה כפי שהם חלים על כל קריאת כלי. כדי לאפשר לתהליך העבודה להתחיל בריצות אלה, השתמש באחת מהדרכים הבאות:

• כלל הרשאה: Workflow בכללי ההרשאה שלך מאשר כל תהליך עבודה, ו-Workflow(<name>) מאשר תהליך עבודה שמור יחיד לפי שמו.
• מצב הרשאה אוטומטי: המסווג בודק את הקריאה ויכול לאשר אותה.
• מצב עקיפת הרשאות: Claude Code מאשר את הקריאה.
• נקודת חיבור PreToolUse: נקודת חיבור שמחזירה allow עבור הקריאה מאשרת אותה.
• המארח שלך: דגל --permission-prompt-tool מאשר אותה, או, ב-Agent SDK, פונקציית משוב מסוג canUseTool או נקודת חיבור PermissionRequest מאשרים אותה.

ביישום השולחני (Desktop), כרטיס אישור מציג את שם תהליך העבודה, רשימת השלבים ואזהרת שימוש באסימונים, עם הפעולות Once, Always ו-Deny. תצוגת ההתקדמות מופיעה בחלונית הצד של משימות רקע.

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

#שמירת תהליך העבודה לשימוש חוזר

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

הרץ את /workflows, בחר את הריצה שברצונך לשמור, ולחץ על s. בתיבת הדו-שיח של השמירה, Tab מחליף בין שני מיקומי שמירה:

• .claude/workflows/ בפרויקט שלך: משותף עם כל מי שמשכפל את המאגר.
• ~/.claude/workflows/ בתיקיית הבית שלך: זמין בכל פרויקט, גלוי רק לך. אם הגדרת את CLAUDE_CONFIG_DIR, מיקום זה הוא ספריית workflows/ תחת נתיב זה.

תיבת הדו-שיח של השמירה מציגה את הנתיב המפוענח עבור המיקום האישי.

לחץ על Enter כדי לשמור. תהליך העבודה ירוץ כ-/<name> בהפעלות עתידיות מכל אחד משני המיקומים.

Claude Code בודק את מיקום השמירה לאיתור קישורים סמליים (symlinks) לפני הכתיבה, ומציג שגיאה במקום לכתוב דרך קישור סמלי. מה שהוא בודק תלוי במיקום שבו אתה שומר:

• מיקום הפרויקט: Claude Code מסרב אם .claude, .claude/workflows או קובץ היעד הם קישור סמלי.
• מיקום אישי: Claude Code מסרב רק אם קובץ היעד עצמו הוא קישור סמלי, כך שספריית ~/.claude המנוהלת על ידי כלי dotfiles עדיין פועלת.

לפני גרסה v2.1.216, Claude Code עקב אחר הקישור, דבר שעלול היה למקם את הקובץ מחוץ למיקום שבחרת.

ב-monorepo עם מספר ספריות .claude/, באפשרותך לשמור תהליכי עבודה לצד החבילה שעליה הם חלים. החל מגרסה v2.1.178, שמירה במיקום הפרויקט כותבת לספריית .claude/workflows/ הקרובה ביותר שכבר קיימת בין ספריית העבודה שלך לבין שורש המאגר, או לשורש המאגר אם אף ספרייה כזו עדיין אינה קיימת. תהליכי עבודה של הפרויקט נטענים גם מכל ספריית .claude/workflows/ לאורך נתיב זה, וכאשר יותר מתהליך עבודה אחד מגדיר את אותו השם, Claude Code מריץ את זה שהכי קרוב לספריית העבודה.

אם תהליך עבודה של פרויקט ותהליך עבודה אישי חולקים את אותו השם, תהליך העבודה של הפרויקט הוא זה שרץ.

#הפצת תהליך עבודה בתוסף

כדי לשתף תהליך עבודה בין צוותים או מאגרים, כלול אותו בתוסף (plugin). מקם את הסקריפט בספריית workflows/ בשורש התוסף, או הצבע על מיקום שונה באמצעות שדה המניפסט workflows.

תהליכי עבודה בתוסף מקבלים מרחב שמות לפי שם התוסף. תוסף בשם acme-tools המכיל סקריפט שבו meta.name הוא release-audit ירוץ בתור /acme-tools:release-audit.

#העברת קלט לתהליך עבודה שמור

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

ההנחיה הבאה מריצה תהליך עבודה שמור עם רשימה של מספרי issues:

Run /triage-issues on issues 1024, 1025, and 1030

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

#דוגמאות להנחיות של תהליכי עבודה

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

#ביקורת של קבצים רבים לאיתור אותה הבעיה

פיזור סוכן אחד לכל קובץ, ולאחר מכן איסוף ואימות הממצאים.

use a workflow to audit every route handler under src/routes/ for missing authentication checks, and adversarially verify each finding before reporting it

#המשך תיקון עד שבדיקה עוברת

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

use a workflow to run npx tsc --noEmit and keep fixing the reported errors until the type check passes or two rounds in a row make no progress

#העברת קבצים רבים במקביל

איתור הקבצים להעברה, המרת כל אחד מהם בעותק מבודד כדי שעריכות לא יתנגשו, ואימות של כל תוצאה.

use a workflow to migrate every component under src/components/ from JavaScript to TypeScript, working on each file in its own isolated copy

#סקירה של כל קובץ שהשתנה וכתיבת סיכום אחד

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

use a workflow to review every file changed in this PR for correctness issues, then merge the per-file findings into one ranked summary

#מחקר נושא על פני מקורות רבים

פיזור קוראים על פני יומני שינויים, issues ותיעוד, ולאחר מכן סינתזה. תהליך העבודה המובנה /deep-research עושה זאת, באפשרותך גם לתאר גרסה ממוקדת יותר.

use a workflow to research how our three competitors handle rate limiting: read their public docs and recent changelog entries in parallel, then compare the approaches

#מציאת בעיות עד שהרשימה מפסיקה לגדול

המשך חיפוש בסבבים ועצירה כאשר סבבים חדשים אינם מגלים שום דבר חדש.

use a workflow to find flaky tests in this repo: run the suite repeatedly, record which tests fail intermittently, and stop once two rounds in a row find nothing new

#כיצד נראה הסקריפט השמור

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

export const meta = {
  name: 'audit-routes',
  description: 'Audit every route handler for missing auth checks',
}

const found = await agent('List every .ts file under src/routes/.', {
  schema: { type: 'object', required: ['files'], properties: { files: { type: 'array', items: { type: 'string' } } } },
})

const audits = await pipeline(found.files, file =>
  agent(`Audit ${file} for missing authentication checks.`, { label: file }),
)

return audits.filter(Boolean)

גוף הסקריפט הוא JavaScript רגיל עם await ברמה העליונה. הפונקציה agent() מפעילה תת-סוכן אחד, pipeline() מריצה סוכן אחד לכל פריט ברשימה, ו-parallel() מריצה קבוצה של משימות סוכנים בו-זמנית וממתינה לכולן.

קריאה ל-agent() מניבה null אם אתה עוצר אותה באמצע הריצה או אם היא נתקלת בשגיאת API שלא ניתן להתאושש ממנה. הפונקציה pipeline() שומרת את ה-null הזה במערך התוצאות, וזו הסיבה שהדוגמה מסתיימת ב-.filter(Boolean) כדי להשמיט רשומות אלו.

#עריכת סקריפט שמור

כדי לשנות תהליך עבודה ששמרת, ערוך את קובץ ה-.js שלו או בקש מ-Claude לבצע את השינוי. לפני שאתה עורך או מבקש, הרץ את המיומנות המובנית /workflow-authoring כדי לטעון את מדריך ההתייחסות לכתיבת סקריפטים שממנו Claude עובד. המיומנות דורשת את Claude Code בגרסה v2.1.248 ואילך.

כדי להריץ את הגרסה הערוכה בהפעלה הנוכחית, הרץ את /reload-skills כדי לקרוא מחדש את ספריות תהליכי העבודה, ולאחר מכן הרץ שוב את /<name>.

Claude Code מחיל את הכללים הבאים על כל חלק בקובץ כאשר הוא טוען ומריץ את הסקריפט:

• בלוק meta: השאר את export const meta כהצהרה הראשונה, ושמור עליו כאובייקט ליטרלי פשוט עם name ו-description. אם הוא מכיל משהו שאינו ערכים ליטרליים, כגון משתנה, קריאה לפונקציה או פיזור, Claude Code משמיט את /<name> מההשלמה האוטומטית של /.
• גוף הסקריפט: מלבד agent(), pipeline() ו-parallel(), באפשרותך לקרוא ל-phase() כדי לקבץ את הסוכנים הבאים תחת כותרת בתצוגת ההתקדמות, לקרוא ל-log() כדי להציג הודעה מעל השלבים, ולקרוא את המשתנה הגלובלי args. אם בגוף הסקריפט יש שגיאת תחביר, Claude Code ידווח עליה בעת הרצת תהליך העבודה.
• phases: אם אתה מפרט אותם ב-meta, תן לכל רשומה בדיוק את אותה הכותרת שאתה מעביר ל-phase(). כותרת phase() ללא רשומה מקבלת קבוצת התקדמות משל עצמה.
• חותמות זמן ואקראיות: Claude Code גורם ל-Date.now(), ל-Math.random() ול-new Date() ללא ארגומנטים לזרוק שגיאה בתוך הסקריפט, כדי שריצה שמופעלת מחדש תחזור על אותן קריאות agent(). העבר חותמת זמן דרך args במקום זאת.

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

#כיצד תהליך עבודה רץ

סביבת הריצה של תהליך העבודה מריצה את הסקריפט בסביבה מבודדת, נפרדת מהשיחה שלך. תוצאות ביניים נשארות במשתני סקריפט במקום לנחות בהקשר של Claude.

כל ריצה כותבת את הסקריפט שלה לקובץ תחת ספריית ההפעלה שלך ב-~/.claude/projects/. Claude מקבל את הנתיב עם תחילת הריצה, כך שתוכל לבקש אותו. באפשרותך לפתוח קובץ זה כדי לקרוא את התזמור ש-Claude כתב, להשוות אותו מול סקריפט של ריצה קודמת, או לערוך אותו ולבקש מ-Claude להפעיל מחדש מהגרסה הערוכה.

Claude יכול להתחיל תהליך עבודה רק מקובץ סקריפט שלהפעלה כבר מותר לקרוא. כדי להריץ סקריפט שנשמר מחוץ לספריית העבודה שלך, הוסף תחילה את הספרייה שלו באמצעות /add-dir או באמצעות כלל הרשאת קריאה תחילה.

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

#שמירת הנחיות במטמון בהפצה מרובת סוכנים

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

בקשות של סוכן בתהליך עבודה נופלות מחוץ למכל ה-TTL של מטמון השיחה הראשית, ולכן המטמון שלו נשמר למשך חמש דקות כברירת מחדל, כולל במנוי Claude. כדי לשמור אותו למשך שעה, הגדר את subagentPromptCacheTtl ל-1h. ה-API מחייב כתיבות מטמון של שעה אחת בתעריף גבוה יותר.

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

#התנהגות ומגבלות

סביבת הריצה מחילה את המגבלות הבאות:

#ניהול ריצות

ברגע שריצה מתחילה, אתה מנהל אותה מתצוגת /workflows, או על ידי הרחבת שורת ההתקדמות שלה בחלונית המשימות שמתחת לתיבת הקלט.

#חידוש לאחר השהיה

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

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

מקרה אחרון זה אומר שכישלון באמצע הפצה מרובת סוכנים מריץ מחדש עבודה שכבר הסתיימה. אם סקריפט מתחיל את A, B, C ו-D בסדר זה ו-B נכשל, הפעלה מחדש מחזירה את A מהמטמון ומריצה את B, C ו-D שוב.

באפשרותך לחדש ריצה בתוך אותה הפעלת Claude Code. מה שקורה לתהליך עבודה פעיל כאשר אתה עוזב את ההפעלה תלוי באופן שבו אתה עוזב:

• אם אתה מעביר את ההפעלה לרקע, Claude Code מנגן מחדש את הריצה באותו אופן בהפעלת הרקע וממשיך אותה.
• אם אתה יוצא מ-Claude Code בזמן שתהליך עבודה רץ ותצוגת סוכן מופעלת, תיבת הדו-שיח של היציאה מציעה את Move to background and exit, פעולה שמעבירה את הריצה באותו אופן. אם תבחר ב-Exit and stop tasks במקום זאת, או אם האפשרות אינה מוצעת, הריצה תיעצר יחד עם ההפעלה. Claude Code שומר את התוצאות השמורות של הריצה תחת ספריית אותה הפעלה ב-~/.claude/projects/, כך שהפעלה שתחדש באמצעות claude --resume תוכל לנגן אותן מחדש כשתבקש מ-Claude להפעיל מחדש את תהליך העבודה, בעוד שהפעלה שתתחיל מחדש אינה כוללת דבר לניגון מחדש ותתחיל את תהליך העבודה מההתחלה.

#עלויות

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

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

Claude Code גם מסמן ריצה שגדלה באופן חריג. כאשר תהליך עבודה מתזמן יותר מ-25 סוכנים, או שכמות האסימונים החזויה שלו עוברת 1.5 מיליון, שורת ההתקדמות שלו בחלונית המשימות שמתחת לתיבת הקלט מציגה אזהרת Large workflow. האזהרה מפנה אותך אל /workflows, שם תוכל לעצור את הריצה.

האזהרה היא בגדר המלצה בלבד: היא אינה משהה או מגבילה את הריצה. שתי הגדרות משנות את מועד הופעתה:

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

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

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

• בדוק את /model לפני ריצה גדולה אם אתה נוהג לעבור למודל קטן יותר עבור עבודה שגרתית.
• בקש מ-Claude להשתמש במודל קטן יותר עבור שלבים שאינם זקוקים למודל החזק ביותר כאשר אתה מתאר את המשימה.

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

#הגדרת הנחיית גודל

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

כל ערך ממופה לספירת סוכנים:

ברירת המחדל היא medium. עד שתבחר ערך, השורה ב-/config מציגה medium (default) ושורת Running in background של תהליך העבודה מציגה medium size (/config). דורש את Claude Code בגרסה v2.1.219 ואילך, גרסאות קודמות מוגדרות כברירת מחדל ל-unrestricted.

כדי לשנות את ההנחיה, בחר ערך עבור ההגדרה Dynamic workflow size ב-/config, או הרץ /config workflowSizeGuideline=small. בגרסה v2.1.219 ואילך, באפשרותך גם להגדיר את המפתח workflowSizeGuideline בכל קובץ הגדרות, ערך זה מקבל עדיפות על פני /config, ו-Claude Code מסתיר את השורה ב-/config כאשר קובץ הגדרות מספק ערך כזה.

השינויים נכנסים לתוקף בהנחיה הבאה. מגבלות הסוכנים של סביבת הריצה עדיין חלות ללא קשר להגדרה.

#כיבוי תהליכי עבודה

תהליכי עבודה זמינים ב-CLI, ביישום השולחני, בהרחבות ה-IDE, במצב לא-אינטראקטיבי עם claude -p, וב-Agent SDK. אותן הגדרות השבתה חלות בכל הממשקים.

כדי לכבות תהליכי עבודה עבור עצמך:

• העבר את Dynamic workflows למצב כבוי ב-/config. נשמר על פני הפעלות.
• הגדר "disableWorkflows": true ב-~/.claude/settings.json. נשמר על פני הפעלות.
• הגדר CLAUDE_CODE_DISABLE_WORKFLOWS=1. נקרא בעת ההפעלה, ולכן חל בכל מקום שבו הגדרת אותו.

כדי לכבות תהליכי עבודה עבור כל הארגון שלך, הגדר "disableWorkflows": true בהגדרות מנוהלות, או השתמש במתג בדף ההגדרות של מנהל Claude Code.

כאשר תהליכי עבודה מושבתים, פקודות תהליכי העבודה המובנות ומיומנות /workflow-authoring אינן זמינות, מילת המפתח ultracode אינה מפעילה עוד ריצה, ו-ultracode מוסר מתפריט /effort.

#משאבים קשורים

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