📘 תיעוד 45

תזמור סוכני משנה בקנה מידה גדול עם תהליכי עבודה דינמיים

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

[!NOTE]

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

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

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

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

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

תהליך עבודה מעביר את התוכנית אל הקוד. עם סוכני משנה, מיומנויות וצוותי סוכנים, 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 כדי לפתוח את תצוגת ההתקדמות שלה:

/workflows

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

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

4. קריאת הדוח

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

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

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

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

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

/deep-research רץ רק כשאתם מפעילים אותו.

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

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

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

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

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

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

#תן לקלוד לכתוב תהליך עבודה

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

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

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

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

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

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

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

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

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

אם לא התכוונת להתחיל תהליך עבודה, לחץ 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 שהועברו לשיחה

#תן לקלוד להחליט עם ultracode

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

/effort ultracode

כדי להתחיל סשן כש ultracode כבר פועל, הפעל עם claude --effort ultracode, מה שגם מגדיר את רמת המאמץ ל xhigh.

כדי להפעיל אותו ממחוון /effort, לחץ Tab כדי להפוך את המתג Ultracode, ואז Enter כדי להחיל אותו. התאם את רמת המאמץ מפרט את המסלולים שמפעילים את ultracode.

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

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

• האזהרה Large workflow לא מופיעה בהרצת תהליך עבודה
• מגבלת תת הסוכנים המקבילים של הסשן לא נאכפת על תת הסוכנים שקלוד מפעיל באמצעות הכלי Agent
• במצב הרשאה אוטומטי לא מבקשים ממך לאשר את השקת תהליך העבודה הראשונה

/effort ultracode תקף לסשן הנוכחי. כדי שכל סשן יתחיל איתו, הגדר את ההגדרה ultracode. כבה אותו עם /effort ultracode off כשחוזרים לעבודה שוטפת. מחוון /effort מציע את המתג רק כש ultracode זמין. לפני v2.1.284, /effort ultracode הגדיר את הסשן ל xhigh, ו /effort ultracode off נכשל עם Invalid argument.

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

ב CLI, ההנחיה של כל הרצה מציגה את השלבים המתוכננים ואת האפשרויות האלה:

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

Ctrl+G פותח את הסקריפט בעורך שלך. כש Yes, run it או No נבחרים, לחץ Tab כדי להוסיף תגובה לתשובה שלך.

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

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

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

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

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

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

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

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

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

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

Claude Code בודק את מיקום השמירה לאיתור symlink לפני הכתיבה, ומציג שגיאה במקום לכתוב דרך אחד:

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

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

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

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

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

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

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

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

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

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

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

#דוגמאות להנחיות לזרימת עבודה

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

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

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

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 ואחריו גוף סקריפט שמתזמר תת-סוכנים. בדרך כלל אין צורך לערוך אותו, אבל הנה הצורה של סקריפט קטן כדי שתוכל לזהות את מה שקלוד יצר:

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) כדי להשמיט את הרשומות האלה, כולל המקום של סוכן שנתקע בכל ניסיון.

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

אם מעבירים schema בקריאה ל-agent(), תת-הסוכן מחזיר JSON שתואם לצורה במקום פרוזה. Claude Code בודק את הסכמה לפני הפעלת תת-הסוכן: כשהוא יכול להוכיח שהסכמה סותרת את עצמה, הקריאה נכשלת עם שגיאה שמציינת את הסתירה, ותת-הסוכן לא מופעל. סתירה אחת שהוא יכול להוכיח היא מפתח required ש-additionalProperties: false פוסל.

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

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

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

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

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

• בלוק meta: השאר את export const meta כמשפט הראשון, והשאר אותו כאובייקט מילולי פשוט עם name ו-description. אם הוא מכיל משהו שאינו ערכים מילוליים, כמו משתנה, קריאת פונקציה, או spread, 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 Code כותב את הסקריפט של הריצה לקובץ תחת תיקיית הסשן שלך ב-~/.claude/projects/. קלוד מקבל את נתיב הסקריפט כשהריצה מתחילה, אז אפשר לבקש אותו. אפשר לפתוח את הקובץ כדי לקרוא את התזמור שקלוד כתב, להשוות אותו מול סקריפט של ריצה קודמת, או לערוך אותו ולבקש מקלוד להפעיל מחדש מהגרסה הערוכה.

קלוד יכול להתחיל זרימת עבודה רק מקובץ סקריפט שהסשן כבר מורשה לקרוא. כדי להריץ סקריפט שנשמר מחוץ לתיקיית העבודה, הוסף את התיקייה שלו עם /add-dir או עם כלל הרשאת Read קודם.

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

#שמירת מטמון של הנחיות בפיזור

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

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

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

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

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

