חזרה לפיד
articlesמקור: Lovable Blog24.9.2026

איך עובדים סוכני ה-AI של Lovable?

אמ;לק

מאחורי הקלעים של Lovable: הבנה של אופן העבודה המשותף של סוכני ה-AI, ניהול אירועים דמוי Git, ושימוש ב-Agent Control Plane ליצירת אפליקציות ששורדות תהליכי פריסה.

סיכום בעברית: מערכת VibeSec · מדיניות המקורות

נוסף ל-VibeSec:

כותרת מקורית: Inside Chats: How Lovable's Agents Work Together

$cat article.txt

>מאחורי הקלעים של Lovable: הבנה של אופן העבודה המשותף של סוכני ה-AI, ניהול אירועים דמוי Git, ושימוש ב-Agent Control Plane ליצירת אפליקציות…

התוכן המלא בעברית

תרגום אוטומטי מהמקור; מונחים טכניים נשארו באנגלית. לנוסח המחייב — הכתבה המקורית.

בניית מוצר מבוסס סוכנים (agentic) הופכת למעניינת יותר כאשר שיחה אחת צריכה להניע עבודה במקום אחר.

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

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

Chats מתבסס על תשתית שפיתחנו במקור כדי שסוכנים ותת-סוכנים יוכלו לעבוד יחד. ביום חול טיפוסי, מערכת ה-Trajectory System שלנו מוסיפה בערך חצי מיליארד אירועים, המכסים כ-2.6 מיליון תורות של משתמשים (user turns).

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

הגרסה הקצרה

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

אנו מתעדים את מה שקרה בהיסטוריה שניתן רק להוסיף לה (append-only), הנקראת trajectory. ההקשר (context) של המודל עבור כל סוכן נבנה מתוך ההיסטוריה הזו, במקום להתייחס להיסטוריה עצמה כאל הנחיה (prompt). סוכנים מתקשרים דרך תיבות דואר נכנס (inboxes) עמידות, בעוד שהפעלות (activations) דואגות לכך שהם ירוצו ויאספו משימות חדשות.

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

מסלולים: יומן אירועים שעוצב לפי ⁦Git⁩

כל שיחת סוכן ב-Lovable היא יומן אירועים. אנו לוכדים את כל מה שה-LLM מייצר ברמת הפירוט של ה-Lovable Agent Framework: UserMessage, AgentStart ו-AgentDone תוחמים את תגובת הסוכן, IterationStart ו-IterationEnd מקיפים כל קריאת LLM, החשיבה של המודל, התוכן, פלט ה-tool_call ומחזור החיים המלא של הכלי—ToolParametersValidated, ToolExecutionStart, ToolExecutionEnd, בתוספת ToolApprovalRequired כאשר אדם נדרש להתערב. כל קריאה לכלי מותאמת לתוצאה שלה. שום דבר לא נמחק: האירועים הם בלתי ניתנים לשינוי וניתנים להוספה בלבד, ואפילו פעולת ביטול מתועדת כאירוע Revert ולא על ידי מחיקת דבר מה.

העיצוב מבוסס על מבנה ה-commits וההיסטוריה של Git. כל אירוע נושא מצביע אב יחיד. אם עוקבים אחר שרשרת האב לאחור, מקבלים את היומן המלא. ראשים בעלי שם (Named heads) מצביעים על הקצה של כל שורה בהיסטוריה, בדומה לענפים (branches) ב-Git.

המאפיין היחיד הזה נותן לנו יכולת חזקה בחינם: כל גבול איטרציה יכול להתפצל (fork). מכל נקודת IterationEnd או AgentDone בשיחה, נוכל ליצור ראש חדש הממוקם באותו אירוע. השרשור החדש חולק את כל ההיסטוריה עד לאותה נקודה, בדיוק כמו הסתעפות ב-Git, ופיצול כזה כמעט אינו גובה משאבים מכיוון שלא מועתקים אירועים – האירוע הראשון בפיצול, ThreadForkConfig, פשוט מציין את נקודת הפיצול כאב שלו.

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

ההקשר הוא השלכה של המסלול

המסלול הוא מקור האמת, אך הוא אינו בדיוק מה שאנו שולחים למודל. בתחילת כל איטרציה, מיד לאחר כתיבת ה-IterationStart, בונה ההנחיות (prompt builder) הולך לאחור לאורך ראש הסוכן ומרכיב את ההנחיה מתוך המסלול. יומן האירועים לוכד את כל מה שקרה; כמות המידע שהמודל רואה, ובאיזו צורה, היא החלטה נפרדת שמתקבלת עבור כל קריאה.

