xAI פתחו את Grok Build - וכך בנינו ממנו את Logan

"xAI לקחו את סוכן הקוד שרץ אצלם בטרמינל, Grok Build, ופשוט שחררו אותו כקוד פתוח תחת רישיון Apache 2.0 - כולל מנוע הסוכן המלא." זה קרה השבוע, וזה הרבה יותר גדול ממה שזה נשמע. כי מסתבר שברגע שכלי כזה נפתח, אנחנו יכולים לפתוח אותו, למדוד אותו, ולכוונן אותו בדיוק במקום שכל שאר הכלים מסתירים: כמה טוקנים הכלי שורף עוד לפני שהקלדנו אות אחת.

בדיוק את זה עשינו. לקחנו את Grok Build, פירקנו (forked, יצרנו עותק עצמאי שלנו) אותו, ובנינו ממנו את Logan - סוכן הקוד שלנו, שקרוי על שם וולברין (מחלים, מסתגל, ומוציא ציפורניים על באגים קשים). הוספנו לו ניהול זיכרון, אוטומציות, ניתוב מודלים חכם, ו-שקיפות טוקנים מלאה - היכולת לראות כל טוקן שנשרף, בזמן אמת. בפוסט הזה נפרק את כל הסיפור, ונשווה שישה סוכני קוד לטרמינל זה מול זה: Grok Build, Claude Code, GitHub Copilot CLI, OpenCode, Hermes, ו-Logan שלנו.

מה בעצם xAI שחררו (ולמה "SpaceX" קופץ פה)

בואו נפתח בבלבול קטן ששווה ליישר. הריפו יושב תחת הארגון xai-org בגיטהאב, וה-README מסביר שהקוד "מסונכרן מדי פעם מה-monorepo של SpaceXAI". כלומר זו xAI, החברה של אילון מאסק, והשם הפנימי שהם נותנים למאגר הקוד הענק שלהם הוא SpaceXAI. אז אם ראיתם "SpaceX", זה משם. זו לא חברת הרקטות ששיגרה כלי קוד, זו זרוע ה-AI.

מה יש שם בפועל? Grok Build הוא סוכן קוד שרץ בטרמינל כ-TUI (Text User Interface, ממשק טקסטואלי מלא-מסך - תחשבו על אפליקציה גרפית, אבל מצוירת מאותיות בתוך הטרמינל). הוא מבין את בסיס הקוד, עורך קבצים, מריץ פקודות שֶׁל, מחפש באינטרנט ומנהל משימות ארוכות. הכל כתוב ב-Rust (99.6% מהקוד), עם 2.2 אלף כוכבים ו-306 forks נכון להיום.

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

המס הנסתר: מה כל כלי שולח לפני שהקלדנו מילה

עכשיו לחלק שהכי אוהבים אצלנו בניוזרום - הדאטה. לכל סוכן קוד יש "מס כניסה" קבוע: עוד לפני שהקלדנו את הבקשה, הכלי שולח למודל פרומפט-סיסטם (system prompt - הוראות הרקע שמגדירות מי הסוכן ומה מותר לו) ואחריו רשימת סכימות (schemas - תיאורים פורמליים) של כל הכלים שברשותו. תחשבו על זה כמו מלצר שלפני שהוא בכלל שואל מה תרצו, מקריא לכם את כל התפריט, את חוקי המסעדה ואת הוראות הבטיחות - בכל פעם מחדש. כל הטקסט הזה עולה טוקנים, ואנחנו גם משלמים עליו וגם ממלאים בו את חלון הקונטקסט (context window - כמות הטקסט המקסימלית שהמודל מחזיק בראש בבת אחת).

וכאן ההבדלים ענקיים. חוקרים ב-Systima חיברו "פרוקסי" (proxy - מתווך שמיירט את התעבורה) בין הכלי למודל, ומדדו את המספרים המדויקים. Claude Code שולח כ-32,800 טוקנים לפני שהקלדנו אות אחת: כ-6,500 על הפרומפט-סיסטם עצמו, כ-24,000 על סכימות של 27 כלים, ועוד כ-2,000 על תבנית ההודעה הראשונה. OpenCode, לעומתו, שולח כ-6,900 טוקנים בלבד, פי 4.7 פחות, כי הוא נושא רק 10 כלים. זו לא רשלנות של Claude Code, זו בחירה: יותר כלים קונים יותר יכולת, והמחיר הוא יותר טוקנים קבועים (גישה אחרת, לא גרועה יותר).

