Goose מבפנים: harness מבוסס MCP עם פרוטוקול במרכז
איך Goose בונה את לולאת ה-agent סביב הרחבות MCP, אישורים וניהול הקשר, ומה נקודת העיצוב הייחודית שמחזיקה את זה יחד יחד עם לקח למי שבונה harness.
קל לתאר את Goose כ-agent בקוד פתוח עם אפליקציית דסקטופ, CLI ו-API. אבל התיאור המדויק יותר הוא ארכיטקטוני: Goose הוא harness שנבנה סביב פרוטוקול. במקום להתייחס לכלים, הרחבות ואינטגרציות כאל פיצ’רים נפרדים, הוא מנסה לגרום לכולם לדבר באותה שפה.
הבחירה הזו ניכרת כמעט בכל מקום: במערכת ההרחבות, בלולאה האינטראקטיבית, בזרימות האישור, ואפילו בכיוון אליו ה-runtime של ה-agent מתפתח. כשקוראים את Goose כ“לקוח MCP שבמקרה גם מריץ agent”, הרבה מהחלטות העיצוב שלו נהיות הגיוניות.
הצורה הכללית של ה-harness
ברמה גבוהה, Goose מתאים לאנטומיה שמיפינו בפוסט הסקירה:
- ממשק: אפליקציית דסקטופ או CLI אוספים קלט מהמשתמש ומציגים תוצאות.
- Agent: ה-runtime המרכזי מנהל את הלולאה, ה-state והתיאום.
- Extensions: ספקי יכולות חושפים כלים שה-agent יכול לקרוא להם.
הפרט המכריע הוא איך ההרחבות מתחברות. Goose משתמש ב-Model Context Protocol (MCP) כשכבת האינטרופרביליות בין ה-agent לבין שרתי יכולות. יכולות מובנות, שרתי MCP חיצוניים וצורות הרחבה נוספות נכנסות לאותו עולם של tool calling. בארכיטקטורה של Goose, ההרחבות חושפות כלים, והכלים הם הפעולות הקונקרטיות שהמודל יכול לבקש.
זה נותן ל-harness מרכז כובד ברור:
- גילוי ותיאור מגיעים מהגדרות הכלים.
- הרצה מתבצעת דרך dispatch של הרחבות וכלים.
- בטיחות יכולה להיאכף סביב בקשות ותוצאות של כלים.
- צמיחה מגיעה מהוספת הרחבות בלי לכתוב מחדש את ה-agent.
איך זורם צעד אחד
התיעוד של Goose מתאר לולאה אינטראקטיבית פשוטה יחסית:
- בקשה של משתמש מתחילה את התור.
- ה-agent שולח למודל את הבקשה ואת רשימת הכלים הזמינים.
- המודל עשוי להחזיר טקסט ו/או בקשות לקריאת כלים.
- Goose מריץ את הקריאות דרך ההרחבה הרלוונטית.
- תוצאות הכלים חוזרות למודל.
- Goose מבצע עדכון הקשר כדי לשמור על סט עבודה שימושי.
- המודל מחזיר תשובה סופית, או שהלולאה ממשיכה אם עדיין יש עבודה.
זו טריטוריה מוכרת של לולאת agent, אבל שני פרטי מימוש חשובים כאן.
ראשית, שגיאות הן חלק מהשיחה. במקום לתת לכשלים רבים להפיל את הריצה, Goose יכול ללכוד בעיות הרצה ולהחזיר אותן למודל כתוצאות כלי. כך למודל יש הזדמנות להתאושש, לנסות אחרת או להסביר מה השתבש.
שנית, עדכון הקשר הוא נושא מרכזי. Goose מתייחס במפורש לניהול טוקנים כחלק מה-harness: סיכומים, הסרת מידע ישן או לא רלוונטי, העדפת פעולות ממוקדות (כמו חיפוש והחלפה או חיפושים ממוקדים) על פני כתיבה מחדש בנפח גדול, ושמירה על פלטים מילוליים תחת שליטה. במילים אחרות, הלולאה היא לא רק “לקרוא לכלים עד שמסיימים”, אלא “לשמור את קריאת המודל הבאה אפשרית ושימושית”.
יותר ממצב ריצה אחד
עבודות אחרונות סביב Goose מצביעות גם על מעבר ארכיטקטוני עמוק יותר. הערות ארכיטקטורה ודיונים בקוד מתארים לולאה ותיקה לצד נתיב חדש, מבוסס state machine ו-effects, שניתן להפעיל באופן אופציונלי (למשל מאחורי GOOSE_STATE_MACHINE=1 במימושים מסוימים). הדבר החשוב כאן הוא לא הדגל עצמו, אלא הכיוון: מעבר מלולאה אימפרטיבית גדולה למודל ריצה מפורש ומונחה צעדים.
למה זה חשוב? כי התנהגות של agent קלה יותר להבנה כשההגדרות של כל צעד, הקלט, הפלט וההשפעות המתועדות ברורות. ניסיונות חוזרים, אישורים, compaction ועבודות בתור מרגישים פחות כמו קסם כשאפשר להגיד בדיוק באיזה מצב ה-runtime נמצא ומה האירוע שמקדם אותו. גם באמצע מעבר כזה, הלחץ לבהירות הוא סימן ל-harness שמתבגר.
נקודת הסוד: גבול פרוטוקול אחד לכל יכולת
אם צריך לבחור את ה“סוד” שמסביר למה Goose עובד כמו שהוא עובד, זו הנקודה: Goose מתייחס ל-MCP כגבול האוניברסלי בין ה-agent לבין יכולות.
זה נשמע פשוט, אבל זו קומפרסיה חזקה. כשכלים מובנים, שרתים מקומיים, שרתים מרוחקים ואינטגרציות עתידיות מגיעים דרך אותו חוזה פרוטוקולי, ליבת ה-agent יכולה להתמקד בתזמור במקום בטיפול במקרים מיוחדים. גילוי כלים, קריאה אליהם, טיפול בתוצאות, הרשאות ואפילו חוויית האישור יכולים כולם להישען על אותו seam עקבי.
בגלל זה Goose מרגיש native להרחבות, ולא כזה שהרחבות הודבקו אליו בדיעבד. ה-harness הוא פחות “agent מרכזי ועוד כמה plugins” ויותר “לקוח פרוטוקול עם לולאת agent מסביבו”. הפריימינג הזה מסביר איך Goose יכול לפעול ב-CLI, בדסקטופ, ב-API ועם מנגנוני תעבורה שונים של הרחבות בלי להמציא סיפור אינטגרציה חדש בכל פעם.
לקח למי שבונה harness
הלקח שאפשר לקחת מ-Goose הוא: לבחור חוזה יכולות אחד ולגרום לכל המערכת לכבד אותו.
אם לכל מסלול של כלי יש סמנטיקה אחרת, צורת שגיאה אחרת ו-hooks שונים להרשאות, ה-harness צובר מורכבות שקופה. בסוף מבלים זמן בדיבאג של שכבת האינטגרציה במקום בשיפור ה-agent. חוזה חזק (MCP או חוזה משלכם) נותן מקום מרכזי ל:
- ציפיות לסכמה ולולידציה,
- התנהגות הרצה ו-timeouts,
- אכיפת הרשאות ומדיניות,
- לוגים ותצפיתיות,
- והתאוששות מכשלי כלים.
לא חייבים להשתמש דווקא ב-MCP. אבל כן כדאי לאמץ את האינסטינקט של Goose: לצמצם את מספר הדרכים שבהן “לעשות עבודה” קורה במערכת. ככל שהגבול אחיד יותר, כך קל יותר לפתח את הלולאה, להוסיף יכולות ולשמור על בטיחות עקבית.
מקורות
- הריפו של Goose
- Goose architecture: how it works
- Goose extensions design
- Goose error handling
- MCP specification and ecosystem
סדרה שבועית
אפשר לקרוא את הפוסטים לפי הסדר:
- הוספתי בלוג לאתר האישי (בלי לבנות הכול מחדש) - 2026-11-11
- למה PostHog הוא אחד הכלים הראשונים שאני מוסיף למוצר חדש - 2026-11-18
- האנטומיה של coding harness: מה באמת מפעיל סוכני קידוד - 2026-11-11
- ניהול context ב-coding harnesses: מה באמת נשלח למודל ולמה זה חשוב - 2026-11-18
- Goose מבפנים: harness מבוסס MCP עם פרוטוקול במרכז (הפוסט הזה) - 2026-11-11
- Pi מבפנים: harness מינימלי שנבנה סביב עץ סשנים ופרימיטיבים - 2026-11-18
- OpenCode מבפנים: לולאה אחת, מודלים רבים, ומשוב אמיתי מהסביבה - 2026-11-11
- DeepSeek Harness מבפנים: הכול plugin, והלוג הוא החוזה - 2026-11-18
הקודם: ניהול context ב-coding harnesses: מה באמת נשלח למודל ולמה זה חשוב הבא: Pi מבפנים: harness מינימלי שנבנה סביב עץ סשנים ופרימיטיבים