#ניהול הרצות

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

כשעוצרים הרצה, היא נשארת בלוח המשימות כל עוד תהליכים של סוכנים שלה עדיין רצים. אם עוצרים אותה שוב, Claude Code משדר שוב איתות לתהליכים האלה.

#המשך אחרי השהיה

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

#אילו סוכנים רצים שוב

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

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

  לפני v2.1.305, סוכנים שהושלמו יכלו גם לרוץ שוב כשהפעלת מחדש סקריפט שלא נערך, ופריטי pipeline() או משימות parallel() שלו הריצו יותר מסוכן אחד כל אחד. כדי לעצור את הריצות החוזרות האלה להרצות חדשות, עדכן את Claude Code.

• עדיין רץ כשעצרת: מתחיל מחדש. עצירת כל ההרצה לא נחשבת ככישלון של אף סוכן.

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

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

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

#המשך אחרי שעוזבים את הסשן

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

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

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

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

#כשהרצה מגיעה למגבלת השימוש שלך

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

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

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

• הסשן אינטראקטיבי ומחובר עם מנוי claude.ai. הרצה לא מושהית במצב לא אינטראקטיבי עם claude -p או עם Agent SDK, בסשן רקע, או בסשן של עמית ב-Remote Control או בצוות סוכנים.
• autoContinueAtUsageLimit מופעל, אותה הגדרה שמאפשרת לסשן עצמו להמתין לאיפוס מגבלת שימוש. אם מכבים אותו במהלך המתנה, ההמתנה מסתיימת והסוכנים הממתינים נכשלים.
• המגבלה מתאפסת בתוך 24 שעות. מגבלה שבועית יכולה להתאפס רחוק יותר.
• ההרצה לא המתינה כבר פעמיים. כשהיא מגיעה למגבלה בפעם השלישית, הסוכן נכשל.

#כשסוכן נתקע ומתחיל מחדש

סוכן שהפלט שלו מפסיק להגיע לזמן ארוך מספיק מתחיל מחדש מאותו פרומפט. ב-/workflows, השם שלו מקבל סיומת (retry 1) והפירוט שלו מציג attempt 2 (stalled). ההתחלה מחדש אוטומטית, כך שאין צורך לעשות דבר.

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

סוכן מתחיל מחדש לכל היותר חמש פעמים, כולל כל התחלה מחדש שמבקשים עם r. אם גם הניסיון השישי נתקע, הקריאה ל-agent() נכשלת, ותחילת השגיאה אומרת למה:

• agent stalled on all 6 attempts: כל ניסיון עבר את כל החלון בלי פלט. אם העבודה של הסוכן משאירה אותו שקט כל כך הרבה זמן, הארך את החלון
• agent lost its reply on all 6 attempts: זרם התגובה של כל ניסיון השתתק ו-Claude Code ויתר על ההמתנה לו. הארכת חלון התקיעה לא עוזרת, כי streaming idle watchdog סיים את התגובה קודם ו-CLAUDE_STREAM_IDLE_TIMEOUT_MS קובע את ה-timeout של ה-watchdog הזה
• agent abandoned after 6 attempts: הניסיונות הסתיימו בדרכים שונות, שהשגיאה מפרטת לפי הסדר

כדי לתת לסוכן יותר זמן לייצר פלט לפני שהחלון נגמר:

• סוכן אחד: העבר stallMs באלפיות שנייה בקריאה ל-agent() שלו, למשל agent(prompt, { stallMs: 1800000 }) ל-30 דקות
• כל סוכן: הגדר CLAUDE_ASYNC_AGENT_STALL_TIMEOUT_MS, שחל גם על תת-סוכנים מחוץ ל-workflows

האם ההרצה ממשיכה אחרי הכישלון תלוי באיך הסקריפט קרא לסוכן:

• בתוך parallel() או pipeline(): ההרצה ממשיכה עם null במקום תוצאת הסוכן
• בהמתנה ישירה: ההרצה מסתיימת עם השגיאה

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

#עלות

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

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

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

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

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

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

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

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

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

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

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

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

ברירת המחדל היא medium, או small כשמחוברים בתוכנית Pro עם Claude Code v2.1.271 או חדש יותר. עד שבוחרים ערך, שורת /config מסמנת את הערך כברירת המחדל, ושורת Running in background של ה-workflow מציינת את הגודל שבתוקף.

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

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

#כיבוי workflows

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

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

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

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

כש-workflows כבויים:

• /workflows, פקודות ה-workflow, והמיומנות /workflow-authoring לא זמינים
• מילת המפתח ultracode כבר לא מפעילה הרצה, ומתג Ultracode מוסר מ-/effort

הרצה שכבר הייתה בעיצומה ממשיכה.

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

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

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