ואיפה אנחנו בתמונה? Grok Build, וממנו Logan, בנויים על אותה ארכיטקטורה רזה של כ-10 כלים - בדיוק כמו OpenCode. מדדנו בעצמנו את טקסט הבסיס של הפרומפט-סיסטם של Logan, והוא 1,034 טוקנים בלבד. הנה ההשוואה:

שישה כלים, שש פילוסופיות

עכשיו בואו נכיר את כל השחקנים, כי לכל אחד גישה משלו. Grok Build ו-Logan הם מחנה ה"רזה ופתוח": Rust מהיר, מעט כלים, ואפשר לפרק ולכוונן. OpenCode של SST (היום Anomaly) הוא הילד הפתוח באמת של הקהילה, עם כ-160 אלף כוכבים, 75+ ספקי מודלים, ורישיון פתוח שמזמין תרומות. Hermes של Nous Research הולך על זווית שונה לגמרי, תחת רישיון MIT, עם דגש על סוכן שלומד אותנו לאורך זמן: הוא בונה לעצמו skills מניסיון, משפר אותם תוך כדי עבודה, זוכר מי אנחנו בין סשנים, ורץ גם בטלגרם, דיסקורד וסלאק. Claude Code של Anthropic ו-Copilot CLI של גיטהאב הם המחנה הקנייני (סגור): שניהם עשירים ומלוטשים בטירוף - Claude Code עם חלון של עד מיליון טוקנים ואקוסיסטם MCP ענק, ו-Copilot CLI (שהגיע ל-GA בפברואר 2026) עם Plan mode, מצב Autopilot, ו-/fleet שמתזמר תת-סוכנים ברקע - אבל שניהם דורשים מנוי וסוגרים את הקוד.

מה הוספנו ב-Logan

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

• ניהול זיכרון (memory): לוגן שומר קובץ MEMORY.md עם אינדקס היברידי, ומריץ hooks (ווים - קוד שרץ אוטומטית באירועים מסוימים) בסוף כל תור ובסוף כל סשן שכותבים לבד "רפלקציות" - מה עבד ומה נכשל. שתי skills, self-improve ו-learn-user, מזקקות את זה ללקחים ולפרופיל העדפות אישי. תחשבו על זה כמו יומן שהסוכן מנהל על עצמו ועלינו, כדי לא לחזור על אותן טעויות.
• אוטומציות ומטרות: פקודת /loop להרצה חוזרת, חיבור ל-cron, ל-launchd (מק) ול-Task Scheduler (ווינדוס), ופקודת /goal שנותנת לסוכן מטרה שלמה ("תעביר את האימות ל-OAuth") - והוא מתכנן ומריץ אותה לבד.
• ניתוב מודלים חכם: הדגל --route auto מסווג כל משימה ושולח אותה לשכבה המתאימה - משימה טריוויאלית ל-haiku/flash/ollama הזול, ומשימת ארכיטקטורה מסובכת ל-opus/מודל חזק. ככה אנחנו לא מבזבזים מודל יקר על "תריץ את הטסטים".
• דו-מחסנית וספקים (dual-stack): 8+ ספקים מוכנים להעתקה (Anthropic, OpenAI, Gemini, OpenRouter, Ollama, LM Studio, LiteLLM, Bedrock), ואפשר אפילו לקודד עם Claude ולחפש ברשת עם Grok במקביל, כל אחד במה שהוא הכי טוב בו.
• התקנה בפקודה אחת: bash scripts/install-logan.sh מסדר PATH, בינארי מנוהל, קונפיג וסנכרון skills, כדי שנתחיל לעבוד תוך דקות.

וזה בדיוק המקום להיות הוגנים: Logan הוא פורק צעיר. חלק גדול מהתשתית עדיין נושא שמות פנימיים של xai-grok-*, ה-Bedrock עובד דרך פרוקסי (LiteLLM) ולא נייטיב, וניקוד-תוצאות אוטומטי חכם עוד לפנינו. אנחנו בונים על בסיס מצוין, אבל הוא בסיס - לא מוצר גמור.

