מבוא: מלופים לגרפים
בשבועות האחרונים כולם עברו לדבר על גרפים במקום על לופים, וזה קצת מבלבל. בפועל מדובר בשתי דרכים שונות להריץ סוכן AI על משימה. במדריך הזה נפרק בדיוק מה ההבדל ביניהם, למה גרף יוצא מהר וזול יותר, ואיך בונים גרף (מה שנקרא ב-Claude Code בשם Dynamic Workflow) צעד אחרי צעד.
אם כבר עבדתם עם Claude Code, יש סיכוי טוב שכבר הרצתם גרף בלי לשים לב.
הריל שעליו מבוסס המדריך: מהנדסת לופים להנדסת גרפים
מה זה לופ
לופ הוא סוכן אחד שמקבל מטרה ורץ עליה בקו ישר: עושה צעד, בודק את עצמו, וממשיך לצעד הבא. אחד אחרי השני, עד שהוא מגיע ליעד. את הצורה הזו אתם כנראה כבר מכירים, נותנים לקלוד מטרה, והוא רץ איתה לבד עד הסוף.
הבעיה: כל צעד ממתין לצעד שלפניו, גם כשאין ביניהם שום תלות. נוצרת שרשרת שרצה שלב אחרי שלב, וזה מאוד איטי, גם חלקים שיכלו לרוץ במקביל תקועים בתור ומחכים.
בלופ כל צעד ממתין לקודם, גם כשאין ביניהם שום קשר
מה זה גרף
גרף מפרק את המשימה. במקום סוכן אחד שטוחן את הכול לבד, מפצלים את המשימה לחלקים, וכל חלק מקבל סוכן משלו.
במקום סוכן יחיד שטוחן את כל המשימה לבד
כל חלק כזה נקרא נוד (node): סוכן שרץ בנפרד, עם הקונטקסט שלו בלבד. במקום קונטקסט אחד ענקי, לכל נוד יש בדיוק את המידע שהוא צריך.
מפצלים את המשימה לנודים, כל נוד עם קונטקסט משלו
הנודים מחוברים ביניהם ב-edges (קשתות). ה-edges לא רק מעבירים מידע בין נוד לנוד, אלא גם קובעים את סדר הריצה, מי רץ אחרי מי. נודים שאין ביניהם תלות רצים במקביל.
הנודים מחוברים ב-edges שמעבירים מידע וגם קובעים סדר ריצה
דוגמה: תכנון, כתיבה, ביקורת, תיקון
ניקח משימה קלאסית: לתכנן, לכתוב, לבקר ולתקן.
בלופ זה רץ בטור: סבב שלם, אחד אחרי השני. ואם צריך תיקון או עוד סבב ביקורת, זה שוב רץ אחד אחרי השני.
בגרף מריצים במקביל רק את החלקים שאין ביניהם תלות. למשל, במקום לבקר ב-3 סבבים נפרדים, שולחים 3 מבקרים שונים בו-זמנית ומאחדים את כל ההערות בבת אחת. מה שבלופ לקח 3 סבבים, בגרף קורה בסבב אחד.
מה שבלופ לוקח 3 סבבים, בגרף קורה בסבב 1
מהיר יותר, וגם זול יותר
אפשר לחשוב על זה כמו ההבדל בין עובד יחיד שעושה הכול שלב אחרי שלב, לבין צוות שכל אחד לוקח חלק בו-זמנית.
וזה לא רק מהיר יותר, זה גם זול יותר. לחלקים הפשוטים אפשר לתת מודל קטן וזול (למשל Haiku), ולשמור את המודל החזק (Opus) רק לחלקים שבאמת דורשים אותו. לא צריך להפעיל את המודל הכי גדול על כל דבר.
עובד יחיד מול צוות, ולכל נוד המודל שמתאים לו
השמות: Dynamic Workflow, גרף, ו-Graph Engineering
קל להתבלבל בין המושגים, אז נסדר אותם:
| מושג | מה זה |
|---|---|
Dynamic Workflow | שם הפיצ’ר ב-Claude Code, היכולת להריץ את המבנה הזה בפועל |
גרף (Graph) | המבנה עצמו: מאילו סוכנים (נודים) הוא בנוי ואיך הם מחוברים (edges) |
Graph Engineering | תכנון המבנה הזה: לא רק להריץ workflow, אלא לעצב אותו נכון |
במילים אחרות: Dynamic Workflow זה הכלי, גרף זה המבנה, ו-Graph Engineering זה המקצוע של לתכנן את המבנה טוב.
Dynamic Workflow הוא שם הפיצ’ר, גרף הוא שם המבנה
אזהרה: נוד אחד טועה מזהם את הכול
לגרף יש מחיר שחשוב להכיר. גרף סורק המון טוקנים: הרבה סוכנים שרצים במקביל צורכים יחד יותר קונטקסט מסוכן בודד.
וחשוב מזה: מספיק שנוד אחד טועה כדי לזהם את כל הפלט. אם נוד באמצע מחזיר מידע שגוי, כל הנודים שתלויים בו יקבלו קלט מורעל, והטעות תזלוג עד הפלט הסופי. לכן תכנון הנודים והוולידציה שלהם הם קריטיים.
מספיק שנוד אחד טועה כדי לזהם את כל הפלט
איך בונים גרף ב-Claude Code, צעד אחרי צעד
הנה מסגרת עבודה מעשית לבנות גרף (Dynamic Workflow) נכון. המטרה היא לתכנן את המבנה, לא רק להריץ אותו.
שלב 1: לפרק את המשימה לנודים עצמאיים
רשמו את כל תתי-המשימות, וסמנו אילו מהן באמת תלויות זו בזו ואילו לא. כל תת-משימה שאין לה תלות בקודמת היא מועמדת לנוד נפרד. בדוגמה שלנו:
- תכנון: נוד ראשון (הכול תלוי בו)
- כתיבה: תלויה בתכנון
- ביקורת: אפשר לפצל ל-3 מבקרים עצמאיים שרצים במקביל
- תיקון: מאחד את כל ההערות בסוף
שלב 2: להגדיר את ה-edges (סדר וזרימת מידע)
לכל נוד קבעו במפורש: מה הוא מקבל כקלט, ממי, ולמי הוא מעביר את הפלט. ה-edges הם אלה שמגדירים גם את סדר הריצה וגם מה בדיוק עובר בין הנודים. edge לא מוגדר טוב = נוד שמקבל קלט חלקי.
שלב 3: להריץ נודים עצמאיים במקביל
נודים שאין ביניהם תלות: שלחו אותם לרוץ בו-זמנית. ב-Claude Code זה נעשה על ידי הפעלה של כמה תת-סוכנים (subagents) במקביל, כל אחד עם המשימה והקונטקסט שלו. פה מגיע החיסכון האמיתי בסבבים.
טיפ ניסוח: בקשו במפורש להריץ את החלקים העצמאיים במקביל. למשל:
Run the 3 reviewers in parallel as separate subagents, then merge.שלב 4: להתאים מודל לכל נוד
נוד פשוט (סיכום קצר, בדיקת פורמט, סיווג) יכול לרוץ על מודל קטן וזול כמו Haiku. נוד מורכב (תכנון ארכיטקטורה, קוד רגיש, החלטות קשות) שמרו למודל חזק כמו Opus. ההתאמה הזו היא מה שהופך את הגרף גם לזול יותר, ולא רק למהיר.
שלב 5: להוסיף נוד ולידציה ואיחוד
סגרו את הגרף בנוד שמאחד את הפלטים מכל הנודים ובודק אותם לפני שהם ממשיכים הלאה. זו ההגנה מפני ‘נוד אחד טועה’, הוולידציה תופסת פלט מורעל לפני שהוא מזהם את השאר.
שלב 6: לעקוב אחרי עלות הטוקנים
כי גרף צורך הרבה טוקנים, שווה לעקוב אחרי הצריכה ולוודא שהמקביליות באמת חוסכת זמן ולא רק מנפחת עלות. אם נוד לא תורם: הוציאו אותו מהגרף.
טיפים
- פצלו רק חלקים שבאמת עצמאיים; מקביליות מלאכותית רק מנפחת טוקנים בלי להאיץ
- תנו לכל נוד קונטקסט ממוקד ומינימלי, ככה הוא גם מדויק יותר וגם זול יותר
- הצמידו מודל קטן (Haiku) לנודים פשוטים, ומודל חזק (Opus) רק לקריטיים
- תמיד סגרו את הגרף בנוד ולידציה או איחוד לפני הפלט הסופי
- הגדירו את ה-edges במפורש: מה עובר בין הנודים ובאיזה סדר
- עקבו אחרי צריכת הטוקנים; גרף מהיר שעולה פי כמה לא בהכרח משתלם
- התחילו קטן: 2-3 נודים במקביל, ורק אחרי שזה עובד הרחיבו
לסיכום
לופ זה סוכן אחד שרץ בקו ישר, צעד אחרי צעד. גרף מפרק את המשימה לנודים עצמאיים שרצים במקביל ומחוברים ב-edges, וכך מסיים את אותה עבודה בפחות סבבים, מהר יותר וזול יותר. ב-Claude Code המבנה הזה נקרא Dynamic Workflow, והמקצוע של לתכנן אותו נכון נקרא Graph Engineering.
לינקים
- אתר Claude Code: anthropic.com/claude-code
- התיעוד הרשמי: docs.anthropic.com/en/docs/claude-code
- תת-סוכנים (Subagents): docs.anthropic.com/en/docs/claude-code/sub-agents
