→ חזרה לבלוגEnglish

Pi מבפנים: harness מינימלי שנבנה סביב עץ סשנים ופרימיטיבים

איך Pi שומר על ליבה קטנה ועדיין תומך בהרחבות, skills, חבילות וממשקים שונים, ומה נקודת העיצוב הייחודית מאחוריו יחד עם לקח למי שבונה harness.

Pi מתאר את עצמו כ-harness מינימלי לסוכני קוד. זו לא ענווה שיווקית, זו החלטת העיצוב המרכזית. במקום לשלוח כל workflow כפיצ’ר מובנה בתוך המוצר, Pi מתמקד ב-runtime קטן ונותן למשתמשים פרימיטיבים שאפשר להרכיב מהם התנהגות: extensions, skills, prompt templates, themes ו-packages.

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

ארכיטקטורת ה-runtime של Pi סביב עץ הסשן

ליבה קטנה, אותו מנוע בכל מקום

Pi יכול לרוץ במצב אינטראקטיבי בטרמינל, כפקודת print/JSON חד-פעמית, כתהליך RPC, או כ-SDK של TypeScript בתוך תהליך קיים. מהבחוץ המצבים האלה נראים שונים, אבל הפרויקט מדגיש שהם כולם משתמשים באותם מנגנונים של agent וסשן.

זה אילוץ ארכיטקטוני חשוב. המשמעות היא שיכולות כמו הרצת כלים, הרכבת הקשר, compaction ו-branching לא שייכות ל-TUI או ל-SDK, אלא לליבת ה-runtime. הממשקים מציגים ושולטים במנוע, אבל הם לא הופכים למימושים נפרדים שלו.

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

איך Pi מדגם שיחה

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

המבנה הזה נותן ל-Pi בסיס עמיד לדברים שמשתמשי agent באמת עושים:

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

פורמט הקובץ (JSONL) ומודל העץ הופכים את מצב השיחה למשהו שאפשר לבדוק, לשחזר ולנווט בו. במקום להתייחס להיסטוריה כטקסט צ’אט חולף, Pi מתייחס אליה כנתונים שה-runtime יודע לעבוד איתם.

לולאת התור והרכבת הקשר

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

Pi מתעד את התגובה, מריץ כל כלי שהתבקש, מתעד את התוצאות ומתחיל תור נוסף אם עדיין נשארה עבודה. הודעות steering יכולות להיכנס אחרי תור ה-assistant הנוכחי, בעוד הודעות follow-up ממתינות עד שה-agent מסיים את העבודה הממתינה. ביטול עוצר את הריצה ומחזיר הודעות בתור לעורך.

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

Extensions כמשטחי תכנות

מערכת ההרחבות של Pi היא המקום שבו המינימליזם משתלם. הרחבות הן מודולי TypeScript שנטענים לתוך תהליך Pi ויכולים לרשום כלים, פקודות, קיצורי מקלדת, ספקים, מטפלי אירועים, רכיבי תצוגה ואלמנטים של UI. בפועל, זה אומר ש-workflows שמערכות אחרות שולחות כמצבים מובנים (תתי-סוכנים, מצב תכנון, שערי הרשאות, התנהגות compaction מותאמת, עורכים מותאמים ועוד) יכולים להיות ממומשים כהרחבות או כחבילות.

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

נקודת הסוד: עץ הסשן הוא ליבת המוצר

הסוד שמאפשר ל-Pi להיות מינימלי ועדיין חזק הוא זה: Pi מתייחס לעץ הסשן כמרכז העמיד של ה-harness.

כשמצב השיחה הוא מבנה שניתן לניווט, התמדה ושחזור (ולא רק באפר גלילה), יכולות רבות הופכות טבעיות: branching, fork, replay, סיכומי compaction, ממשקים מרובים ואוטומציה ניתנת לשחזור. הליבה יכולה להישאר קטנה כי ה-runtime פועל על פרימיטיב חזק: עץ של אירועים והודעות עם מצביע למיקום הנוכחי.

זו הסיבה ש-Pi יכול לתמוך במצבים אינטראקטיבי, print, RPC ו-SDK בלי לפצל את ההתנהגות. אלה דלתות שונות לאותו מנוע סשן. ליבה מינימלית לא אומרת יכולת מינימלית; זה אומר שהיכולת מאורגנת סביב כמה אבסטרקציות טובות.

לקח למי שבונה harness

הלקח שאפשר לקחת מ-Pi הוא: להשקיע בפרימיטיבים של state לפני שמשקיעים בפיצ’רים.

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

למי שבונה harness, זה אומר:

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

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

מקורות

סדרה שבועית

אפשר לקרוא את הפוסטים לפי הסדר:

  1. הוספתי בלוג לאתר האישי (בלי לבנות הכול מחדש) - 2026-11-11
  2. למה PostHog הוא אחד הכלים הראשונים שאני מוסיף למוצר חדש - 2026-11-18
  3. האנטומיה של coding harness: מה באמת מפעיל סוכני קידוד - 2026-11-11
  4. ניהול context ב-coding harnesses: מה באמת נשלח למודל ולמה זה חשוב - 2026-11-18
  5. Goose מבפנים: harness מבוסס MCP עם פרוטוקול במרכז - 2026-11-11
  6. Pi מבפנים: harness מינימלי שנבנה סביב עץ סשנים ופרימיטיבים (הפוסט הזה) - 2026-11-18
  7. OpenCode מבפנים: לולאה אחת, מודלים רבים, ומשוב אמיתי מהסביבה - 2026-11-11
  8. DeepSeek Harness מבפנים: הכול plugin, והלוג הוא החוזה - 2026-11-18

הקודם: Goose מבפנים: harness מבוסס MCP עם פרוטוקול במרכז הבא: OpenCode מבפנים: לולאה אחת, מודלים רבים, ומשוב אמיתי מהסביבה