הפיצ'ר שהכי גאה בו: לראות כל טוקן

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

• שכבה 1, שורת סטטוס חיה: בלי שום פקודה, אחרי כל תגובה, רואים כמה מהחלון מלא ומה הקריאה האחרונה עלתה. שימו לב לתו ! שמזהיר עוד לפני דחיסה (compaction - כיווץ ההיסטוריה כשהחלון מתמלא).
• שכבה 2, /stats: ספר החשבונות הצבעוני של הסשן - קלט, פלט, מטמון, טוקני חשיבה ועלות משוערת, מפורק לפי מודל.
• שכבה 3, /context deep: וזה החלק שהכי אוהבים. הפקודה הזו מראה את הטקסט האמיתי של הפרומפט-סיסטם שיושב בחלון שלנו, מילה במילה. כלומר, את המס הנסתר שדיברנו עליו כל הפוסט, אנחנו פשוט יכולים לקרוא בעיניים.

הנה איך זה נראה בפועל:

# שורת הסטטוס (בלי פקודה) - אחרי כל תגובה:
m grok-4.5 · s grok-search · mcp 3    24K / 200K 12% · in 2.4K out 180 c 1.2K
#                                     ^ מילוי החלון        ^ הקריאה האחרונה

# /stats - ספר החשבונות הצבעוני של הסשן:
IN 12.4K   OUT 1.8K   CACHE 40.2K   REASON 900
est. cost  $0.012340

# /context deep - מפרק את החלון וגם מראה את הטקסט עצמו:
sys 4.2K · msg 18K · tools 14K · free 163K · compact@85%

וגם הדחיסה כנה: כשהחלון מתמלא, Logan אומר בפירוש Compacted 90K -> 24K (saved 66K) במקום לכווץ בשקט מאחורי הגב.

איך מדדנו את זה - כי אנחנו לא מנחשים

הכלל אצלנו קדוש: מודדים, לא מנחשים. וזה בדיוק מה שכתוב במסמכי Logan עצמם: "בנוי כך שלעולם לא תנחשו לאן הלכו הטוקנים". אז את המספר 1,034 טוקנים לא המצאנו. הרצנו את טקסט הבסיס של Logan דרך אותו tokenizer (מחשב-טוקנים, o200k) שהמודלים באמת סופרים בו, וספרנו. הנה בדיוק זה:

import tiktoken

# ה-tokenizer שהמודלים באמת סופרים איתו (o200k)
enc = tiktoken.get_encoding("o200k_base")

# תבנית הבסיס של Logan (הזהות, הבטיחות, חוקי הכלים)
base = open("templates/prompt.md").read()

print(len(enc.encode(base)), "tokens",
      "/", len(base), "chars")

ואם תהיתם למה בכלל צריך פרומפט-סיסטם "בשכבות", הנה איך Logan מרכיב אותו, שכבה על שכבה, כשכל שכבה מתקצבת (budget) את עצמה כדי לא לפוצץ את החלון:

בעיניי

בעיניי, הסיפור האמיתי כאן הוא לא Logan, וגם לא מי שולח הכי מעט טוקנים. הסיפור הוא ש-xAI לקחו כלי פרודקשן אמיתי, כזה שרץ אצלם בבית, ופתחו אותו מספיק כדי שאנחנו נוכל למדוד ולכוונן אותו. רוב הכלים מסתירים מאיתנו את המס שאנחנו משלמים על כל תור; פורק פתוח נותן לנו לראות אותו, ואז להוריד אותו. זה לא אומר ש-Logan "טוב יותר" מ-Claude Code - Claude Code עשיר, יציב ומלוטש בטירוף, ו-27 הכלים שלו קונים יכולת אמיתית שאנחנו לא מזלזלים בה. זו פשוט גישה אחרת: לשלם פחות מס קבוע, ולראות כל טוקן בעיניים.

מה שמסקרן אותי עכשיו: אם כל סוכן קוד היה מראה לנו בשקיפות מלאה כמה טוקנים הוא שורף עוד לפני שהקלדנו מילה, כמה מאיתנו היו בוחרים אחרת?