כדי להבהיר, ההקשר תמיד מורכב מהמסלול – היתרון הוא לא הימנעות מהעבודה הזו, אלא הגמישות להרכיב אותו כך שיתאים למצב. דחיסה (compaction) היא הדוגמה המובהקת ביותר, והיא מתועדת ביומן כמו כל דבר אחר. כאשר הסוכן מחליט לבצע דחיסה, הוא כותב PromptCompactionStart על המסלול שלו וממשיך הלאה. סיכום רץ ברקע כסוכן קטן בפני עצמו, על מסלול צדדי שמסתעף מההיסטוריה של הסוכן. התוצאה שלו לעולם לא נוחתת ישירות על מסלול הסוכן. במקום זאת, המסלול הצדדי פועל בדומה לתיבת דואר נכנס: בגבול האיטרציה הבא שלו, הסוכן מחליט לקבל את הסיכום המוגמר ומתעד אותו כ-PromptCompactionEnd במסלול שלו. בניית ההנחיה הבאה מתבצעת אז בהליכה לאחור: כאשר הבנאי פוגש אירוע End המשויך ל-Start שלו, הוא מאמץ את הסיכום במקום האירועים הישנים יותר ומציג את כל מה שאחרי נקודת הדחיסה כהיסטוריה רגילה.

ההפרדה הזו בין יומן האירועים להקשר ⁦LLM⁩ פותחת מספר דפוסים:

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

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

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

סטרימינג: אירועים חלקיים ודלתות שדה (field deltas)

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

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

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

שני יומנים לכל סוכן: תיבת הדואר הנכנס ומסלול הסוכן

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

• תיבת הדואר הנכנס. כל מה שנשלח לסוכן נוחת כאן: ⁦UserMessages⁩, ו-⁦ExternalAgentNotifications⁩ של המשתמש מסוכנים אחרים או ממישור הבקרה - סיום סוכן משנה, הודעה מסוכן אחר, השכמה מתוכננת.

• מסלול הסוכן. היסטוריית הריצה בפועל של הסוכן: מה הוא חשב, אמר ועשה.

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

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

ה-⁦Agent Control Plane⁩

ה-Trajectory System נותן לכל סוכן היסטוריה עמידה וניתנת לפיצול. הוא לא אומר דבר על מתי סוכן רץ, היכן הוא רץ, או איך עבודתו של סוכן מגיעה לאחר. ברגע שיש לך יותר מסוכן אחד, השאלות האלה מגיעות בבת אחת. בונה משריץ תת-סוכנים לצורך חקירה וזקוק לתוצאות שלהם בחזרה. פיצול רקע צריך לפעול כאשר הסשן מושהה. סוכן אחד רוצה להעביר עבודה לכמה אחרים ולשמוע איך הם מתקדמים. משימה מתוזמנת צריכה להעיר סוכן שאף אחד לא דיבר איתו במשך ימים. כל אחד מאלה הוא דפוס תזמור מעט שונה – הורה וילד, פיצול והתכנסות (fan-out and fan-in), אש-ושכח (fire-and-forget), טיימרים – ואף אחד מהם לא שייך ללופ של הסוכן עצמו.

זו העבודה של ה-Agent Control Plane, או ACP: שכבת התזמור שיושבת על גבי ה-Trajectory System. הוא יודע אילו סוכנים קיימים ועל איזה מסלול כל אחד רץ. הוא יוצר סוכנים חדשים – או מאפס על מסלול חדש, או כמזלג (fork) של סוכן קיים. הוא מעביר הודעות בין סוכנים. והוא מחליט מתי סוכן צריך לפעול על ידי הוצאת הפעלות (activations): אותות התעוררות שכל צומת בצי שלנו יכול לקלוט כדי לאתחל את הסוכן עם המסלול שלו ולהפעיל אותו.

הסיבה שהוא קיים כשכבה נפרדת היא שהוא ממוטט את כל הדפוסים האלה לפרימיטיב אחד. כל אינטראקציה בין סוכנים – יצירה, תוצאה, דוח התקדמות, העברת עבודה מסוכן אחד למשנהו, השכמה מתוזמנת – היא אותם שני שלבים: הוספת הודעה לתיבת הדואר הנכנס של הנמען, ואז שליחת הפעלה. סוכנים לא קוראים אחד לשני, לא מחזיקים חיבורים זה לזה או יודעים באיזו מכונה נמצא האחר. הם כותבים לתיבת דואר נכנס ונותנים ל-ACP לטפל בכל השאר. הממשק שלו קטן בהתאם: SpawnAgent, ForkAndSendMessage, SendMessage, NotifyParents, StopAgent, וכמה פעולות קריאה.

הנה אחד מהדפוסים האלה מקצה לקצה - סוכן משנה שמדווח לבונה שהוליד אותו:

• מעטפת ההשלמה שלו קוראת ל-⁦NotifyParents⁩, אשר בונה ⁦ExternalAgentNotification⁩ עם התוצאה ומצב מסוף (⁦Completed⁩, ⁦Failed⁩ או ⁦Cancelled⁩).

• SendMessage מוסיף אותו לתיבת הדואר הנכנס של ההורים. הכתיבה הזו היא החלק העמיד: ההודעה בטוחה כעת בכל מה שיקרה אחר כך.

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

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

השעיה (Suspend) וחידוש (Resume): סוכנים ששורדים פריסה

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

#lovable#ai-agents#vibe-coding
קרא במקור