DATA&AI / Daily Dose of DS
DAILY DOSE OF DATA SCIENCE · מדריך בעברית

Daily Dose of Data Science בעברית

הסבר בעברית לכל גיליון של הניוזלטר Daily Dose of Data Science. כל כרטיס נכתב מתוכן הגיליון עצמו, מהחדש לישן, עם הנקודות העיקריות וקישור לגיליון המקורי.

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

17 בנובמבר 2026

Security Breaks in the Gaps Between Your Reviews

17 בנובמבר 2026

בקצרה: הגיליון מסביר את חמשת הפרימיטיבים שמרכיבים סוכן always-on (לפי מדריך של Anthropic, שהוזכר בלי קישור ישיר) ואז מציג הדגמה ממומנת של CodeRabbit Secure: שני שירותי FastAPI עם פער בדיקת בעלות (IDOR) ביניהם, סריקה חוצת-מאגרים שמוצאת את הבאג, תיקון אוטומטי דרך PR, בדיקת Security שחוסמת מיזוג, ומפת שטח תקיפה שמסמנת קוד שלא עבר סקירה. החלק השני הוא תוכן ממומן של הספק, והטענות והמספרים בו לא אומתו.

  • הרעיון המרכזי: סוכן always-on לא רץ כל הזמן אלא 'ישן' ומתעורר לריצות קצרות. כל ריצה מקבלת אירוע, מבצעת את העבודה ושומרת מה קרה. לפי הגיליון, מדריך של Anthropic טוען שלולאת הסוכן עצמה לא משתנה - כל החידוש הוא הארכיטקטורה שמסביב לה.
  • פרימיטיב 1, תיבת אירועים: webhooks, משימות מתוזמנות והודעות משתמש נוחתים בטבלה עמידה ולא קוראים לסוכן ישירות (קריאה ישירה מאפשרת ריצות מתחרות, וקריסה מאבדת את האירוע). worker יחיד לכל inbox קורא מהטבלה ומפעיל ריצות, אירועים מנוקים מכפילויות לפי מזהה מקור, ואירוע ממתין יקבל retry אם ה-worker מת.
  • פרימיטיבים 2-3, טיימרים וזיכרון: follow-ups הם דדליינים שהסוכן קובע לעצמו, ו-scheduler דוגם טיימרים שפגו ומוסיף אירוע ל-inbox - כך כל ריצה עדיין מתחילה שם. כל ריצה פותחת בהקשר חדש, ולכן שומרים רק מה שאי אפשר לשלוף מחדש ומחזיקים מצביעים לשאר: הוראות, אינדקס ולוג של מה שהמשתמש כבר שמע נטענים בכל ריצה, ומה שחייב לשרוד compaction נכתב במהלך הריצה.
  • פרימיטיבים 4-5, הרשאות ו-outbox: ההרשאות הן נקודת הסיכון הגדולה כי הריצה מחזיקה את הגישה של המשתמש בלי השגחה - הבקשות יוצאות בלי credentials ופרוקסי מוסיף אותן לפני ההעברה, והחלטה שדורשת אדם היא deferred tool call: הסשן נשמר באמצע, המשתמש רואה כרטיס אישור, והתשובה חוזרת כאירוע inbox שממשיך את הסשן. ה-outbox נותן למשתמש את התוצאה ולא כל צעד; ההמלצה להתחיל בשקט ולכוונן רעש עם evals.
  • דוגמה חיה: Alook (קוד פתוח, github.com/alookai/alook) מוצג כמימוש של הרעיונות - הוא הופך סוכני קוד כמו Claude Code ל'אורג-צ'ארט' עם תפקידים ותיבות מייל אמיתיות לשיתוף פעולה מרובה-סוכנים. זו הצגה של הפרויקט בגיליון, לא בדיקה עצמאית.
  • הרקע לחלק הממומן, כטענות הגיליון בלבד: ב-21 באוקטובר תוקנה ב-GitLab פרצה מ-2014 שאפשרה הרצת קוד בלי התחברות, ובאותה שבוע חוקרים עם מודל של OpenAI חשפו באגי PHP קריטיים בני עשרות שנים. הזמן מפרסום באג לניצול ראשון ירד לטענתו מכמעט שנה ב-2021 ל'קצת יותר מיום' ב-2026, ו-CodeRabbit דיווחה על 43,000+ פגיעויות high או critical בסריקות של עשרה ימים. אף אחת מהטענות לא אומתה.
  • הניסוי עצמו: שני שירותים שנכתבו עם Claude Code בלי הנחיות אבטחה - shop-gateway (FastAPI עם JWT, מעביר X-User-Id) ו-shop-orders (FastAPI עם SQLite). Claude Code דווקא הוסיף אמצעים שלא ביקשו, כולל בדיקת בעלות; אותה הורידו בכוונה מ-GET /orders/{id} כדי לשחזר את דפוס ה-bypass של Next.js משנה שעברה (CVE-2025-29927: header פנימי שמקורו לא אומת). bob הצליח לקרוא את ההזמנה של alice.
  • מה הכלי מצא, לפי ההדגמה: Deep Scan עם Multi-Repo Analysis זיהה את הבדיקה החסרה וסימן IDOR (CWE-639) בדירוג Medium, עם trace נגיש-מבחוץ שחוצה מה-gateway לשאילתה ב-orders וציטוטים מארבעה חלקים בקוד ה-gateway. נבנתה Attack Surface Map עם 37 נקודות שכולן אומתו. Fix with AI פתח PR שהחזיר את בדיקת הבעלות לתוך השאילתה עצמה והוסיף טסט שמחזיר אותו 404 כמו להזמנה שלא קיימת.
  • שלושת התרחישים הנוספים: ב-PR ל-endpoint reorder חדש תפס ה-PR scan אותו IDOR (דירוג Major), וכפתור ה-merge נחסם רק אחרי שבדיקת ה-Security הוגדרה כ-required ב-branch protection; refactor של קוד ה-forwarding ב-gateway עבר נקי עם סיכון Minimal כי ה-overwrite של X-User-Id נשמר; push ישיר ל-main בלי סקירה הוריד את כיסוי המפה המאומת מ-100% ל-89.2% וסימן ארבע נקודות כ-stale עד לסקירה או סריקה מחודשת.
  • מסקנת הגיליון: באגי הרשאה נופלים בין השירותים כי אף קובץ יחיד לא מכיל אותם, ולכן כלי שעוקב אחר קשרים חוצי-מאגרים מוצא מה שסקירה אנושית מפספסת. החלק מסתיים בקריאה לתקופת ניסיון של הספק ובתודה מפורשת ל-CodeRabbit על השיתוף.

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

החלק השני של הגיליון (הדגמת CodeRabbit Secure) הוא תוכן ממומן של הספק, כפי שצוין במפורש בגיליון; כל הטענות, המספרים והתוצאות בו הם דיווח עצמי ולא אומתו. המדריך של Anthropic בחלק הראשון מוזכר בלי קישור ישיר בגיליון, וקישור תקופת הניסיון של הספק לא נכלל בכרטיס.

always-on agentssecurityIDORCodeRabbitAlooksponsored
לגיליון המקורי ←

16 בנובמבר 2026

Moving from RAG Apps to RAG Systems Engineering

16 בנובמבר 2026

בקצרה: הגיליון מכריז על ארבעה חלקים חדשים (16-19) בקורס RAG Systems של המפרסם, וממפה את המעבר מ'אפליקציית RAG' להנדסת מערכת: מדיניות retrieval שהמודל עצמו שולט בה, הנדסת הקשר ללולאות ארוכות, עקביות וסינון הרשאות מול האינדקס, ותשתית חיפוש בעשרה מיליון וקטורים. לכל חלק מוצג מימוש מלא, ומפת אבחון מקשרת כל כשל לשכבה שאחראית עליו.

  • חלק 16 מחליף קריאת top-k קבועה במדיניות retrieval: המודל בוחר בין חיפוש לקסיקלי, חיפוש סמנטי, בדיקת קבצים וקריאה מוגבלת, מנסח את השאילתה מחדש אחרי שהוא רואה ראיות, ועוצר כשהטענות הנדרשות נתמכות. המימוש מכסה גם את מצבי הכשל של החופש הזה: חזרה על אותה ראיה, קריאות חופפות, דבקות בהיפותזה שכבר נדחתה ושריפת תקציב ההקשר בלי התקדמות.
  • חלק 17 עוסק ב-context engineering ללולאות retrieval ארוכות: מה נשאר בהקשר הפעיל, מה מנוקה, מה מכווץ ומה עובר לרשומה חיצונית. הפרק משווה ניקוי תוצאות כלים, סיכום היסטוריה, פתקים חיצוניים, לוגים של סשן הניתנים לחיפוש ובידוד של סאב-אייג'נטים - בחירות שקובעות אם המערכת משחזרת עובדה קודמת ושומרת מזהים מדויקים.
  • חלק 18 עובר לצד ה-backend והמערכות המבוזרות: הבחירה בין pgvector לבסיס וקטורי ייעודי היא רק חלק מהעבודה, והשאלות הקשות הן בעלות ועקביות - מה קורה כשמסמך משתנה, נמחק או מאבד הרשאה. המימוש בונה dual writes ישירים, transactional outbox, version guards, עבודות reconciliation וסינון retrieval לפי הרשאות.
  • חלק 19 יורד לתשתית חיפוש בעשרה מיליון וקטורים: product quantization, scalar quantization, binary codes, RaBitQ, IVF, HNSW, קאשינג, וקטורים מגובי דיסק ו-rescoring מדויק. הדגש הוא שיקול משותף של recall, זיכרון, latency וטריות האינדקס - אינדקס מהיר חסר ערך אם הוא מפספס את הראיה שהאפליקציה צריכה.
  • המפה המשולבת מקשרת תסמין לשכבה: שאילתה חלשה או חיפוש חוזר מצביעים על מדיניות retrieval; מועמדים רלוונטיים שלא מגיעים לתשובה מצביעים על טיפול בהקשר; מסמכים ישנים או הרשאות שגויות מצביעים על סנכרון וסינון; recall יורד או latency עולה בסקייל מצביעים על האינדקס, הקאש או האחסון.

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

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

RAGretrieval policycontext engineeringvector databasequantizationHNSW
לגיליון המקורי ←

14 בנובמבר 2026

How to Deploy Agent Teams Across Your Company (Complete Guide)

14 בנובמבר 2026

בקצרה: הגיליון מדגים צוות של ארבעה סוכני Claude Code בחדרי Alook, עם Nimble למחקר אתרים והשוואת snapshots מתוארכים. החלק הממומן מציג Swamp להמרת תהליך חוזר ל-workflow שבו קוד מנהל את הלולאה. זו הדגמת עבודה ושיתוף, לא ניטור מיידי, הבטחה לפריסה ארגונית בטוחה או מערכת ללא עלויות מודל ו-API.

  • Swamp מוצג בחסות Swamp Club כמערכת שמרכיבה behaviors עם קלט ופלט מוקלדים ונותנת לקוד לבחור את הצעד הבא. מודל נשאר בשלבים שדורשים שיפוט. לפי הספק נשמרים נתונים בגרסאות, תיעוד ריצות ושליפת secrets עם redaction; ההבטחות לא נבדקו בפועל כאן.
  • בדוגמת code review המדווחת: skill ב-Codex השתמש בכ-4.6 מיליון tokens,23 סוכנים ו-12.8 דקות, לעומת כ-506 אלף tokens,3 סוכנים ו-6.6 דקות ב-Swamp. זו דוגמת ספק, לא benchmark ששוחזר או הוכחת שקילות איכות. אין להסיק שכל skill חייב לתכנן מחדש כל שלב או שכל workflow ישיג חיסכון דומה.
  • Alook מוצג כפלטפורמת חדרים משותפים לסוכנים מקומיים עם handles ותיבות הודעות. הדוגמה משתמשת ב-Claude Code לכל ארבעת הסוכנים; תמיכה ב-Codex, Cursor, OpenCode ו-Pi היא טענת המוצר, לא בדיקת תאימות שבוצעה כאן. אלה חדרי Alook, לא אינטגרציית Slack.
  • חלוקת התפקידים בדוגמה: Atlas מרכז בקשות ומעקב, Mara מנסחת spec ובודקת תוצרים, Theo מריץ מחקר ו-Ren מפרסם התראות. המחקר עובר בחדר intel, וההתראות בחדר alerts עם קהל מצומצם. שמות CEO או PM הם תפקידי דוגמה ואינם מקנים הרשאה או סמכות לפעול בשם עובדים.
  • ה-daemon וסביבת העבודה נשארים מקומיים, אבל בגרסת הענן האפליקציה מארחת הודעות וקבצים משותפים. קריאות מודל נשלחות לספק המודל ובקשות web ל-Nimble. לכן ריצה מקומית אינה אומרת שכל המידע נשאר במחשב; צריך לבדוק כל יעד, הרשאה וחברות בחדר לפני שיתוף תוכן ארגוני.
  • competitor-positioning של Nimble מגלה URLs, אוסף דפים ושומר snapshot עם זמן ומקורות. הריצה הראשונה היא baseline, והריצות הבאות משוות אליו. ההיסטוריה המתוארת היא התנהגות של ה-skill הזה, לא של כל Nimble skill. קבצי Markdown שמורים אינם מתעדכנים מעצמם.
  • המדריך מתאר prerequisites, התקנת Alook ו-Nimble, חשבון ומפתח API והפעלת daemon עם ההגדרה המתאימה. קוד פתוח של skills אינו שקול ל-API חינמי, וכל ריצה עדיין עשויה לצרוך מודל ו-API. לא בוצעה התקנה, הרשמה, יצירת מפתח, חיבור חשבון או הרצת הדוגמה לצורך הסיכום.
  • בדוגמת Railway מושווה baseline מ-9 בספטמבר2026 ללכידה מ-23 באוקטובר2026: מדווחים על שינוי אזור Sandboxes & VMs וניסוח tier, לצד מחירי plans שלא השתנו בדוגמה. אלו לכידות היסטוריות של הכתבה, לא אימות של מחירים או זמינות נוכחיים.
  • הבדיקה השנייה הופעלה בבקשה ידנית כשישה שבועות אחרי הראשונה. ההתראה מגיעה אחרי בדיקה חדשה, לא ברגע שהדף השתנה, ולא הוכח שנוצר ניטור רציף או schedule אוטומטי. דוח שימושי צריך להראות את שני תאריכי הלכידה, השינוי והקישור למקור.
  • המקור מתאר הרחבת הדפוס לכמה מתחרים, אך אין כאן מבחן scale ארגוני, הרשאות מקצה לקצה או איכות החלטות של צוות רב-סוכני. Swamp הוא קטע שותפות מפורש; התמונות, ה-GIF וה-repositories לא נבחנו בנפרד, והרישוי, הביצועים והתאימות מדווחים מהגיליון בלבד.

למי זה מתאים: צוותי AI ומודיעין תחרותי שרוצים לשתף סוכנים ותוצאות מחקר עם מקורות והיסטוריית לכידות.

מבוסס על הטקסט הציבורי המלא ועל גוף המייל שהתקבל ב-14 בנובמבר2026 בשעה02:01 בישראל. חותמת הארכיון14 בנובמבר00:00UTC. קטע Swamp הוא שותפות מסחרית מפורשת; טענות חיסכון, redaction, רישוי ותאימות לא אומתו עצמאית. מחירי Railway בדוגמה היסטוריים. תמונות ו-GIF לא נבחנו בנפרד; ללא הרצת קוד, התקנות, חשבונות, מפתחות, שיתוף מידע פרטי או הוצאה כספית.

AlookNimbleSwampmulti-agentsnapshotscompetitive intelligenceחסות
לגיליון המקורי ←

13 בנובמבר 2026

How Top AI Teams Scale to 1,000+ Agents

13 בנובמבר 2026

בקצרה: הגיליון מדגים זיכרון משותף לסוכנים עם branches, diff ובדיקת merge כדי למנוע lost updates, באמצעות Omnigraph. לצד זה מוצג Rowboat לתיאום צוות סוכנים. למרות הכותרת על1,000+ סוכנים, הניסוי המתואר הוא מקומי עם מפתח אחד ושני סוכנים, ולא בדיקת ביצועים בקנה מידה כזה.

  • Lost update נוצר כששני writers קוראים אותה גרסה ושומרים אחר כך עותק מלא: אחד משנה store מ-Redis ל-Postgres, והשני מוסיף owner אך מחזיר בטעות את ה-store הישן. שתי הכתיבות יכולות לדווח הצלחה בלי לשמור את שתי הכוונות. זו בעיית תחרות בין עדכונים, לא תכונה הכרחית של כל סוכן או מסד נתונים.
  • הגיליון משווה single writer, נעילות, optimistic version checks ו-last-write-wins. חשוב להפריד בין מניעת התנגשות לבין diff, review והיסטוריה. אין להסיק שמסדי נתונים רגילים מוגבלים בהכרח לרשומה אחת או אינם תומכים בטרנזקציות מרובות רשומות; אלה הכללות במקור, לא מסקנה שנבדקה כאן.
  • Omnigraph מתואר במקור כ-graph database בקוד פתוח, Rust ורישיון MIT, עם branches, diffs, merges ו-snapshot reads. כל סוכן עובד על ענף נפרד, ו-merge בודק את השינוי מול בסיס משותף לפני פרסום ל-main. תכונות המוצר והרישוי מדווחים מהגיליון ולא אומתו מול קוד ה-repository.
  • בהדגמה נוצרים schema ונתוני seed לרכיבים sessions ו-billing; שדה slug מסומן ב-@key כדי לזהות רשומות לאורך ענפים. Claude Code מבצע שש כתיבות קשורות ב-commit אחד, ו-Codex משנה owner בענף אחר. תחילה ממזגים את ענף Claude ב-fast-forward.
  • ניסיון המיזוג של Codex נדחה ב-divergent_update כי אותה רשומה השתנתה גם ב-main. הבדיקה היא ברמת רשומה ולא שדה, ולכן נחסם גם שינוי בשדה אחר. זו פשרה שמעדיפה retry על פני merge שקט של עותק ישן; היא אינה מוכיחה ששני השינויים סותרים מבחינה עסקית.
  • לאחר קריאת main העדכני Codex יוצר ענף חדש ומחיל מחדש רק את שינוי ה-owner. בדוגמה נשמרים גם Postgres וגם ה-owner החדש. קריאת snapshot של ה-commit המקורי עדיין מציגה Redis וללא owner. היסטוריית גרסאות עוזרת לשחזר מה השתנה, אך אינה מאשרת שהעובדה שנכתבה נכונה.
  • לוקלית, --as הוא תווית ייחוס ולא מנגנון אימות, וסוכן יכול למזג את עצמו. כדי להגביל מיזוגים, המדריך עובר לשרת עם tokens נפרדים ומדיניות Cedar: agents כותבים בענפים שלהם ורק reviewer יכול למזג ל-main. המקור מציג403 לניסיונות לא מורשים. לא נוצרו tokens או הרשאות לצורך הסיכום.
  • Rowboat מוצג כשכבת תיאום self-hostable: סוכן מתאם מבקש רשות ליצור עובדים, מחלק עבודה, מעביר הקשר ב-threads ומרכז תוצרים ב-whiteboard. בדוגמה מתוארים נתוני PostHog, משוב משתמשים ו-dashboard. הטענות על חיבור כל סוכן MCP, שימוש במינויים קיימים וזמינות חינמית הן של המפרסם, לא בדיקת תאימות או עלות בפועל.
  • הכותרת על1,000+ סוכנים היא הבטחת קנה מידה של הכתבה, בעוד ההדגמה כוללת שני סוכנים בלבד. לא הוצגו בסיכום benchmark של throughput, contention או latency בקנה מידה גדול. סרטוני ההדגמה והתמונות לא נבחנו בנפרד ולא הורצו scripts או repos.
  • הגיליון כולל קידום מוצרים וקישורי membership וקורסים, אך בגוף שנקרא לא זוהתה תווית חסות מפורשת ל-Rowboat או Omnigraph. אין לקבוע שהיה תשלום על ההצגה בלי ראיה. לא בוצעו התקנה, הרשמה, חיבור מידע פרטי או הוצאה כספית.

למי זה מתאים: מפתחי multi-agent systems שרוצים להפריד כתיבות מקבילות, לבדוק שינויים ולמנוע דריסת זיכרון משותף.

מבוסס על הטקסט הציבורי המלא ועל גוף המייל שהתקבל ב-13 בנובמבר2026 בשעה00:52 בישראל. חותמת הארכיון12 בנובמבר22:52UTC, ותאריך הכרטיס לפי ישראל. קידום מוצרים ללא תווית חסות מפורשת בגוף שנקרא; טענות scale, רישוי, חינם וביצועים לא אומתו עצמאית. סרטונים ותמונות לא נבחנו בנפרד, וקוד, repositories וקורסים לא הורצו או נבדקו.

OmnigraphRowboatagent memorylost updatebranchingCedarmulti-agent
לגיליון המקורי ←

12 בנובמבר 2026

Find Production Agent Failures Before Users Do

12 בנובמבר 2026

בקצרה: הגיליון מציג שתי דרכים לבדוק סוכנים לפני שמשתמשים נפגעים: להשוות את השילוב של harness ומודל על משימה אמיתית, ולהריץ סימולציות של מקרי קצה עם בדיקת פעולות ותיקונים. Harness Arena ו-PlurAI מוצגים דרך טענות המפרסם; אין כאן ניסוי עצמאי או הוכחה שסימולציה מכסה את כל סיכוני הייצור.

  • Harness Arena, בתוך HarnessRouter, מתואר ככלי שמשווה כמה צירופי harness ומודל עם אותם prompt, קבצים, tools, skills ובדיקות. התוצרים כוללים הצלחה במשימה, עלות, זמן וקבצים. קודם מסננים ריצות שנכשלו, ורק אחר כך משווים מחיר ומהירות בין אלה שעברו.
  • כדי למדוד השפעה של harness בלבד צריך להשאיר את המודל קבוע. בדוגמה בגיליון משתנים גם ה-harness וגם המודל: Hermes עם GPT-5.2 מול Claude Code עם Opus 4.8. לכן אי אפשר לייחס את הפער ל-harness לבדו, גם אם יתר קלטי הניסוי זהים.
  • לפי הגיליון, בדוגמה אחת Hermes עם GPT-5.2 הצליח ב-5 מתוך5 ריצות עם0.47 credits, והצירוף השני ב-3 מתוך5 עם223 credits. היחס הוא בערך474.5, אך מדובר במדגם זעיר וביחידות זיכוי של המערכת, לא בחיסכון כספי כללי או במדד אמינות לכל משימה. הנתונים לא שוחזרו כאן.
  • HarnessRouter מציע לפי המקור ממשק UHP משותף ל-sessions, streaming, קבצים, artifacts, ביטול וכשלים. ממשק אחיד יכול להקל השוואת חלופות, אבל אינו מבטיח שקילות התנהגות, בטיחות או איכות של כל backend.
  • PlurAI Simulation מוצג כ-plugin ל-Claude Code ול-Codex שמנסה לשחזר סוכן, כלים וסביבה מהקוד, להפעיל משתמשים מדומים ולבדוק את הפעולות שבוצעו. הדוגמה היא סוכן שמצהיר על החזר לחשבונית בלי לאמת לקוח. לוג נקי או תשובה משכנעת אינם הוכחה שפעולה מורשית אכן התבצעה.
  • לפי תיאור המוצר, כל כשל מלווה בריצה שחושפת אותו ובהצעת תיקון שאפשר לאמת. כשל ייצור יכול להפוך לתרחיש replay נגד גרסאות הבאות. זו דרך לבנות regression tests התנהגותיים, לא אישור אוטומטי לפרוס תיקון שנוצר בידי מודל.
  • החלק על PlurAI הוא תוכן שיווקי בשיתוף הצוות, כפי שהגיליון מציין. הטענות שהוא עובד עם כל סוכן ושהשימוש חינם הן טענות המפרסם, לא תנאי שירות או מחירים שאומתו. לא הותקן plugin, לא חובר קוד פרטי ולא נפתח חשבון או trial.
  • הדגמות הווידאו המקושרות לא נצפו בנפרד, וה-repository לא הורץ או נבדק כאן. הסיכום מבוסס על הטקסט המלא, כולל גוף המייל; קורסים וקישורי membership בסוף המייל הם חומרי המשך שיווקיים שלא נבחנו.

למי זה מתאים: בוני סוכנים וצוותי evals שרוצים להשוות runtime שלם ולשחזר כשלים לפני פריסה.

מבוסס על מלוא הטקסט הציבורי ועל גוף המייל שהתקבל ב-12 בנובמבר2026 בשעה01:34 בישראל. תאריך הכרטיס לפי זמן ישראל; חותמת המקור היא11 בנובמבר23:33UTC. הגיליון מציין שיתוף פעולה עם PlurAI. סרטונים, repository וקורסים לא נבדקו בנפרד; ללא התקנה, חיבור נתונים, הרצת קוד או אימות מחירים וביצועים עצמאי.

agent evalsHarness ArenaHarnessRouterPlurAIsimulationreplayתוכן שיווקי
לגיליון המקורי ←

11 בנובמבר 2026

16 Policy Optimization Methods for LLM Training

11 בנובמבר 2026

בקצרה: הגיליון ממפה16 שיטות policy optimization לפי בחירת baseline וטיפול ביחסי הסתברויות, ומשווה ארכיטקטורות hybrid שמצמצמות KV cache באמצעות פחות שכבות attention. הוא מדגיש פשרות בין זיכרון, rollout ויציבות. פינת Speechmatics Linden ממומנת. נתוני מאמרים וביצועים הם דיווחי המקור, לא השוואה עצמאית באותם תנאים.

  • לולאת RL שבגיליון: דוגמים תשובות מה-policy, מדרגים עם reward model או verifier, מחשבים advantage ומעדכנים הסתברויות. baseline ו-clipping הם מסגרת מיון שימושית, אך אינם כל ההבדלים בין שיטות. איכות reward, נתונים, תקציב rollout ו-KL חשובים גם הם.
  • משפחת value-based כוללת PPO,VAPO,VinePPO. critic נותן אומדן ברמת token, אך מוסיף עלות ועלול לטעות. VAPO מנסה לשפר אומדני value בשרשראות ארוכות; VinePPO מחליף value network בדגימות המשך מ-prefixes. חיסכון במודל עשוי לעלות בעוד rollouts.
  • משפחת REINFORCE כוללת REINFORCE,RLOO,ReMax,REINFORCE++,OPO. השאלה היא מה מפחיתים מה-reward: למשל ממוצע שאר התשובות ב-RLOO או reward של תשובה greedy ב-ReMax. normalization גלובלי ובסיס משוקלל אורך משנים שונות והטיה. טענת חיסכון46% בזיכרון של ReMax מתייחסת לניסוי7B המתואר, לא לכל אימון.
  • GRPO משתמש בקבוצות תשובות, נרמול reward ויעד clipped ללא critic. Dr. GRPO משנה נרמול אורך וסטיית תקן; DAPO משנה clipping, sampling, שקלול tokens ועונש אורך; LitePPO בודק שילוב מצומצם של טריקים. ציוני AIME ממודלים ומתכונים שונים אינם leaderboard ישיר או ראיה ששינוי יחיד גרם לכל השיפור.
  • GSPO,GMPO,CISPO,SAPO משנים את אופן שקלול או הגבלת היחסים בין policy חדש לישן. GSPO פועל ברמת sequence; CISPO חוסם gradient דרך משקל importance sampling; SAPO מציע שער רך ברמת token. טענות היציבות, הקצב והציונים הן של המחקרים כפי שהגיליון מדווח, ולא שחזור ניסויים.
  • בחלק הארכיטקטורה, שכבות attention שומרות K ו-V לכל token, ואילו שכבות recurrent או state-space שומרות state בגודל קבוע ביחס לאורך ההקשר. hybrid משאיר חלק משכבות attention ומחליף אחרות. state דחוס הוא lossy, ולכן יש פשרה ביכולת אחזור והסתמכות על דוגמאות בהקשר.
  • דוגמת החישוב:2 ראשי KV כפול256 ממדים כפול K ו-V כפול2 bytes הם2,048 bytes לכל token ושכבת attention. ב-262,144 tokens מתקבלים512MiB לשכבה:40 שכבות הן20GiB ו-10 הן5GiB. זו השוואת רכיב KV היפותטית בתנאים שנקבעו, לא כלל זיכרון המודל, הכולל משקולות, recurrent states, buffers ורכיבים נוספים.
  • Qwen,Jamba,MiniMax,Granite,Nemotron מוזכרים עם יחסי hybrid שונים וטענות ספק על throughput,FLOPs או RAM. אין להשוות ישירות אחוז RAM מול FLOPs מול throughput. גם במודל hybrid ה-KV של שכבות attention שנותרו גדל עם ההקשר; state קבוע אינו אומר שזיכרון כולל קבוע. התועלת תלויה באורך, batching ומימוש מנוע ההגשה.
  • חסות Speechmatics: Linden מוצג כ-STT לסוכני קול עם תמיכה בשפות, מילונים ואינטגרציות. כ-250ms מתייחסים ל-final transcript אחרי אות ForceEndOfUtterance, לא latency מקצה לקצה של שיחה. מחירים, זיכויים ודיוק אינם מאומתים כאן; לא נפתח trial, לא נוצר חשבון ולא נעשה שימוש בקרדיטים.
  • קורסי RL וכתבת KV engineering הם קישורי המשך בגיליון, לא תוכן שנבדק במלואו לצורך הסיכום. תמונות המקור והמאמרים המחקריים לא נבחנו בנפרד. לפני בחירת שיטה כדאי לקבוע מגבלת זיכרון, עלות דגימות ו-evals יציבות, ולא לבחור רק לפי שם אלגוריתם.

למי זה מתאים: מהנדסי post-training ו-serving שרוצים למפות משפחות RL ולחשב מה בדיוק נחסך ב-hybrid KV cache.

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

policy optimizationPPOGRPOhybrid LLMKV cacheSpeechmaticsחסות
לגיליון המקורי ←

9 בנובמבר 2026

Pages in Grok Bot, clearly explained:

9 בנובמבר 2026

בקצרה: הגיליון מציג Pages ב-Grok Bot כבית מתעדכן לתוצרי סוכן, לצד חיפוש מקומי ברגעים בווידאו באמצעות embeddings. הוא מפריד בין קוונטיזציה של משקולות לבין דחיסת אינדקס. פינת MongoDB Atlas היא תוכן ממומן על מסדי נתונים זמניים. יכולות המוצרים ונתוני הביצועים הם דיווחי המחברים והספקים, לא בדיקה עצמאית.

  • Page מתואר כדשבורד אינטראקטיבי מתמשך, לא PDF או מצגת: טקסט, טבלאות, תרשימים ובקרות כמו סינון ומתגים. הסוכן יכול לעדכן את אותו עמוד בהמשך, גם באמצעות routine, כך שהקישור נשמר כשהתוכן משתנה.
  • העמוד אינו מחליף את הבוט אלא נותן לתוצר שלו מקום שאפשר לחזור אליו בלי לחפש בשיחה. קישור קבוע אינו מבטיח שהמידע מעודכן בכל רגע; צריך לדעת מה עודכן, מתי ועל בסיס איזה מקור, ולהגדיר הרשאות צפייה מתאימות.
  • תוכן הסרטון לפי פירוט הגיליון: סיור HQ, לוח Notion עם routine, ניתוח מותאם של X, מדריך למידה אינטראקטיבי, שיתוף ודפדפן ומובייל, ודמו של תנועת קליע. הסרטון לא נצפה כאן ולכן אין טענה שאומתו התנהגות הבקרות או איכות הדמואים.
  • בחיפוש הווידאו המוצג, שאילתת טקסט מחזירה פריימים ומאפשרת קפיצה לזמנם בסרטון. הגיליון מייחס ל-EmbeddingGemma 2 מרחב משותף לטקסט, תמונה, וידאו ושמע, וכ-740 מיליון פרמטרים בגרסה המולטימודלית המלאה. השם והמפרט מובאים כפי שפורסמו, ללא אימות מול model card.
  • הגיליון מבדיל בין checkpoint טקסטואלי קטן של Unsloth, המתואר כ-GGUF של 176 MB ב-4 ביט, לבין מסלול מולטימודלי מלא. קובץ embeddings לטקסט לבדו אינו כולל את נתיב הראייה הדרוש לחיפוש בפריימים.
  • בניסוי המחברים על סרטון של דקה ב-Apple M3 Pro, על CPU, דווחו 29 שניות אינדוקס, ממוצע חיפוש של 25 מילישניות בתשע שאילתות ו-180 KiB לווקטורים השמורים. זה benchmark קטן של הדמו, לא מדד לדיוק, לשירות מקבילי או לספריית וידאו גדולה.
  • האינדוקס הוא עיבוד מוקדם חוזר לכל וידאו חדש; בשאילתות הבאות מטמיעים את הטקסט ומשווים לווקטורים שנשמרו. המחברים אומרים שהכול נשאר במחשב, אך פרטיות מקומית תלויה גם בהתקנה, בתלויות ובהגדרות רשת שלא נבדקו כאן. לא הורץ או הותקן דבר לצורך הסיכום.
  • קוונטיזציה של משקולות מקטינה את זיכרון המודל. דחיסת אינדקס מקטינה רכיב נפרד שגדל עם מספר הסרטונים. מעבר מ-float32 לביט אחד לממד מקטין פי 32 את מטען הווקטורים הגולמי בלבד, לא בהכרח את כל האינדקס או זיכרון המערכת; יש לבדוק גם פגיעה באיכות retrieval.
  • חסות MongoDB: Atlas Ephemeral Clusters מוצגים כ-public preview שבו סוכן יכול לבקש מסד זמני ללא חשבון או API key. לפי החסות, מסד שלא נתבע מושהה לאחר יומיים ונמחק לאחר שבעה; רק אדם יכול להעבירו לבעלות חשבון, תוך שמירת הנתונים ומחרוזת החיבור. זו טענת ספק ולא אישור ליצור משאב, למסור נתונים או להתחייב לתוכנית.
  • הגיליון אומר ש-claim הופך את המסד לקבוע וחינמי. אין כאן אימות תנאים, מגבלות או עלויות עתידיות, ולא נוצר מסד לצורך הסיכום. מחרוזת חיבור היא מידע רגיש שיש לשמור, ולא להדביק בתוצר משותף. קישורי membership והמאמרים המורחבים אינם מסוכמים.

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

מקור: מלוא טקסט הגיליון הציבורי וגיליון המייל המקביל. תאריך הארכיון הוא 9 בנובמבר 2026 לפי UTC; המייל התקבל ב-10 בנובמבר לפי שעון ירושלים. סרטוני הדמו, המדריכים המקושרים והתיעוד הטכני לא נבדקו. יש בגיליון חסות MongoDB. טענות המוצרים והביצועים מיוחסות למקור.

Grok BotPagesEmbeddingGemma 2video retrievalקוונטיזציהMongoDB Atlas
לגיליון המקורי ←

7 בנובמבר 2026

7 MoE routing strategies in production, clearly explained

7 בנובמבר 2026

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

  • Token-choice: כל טוקן בוחר top-k מומחים. מספר קבוע של מומחים לטוקן אינו מבטיח עומס שווה למומחה: ארבעה טוקנים יכולים לבחור את אותם שני מומחים ולהשאיר אחרים פנויים. גם יעד איזון בזמן אימון אינו מבטיח איזון בכל batch בשירות.
  • Expert-choice: כל מומחה בוחר טוקנים עד קיבולת קבועה. כך עומס המומחים יכול להיות שווה, אך טוקן אחד עשוי להיבחר פעמיים ואחר לא להיבחר כלל. לפי הגיליון, העבודה המקורית מציינת מגבלות ביצירה אוטורגרסיבית וב-batches קטנים; אי אפשר לבחור מתוך טוקנים עתידיים שאינם קיימים.
  • Dynamic routing: מספר המומחים משתנה לפי הטוקן. דוגמה במקור היא הוספת מומחים לפי דירוג עד שסכום הסתברויות הנתב מגיע לסף. ביטחון הנתב אינו מדידה ישירה של קושי הטוקן, ויותר מומחים אינם הוכחה לאיכות טובה יותר. יש למדוד איכות וזמן בפועל.
  • Balanced assignment: התאמה משותפת לקבוצת טוקנים שומרת על מגבלות עומס ומנסה לשמר התאמה למומחים. המחיר הוא חישוב ההתאמה ולעיתים ויתור על הבחירה הראשונה של טוקן. BASE Layers מובא כדוגמה מחקרית, לא כהוכחה שכל decoder בפרודקשן פותר התאמה גלובלית בכל צעד.
  • Hash-based routing: מיפוי דטרמיניסטי בוחר מומחים ללא gate נלמד. בגרסה המבוססת על מזהה טוקן הבחירה קבועה גם כשההקשר משתנה, אף שהייצוג שהמומחה מעבד עדיין תלוי בהקשר. בחירה פשוטה יותר באה עם פחות גמישות; טוקנים שכיחים עדיין עלולים לרכז עומס.
  • Soft MoE: המומחים מעבדים תערובות משוקללות של ייצוגי טוקנים דרך slots, ואז משלבים את התוצאות חזרה. זה שונה ממשלוח טוקן בודד ל-top-k מומחים. הגיליון מדגיש שמקור הגישה בזיהוי חזותי ושערבוב טוקנים בפענוח חייב לשמור על סיבתיות, בלי דליפת מידע מהעתיד.
  • Group-limited routing: תחילה מגבילים קבוצות מומחים כשירות, ואז בוחרים בתוכן. כאשר הקבוצות תואמות למיקום החומרה אפשר להגביל תקשורת בין התקנים או צמתים. הגיליון מביא את DeepSeek-V3 כדוגמה של עד ארבעה צמתים לטוקן. קבוצות לוגיות שרירותיות אינן מבטיחות פחות תעבורה, והוספת מגבלה למודל מאומן יכולה לשנות את החישוב שלו.
  • איזון אינו שווה latency נמוך: גם חלוקה שווה עלולה להשאיר batches קטנים למומחה ועלות העברת טוקנים גבוהה. פרקו את המדידה לניתוב, העברת טוקנים, חישוב המומחים ושילוב הפלט, כדי למצוא את השלב האיטי בפועל.
  • מסלול לימוד serving: הגיליון מציע פרויקט שירות אחד לאורך עשרה שבועות, עם 50 מפגשים בני חצי שעה. הנושאים כוללים vLLM ו-SGLang, PagedAttention, מדידה לפני אופטימיזציה, continuous batching, chunked prefill, קוונטיזציה ו-speculative decoding. זה תכנון לימודים, לא התחייבות שכל התקנה או ניסוי יסתיימו בחצי שעה.
  • מדדים ו-cache: עקבו אחרי זמן לטוקן ראשון, זמן בין טוקנים, throughput, עומק תור ו-p50/p95/p99 בעומסים שונים. Prefix caching חוסך חישוב של קידומת משותפת ולא יצירת טוקנים חדשים. יש להבחין בין פינוי קידומות לשימוש חוזר לבין מחיקת היסטוריית attention שבקשה פעילה עדיין צריכה.
  • ניסוי של אלף בקשות במקביל הוא תרגיל עומס מותנה בחומרה ובמשימה, לא הבטחה לכושר שירות של GPU כלשהו. השוו איכות לצד זיכרון ומהירות, ותעדו benchmark שאפשר לשחזר במקום להסתמך על ממוצע או ציון מודל יחיד.
  • Onyx, שחוזר גם בגיליון קודם, מוצג כפלטפורמת צאט שאפשר לארח עצמאית עם מודלים שונים, אינדוקס מקורות, כלי מחקר ו-MCP. טענות המחברים על מספר connectors, רישוי, דירוג benchmark ומהירות חיפוש אינן אימות עצמאי ולא מעידות על התאמה לכל ארגון.

למי זה מתאים: מהנדסי inference שבוחנים MoE, עומסי serving ותוכנית למידה מעשית, ורוצים להפריד בין תכנון מודל לבין הגדרות פריסה.

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

MoEroutinginferenceservingOnyx
לגיליון המקורי ←

5 בנובמבר 2026

Finding Every Vulnerability Made Security Harder

5 בנובמבר 2026

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

  • תיאום סוכנים: בדוגמת Grok Bot של המחברים יש מנהל פרויקט, מפתח backend, מפתח frontend ובודק. רק מנהל הפרויקט מעדכן את לוח המשימות. כל מסירה כוללת נתיבי קבצים, חוזה ממשק, החלטות ועבודה שנותרה; תואר תפקיד לבדו אינו מעביר את המידע הזה.
  • InsForge מתואר בגיליון כ-backend עם Postgres, אימות, אחסון ו-edge functions. מפתח ה-backend בודק את המצב הקיים לפני שינוי, כדי שהנחה שגויה לא תעבור למסמך המסירה ותהפוך לתוכנית של הסוכן הבא. זו הצגת הכלי של המחברים, לא בדיקת מוצר שלנו.
  • צוואר הבקבוק הוא אימות הממצאים: הגיליון מצטט 29,439 חולשות מועמדות ב-Project Glasswing, ו-516 תיקונים מתוך 6,157 ממצאים שדווחו למתחזקים נכון ל-2 באוקטובר. אלה מספרים המובאים במקור ולא אומתו כאן בנפרד; מועמד לחולשה אינו חולשה מאומתת.
  • שרת מקומי אינו גבול אבטחה מספיק: לפי תיאור מקרה OpenCode בגיליון, בקשה מדף חיצוני יכלה להגיע לשירות מקומי ולעבור דרך קלט שלא נבדק עד למנגנון התקנת חבילות. הבעיה נבעה משילוב של כמה רכיבים ומאובדן בדיקה בזמן מעבר מסגרת, לא משורה בודדת שנראתה חשודה.
  • הניסוי המדווח: המחברים בנו דשבורד מקומי עם Claude Code, כ-2,150 שורות בשני תריסרי מודולים ו-90 בדיקות שעברו. הם הוסיפו בכוונה מודול המדמה את פגם העדכון. לכן מעבר הבדיקות אינו הוכחה לאבטחה, והדוגמה אינה מבחן עיוור על קוד טבעי בלבד.
  • לפי המחברים, Deep Scan של CodeRabbit על main החזיר שישה ממצאים: חמישה בדרגה בינונית ואחד נמוך. בין הדוגמאות: מסלול קלט למתקין, CSRF, SSRF כתוצאה מבדיקת DNS שאינה זהה לחיבור בפועל, מניעת שירות ושמירת הגדרות ללא הרשאה. אלה תוצאות של ניסוי יחיד המוצג בשיתוף מסחרי.
  • ראיה מועילה לממצא כוללת נקודת כניסה, מסלול בין קבצים, נגישות הנתיב ותנאי ניצול. כך אפשר לבדוק את הטענה מול הקוד במקום להתחיל את החקירה מחדש. המקור מציין גם גבול: סורק של מאגר אחד אינו יודע בהכרח את ההקשר החיצוני.
  • תיקון אינו סוף הבדיקה: בדוגמה המדווחת נוצר PR שמגביל את קלט העדכון לגרסה תקינה ומוסיף בדיקות רגרסיה. העיקרון הוא לעצור קלט לא מורשה לפני פעולה רגישה, ולבדוק שהמסלול המקורי אכן נחסם. הסיכום אינו אימות לגרסה בטוחה של מוצר כלשהו.
  • הבחנה שימושית: בדיקת אבטחה של PR מתמקדת בשינוי; סריקה של המאגר הקיים יכולה למצוא מסלולים שלא הופיעו ב-diff חדש. אין בגיליון הוכחה שסורק אחד מוצא את כל החולשות או מחליף סקירה אנושית.

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

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

אבטחהCodeRabbitInsForgeמסירות עבודהתוכן ממומן
לגיליון המקורי ←

4 בנובמבר 2026

Grok Bot Masterclass

4 בנובמבר 2026

בקצרה: גיליון המייל מציג שני נושאים: Harness Arena להשוואת תצורות סוכן, ותוכנית של מדריך וידאו בן 38 דקות לבניית צוות Grok Bot. הכיסוי כאן הוא של טקסט המייל ורשימת הפרקים בלבד, לא של הווידאו עצמו. פער הקרדיטים המוצג במייל משווה גם harness וגם מודל שונים, ולכן אינו מוכיח יתרון של harness לבדו.

  • Harness Arena, כחלק מ-HarnessRouter, מתואר ככלי שמריץ אותה משימה מול כמה צירופי harness ומודל, עם אותם קבצים, כלים, skills ובדיקות. הפלט כולל עלות, זמן, pass/fail ותוצרים. זו הצגת הכלי של מחברי הניוזלטר, לא בדיקה עצמאית שלנו.
  • קודם נכונות, אחר כך מחיר: לפי המייל, תצורה צריכה לעבור את המשימה לפני שמשווים עלות וזמן. ריצה זולה שנכשלה אינה חיסכון שימושי.
  • ההשוואה המספרית דורשת זהירות: המחברים מציגים Hermes עם GPT-5.2 שעבר 5 מתוך 5 ריצות ב-0.47 קרדיטים, מול Claude Code עם Opus 4.8 שעבר 3 מתוך 5 ב-223 קרדיטים. יחס של כ-475 בקרדיטים הוא תוצאה מדווחת של משימה אחת עם שני משתנים שונים, לא ניסוי מבוקר ב-harness בלבד ולא יחס מחירים כללי.
  • כדי לבדוק harness בנפרד צריך לקבע את המודל, המשימה והבדיקות. אפשר גם להשוות תצורות שלמות אם זו ההחלטה העסקית, אך אז צריך לקרוא לתוצאה השוואת תצורות ולא לייחס את ההבדל למרכיב יחיד.
  • מדריך Grok Bot: המחברים אומרים שהשקיעו מעל 100 שעות בשבועיים ומפעילים 14 בוטים, אך משוחחים ישירות רק עם ארבעה. אלה נתונים אישיים שלהם, לא המלצה על מספר בוטים מתאים לכל צוות.
  • רשימת פרקי הווידאו כוללת יצירת בוט, routines, שימוש במחשב ואפליקציות מחוברות, skills והפקת skill מהקלטת מסך. בהמשך מוצג מבנה של מנהלים ועובדים, לוח משימות ב-Notion ותקשורת הנהלה בקבוצה.
  • תרחישי ההדגמה לפי רשימת הפרקים: סריקת תיבות וקבוצות, ניתוח תוכן ומתחרים, איורים וטיוטות, וזרימה מ-GitHub issue ל-PR. לא צפינו בהדגמות ולכן אין כאן הוראות התקנה, אימות שהפעולות עובדות או המלצה להעניק גישה לחשבונות.
  • הערת מקור וכיסוי: הסיכום מבוסס על גיליון המייל ועל טקסט הגיליון המקביל בארכיון הציבורי, שפורסם ב-4 בנובמבר 2026 לפי UTC. הקישור הוא לגיליון המקורי. חלק Grok Bot מסכם את רשימת פרקי הווידאו בלבד; הווידאו עצמו לא נצפה ולא סוכם.

למי זה מתאים: מי שמשווה תצורות סוכנים או רוצה להבין את נושאי מדריך Grok Bot לפני צפייה, בלי להסיק מסקנות מתוצאה יחידה.

Grok BotHarnessRouterbenchmarksצוותי סוכניםכיסוי חלקי
לגיליון המקורי ←

3 בנובמבר 2026

Agent Framework vs. Agent Harness, clearly explained!

3 בנובמבר 2026

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

  • [ממומן: DigitalOcean] הפתיח מציג ניתוב בקשות למודלים זולים כפתרון שיכול דווקא לייקר עבודה: סיווג מוסיף זמן, כללים מתיישנים, ומעבר מודל באמצע סשן עלול לפגוע ב-prefix cache וביציבות. מוזכרים session pinning ו-model affinity, וכן Plano ו-Arch-Router. אלה טענות והצעת מוצר בפינת שותפות, לא המלצה שנבדקה עצמאית.
  • Framework מספק הפשטות למודלים, כלים, מצב ותזמור. בדוגמת עיבוד חשבוניות, המודל מציע פעולה והקוד בודק אם עברו תנאי האישור. תזמור מפורש מפריד שיקול דעת מחוקים דטרמיניסטיים, במיוחד כשכסף או רשומות משתנים.
  • Framework אינו מחייב מסלול קבוע מראש: LangGraph יכול לשלב צעדים דטרמיניסטיים, החלטות מודל, שמירת מצב והתערבות אנושית. גם גרף מבוקר יכול להכיל לולאת סוכן שהפעולה הבאה שלה נקבעת מתוך הממצאים.
  • Harness מוסיף בחירות תפעוליות סביב הלולאה: גישה לקבצים, הרצת פקודות, ניהול הקשר, מעקב התקדמות והאצלת עבודה. Deep Agents מוצג כדוגמה הבנויה מעל LangChain ו-LangGraph. במקום לבנות כל רכיב, מגדירים סביבת עבודה, כלים וגבולות גישה.
  • משימה ארוכה צריכה מצב בר-בדיקה מחוץ לשיחה: סיכום יכול לשמור מטרה ולפספס איזו מיגרציה כבר רצה או איזה טסט עוד נכשל. commits, תוצאות בדיקות וקובצי משימות עונים על שאלות שונות. הגיליון מפנה לעבודה של Anthropic על setup ראשוני וסשנים מצטברים עם בדיקות תכונה מפורשות.
  • ארכיטקטורה משולבת: workflow חיצוני אוכף הרשאות ורושם תוצאה; בתוך צעד שלו harness מאפשר לסוכן לחקור כשל ולהחזיר ראיות. הלולאה שעובדת אינה הוכחה שהפיצ׳ר שהוזמן באמת עובד. האחריות להגדרת הצלחה ולווידוא התוצאה נשארת אצל האפליקציה.
  • בדיקה שימושית: להפסיק משימה בכוונה ולחדש אותה. האם הסוכן חוזר על עבודה שהושלמה, שוכח כשל פתוח או מכריז הצלחה בלי בדיקה? לבדוק גם התאוששות מכלי שנכשל, מצב אחרי restart, ואכיפת אישורים על תתי-סוכנים. מבחן מופרע מלמד יותר מדמו נקי.
  • Latent Sparse Attention: לפי סיכום המאמר בגיליון, במקום לסרוק כל key כדי לבחור קשב דליל, מאגדים keys לאשכולות משמעות ומחפשים דרך centroids; אחר כך מריצים attention מדויק על המפתחות שנבחרו. המנגנון מוזיל את הבחירה, אך אינו מבטל את גידול ה-KV cache עם אורך ההקשר.
  • חשוב לקרוא את מכפיל המהירות בהקשר: 22.7x מול sparse attention של GLM ו-72.4x מול full attention של Qwen הם נתוני prefill לשכבה אחת, ב-10 מיליון טוקנים ועל H200 יחיד. שיפור זמן מקצה לקצה עד הטוקן הראשון הוא 2.2x ו-9.2x בהתאמה; מתחת לכ-512 אלף טוקנים התועלת מקצה לקצה קרובה לאיזון. אלה מספרי המקור שמסכם הגיליון, לא הבטחת ביצועים כללית.

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

agent harnessframeworkLangGraphניהול מצבattentionLLM routing
לגיליון המקורי ←

2 בנובמבר 2026

12 Optimizers for Training Neural Networks, clearly explained!

2 בנובמבר 2026

בקצרה: שלושה נושאים. המרכזי: 12 אופטימייזרים לאימון רשתות נוירונים דרך המבט ההנדסי - מה כל אחד שומר בזיכרון ואיך הוא הופך גרדיינט לעדכון. בנוסף: 6 שלבים מלאים לבניית מודל ML (האלגוריתם הוא אולי 15% מהעבודה), ובמבוא - פינת ממומנת ל-Beacon של Asymptote Labs, שכבת זיכרון לסוכני קוד. הערה: הניוזלטר עבר פלטפורמה (מ-Substack ל-Kit/Ghost); הגיליון התקבל במייל, ומאז פורסם גם בעמוד ווב - הקישור מוביל אליו.

  • [ממומן - שותפות עם Asymptote Labs, הטענות שלהם] Beacon: שכבת זיכרון open-source לסוכני קוד (Claude Code, Cursor, Codex, OpenCode, Cline ועוד 20+ harnesses). סוכן שלמד פתרון debug אתמול שוכח אותו מחר - Beacon לוכד traces של סשנים (פקודות, שינויי קבצים, שגיאות), מחלץ מהם ידע לשימוש חוזר כ-skills, ומעדכן או מוציא משימוש ידע שהפסיק לעבוד. Beacon Cloud מסווג ממצאים שעתיים ל-security/skill/behavior, ו-beacon handoff מאפשר להמשיך עבודה בסוכן אחר. הם טוענים שרץ מקומית בלי backend; השקה ב-Product Hunt. לא נבדק על ידינו.
  • מומנטום וצעדים אדפטיביים: SGD עם momentum צובר ממוצע נע של גרדיינטים - כיוונים עקביים נצברים ומתנגשים מבטלים זה את זה, אבל אין צעד פר-פרמטר. AdaGrad מוסיף צבירת ריבועי גרדיינטים לכל פרמטר (טוב לפיצ'רים דלילים) אבל המכנה רק גדל וצעדים קטנים ל-0; RMSprop מחליף בממוצע נע אקספוננציאלי; Adam משלב momentum + מומנט שני - וזו לא מדידת קמור (Hessian).
  • רגולריזציה וזיכרון: AdamW מנתק את weight decay מהעדכון האדפטיבי (ב-Adam רגיל הקנס מחולק גם ב-√v). בעלות זיכרון: שני מומנטים של Adam ב-FP32 = כ-8GB על מיליארד פרמטרים. Adafactor שומר סטטיסטיקות שורה+עמודה (n+m במקום n×m); Lion שומר רק סימן של שילוב momentum-גרדיינט (כל קואורדינטה זזה באותו גודל; דורש LR קטן יותר, אל תעתיקו מ-AdamW); AdEMAMix משלב EMA מהיר ואיטי עם מומנט שני.
  • מבנה מטריצות וקמור: Shampoo מעבד את הגרדיינט עם סטטיסטיקות מטריציוניות (יקר באחסון ובחישוב); SOAP מסובב לבסיס העצמי של ה-preconditioners של Shampoo, מריץ שם Adam ומסובב חזרה; Muon כמעט-מאורתגונל עדכוני momentum למטריצות מוסתרות עם Newton-Schulz (embeddings, שכבת פלט ווקטורים נשארים על AdamW); Sophia משתמשת באומדן קמור אלכסוני שמתרענן מדי פעם + clipping פר-איבר.
  • המלצת ההשוואה של המחבר: AdamW כריצת ייחוס; לחץ זיכרון → Adafactor או Lion; עדכוני מטריצות → Muon/Shampoo/SOAP. לכל אופטימייזר חיפוש LR משלו, אותה דאטה/מודל/eval, ולדווח גם איכות ב-budget קבוע וגם זמן לאיכות יעד. החשבון שחובר לזכור: 20% פחות צעדים ב-30% יותר זמן לצעד = ~4% יותר איטי בסך הכל.
  • נושא MLOps: 6 שלבים לבניית מודל - הגדרת מטרות ו-KPIs (כולל שאלה אם ML בכלל מתאים), הכנת דאטה (רוב הזמן), בחירת אלגוריתם ו-framework, אימון איטרטיבי עם כיוונון היפר-פרמטרים, הערכה על test set כולל בדיקת הטיה, ופריסה + מוניטורינג ל-drift. האלגוריתם מקבל את כל תשומת הלב אבל הוא אולי 15% מהעבודה - השאר הנדסה ותשתיות.
  • הערת מקור: הניוזלטר עבר מ-Substack ל-Kit (מייל) עם אתר Ghost חדש. גיליון זה התקבל במייל במלואו והסיכום נכתב ממנו; מאז פורסם עמוד הווב של הגיליון והקישור עודכן להוביל אליו.

למי זה מתאים: מאמני מודלים שרוצים מפה הנדסית של tradeoffs בין אופטימייזרים (זיכרון/חישוב/איכות), ומי שבונה תהליך ML מקצה לקצה.

אופטימייזריםאימוןMLOpsסוכני קודממומן
לגיליון המקורי ←

31 באוקטובר 2026

Why Other Requests Change Your LLM's Output

31 באוקטובר 2026

בקצרה: שלושה נושאים. המרכזי: אותה שאילתה בטמפרטורה 0 יכולה להחזיר תשובות שונות בגלל בקשות אחרות שחולקות אתה batch על ה-GPU - חיבור נקודה-צפה לא אסוציאטיבי, וה-kernel מפצל סכומים שונה לפי גודל ה-batch. הפתרון: batch-invariant kernels (דגל ב-vLLM, SGLang ו-DeepInfer) במחיר throughput. בנוסף: UHP - פרוטוקול אחיד להרצת harnesses של סוכנים (מספרי הבנצ'מרק של הפרויקט עצמו), ו-retriever-free RAG ממאמר של Cornell/ASAPP שמנווט עץ מסמכים עם decision model.

  • המדידה של Thinking Machines Lab: 1,000 השלמות של 'Tell me about Richard Feynman' מ-Qwen3-235B בטמפרטורה 0 נתנו 80 השלמות שונות. כולן זהות ב-102 הטוקנים הראשונים; בטוקן 103 התפצלו - 992 'Queens, New York' מול 8 'New York City'.
  • המקור הפיזיקלי: רוב ה-forward pass הוא צבירת סכומים, וחיבור נקודה-צפה לא אסוציאטיבי (כל חיבור מעגל). ב-fp16, (1024 + 0.4) + 0.4 = 1024 אבל 1024 + (0.4 + 0.4) = 1025. ה-kernel בוחר אסטרטגיית פיצול (split-K / split-KV) לפי גודל ה-batch כדי להעסיק את כל ה-SMs - batch קטן מפצל כל סכום על פני SMs, batch גדול סוכם בשורה אחת. סדר חיבור שונה = logits שונים במקצת. זה לא רעש אקראי: אותו batch בדיוק נותן תוצאות זהות ב-bit.
  • מתי זה משנה: כששני טוקנים כמעט תקועים שווים (הפרש של 0.0002 ב-logits מספיק להפוך argmax בטמפרטורה 0), וכל טוקן הבא מותנה ב-prefix אחר - כך כל ההשלמה מתפצלת. בפרודקשן עם continuous batching, גודל ה-batch משתנה בכל צעד פענוח, כך שכל טוקן שלכם עלול לרוץ ב-batch אחר.
  • התיקון: batch-invariant kernels - כל שורה מצטמצמת באותו סדר קבוע ללא קשר ל-batch, במחיר throughput (ה-kernel לא יכול לבחור את הפיצול האופטימלי). הדגלים: VLLM_BATCH_INVARIANT=1 ב-vLLM (בטא), --enable-deterministic-inference ב-SGLang (האטות של 25-45% בבנצ'מרקים של LMSYS לפי הניוזלטר), DEEPINFER_BATCH_INVARIANT=1 ב-DeepInfer של DeepSeek (NVIDIA בלבד). עם הדגל דולק, כל 1,000 ההשלמות יצאו זהות.
  • למי זה קריטי: evals, RL rollouts וכל מה שדורש שחזוריות. ב-RL הרווח הגדול ביותר - כשה-sampler וה-trainer מחשבים מספרים זהים ב-bit, האימון נשאר באמת on-policy (ה-KL divergence נשאר 0 בריצה שלהם). ההמלצה: להדליק ולהתייחס ל-batch composition כחלק מהסט-אפ הניסיוני.
  • נושא 2 - UHP (Unified Harness Protocol): פרוטוקול סטנדרטי להרצת משימות סוכנים על כל harness - ה-backend שולח משימה עם harness_id, HarnessRouter (מימוש השרת בקוד פתוח) מריץ את הלולאה הנטיבית ומזרים בחזרה תוצאות. תומך ב-30 harness bases לפי הפרויקט, כולל Codex, Claude Code ו-Gemini CLI; Qoder של Alibaba אימץ. הבנצ'מרק שפורסם על ידי הפרויקט עצמו (לייחס אליו, לא מדד עצמאי): אותה משימה ואותו מודל עם harness שונה חסך 32-53% קרדיטים, וההפרש בין הזול ליקר ביותר היה 99.8% - משימה אחת בלבד, אז המספרים שלכם ישתנו.
  • נושא 3 - retriever-free RAG (מאמר Cornell/ASAPP): בניגוד ל-vectorless RAG מאתמול (LLM גנרטיבי מנווט עץ), כאן decision model - מודל שלא מייצר טקסט אלא מחזיר במעבר אחד הסתברות לכל שאלת כן/לא על קונטקסט משותף ('האם המסמך רלוונטי?') - מנווט עץ מסמכים: מדרג מסמכים, פותח רק את הנבחרים, מדרג פסקאות, ובשאלה אחת מרובת-ברירות מסדר את ה-top 20.
  • התוצאות על Natural Questions (מספרי המאמר): התשובה בבחירה הראשונה 65.4%, מול 48.0% לחיפוש embedding + reranker בגודל 8B ו-60.8% ל-GPT-5 שמדרג את ה-dense top 20. היתרון הוא בדירוג, לא בכיסוי: top 100 של embedding מכיל את התשובה ב-98.4% מול 94.0% לניווט - אבל כששניהם מכילים, הניווט מציב אותה ראשונה ב-70.1% מול 61.9%.
  • המגבלות (כפי שצוינו): צריך היררכיה הגיונית; מסמך שנגזם מוקדם אבוד לתמיד; והדילוג על embeddings הוא רק בזמן שאילתה - עץ הויקיפדיה (2.68M פסקאות מ-108,626 עמודים ל-1,000 אשכולות) נבנה אופליין עם e5-base-v2 embeddings ו-k-means, וסיכומים נכתבו על ידי Qwen3-8B. מדיונ retrieval: פחות מ-2 שניות לשאילתה - אבל כל שיטה תורזמה בסט-אפ שונה, אז זו לא השוואת מהירות מבוקרת.

למי זה מתאים: מהנדסי ML שמריצים evals או RL וצריכים שחזוריות, בוני RAG שמשווים גישות retrieval, ומי שמתכנן תשתית סוכנים רב-harness.

סקירת ה-UHP/HarnessRouter כוללת מספרי בנצ'מרק שפורסמו על ידי הפרויקט עצמו (משימה אחת) וקריאה לכוכב ב-GitHub - נראה כמו תוכן קידומי, המספרים מיוחסים למקור. הקישורים ל-RAG crash course (חלקים 1-15) הם קידום הקורס של הניוזלטר. מספרי Natural Questions הם מספרי המאמר, לא אומתו עצמאית.

determinismbatch-invariant kernelsRAGretrievalharnessevals
לגיליון המקורי ←

30 באוקטובר 2026

RAG vs. Vectorless RAG, clearly explained!

30 באוקטובר 2026

בקצרה: שני נושאים. המרכזי: למה חיפוש דמיון וקטורי נכשל על מסמכים ארוכים ומובנים (אותה תבנית כל שנה, הפניות לאנספים), ואיך RAG בלי וקטורים - אינדקס עץ-תוכן שה-LLM מנווט בו כמו אנליסט שקורא 10-K - פותר את זה, במחיר קריאות LLM לכל שאילתה ובניית אינדקס יקרה. בנוסף: Weaver של Mirai מאיץ speculative decoding על מקבוק (מספרי היצרן).

  • שני כשלים של similarity search על מסמכים מובנים: דוחות שנתיים של אותה חברה זהים בתבנית ורק המספרים משתנים - שאלה על FY2022 נוחתת באותו מרחק מצ'אנק של FY2025, והמודל עונה מהשנה הלא נכונה בלי ששום דבר מסמן את זה; והפניות - הצ'אנק עם 'ראה נספח G' עולה ב-top-k, אבל הטבלה בנספח עצמה לא דומה לשאילתה ולעולם לא נשלפת. contextual retrieval של Anthropic + reranker מורידים כשלי retrieval מ-5.7% ל-1.9%, אבל עדיין מדרגים לפי דמיון.
  • האלטרנטיבה: בלי embeddings ובלי vector DB. ב preprocessing, פריסת ה-layout של כל מסמך לעץ תוכן - כל צומת מחזיק כותרת סעיף, טווח עמודים ותקציר קצר; שום דבר לא מפוצל לצ'אנקים (טבלה לא נחתכת באמצע) והעץ כולו נכנס בקונטקסט. ב-PageIndex, המימוש ה-open-source הפופולרי, המבנה נלקח מה-layout ומודל בסיסי רק כותב את התקצירים.
  • בזמן שאילתה: ה-LLM קורא את העץ ובוחר את הסעיפים המבטיחים - כולל ללכת בעקבות הפניה לנספח, בדיוק כמו אנליסט שפותח דוח שנתי. אם הראיות לא מספיקות, חוזרים לעץ ופותחים עוד צמתים; התשובה מגיעה עם ציטוטי עמוד, והמערכת מודעת להיסטוריית הצ'אט.
  • המחיר (בנצ'מרק של צוות PageIndex עצמו - יש לייחס): 63 שאלות על דוחות NVIDIA של FY2022-FY2026 - העץ ענה נכון על כל ה-63 בעלות של כ-$110 ל-1,000 שאילתות; סטאפ וקטורי הכי טוב הגיע ל-92.1% רק עם top-100 צ'אנקים (~$134); ב-top-10 וקטורי עולה רק ~$15 אבל לא עבר 76.2%. כלומר וקטורי זול יותר ב-k רגיל, פחות מדויק על מסמכים כאלה.
  • עוד שני מחירים: latency - כל קפיצה בעץ היא קריאת LLM נוספת, ו-PageIndex לא פרסם מספרי latency; ועלות בניית האינדקס - בנצ'מרק עצמאי על ~1,000 מסמכים ויתר מראש על עצים כי הבנייה ארכה 2-5 דקות של קריאות LLM למסמך. והעץ עובד רק כשיש מבנה אמיתי - לערימת פניות תמיכה אין תוכן עניינים.
  • כלל אצבע: עץ למסמכים ארוכים ומובנים (דיווחים, חוזים, מדריכים); vector DB להרבה טקסט קצר ולא קשור. הניסוח שלהם: חיפוש וקטורי שואל איזה טקסט נראה כמו השאלה; RAG בלי וקטורים שואל איפה במסמך התשובה אמורה להיות.
  • הנושא הנוסף - speculative decoding על מקבוק (חפוף לגיליון 28.10; מדידות של היצרן על חומרה שלו): Qwen3.5 9B על M5 MacBook Pro - 22.0 טוקנים/שנייה בלי, 34.7 עם speculative decoding רגיל, ו-92.1 עם DFlash + Weaver במנוע Uzu. DFlash מנחש כל פוזיציה במקביל אבל בלי תלות, ואי-התאמה מוקדמת זורקת את ההמשך; Weaver (שכבת Transformer אחת, 56.7M פרמטרים) בוחר משמאל-לימין בין המועמדים ובונה עץ המשכים שהמודל הראשי מאמת במעבר אחד - 7.5 טוקנים לכל מעבר של ה-9B. במאמר: 4.08x על B200. הקוד פתוח ב-github.com/trymirai/uzu.

למי זה מתאים: מי שבונה RAG על מסמכים ארוכים ומובנים (דוחות כספיים, חוזים, מדריכים) ורואה תשובות מדויקות-לכאורה מהמקור הלא נכון; וכל מי שמריץ inference מקומי על Apple Silicon.

בנצ'מרק PageIndex (63/63, מחירים) הוא דיווח עצמי של הצוות; מספרי Uzu/Weaver הם מדידות יצרן (Mirai) על חומרה שלו - לא אומתו. הגיליון במייל כלל גם פריט hands-on על RAG חסכוני בזיכרון ('32x' מתייחס לאחסון וקטורים בינארי מול float32 בלבד) שאינו חלק מהפוסט הזה - תוכן מנויים נפרד שלא כוסה כאן.

RAGretrievalPageIndexspeculative decodingvector DB
לגיליון המקורי ←

29 באוקטובר 2026

Prefix-Aware LLM Routing, clearly explained

29 באוקטובר 2026

בקצרה: שלושה נושאים. המרכזי: prefix-aware routing - אותה בקשה על אותם GPU יכולה לחכות 92 שניות או חצי שנייה לטוקן הראשון, תלוי רק לאן הראוטר שולח אותה. הראוטר מעשיר את הבקשה ל-worker שכבר מחזיק את הקידומת הארוכה ביותר ב-KV cache שלו, דרך האשים של בלוקים ואינדקס זעיר. בנוסף: למה LLM inference שונה מ-ML רגיל, וקטע חסות של AWS על RLVR ב-SageMaker.

  • הבעיה: בתוך מנוע אחד prefix caching עובד מצוין, אבל בקלאסטר כל רפליקה מחזיקה KV cache משלה. עם 8 רפליקות וראוטינג אקראי, התור הבא של השיחה נוחת על ה-GPU החם רק פעם מ-8 - ובשאר הפעמים GPU אחר מחשב מחדש קידומת שכבר קיימת בזיכרון אצל מישהו אחר.
  • איך זה עובד: ה-cache מאוחסן בבלוקים של 16 טוקנים, וכל בלוק מקבל האש שכולל את האש האב - שינוי טוקן אחד משנה את כל ההאשים אחריו. הראוטר מחזיק רק אינדקס hash→workers: לפי החשבון של llm-d, מאגר KV של 365GB (DeepSeek-R1 ב-FP8 על 8 H200) צריך אינדקס של כ-339KB בלבד. כל worker מדווח על יצירה/פינוי של בלוק באירועי ZMQ, כך שהאינדקס משקף מה שבאמת בזיכרון - זה ההבדל מראוטינג 'משוער' שמנחש מהיסטוריית הראוטינג שלו.
  • עומס מול cache: אם הראוטר רודף רק אחרי hits, ה-GPU החם נעמס. ב-NVIDIA Dynamo הנוסחה מאזנת: (בלוקי prefill פחות בלוקים ב-cache) ועוד עומס decode - ולפעמים worker עם פחות התאמה מנצח כי הוא פנוי יותר. זה knob: יותר קרדיט ל-cache מוריד TTFT, פחות מפזר עומס ומוריד latency בין טוקנים.
  • המספרים (בדיקות של llm-d עצמה, לא אומתו כאן): על 8 pods של vLLM ו-16 H100, עם 150 'לקוחות' שחולקים קונטקסט של 6,000 טוקנים, p90 של time-to-first-token ירד מ-92.6 שניות בראוטינג אקראי ל-0.54 שניות בראוטינג מדויק מבוסס קידומת - פי 170. ה-throughput כמעט הוכפל (4,429 ל-8,730 טוקנים/שנייה). ראוטינג מבוסס עומס בלבד לא עזר בכלל (94.9). בהרצה חוזרת על vLLM חדש יותר הפער הצטמצם אבל עדיין מעל 99% שיפור ב-p90.
  • התנאי שזה יעבוד: הקידומת חייבת להישאר זהה בדיוק. טיימסטמפ בראש ה-system prompt שובר את כל הבלוקים אחריו; אותו טיימסטמפ בסוף עולה רק את הזנב. לכן חלקים יציבים (system, כלים, מסמכים) קודם, ומה שמשתנה בסוף.
  • בונוס: למה LLM inference שונה מ-ML רגיל - continuous batching (אין גדלים קבועים, מחליפים רצפים שסיימו בחדשים), פירוק prefill-decode לבריכות GPU נפרדות, KV cache עם PagedAttention נגד פרגמנטציה, ו-expert parallelism ב-MoE שדורש מנוע מסובך יותר מרפליקציה פשוטה. (קטע ראשון בחסות AWS: RLVR ו-verifier engineering ל-text-to-SQL דרך SageMaker - כולל טענות השיווק של הספונסר, לא אומתו.)

למי זה מתאים: מהנדסי inference ופלטפורמה שמשרתים LLMs על יותר מרפליקה אחת, וכל מי שמשלם על GPU ורוצה לנצל את ה-KV cache בקלאסטר.

הקטע הראשון (RLVR ב-SageMaker) הוא תוכן ממומן של AWS - סומן כחסות ולא כוסה כהמלצה. מספרי הביצועים (פי 170 ב-TTFT, הכפלת throughput) הם מבדיקות של llm-d עצמה ולא אומתו. הסיכום נכתב מהטקסט המלא, בגישה מלאה.

inferenceprefix cachingKV cachevLLMllm-dראוטינגGPU
לגיליון המקורי ←

28 באוקטובר 2026

Why DeepSeek stores its KV cache on disk

28 באוקטובר 2026

בקצרה: שלושה נושאים בגיליון. המרכזי: למה DeepSeek שומרת את ה-KV cache שלה על דיסק - כשה-cache קטן מספיק (MLA דוחסת אותו ב-93.3%) והאחסון רחב מספיק (מערכת הקבצים 3FS קוראת מאלפי SSD במקביל), טעינה מדיסק הופכת מהירה מחישוב מחדש. לפי DeepSeek, פרומפט של 128K טוקנים שפגע ב-cache קיבל טוקן ראשון תוך חצי שנייה במקום 13 שניות, ו-cache hit זול פי 50. לצידם: Magnitude, מנוע inference פתוח ב-Rust שמכוונן את עצמו לשבב שלך, והסבר על early exaggeration ב-t-SNE.

  • הבעיה: prefill על פרומפט ארוך הוא החלק האיטי בשרת, ובקשות רבות חוזרות על אותה קידומת - system prompt, הגדרות כלים, תורי שיחה קודמים. ברירת המחדל היא לשמור את ה-KV בזיכרון ה-GPU, אבל הוא קטן וקידומות ישנות נדחפות החוצה מהר מדי.
  • שני החלקים של הפתרון: MLA (Multi-head Latent Attention) שומרת וקטור דחוס אחד לטוקן לשכבה במקום K/V נפרדים לכל ראש - קיצוץ של 93.3% ב-cache לעומת מודל 67B הקודם שלהם. ו-3FS, מערכת הקבצים המבוזרת שלהם, מפזרת בלוקים על אלפי SSD וקוראת במקביל, כך שרוחב הפס מצטבר; ההעתקה ל-GPU נעשית שכבה-שכבה תוך כדי שהמודל כבר רץ.
  • מהפקת לקחים לפי DeepSeek (נתוני החברה, לא נבדקו כאן): ביום אחד של תעבורת פרודקשן 56% מטוקנני הקלט הוגשו ישירות מהדיסק; הקידומות נשמרות 3 ימים לתעבורת סוכנים ו-7 ימים לצ'אט; וב-deepseek-flash cache hit עולה פי 50 פחות מ-miss. טיפ פרקטי: רק התאמה מדויקת מהטוקן הראשון נחשבת hit, אז כדאי לשים את החלקים היציבים (system, כלים, מסמכים) בתחילת הפרומפט.
  • Magnitude (Apache 2.0, Rust): מנוע inference מקומי שמקמפל את ה-kernels של המודל על המכונה שלך במקום קונפיגורציה אחת לכולם, בוחר את המהירה ביותר לשבב שלך ומצמיד drafter ל-speculative decoding. הכותב מדווח על פי 2.7 ב-decode מול Ollama - מבדיקה עצמית אחת על M5 בסיסי עם Qwen3.5 4B ב-4 ביט, מספר לא מאומת שדורש בדיקה עצמאית.
  • Early exaggeration ב-t-SNE: בשלבי האופטימיזציה הראשונים מכפילים את הסתברויות השכנות P בקבוע גדול מ-1, מה שמייצר אשכולות הדוקים ומופרדים יותר במפה הדו-ממדית. החיסרון: ההגזמה פוגעת גם בזוגות רחוקים, והשיפור המוצע הוא סף (למבדא) שמגזים רק זוגות קרובים ומחליש את הרחוקים.

למי זה מתאים: מהנדסי LLM ו-inference, מי שמריץ מודלים מקומית על Mac, וכל מי שמשלם על API ורוצה להוזיל זמן תגובה ועלות דרך cache hits.

מספרי הביצועים של Magnitude (פי 2.7) הם מבדיקה עצמית אחת של הכותב ולא אומתו; נתוני DeepSeek (פי 26 מהירות, פי 50 מחיר, 56% מהתעבורה) הם פרסום של החברה עצמה. הסיכום נכתב מהטקסט המלא של הגיליון, בגישה מלאה.

KV cacheDeepSeekMLA3FSinferencet-SNEמקומיspeculative decoding
לגיליון המקורי ←

27 באוקטובר 2026

Which OCR Solution Works Best for Your Documents?

27 באוקטובר 2026

בקצרה: מודל ה-OCR עם הממוצע הטוב ביותר יכול להיות הבחירה הלא נכונה עבור המסמכים שלך. הגיליון מריץ את DeepSeek-OCR, PaddleOCR-VL ו-Surya של Datalab על אותם 150 עמודים ומנתח לפי סוג עמוד במקום ממוצע אחד: Datalab מובילה בממוצע (88.2 מול 77.5 ו-73.4), אבל DeepSeek-OCR מוביל בטבלאות (87.2), ובטופס מס 1040 מלא PaddleOCR-VL החזיר רק את הכותרת. הכלי הוא OmniParse Bench - בנצ'מרק פתוח של מבחני עובר/נכשל עם תגיות קושי, כך שאפשר למדוד parser רק על עמודים שדומים לשלך.

  • למה ממוצע מטעה: אף אחד לא מעבד "מסמך ממוצע" - צוות ביטוח מעבד טפסי תביעה סרוקים, צוות מחקר מאמרים דו-טוריים עם משוואות, צוות כספים טבלאות צפופות. ה-parser שמוביל בממוצע יכול להיכשל דווקא בסוג העמוד שחשוב לך.
  • לוח התוצאות מהרצת ה-150 עמודים: Datalab 88.2, DeepSeek-OCR 77.5, PaddleOCR-VL 73.4. אבל בטבלאות DeepSeek-OCR הטוב ביותר (87.2 מול 78.9 ו-78.0) - צוות עם מסמכי טבלאות צפופות יבחר parser אחר ממה שהממוצע מציע.
  • כשלים דרמטיים לפי סוג: בכתב יד Datalab עברה 5 מתוך 6 מבחנים ושני האחרים 0. בטופס 1040 מלא, PaddleOCR-VL החזיר רק את כותרת הטופס (0 מתוך 8), Datalab 8 מתוך 8 ו-DeepSeek-OCR 6 מתוך 8. parse שמחזיר רק כותרת הוא סיכון אחר לגמרי מכמה תאים שגויים - וממוצע אחד מכסה על ההבדל.
  • המתודולוגיה: במקום מספר אחד ל-parser, כל עמוד נבדק במבחני כן/לא פשוטים ("השורה קיימת בפלט?", "התא תחת הכותרת הנכונה?", "A מופיע לפני B?") עם סיבה לכל כשלון. הניקוד רץ כקוד פתוח - אין LLM ששופט את הפלט.
  • OmniParse Bench: 16,288 מבחנים על 2,937 עמודים ב-92 שפות מ-2,343 מסמכי מקור. שלוש משפחות (טקסט, טבלאות, layout) והציון הראשי הוא ממוצע המשפחות; עמוד שקריאת ה-parser בו נכשלה נספר 0, כך שאי אפשר להיראות טוב בזכות השמטת עמודים קשים. תגיות (כתב יד, סיבוב, טקסט זעיר, סריקות מזוהמות, טפסים, מתמטיקה, רב-טוריות, שפה) רק בוחרות מבחנים, לא משנות מעבר - אפשר לנקד parser על כתב יד בלבד או על טבלאות בצרפתית בלבד.
  • גלוי נאות: Datalab בנתה את הבנצ'מרק, ו-Surya הוא המודל שלה. בדיוק בגלל זה חשוב שהניקוד פתוח - אפשר להריץ מחדש כל מבחן ולקרוא למה כל אחד עבר או נכשל, בלי לסמוך על leaderboard של אף אחד. לפני שמתחייבים ל-parser, מריצים אותו על הפרוסות שמתאימות למסמכים שלך.
  • מאמר נוסף בגיליון: החוקר העמוק (deep research) שמדורג ראשון ב-DeepResearch Bench - Onyx, קוד פתוח. הממצא המפתיע: לסוכן ה-orchestrator שמנהל את כל אסטרטגיית המחקר אין גישת חיפוש בכלל. ברגע של-orchestrator יש חיפוש, הוא מתחיל לענות בעצמו במקום לפרק משימות. בלי חיפוש הוא נאלץ לכתוב בריפים מלאים וקוהרנטיים לכל סוכן מחקר. הארכיטקטורה מוגבלת לשני רמות (מניעת עיוות בסיכומים) ורצה בשלושה שלבים: פירוק ל-6 כיווני מחקר, 3 סוכני מחקר מבודדים עם עד 8 תת-מחזורי חיפוש-קריאה-מחשבה (כולל מסמכים ארגוניים עם הרשאות ברמת מסמך, 100+ קונקטורים), ושלב דטרמיניסטי של איחוד ציטוטים.

למי זה מתאים: צוותי נתונים ו-AI שבוחרים פתרון OCR או document parsing לפרודקשן, ומי שמתעניין בבנצ'מרקים פתוחים ובארכיטקטורות deep research.

המספרים (150 העמודים, הדירוגים והמהירויות) הם של כותב הגיליון ולא אומתו כאן; שים לב לניגוד העניינים המוצהר - Datalab בנתה גם את הבנצ'מרק וגם את המודל המתחרה. הגיליון נפתח בקטע חסות על מנוע ההסקה uzu (Mirai Labs, speculative decoding מקומי) שלא סוכם כאן. הסיכום נכתב מהטקסט המלא של הגיליון.

OCRבנצ'מרקיםOmniParse BenchDatalabDeepSeek-OCRPaddleOCR-VLdeep researchסוכנים
לגיליון המקורי ←

26 באוקטובר 2026

Why Temperature 0 Isn't Deterministic in LLM Inference

26 באוקטובר 2026

בקצרה: למה temperature 0 לא מבטיח פלט זהה: Thinking Machines הריצו את אותו פרומפט 1,000 פעמים על Qwen3-235B וקיבלו 80 תשובות שונות. האשמה היא לא ה-sampling אלא סדר החיבור ב-reductions של ה-GPU, שמשתנה לפי גודל ה-batch - כלומר לפי עומס השרת באותו רגע. הפתרון הוא batch-invariant kernels, שכבר זמינים ב-vLLM וב-SGLang במחיר של האטה.

  • הניסוי: "Tell me about Richard Feynman" 1,000 פעמים ב-temperature 0 הניב 80 השלמות שונות. כל הריצות היו זהות ב-102 הטוקנים הראשונים; בטוקן 103 רשמו 992 "Queens, New York" ו-8 "New York City", ומכאן, כי הג'נרציה אוטו-רגרסיבית, כל ריצה המשיכה מקידומת אחרת.
  • חיבור נקודה צפה אינו אסוציאטיבי: fp16 שומר 11 סיביות מנטיסה, ובין 1024 ל-2048 הערכים מרווחים בדיוק ב-1. לכן (1024+0.4)+0.4=1024 אבל 1024+(0.4+0.4)=1025 - אפשר לשחזר ב-numpy בשתי שורות. forward pass מבצע מיליארדי חיבורים כאלה, ושינוי סדר קטן מזיז את ה-logits.
  • ההסבר הפופולרי - "threads מקבילים מסיימים בסדר לא צפוי" - אינו הסיבה העיקרית: אותו קרנל על אותו קלט מחזיר תמיד ביטים זהים. הסיבה האמיתית היא ה-batch: שרת ההסקה מאחד בקשות של משתמשים שונים, והקרנלים מחלקים את העבודה לפי גודל ה-batch (split-K ב-matmul, RMSNorm, ו-split-KV/FlashDecoding ב-attention). גודל batch אחר = סדר חיבור אחר = logits שונים במקצת.
  • ההיפוך מתרחש רק כשהמובילים כמעט תקועים: logits של 12.3417 מול 12.3415 יכולים להתחלף ברעש עיגול; כשיש פער נוח, הרעש לא משנה כלום. ומכיוון שגודל ה-batch תלוי בעומס השרת, מבחינתך הפלט נראה אקראי. התכונה החסרה נקראת batch invariance - שהמספרים של בקשה לא ישתנו לפי מה שעוד רץ ב-batch.
  • התיקון נובע מהסיבה: קרנלים שמחלקים את העבודה באותה צורה בלי קשר לגודל ה-batch - ב-attention קובעים את גודל ה-split ולא את מספר ה-splits, ומעדכנים את ה-KV cache לפני הקרנל כדי שטוקנים מה-cache וטוקנים חדשים יצומצמו באותו סדר. עם זה כל 1,000 הריצות יצאו זהות. המחיר הוא מהירות: על Qwen3-8B עם 1,000 בקשות, vLLM רגיל סיים ב-26 שניות, הגרסה הדטרמיניסטית הראשונה ב-55, וקרנל attention משופר הוריד ל-42.
  • זמין היום בשני המנועים הגדולים: vLLM עם משתנה הסביבה VLLM_BATCH_INVARIANT=1 (בטא) ו-SGLang עם הדגל --enable-deterministic-inference (האטה ממוצעת מדווחת של 34.35%). מתי זה משנה: evals שצריכים להיות ניתנים לשחזור, replay של פלט תקול מפרודקשן בדיבוג, ו-RL - שם ה-sampler וה-trainer חייבים לחשב אותן הסתברויות כדי שהאימון יישאר באמת on-policy. לצ'אט רגיל זה כמעט לא משנה.

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

גישה מלאה (audience=everyone), נקרא דרך ה-API הציבורי. הגיליון כולל חלק ספונסר (Deepgram - סוכן קולי עם Flux TTS) שסומן כתוכן ממומן; מספרי הביצועים שם ובדגלים הדטרמיניסטיים הם טענות הניוזלטר ולא אומתו. ללא קודי קופון.

LLMinferencedeterminismbatchingvLLMSGLangThinking Machines
לגיליון המקורי ←

24 באוקטובר 2026

How CUDA Graph Replay Cuts Inference Overhead

24 באוקטובר 2026

בקצרה: למה ה-GPU מחכה ל-CPU בהסקת LLM, ואיך CUDA Graph replay פותר את זה: מקליטים פעם אחת את רצף הקרנלים כתוכנית ביצוע שמורה, ואז מפעילים אותה שוב ושוב בקריאת graph-launch אחת במקום להגיש כל קרנל בנפרד. בגיליון גם: HarnessRouter (קוד פתוח) שמחבר Grok Bot ל-harnesses של סוכנים אחרים, והבדלים בין RAG, Graph RAG ו-Agentic RAG.

  • הבעיה: forward pass הוא לא פעולת GPU אחת אלא המון קרנלים קטנים (attention, כפל מטריצות, normalization, sampling). ה-CPU מגיש אותם אחד-אחד דרך ה-framework, ה-CUDA runtime וה-driver. אם ה-GPU מסיים קרנל לפני שה-CPU הגיש את הבא - הוא יושב בטל, וזה נראה כפערים בפרופיילר.
  • CUDA Graph הוא תוכנית ביצוע שמורה לעבודת GPU: אילו פעולות לרוץ, עם אילו ארגומנטים, ומה התלויות ביניהן. במקום לבנות ולהגיש את הרצף מחדש כל פעם, מכינים את התוכנית פעם אחת.
  • שלושה שלבים: warm-up רגיל (אתחול, בחירת קרנלים, הקצאת buffers וצורות טנסורים), capture (CUDA מקליטה את רצף הלונצ'ים והתלויות, לא את הפלט), ו-replay (מעתיקים קלט חדש לאותם buffers ומריצים הכל בקריאת graph-launch אחת).
  • חשוב: replay לא מחזיר תוצאה ישנה - הוא מריץ מחדש את אותם קרנלים על דאטה חדשה. המודל עושה כמעט אותה חשבון; החיסכון הוא בזמן ההגשה: framework dispatch, הכנת ארגומנטים וקריאות driver יוצאים מהנתיב החם.
  • מתאים במיוחד ל-decoding של LLM כי כל צעד חוזר על אותו מסלול: טוקן נוצר, ה-cache מתעדכן, והמודל רץ שוב. אותו גרף משרת הרבה צעדי decoding.
  • המחיר: גמישות. גרף מוקלט דורש אותם קרנלים, צורות, זרימת בקרה וכתובות זיכרון בכל replay. שרתי פרודקשן מקליטים כמה גרפים לגדלי batch נפוצים; batch שלא מתאים עובר padding או נופל חזרה להרצה רגילה. יותר גרפים = יותר זיכרון וזמן עלייה.
  • גם בגיליון: HarnessRouter (github.com/HarnessRouter/harnessrouter) - שכבת תשתית בקוד פתוח שמריצה משימות של Grok Bot דרך harnesses של Codex, Hermes, Claude Code, DeepSeek ועוד, כשכל סוכן שומר על המודל, הכלים והלולאה שלו.
  • וגם: RAG רגיל לשאילתות עובדתיות חד-שלביות; Graph RAG מוסיף גרף ידע (LLM מחלץ ישויות וקשרים באינדוקס) לשאילתות multi-hop - למשל לחבר 'checkout תלוי ב-payments API' דרך 'cluster-3 בתחזוקה'; Agentic RAG נותן לסוכן LLM להחליט בזמן אמת אילו כלים ומקורות לתשאל. אלו לא רמות התקדמות אלא פתרונות לסוגי שאילתות שונות.

למי זה מתאים: מהנדסי inference ו-LLMOps שמכווננים latency/throughput, וכל מי שרוצה להבין מתי לבחור RAG רגיל, Graph RAG או Agentic RAG.

הגיליון נקרא מהמייל המלא + ה-API הציבורי; גישה מלאה (audience=everyone), ללא חלק ספונסר.

CUDAinferenceLLMGPURAGGraphRAGopen-source
לגיליון המקורי ←

23 באוקטובר 2026

Build a Jev-powered Agentic RAG

23 באוקטובר 2026

בקצרה: מדריך שלב אחר שלב לבניית מערכת RAG סוכנית כ-support desk: מודל החלטה (d1-3B של Liquid AI) בודק אם הראיות שנשלפו מספיקות לענות, ואם לא, הפנייה עוברת לנציג אנושי. הבנייה נעשית עם Claude Code ו-InsForge, וה-embeddings הם EmbeddingGemma 2 לטקסט ולתמונות.

  • שתי בעיות ש-prompt tuning לא פותר: לדעת מתי הראיות לא מספיקות, ולפעול לפי ההחלטה. מודלי החלטה (כמו Jev) לא מייצרים טקסט אלא תשובות מובנות: Choice (בחירה מתוך קבוצה), Score (ציון בסקאלה) ו-Noul (הסתברות שמשפט כן/לא נכון).
  • הרכיבים: InsForge (קוד פתוח) כ-backend עם Postgres ו-pgvector, אימות, אחסון, פונקציות edge, עדכונים בזמן אמת ושער מודלים. EmbeddingGemma 2 מייצר וקטורים ב-768 ממדים לטקסט ולתמונות באותו מרחב. מודל ההחלטה d1-3B של Liquid AI. אירוח המודלים ב-Lightning AI Studio.
  • שלב 1: מתקינים ל-Claude Code את ה-skills של InsForge (ארבעה: SDK, CLI, דיבוג ואינטגרציות), מתחברים ב-CLI ומקשרים פרויקט. נוצר קובץ AGENTS.md שמנחה את Claude Code להשתמש ב-skills במקום לנחש.
  • שלב 2: שרת FastAPI עם endpoints להטמעת שאילתות, דירוג מחדש ואינדוקס מסמכים. לפי המדריך שני המודלים נכנסים ל-GPU אחד מסוג L4 וצורכים כ-7.2GB.
  • שלב 3: טבלאות לכל חברה עם RLS (מסמכים, chunks, שיחות, כרטיסים ויומן החלטות) ואחסון פרטי. כל עמוד במסמך נשמר כקטעי טקסט (כ-220 מילים) וגם כתמונת עמוד שלמה, ולא כאיורים בודדים, כדי לא לאבד כיתובים והקשר. אינדוקס של PDF בן 20 עמודים לוקח כ-27 שניות לפי המדריך.
  • שלב 4, שער ההחלטה: פונקציית edge מטמיעה את השאלה (וצילום מסך אם יש), מחפשת בנפרד בטקסט ובתמונות, ממזגת לפי עמוד ושולחת ל-/rerank. d1-3B נותן לכל מועמד ציון רלוונטיות וניתנות למענה, עם ספים נפרדים לטקסט ולתמונה בטבלה שאפשר לשנות בלי קוד. אם אין מועמד שעובר, מנסים חיפוש רחב יותר פעם אחת, ואם עדיין לא, פותחים כרטיס במקום לקרוא ל-LLM.
  • שלב 5: כשהראיות מספיקות, שער המודלים של InsForge שולח את הטקסט ותמונות העמודים למודל חזותי, שעונה רק מהראיות ומצטט מספרי עמודים. כרטיס חדש מופיע בלוח המחוונים בזמן אמת עם השאלה והמועמדים שנדחו. הנציג עונה, הלקוח מקבל אימייל, ואפשר לשמור את התשובה כידע חדש לאחזור עתידי.
  • הערכה: שלושה צינורות על אותם מועמדים, 75 שאלות מסומנות בארבעה סוגים (אפשר לענות מטקסט, רק מצילום מסך, שאלה עם צילום מסך, וכאלה שצריך להסלים). לפי המדריך שער ההחלטה הגיע לדיוק הגבוה ביותר והיחיד שהחזיק ביצועים מלאים בשאלות מבוססות תמונה. מדרג BGE נמנע מתשובות שגויות אבל הסלים את רוב שאלות התמונה. טבלת התוצאות עצמה לא מופיעה בטקסט שנקרא.

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

הסיכום נכתב מהטקסט המלא של הפוסט (בלי הטבלאות, הקוד והצילומים). בפתיחה יש קטע על Superlinked SIE, שרת הסקה אחד לכמה מודלים על GPU אחד, שלא כוסה בסיכום. הפוסט מקדם את InsForge ואת SIE, ולא מצוין בו במפורש שהוא ממומן, ולכן כל הטענות והמספרים הם של המחבר ולא נבדקו. בלי קודי קופון.

RAG סוכנימודלי החלטהInsForgeClaude CodeRAG רב-מודליHuman-in-the-loop
לגיליון המקורי ←

6 KV Cache Quantization Approaches

23 באוקטובר 2026

בקצרה: שש דרכים לכווץ את ה-KV cache בהסקה: FP8, INT8/INT4, גרנולריות של סולמות, KIVI, דיוק מעורב עם buffer לטוקנים אחרונים, וקוונטיזציה לא-אחידה עם טיפול ב-outliers. בגיליון יש גם מאמר שני על המעבר מ-RAG חד-פעמי לשכבת retrieval עצמאית שסוכנים קוראים לה ככלי.

  • ההפרדה החשובה: קוונטיזציה של משקלי המודל לא מקטינה את ה-KV cache. המשקלים הם פרמטרים שנלמדו, וה-cache מחזיק keys ו-values שנחשבים בזמן הבקשה. מעבר מ-16 ל-8 ביט מחצה את הנתונים הגולמיים, אבל החיסכון בפועל קטן יותר בגלל סולמות, מטא-דאטה ובאפרים בדיוק גבוה.
  • FP8: אחסון כל מספר ב-8 ביט במקום 16, עם scaling factor שהקרנל שומר כדי לפרש נכון את הערכים. 1GiB של KV ב-16 ביט הופך ל-512MiB, בלי שינוי למשקלים. צריך attention kernel ו-GPU תואמים, והאחסון עצמו לא מבטיח מהירות.
  • INT8/INT4: מספרים שלמים עם סולם ולפעמים zero-point. ל-INT4 יש רק 16 רמות עיגול, ולכן שני ערכים קרובים עלולים ליפול על אותה רמה וה-attention כבר לא יבדיל ביניהם. העבודה של פירוק והמרה חזרה יכולה לאכול חלק מהרווח.
  • גרנולריות: כמה מספרים חולקים סולם אחד. ערך חריג אחד (20 בתוך קבוצה של 0-1) גוזל רמות עיגול מכל השאר. קבוצות קטנות מגבילות את הנזק אבל כל קבוצה עולה סולם משלה, ולכן שני מימושים עם 4 ביט יכולים לצאת שונים בזיכרון ובדיוק.
  • KIVI: ניתוח מצא שערכי key חריגים נצמדים לערוצים מסוימים, ולכן keys מקבצים לפי ערוץ על פני בלוק טוקנים, ו-values לפי טוקן. המקור מכוון ל-2 ביט בלי כוונון, אבל הדיוק חייב להיבדק על המודל ועל עומס העבודה הספציפי.
  • דיוק מעורב: טוקנים אחרונים נשמרים ב-buffer בדיוק גבוה, וכשהוא מתמלא מכמתים בלוק לתוך ה-cache. הטוקנים החדשים נמנעים משגיאת קוונטיזציה, ובנוסף נאספים מספיק טוקנים לקיבוץ בסגנון KIVI. באפר גדול יותר שווה פחות חיסכון.
  • לא-אחיד ו-outliers: רמות לא מרווחות באופן שווה (למשל יותר רמות ליד האפס אם שם הריכוז). KVQuant מפריד ערכים חריגים לאחסון דליל עם המיקומים שלהם, ושאר הערכים מקבלים טווח צר יותר, במחיר תקורת אחסון של החריגים.
  • בדיקת כדאיות: cache קטן יותר מאפשר הקשרים ארוכים יותר או יותר בקשות מקבילות על אותו GPU. משווים מול cache לא מכווץ על אותם מודל, פרומפטים ותחרותיות, ובודקים זיכרון כולל, latency של פענוח ואיכות תשובות.
  • המאמר השני בגיליון - שכבת retrieval: לפי הגיליון, Anthropic (עם MCP) וגוגל (עם ה-RAG Engine תחת Gemini) מסכימים ש-retrieval הוא לא צינור חד-פעמי אלא כלי שסוכן קורא לו בתוך לולאה. התיקון: שכבה עצמאית שמפרידה ingestion מ-query, מסנכרנת רק מה שהשתנה (content hashing), ונחשפת ב-API לכל האפליקציות והסוכנים.
  • הבעיות ב-RAG נאיבי: מיושנות (הווקטורים משקפים את המקור מרגע האינדוקס) ושכפול (כל אפליקציה בונה מחדש את החיבורים, החיתוך וההטמעה). השכבה העצמאית פותרת את שתיהן: סנכרון מתמשך, חיפוש היברידי עם rerank, ושיוך מקור לכל תוצאה.

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

הגיליון נפתח בקטע חסות של CopilotKit על פלטפורמת CLiF שלהם; טענות שם הן של הספק. הגיליון מקשר גם לקורס LLMOps בתשלום של היוצרים. הסיכום נכתב מהטקסט המלא של הגיליון.

KV cacheקוונטיזציההסקהLLMOpsRAGארכיטקטורה
לגיליון המקורי ←

22 באוקטובר 2026

Give Claude Code, Codex, and Cursor a Self-improving Shared Memory

22 באוקטובר 2026

בקצרה: גיליון עם הקלטת וובינר (בשיתוף Asymptote Labs) על Beacon, שכבת זיכרון בקוד פתוח לסוכני קוד. היא אוספת פעילות מ-Claude Code, Cursor, Codex ועוד, הופכת אותה להיסטוריה שאפשר לחפש בה, ולומדת ממנה skills וכללי אבטחה שמשותפים בין הכלים.

  • הבעיה: סוכני קוד עובדים בממלכות נפרדות. תיקונים שעשיתם ב-Cursor לא עוברים ל-Claude Code, ו-skills שנבנו ב-Codex לא עוברים אוטומטית לכלים אחרים, אז מעבר בין כלים אומר להתחיל מאפס.
  • שכבת זיכרון אחת ליותר מ-20 סוכני קוד: Beacon אוסף פעילות דרך OpenTelemetry, hooks וקבצי session מקומיים, ומנרמל הכול לפורמט אחד. כל prompt, קריאת כלי, פקודה, שינוי קובץ ותשובה נשמרים כ-trace מובנה שאפשר לחפש בו.
  • המשך עבודה בכלי אחר: אם נגמרה מכסת השימוש ב-Cursor, אפשר לפתוח Claude Code ולבקש להמשיך את ה-session האחרון מ-Cursor. לפי הגיליון, Beacon שולף את ההקשר הרלוונטי תוך אלפיות שנייה.
  • למידה מעבודה קודמת: Beacon מזהה תהליכי עבודה שחוזרים על עצמם והופך אותם ל-skills. בדמו הוא גילה תהליך חוזר של פיתוח ממשק וייצר skill עם פקודות שרת הפיתוח, שלבי צילומי מסך והוראות פריסה.
  • ניקוי skills: במקום לצבור מאה skills ולהשתמש בחמישה, Beacon מנתח שימוש בפועל על פני אלפי sessions וממליץ אילו כדאי לשמור, לאחד או להסיר.
  • כללי אבטחה שעוברים בין כלים: מאות כללי זיהוי שפועלים בין סוכנים, למשל רצף שבו סוכן קורא פרטי גישה רגישים ואז שולח בקשה החוצה לרשת.
  • מקרה אמיתי מהדמו: בבדיקת ההיסטוריה של Justin ב-Cursor, Beacon הצביע על אירוע שבו חלק מסיסמת מסד נתונים בייצור נשלח לספק מודל.
  • התחלה: מדביקים prompt הקמה בסוכן הקוד. הכול קוד פתוח, אפשר להשאיר הכול מקומי במחשב או להשתמש ב-Beacon Cloud בחינם. הקוד ב-github.com/Asymptote-Labs/agent-beacon.

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

הסיכום נכתב מהטקסט המלא של הפוסט. הגיליון ממומן על ידי Asymptote Labs ("thanks to Asymptote Labs for partnering today"), ולכן הטענות על Beacon הן טענות הספק ולא נבדקו. בפתיחה יש פריט קצר על Onyx (פלטפורמת צ'אט בקוד פתוח, 32 אלף כוכבים ב-GitHub), שלא כוסה בסיכום. סרטון הוובינר עצמו לא נצפה. בלי קודי קופון.

סוכני קודBeaconזיכרון סוכניםClaude CodeCursorאבטחה
לגיליון המקורי ←

21 באוקטובר 2026

The Next Step After Karpathy’s Agentic Engineering

21 באוקטובר 2026

בקצרה: גיליון hands-on (בשיתוף Google Cloud, תוכן ממומן) על בעיה אמיתית של סוכנים ארוכי טווח: סוכן RAG שמחכה לאישור אנושי שיכול להגיע אחרי שעות, כשהתהליך והקונטיינר כבר לא קיימים. הפתרון המוצג הוא ריצה שניתנת לחידוש מאותה נקודה ופעולות שבטוח לחזור עליהן (idempotency), עם Agents CLI של Google, ADK ו-Agent Runtime.

  • הבעיה: סוכן RAG שולף ארבעה מסמכי מדיניות ומנסח תשובה מצוטטת ללקוח, אבל הקריאה האחרונה לכלי דורשת אישור אנושי. עד שהאישור מגיע, תהליך הפייתון כבר יצא. הרצה מחדש יוצרת פעולה חדשה: שליפה חדשה יכולה לשנות את הראיות והטיוטה, ופרסום חוזר עלול להתבצע פעמיים. היסטוריית צ'אט לא מספיקה כדי לשחזר את זה בבטחה.
  • הכלים (לפי הגיליון): Agents CLI של Google מתקין שבע skills בסוכן הקוד שכבר משתמשים בו (Claude Code), כמו קוד ADK, scaffolding, הערכות, פריסה, פרסום ותצפיתיות. ההתקנה היא uvx google-agents-cli setup, ואז פרויקט ADK קטן שמכוון ל-Agent Runtime.
  • התרחיש: בסיס ידע של חמישה קבצי Markdown (אירוח אזורי, שמירת נתונים, אימון מודלים, בקרות אבטחה, הסלמת תמיכה). שני כלים: retrieve_passages (שליפת TF-IDF דטרמיניסטית) ו-submit_for_publication שמאמת ציטוטים ועוצר לאישור אנושי. השאלה: איפה נשמרים נתוני לקוחות באיחוד האירופי, כמה זמן נשמרים לוגים וגיבויים, והאם תוכן לקוחות משמש לאימון מודלים.
  • עצירה וחידוש: בהרצה הראשונה השליפה החזירה ארבעה קטעים, הסוכן ניסח תשובה עם מזהה קטע אחרי כל טענה, ועצר בבקשת האישור. ADK שומר את בקשת האישור כחלק מה-invocation, וה-session נשמר ב-SQLite. התהליך יצא לגמרי, ובתהליך חדש האישור חידש את אותה קריאה. מספר השליפות נשאר אחד, כלומר הראיות והטיוטה הגיעו מהתהליך המקורי.
  • ניסיון חוזר חייב להיות לא מזיק: כלים שניתנים לחידוש בדרך כלל מבטיחים ביצוע לפחות פעם אחת, אז אותו כלי עלול לרוץ שוב. אין בעיה בשליפה, אבל בתשלום, אימייל, פתיחת כרטיס או פרסום זה מסוכן. הפתרון: מפתח idempotency שנגזר מהתשובה ומזהי הציטוטים, ובדיקה לפני הפרסום אם כבר קיים רישום שהושלם. אישור כפול החזיר already_published, ושני המונים (שליפה ופרסום) נשארו על אחד. ה-outbox המקומי הוא הדמיה, ובייצור שמים את אותו מפתח במסד נתונים או ב-API החיצוני.
  • עצירה מוקדמת של שאלות לא נתמכות: לשאלה האם למוצר יש הרשאת FedRAMP High אין תשובה בבסיס הידע. השליפה החזירה supported=False, הסוכן לא ניסח טיוטה ולא ביקש אישור, והעניין עבר להסלמה לצוות האבטחה. ציון השליפה משמש כשער פרסום, והסף לא מזהה הזיות בעצמו.
  • מעבר ל-Agent Runtime (בפלטפורמת הסוכנים של Google Cloud): לפני יצירת משאבים Claude Code בדק ותכנן את היעד, ה-Agent Identity, שירות ה-session, ה-APIs וההרשאות. אחרי הפריסה לסוכן יש principal משלו בענן, ו-SQLite הוחלף בשמירת session מנוהלת. אותו תרחיש רץ מרחוק: ההרצה נעצרת בבקשת אישור, הלקוח יוצא, תהליך חדש טוען את ה-session ומאשר, והאישור הכפול מחזיר already_published.
  • המסקנה של הגיליון: פיתוח סוכנים (מגדירים, בונים, בודקים, פורסים) הוא לולאה טובה, אבל בייצור צריך גם שריצה לא גמורה תישאר נגישה מעבר לתהליך שהתחיל אותה, ושפעולה שחוזרת תהיה בטוחה.

למי זה מתאים: מהנדסי AI שבונים סוכנים ארוכי טווח עם אישור אנושי באמצע, ורוצים דפוס פשוט לחידוש ריצה ולניסיונות חוזרים בטוחים. כרגע הדוגמה היא על ADK ו-Agents CLI של Google.

התוכן המלא של הגיליון לא היה נגיש (חסום בתשלום), והסיכום מבוסס על החלק הציבורי בלבד. הסיכום נכתב מהטקסט המלא של המייל. הגיליון ממומן על ידי Google Cloud ("thanks to Google Cloud for partnering with us"), ולכן הטענות על Agents CLI ו-Agent Runtime הן טענות הספק ולא נבדקו. בפוסט באתר התוכן למנויים בלבד, לכן הגישה מסומנת חלקית. בטקסט המייל חסרים קטעי הקוד, הצילומים וסרטוני הדמו, ולכן הסיכום מכסה את הנאמר בטקסט בלבד. קישורי הקידום (membership) לא כוסו. בלי קודי קופון.

סוכניםADKAgents CLIIdempotencyRAGHuman-in-the-loop
לגיליון המקורי ←

20 באוקטובר 2026

Agents 2.0 is here!

20 באוקטובר 2026

בקצרה: גיליון עם שני תוכנים חדשים: (1) Switch — שכבת תיאום open-source בין סוכנים מספקים שונים ואנשים, בסביבת עבודה משותפת (קטגוריית ספונסר). (2) הסבר ויזואלי על continuous batching בסרבינג של LLM — למה static batching מבזבז את ה-GPU כשאורכי הפלט משתנים, ואיך תזמון מחדש אחרי כל forward pass מגיע לפי 23 throughput. קטע ה-Uzu חוזר מהגיליון של 14.10 ואינו חדש.

  • Switch (קטגוריה ממומנת — 'Together with Switch'; טענות לא אומתו): המסגרת — Anthropic, OpenAI ו-xAI כולם ממהרים לבנות 'AI coworker', אבל כל מוצר קושר מודל+runtime+זיכרון+תזמון לסטאק של חברה אחת, ורוב הצוותים עובדים עם כמה ספקים (Claude Code, Codex, OpenCode מקומי, סוכנים פנימיים) — ומרכיבים את הדבק בעצמם.
  • מה Switch מציע (לטענת הגיליון): שכבת תיאום בקוד פתוח שאפשר לארח עצמאית, שמכניסה אנשים וסוכנים מספקים שונים לסביבה משותפת אחת בתוך Slack, Teams, Discord, Telegram או Mattermost. אנשים מדברים עם סוכנים, סוכנים מדברים אחד עם השני, ואפשר להצטרף לשיחה ולהוסיף הקשר תוך כדי העבודה. גיטהאב: github.com/sandbox-quantum/switch.
  • דפוס ה-Manager: נותנים לכל סוכן תפקיד; ה-Manager יוצר חדרים, מכניס את הסוכנים הרלוונטיים, מעביר הקשר ביניהם ומחזיר תוצאה. בדמו נתנו לו שני אינצידנטים (API של inference מחזיר 500 אחרי דיפלוי; ג'וב אימון של מודל המלצות קפוא 6 שעות) — הוא פתח שני חדרים מקושרים עם Software Engineer, Architect ו-QA Lead, הריץ את שתי החקירות במקביל, והמהנדס זיהה שאותו config push גרם לשניהם; ה-Manager החזיר RCA מאוחד לערוץ. מוצג גם Switch Console למעקב אחרי הסשנים. נבנה מקומית עם Docker ו-Mattermost.
  • Continuous batching (התוכן הטכני הראשי): ב-ML קלאסי batch היא מטריצה — כל הקלטים מרופדים לאותו אורך ומסיימים יחד. ב-LLM כל forward pass מייצר טוקן אחד לרצף, ואורך הפלט לא ידוע מראש. ב-static batching בקשה שסיימה ב-30 טוקנים מחזיקה את הסלוט עד שהאיטית ב-batch (400 טוקנים) מסיימת — וה-GPU ממשיך לשלם את קריאת המשקלים המלאה על batch כמעט ריק.
  • הפתרון: התזמונאי מחליט מחדש אחרי כל forward pass — בקשה שסיימה יוצאת בגבול האיטרציה הבא ובקשה ממתינה תופסת את הסלוט מיד. אף סלוט לא נשאר שמור לעבודה שהסתיימה.
  • בנצ'מרק (לטענת הגיליון, Anyscale על OPT-13B עם A100 אחד): באורכי פלט אחידים שתי השיטות שוות כצפוי; ככל שהשונות גדלה, static batching צנח ל-~81 טוקנים לשנייה בעוד vLLM הגיע לפי 23 throughput מול Hugging Face נאיבי. הווריאנס הוא כל הפער — ותעבורת פרודקשן מערבבת תשובות של 30 ו-400 טוקנים, בדיוק התנאי ש-static מתקשה בו.
  • לא משנים את המודל בכלל: vLLM, SGLang, TGI ו-TensorRT-LLM מריצים את זה כברירת מחדל; אצל NVIDIA זה נקרא in-flight batching. מצורף קישור למדריך מעמיק על המתזמן: מה קורה בין שני forward passes, חלוקת טוקנים מול תקציב קבוע, למה אין נתיב נפרד ל-prefill ו-decode, ומחיר ה-preemption כשה-KV cache מתמלא.
  • קטע Uzu (מנוע inference מקומי, 92 טוקנים/שניה מול 22 ב-llama.cpp על M5, פענוח ספקולטיבי עד 16 פוזיציות עם Weaver ואימות עץ): חוזר כמעט מילה במילה מהגיליון של 14.10 — לא תוכן חדש.

למי זה מתאים: מהנדסי ML/AI: מי שמספק מודלים בפרודקשן (החלק על continuous batching רלוונטי ישירות), ומי שמנסה לתאם כמה סוכנים מספקים שונים (קטע הספונסר שווה מבט זהיר).

התקבל במייל 20.10; עדיין לא מופיע בארכיון האתר, לכן הקישור מפנה למדריך ה-continuous batching שאומת (200). קטע ה-Switch הוא תוכן ממומן ('Together with Switch') — טענותיו לא אומתו. קטע ה-Uzu חוזר מהגיליון של 14.10 וסומן כלא-חדש. מדדי הביצועים בשני הקטעים הם טענות הגיליון, לא אומתו עצמאית.

LLM ServingContinuous BatchingvLLMAgentsCoordinationSponsored
לגיליון המקורי ←

17 באוקטובר 2026

Run Jev Inside an Open Agent Harness

17 באוקטובר 2026

בקצרה: שלושה חלקים: (1) דמו end-to-end של סוכן follow-up ללקוחות שמריץ את Jev — מודל החלטות קטן שמחזיר בחירה מובנית עם ציון ביטחון בלי לייצר טקסט — בתוך TrueForge, ה-harness הפתוח (MIT) של TrueFoundry, עם Daytona כסנדבוקס. (2) איך הופכים LLM למודל החלטות: מקפיאים את ה-backbone, מוסיפים LoRA ומחליפים את ה-LM head ב-decision head. (3) מפה של שמונה שכבות ההנדסה מסביב למודל בפרודקשן.

  • הדמו: סוכן שממפה בקשות לקוח ל-GitHub issues. לטענת הגיליון, על 40 בקשות הוא השיג דיוק כמו Opus שמבצע כל התאמה — בעלות החלטה נמוכה פי 150 (טענת ניוזלטר, לא אומתה). התאמות עם ביטחון נמוך חוזרות ל-Opus לביקורת, ובמבחן הביקורת תפסה 5 התאמות שגויות שאחרת היו עוברות.
  • הסטאק: TrueForge כ-harness (קוד פתוח, רישיון MIT, רץ מקומית בפקודה אחת) — שומר על context קטן: טוען הגדרות tools רק לפי צורך, כותב פלטים גדולים לקבצים ונותן לסוכן לעבד דאטה בסקריפטים במקום בשיחה; credentials נשארים מחוץ לסנדבוקס וכל כתיבה ממתינה לאישור. לטענת הגיליון, ב-Enterprise Bench של DevRev הוא פתר בערך כמו Claude Managed Agents בכשליש מהטוקנים (טענת ניוזלטר, לא אומתה). Jev (TypeSafe AI) מקבל את האפשרויות מהאפליקציה ומחזיר בחירה עם ביטחון מכויל — בלי ג'נרציה.
  • איך בונים מודל החלטות מ-LLM: מגדירים שאלות ואפשרויות (איזה צוות יטפל בטיקט? האם לזכות?), מקפיאים את ה-backbone ומוסיפים LoRA, מחליפים את ה-LM head ב-decision head שאוסף ראיות לכל אפשרות ונותן ציון לכל בחירה, softmax נפרד לכל שאלה, אימון ב-cross-entropy רק על ה-head וה-LoRA, וכיול (calibration) על דוגמאות מוחזקות-בצד כדי שהביטחון ישקף דיוק אמיתי. בזמן inference: forward pass אחד מדרג את כל האפשרויות. בדמו המקומי שלהם (Qwen3.5 0.8B): דיוק עלה מ-37% ל-65% ב-60 צעדים, 10 דקות אימון על 4GB VRAM (מספרי הגיליון).
  • מפת 8 השכבות: model foundations (טוקניזציה, embeddings, pre/post-training, context window, logits, sampling); inference ו-serving (prefill מול decode, KV cache, prefix caching, speculative decoding, continuous batching, quantization, PagedAttention, TTFT/TPOT); context engineering (budgeting, context rot, lost-in-the-middle, compaction, offloading, just-in-time retrieval); agents ו-harness (לולאת ReAct, thin מול thick harness, sub-agents, MCP, skills/hooks, verification loops); retrieval וזיכרון; adaptation ואימון (SFT, LoRA, RLHF/DPO, GRPO, distillation, דאטה סינתטי); evals ו-observability; ו-safety ואבטחה.
  • נקודת העלות: לטענת הגיליון, ב-H100 עם Llama 70B בקשה אחת מגיעה ל-92% ניצול GPU ב-prefill וצונחת ל-28% ב-decode — אותה חומרה, עומס שונה; ואין טכניקה אחת שסוגרת את הפער — שילוב של 8-9 טכניקות (compression, attention, decoding, caching, routing) הוא מה שמגיע לפער עלות של 5-8x מול inference נאיבי ב-FP16 (טענות ניוזלטר).

למי זה מתאים: מהנדסי סוכנים שרוצים להוריד עלויות החלטות עם מודל ייעודי במקום LLM גדול לכל בחירה, ומי שמחפש harness פתוח לרוץ איתו מקומית — פלוס סקירה שיטתית של כל שכבות ה-LLMOps.

גיליון 17.10, נכתב מתוכן המייל המלא + הפוסט שעלה (אומת 200). טענות ביצועים/עלות מסומנות כטענות ניוזלטר. פרסומות הקורסים והמינוי הוצאו.

Decision ModelsJevAgent HarnessTrueForgeLoRALLMOpsOpen Source
לגיליון המקורי ←

16 באוקטובר 2026

A Full Walkthrough on Multimodal Jev

16 באוקטובר 2026

בקצרה: גיליון משולב: Jev מקבל יכולת ראייה — walkthrough וידאו מלא של Jev מולטימודלי (תמונות, שאלות מקבילות, caveats). בנוסף: UHP, פרוטוקול סטנדרטי להרצת משימות סוכן מעל כל harness עם HarnessRouter כשרת open-source, ושאלת ראיון על CUDA Graphs — למה מעבר ל-GPU מהיר יותר לא תמיד מזרז decoding.

  • Jev מולטימודלי (הנושא הראשי): 'Jev can see now' — סרטון walkthrough מלא שמדגים עבודה עם תמונות: דמו מולטימודלי, איך Jev עובד, Jev עם תמונות, walkthrough של אפליקציית דמו, עבודה עם מספר תמונות, שאלות מקבילות, ו-caveats עם 'danger zone headers'. למי שלא מכיר: הגיליון מפנה למאמר הרקע על decision models (כבר סוכם כאן בכרטיס 'Jev, clearly explained').
  • UHP — Unified Harness Protocol: ממשק סטנדרטי להרצת משימות סוכן מעל כל agent harness. ה-backend שולח task + harness_id ל-HarnessRouter (מימוש שרת open-source), שמנתב ל-harness המוגדר, מזרים progress ו-artifacts חזרה ומחזיר את הפלט. שלושה רכיבים: Gateway (Responses API, קונפיגורציית harnesses, מפתחות מודלים), Runner (workspaces מבודדים, event stream אחד, checkpoints per turn) וכלים מובנים (MCP servers, דפדפן, DB, GitHub, מדיה).
  • למה זה מעניין: תשתית הסוכנים הופכת להחלפה — מחליפים Codex ב-Claude Code בלי לגעת בקוד המוצר, מריצים אותה משימה על harnesses שונים ומשווים תוצאות, ומוסיפים harnesses חדשים בלי שכתוב. הריפו: github.com/HarnessRouter/harnessrouter.
  • שאלת ראיון (LLMOps): עברתם ל-GPU מהיר יותר, ה-kernels מסתיימים מוקדם יותר, אבל הזמן בין טוקנים כמעט לא השתנה. לאן נעלמה המהירות? התשובה: forward pass הוא רצף של פעולות קטנות, ובלעדי CUDA Graphs ה-CPU מגיש כל kernel בנפרד. ב-decode (טוקן אחד בכל צעד) ה-kernel מסתיים תוך מיקרו-שניות וה-GPU מחכה לעבודה הבאה — הרווחים ב-profiler הם overhead של launch, לא חישוב.
  • CUDA Graphs: לוכדים פעם אחת רצף פעולות עם התלויות ומשחזרים כיחידה אחת. ה-kernels עצמם לא מהירים יותר — הרווח הוא הסרת עבודת ה-CPU ביניהם. ב-prefill ה-kernels ארוכים וממלאים את ה-GPU, אז התועלת קטנה. המחיר: גרף דורש רצף זהה, ארגומנטים יציבים וכתובות זיכרון קבועות — לכן vLLM ו-TensorRT-LLM לוכדים גרפים לכמה גדלי batch נפוצים, ופונים ל-eager או padding כשאין התאמה. יותר captures = יותר זיכרון GPU וזמן עלייה.

למי זה מתאים: מהנדסי AI שעובדים עם סוכנים ו-harnesses, מעוניינים ב-decision models מולטימודליים, ומביני inference שרוצים להסביר מלכודות ביצועים ב-decode.

התוכן המלא של הגיליון לא היה נגיש (חסום בתשלום), והסיכום מבוסס על החלק הציבורי בלבד. הסיכום נכתב מהטקסט המלא של הגיליון ונבדק מול הפוסט באתר. הנושא הראשי הוא סרטון walkthrough, והגיליון מכיל את רשימת הפרקים — לכן הגישה חלקית. קטעי קידום (membership, 'Partner with US') לא כוסו. בלי קודי קופון.

JevMultimodalAgent ProtocolsHarnessRouterCUDA GraphsLLM InferenceLLMOps
לגיליון המקורי ←

15 באוקטובר 2026

Building a Durable Multi-Agent System with LangGraph and LangSmith

15 באוקטובר 2026

בקצרה: גיליון משולב: חלקים 5-6 של קורס Agent Engineering מכסים תזמור סוכנים מקבילים עם LangGraph (state משותף עם reducers, merging דטרמיניסטי, checkpoints ב-Postgres, אישורים עם תפוגה, LangSmith evaluation gates). בנוסף: Jev כשכבת החלטה לפני כתיבה לזיכרון ארוך-טווח ב-Graphiti, וסקירת 13 שכבות של AI engineering מודרני.

  • תזמור סוכנים מקבילים (חלק 5): הלולאה הבסיסית הופכת לצוות של עובדים מומחים עם כלים מצומצמים לקריאה בלבד. state משותף דורש reducers כדי שכתיבות מקבילות ימוזגו באופן דטרמיניסטי. עובד שנכשל הופך לתוצאה חלקית מפורשת במקום לחסום את כל החקירה.
  • עמידות ושחזור (חלק 6): ריצה יכולה להיעצר לאישור, לאבד את התהליך ולחזור שעות מאוחר יותר במכונה אחרת. נדרשים checkpoints סינכרוניים ב-Postgres, interrupts מתמשכים, אישורים עם תפוגה, והחלטה אטומית כדי שאישור, דחייה ותפוגה לא יוכלו לחדש את אותו thread פעמיים.
  • פריסה ובטיחות: thread מושהה מגרסת גרף ישנה חייב לעבוד עם הקוד הנוכחי. שינויי prompt דורשים הערכות התנהגותיות כי בדיקות יחידה דטרמיניסטיות לא תופסות כל רגרסיה. זהות חייבת לבוא מאימות ולא מגוף הבקשה, וגבולות tenant חייבים להחזיק בכל endpoint.
  • Jev לזיכרון סוכנים: extractor שמפיק זיכרונות משיחה לא יודע כמה זמן עובדה צריכה לחיות או היכן היא חלה. העדפת מושב במעברון היא העדפה קבועה, בקשת חלון לטיסה מסוימת היא חד-פעמית, ועיכוב בטיסה רלוונטי רק להיום. Jev מעריך כל מועמד לזיכרון עם שאלות מוקלדות (האם הראיות תומכות? האם חל מחוץ לטrip? מה הסיכון בשימוש חוזר שגוי?) לפני שהאפליקציה כותבת ל-Graphiti.
  • Graphiti מטפל ב-ingestion, entity resolution, עדכונים טמפורליים ושליפה. Jev רק מעריך את המועמד לפני הכתיבה. כך פחות הוראות זמניות ועדכונים שפגו נכנסים לגרף העובדות שריצות עתידיות שולפות.
  • סקירת AI engineering stack: 13 שכבות מיסודות (tokens, embeddings, transformers) דרך prompt engineering, retrieval, סוכנים, context engineering, fine-tuning, inference optimization, deployment, evaluation ו-LLMOps, ועד frontier patterns כמו decision models ו-harness engineering.

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

התוכן המלא של הגיליון לא היה נגיש (חסום בתשלום), והסיכום מבוסס על החלק הציבורי בלבד. הגיליון הוא קידום ישיר של קורסי Agent Engineering ו-LLMOps של Daily Dose of DS, וכל נושא מקושר לחלקי קורס. התוכן המאומת מוגבל לתיאור הנושאים; הקוד וההדגמות בתשלום ולא נבדקו. הסיכום נכתב מטקסט המייל בלבד.

LangGraphסוכנים מקביליםcheckpointsJevGraphitiLLMOps
לגיליון המקורי ←

14 באוקטובר 2026

A Model Decision Is Only as Safe as the System That Executes It

14 באוקטובר 2026

בקצרה: גיליון בשלושה חלקים: מנוע inference בקוד פתוח (Uzu) שמריץ speculative decoding על Apple Silicon, מדריך ממומן של CodeRabbit שבודק סוכן תגובה לאירועים שנבנה עם Claude Code, והסבר על ארבע ההקצאות של זיכרון GPU בהרצת LLM.

  • Uzu (קוד פתוח מבית Mirai, עם bindings ל-Rust, Swift, Python ו-TypeScript): בהרצה של Qwen3.5 9B על MacBook Pro עם M5 בסיסי נמדדו 22.0 טוקנים לשנייה ב-llama.cpp, 25.1 ב-MLX ו-92.1 ב-Uzu. לפי הגיליון זה לא אומר ש-llama.cpp ו-MLX לא ממוטבים: כל טוקן דורש מעבר שמזרים כ-5.2GB של משקולות דרך הזיכרון, ועם רוחב פס של כ-153GB/s התקרה היא כ-29 טוקנים לשנייה בלי קשר למהירות ה-GPU.
  • איך Uzu עוקף את התקרה: speculative decoding שמותאם ל-Apple Silicon. מערכת טיוטה מציעה כמה טוקנים עתידיים, והמודל המלא בודק אותם יחד. הוא מנסח עד 16 מיקומים ומשתמש ב-Weaver כדי להפוך ניחושים בלתי תלויים לרצפים קוהרנטיים, ומאמת כמה רצפים אפשריים כעץ ומשמר מצב רק לנתיב שהמודל המלא קיבל. המודל ה-9B נשאר זה שקובע את הפלט. בהרצה כל מעבר הפיק בממוצע 7.5 טוקנים לעומת 1 בפענוח רגיל. המנוע כולל גם checkpoints מכומתים משלו, ו-kernels של Metal שמריצים אימות דרך מסלול מטריצות int8 מואץ ב-M5. המספרים הם מהרצה של הכותבים.
  • החלק הממומן (CodeRabbit): הדוגמה היא סוכן תגובה לאירועים שנבנה ב-Claude Code בפרומפט אחד: 30 קבצים, 3,383 שורות (לקוח מודל, מנוע מדיניות, לולאת סוכן, כלים, API, דשבורד, fixtures ובדיקות). האפליקציה רצה ו-46 הבדיקות עברו. המודל (בגיליון Jev) לא כותב תשובה פתוחה אלא בוחר מתוך קבוצת אפשרויות ומחזיר הסתברות לכל אחת. הוא עונה בבקשה אחת על שש שאלות (איזה צוות אחראי, חומרה, האם לקוחות מושפעים, האם צריך עוד ראיות, האם אדם צריך להיכנס, ומה הפעולה הבאה) כש-next_action מוגבל לשישה ערכים: לבדוק לוגים, לבדוק deploy, לבדוק בריאות שירות, להקפיץ צוות (page), לבקש בדיקה אנושית או לעצור.
  • שער המדיניות: הסתברות 0.80 ומעלה מתירה את הפעולה, 0.55 עד 0.79 גורמת לאיסוף ראיות נוספות, ומתחת ל-0.55 השליטה עוברת לאדם. הקפצת צוות דורש גם אישור שלקוחות מושפעים. בתרחיש של תקלת תשלומים המודל בחר page_team ב-0.62, אז המדיניות סירבה והריצה inspect_logs, ואז קיבלה 0.50 והריצה נעצרה בלי כלי נוסף.
  • הבאג שהבדיקות החמיצו (לפי הגיליון): ב-decisions.py כשהבחירה חסרה במפת ההסתברויות, הקוד השתמש בהסתברות הגבוהה ביותר מכל אפשרות כרמת הביטחון של הבחירה. כך page_team ללא הסתברות עם inspect_logs ב-0.90 יצר החלטת הקפצה בביטחון 0.90 שהמודל מעולם לא נתן. הדשבורד והבדיקות לא חשפו זאת כי התגובות תמיד כללו את ההסתברות של הבחירה. ההתנהגות הבטוחה היא ביטחון אפס או דחיית התגובה והעברה לבדיקה אנושית.
  • ממצאי אבטחה שהגיליון מציג מ-CodeRabbit (שדירג סיכון מיזוג High והציג שישה ממצאים): טקסט אירוע שנשלח ל-Run API נשמר במצב משותף ומוכנס לדשבורד ללא קידוד, ולכן יש stored XSS. בנוסף: ה-API חושף אירועים ורשומות הערכה בלי הרשאות או בעלות, כתובת בקשת המודל ניתנת לשינוי בלי הגבלת סכמה או יעד, ו-fixture mode יכול ליפול לבקשה חיה כשאין fixture תואם. הכלי מקבץ את 30 הקבצים לשש שכבות לפי תלות ומציג 'security blast-radius'.
  • הערה על מה שנטען: הכותבים מציגים את התוצאה כסיבה להשתמש בביקורת מבוססת כלי, וקוראים לנסות את CodeRabbit (ניסיון חינם ל-14 יום). לפי הגיליון Jev הגיע בתוך 24 שעות לכמעט 13% מהצוותים בתשלום ב-Vercel AI Gateway, יותר מפי שניים מכל השקה קודמת, ונתון זה לא נבדק כאן.
  • הסבר זיכרון GPU: טעינה מוצלחת של מודל לא מבטיחה inference, כי משקולות הן רק אחת מארבע הקצאות VRAM. (1) משקולות: בקירוב ל-70B כ-140GB ב-FP16/BF16, 70GB ב-INT8 ו-35GB ב-INT4 (בלי מטא-דאטה של קוונטיזציה ועלויות מימוש), כמעט קבוע. (2) KV cache: בקירוב 2 × שכבות × ראשי KV × ממד ראש × בתים לערך לכל טוקן, וגדל עם אורך ההקשר ומספר הבקשות הפעילות (GQA ו-MQA מקטינים אותו). (3) אקטיבציות ו-workspace: תלוי בארכיטקטורה, בטוקנים שמעובדים יחד ובקרנלים, ו-prefill שונה מ-decode. (4) תקורת runtime: הקשרי CUDA, קרנלים, allocators, מטא-דאטה ובאפרי תקשורת, וגם פרגמנטציה שיכולה להשאיר מקום פנוי בלי אזור רציף מספיק גדול. סך הכול: משקולות + KV cache + שיא אקטיבציות/workspace + תקורה, ולכן גודל המודל לבדו לא קובע אם אפשר להגיש עומס נתון.

למי זה מתאים: מהנדסי ML ו-AI שמריצים מודלים מקומית או בענן, ומי שבונה סוכנים עם שער מדיניות מעל תשובות מודל.

הסיכום נכתב מהטקסט המלא של הגיליון (המייל) ונבדק מול הפוסט באתר. החלק על CodeRabbit ממומן ומציג את המוצר, וכל טענותיו (ממצאי הבדיקה, דירוג הסיכון, הבאג) הן טענות הגיליון ולא אומתו כאן. ביצועי Uzu (92.1 מול 22.0 ו-25.1 טוקנים לשנייה) הם מהרצה של הכותבים על חומרה אחת. הגרפיקה והסרטונים לא נבדקו, וקישורי הגיליון (כולל הפניות מעקב) לא נכללו.

Uzuspeculative decodingזיכרון GPUKV cacheסקירת קוד של סוכנים
לגיליון המקורי ←

13 באוקטובר 2026

6 Parallelism Strategies for LLM Inference in Production

13 באוקטובר 2026

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

  • HarnessRouter (קוד פתוח, github.com/HarnessRouter/harnessrouter): שכבת תשתית שמאפשרת להריץ harness כלשהו (Codex, Claude Code, Hermes ועוד כ-9 נוספים) מאחורי ממשק אחד, בלי לממש מחדש סשנים, streaming, קבצים, ביטול וטיפול בכשלים. ה-harnesses רצים מקומית, ופרוטוקול Unified Harness Protocol מגדיר ממשק משימה משותף תואם OpenAI Responses.
  • הנקודה המרכזית בפרלליזם: הרצת מודל על ארבעה GPUs לא ממזגת את הזיכרון שלהם. כל GPU עם זיכרון משלו, ונתונים שנמצאים באחר צריכים לעבור בחיבור לפני שהשכבה משתמשת בהם. פרלליזם מסיר מגבלת זיכרון או חישוב מקומית אבל מוסיף תקורת תקשורת.
  • ששת האסטרטגיות: Data parallelism (עותקים שלמים של המודל על קבוצות GPU נפרדות, מעלה throughput ולא עוזר כשמודל גדול מדי), Tensor parallelism (מפצל פעולות מטריצה בתוך כל שכבה, מקטין זיכרון משקולות ל-GPU אך דורש איחוד תוצאות חלקיות לאורך השכבות), Pipeline parallelism (קבוצות שכבות על GPUs שונים, וחוסר micro-batching משאיר שלבים בטלים), Context parallelism (בפיצול prefill מפצלים קלט ארוך להקטנת TTFT, ובפיצול decode מפצלים את היסטוריית ה-KV להגדלת קיבולת, אבל כל שכבה צריכה למזג attention חלקי), Expert parallelism (מפזר מומחי MoE, עם עלות ניתוב טוקנים ועומס לא שווה), ו-Hybrid (למשל tensor בתוך צומת, pipeline בין צמתים ו-data בין עותקים).
  • איך בוחרים: כל שיטה צריכה לפתור צוואר בקבוק שנמדד. אם המשקולות לא נכנסות, tensor או pipeline. אם הצוואר הוא prefill של פרומפטים ארוכים או קיבולת KV, הצורה המתאימה של context parallelism. מודלי MoE עשויים לדרוש expert parallelism. אם עותק אחד עומד ביעד ה-latency אבל בקשות מחכות בתור, מוסיפים עותקי data parallel. שומרים tensor parallelism על הקישורים המהירים, ומודדים שוב זיכרון, TTFT ו-TPOT אחרי כל שינוי, ומוסיפים שיטה נוספת רק כשהמדידה חושפת צוואר בקבוק נוסף.
  • זיכרון סוכן מבוסס סכמה: רוב מערכות הזיכרון מתמקדות ב-recall, אבל הבעיה הקשה היא מה לא לשמור. כשמודל מחלץ ישויות ויחסים מטקסט גולמי בלי סכמה, סוגי ישויות קורסים לתוויות כלליות והיחסים הופכים ל-RELATES_TO אחד, והגרף מתנהג כמו vector store יקר. לדברי הגיליון זו בעיית מבנה ולא בעיית שליפה, והפתרון הוא להגביל את מרחב הפלט לפני היצירה.
  • המרכיבים: ישויות כמודלי Pydantic עם שדות מוקלדים ו-docstrings (מגדירים מה מותר לזכור), קשתות עם מגבלות מקור/יעד (אם אין קשת בין Project ל-Competitor, הקשר לא יכול להיווצר), ופתרון זמני שמבטל עובדות ישנות ושומר היסטוריה. הסכמה מנחה את החילוץ בשני שלבים (ישויות ועובדות), ואילו איחוד כפילויות, זיהוי סתירות וחלונות זמן קורים אוטומטית. כלל אצבע: עד 10 סוגי ישויות, 10 סוגי קשתות ו-10 שדות לכל סוג, להתחיל ב-3-4 ולהרחיב רק כשהשליפה נכשלת. הספרייה שהוזכרה: Zep Graphiti (גרף ידע זמני בקוד פתוח).

למי זה מתאים: מהנדסי ML ו-AI שמריצים מודלים על כמה GPUs או בונים זיכרון לסוכנים.

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

ParallelismLLM inferenceזיכרון סוכניםHarnessRouter
לגיליון המקורי ←

12 באוקטובר 2026

How to Train an LLM With Verifiable Rewards on SageMaker AI

12 באוקטובר 2026

בקצרה: מדריך מעשי ל-RLVR (למידת חיזוק עם תגמולים שניתנים לאימות): מאמנים את Qwen3 0.6B עם GRPO ופונקציית תגמול בקוד בשירות serverless של Amazon SageMaker AI, בודקים על קבוצת הערכה קבועה ופורסים ל-endpoint. הגיליון ממומן בשותפות עם AWS.

  • הרעיון: כשאפשר לבדוק תשובה אוטומטית (מספר סופי במתמטיקה, בדיקות יחידה לקוד, ולידציית סכמה לחילוץ מידע), אין צורך לכתוב תשובה מושלמת לכל דוגמה. המודל מייצר כמה פתרונות, פונקציית תגמול מדרגת אותם, ו-GRPO מגדיל את ההסתברות לתשובות שמקבלות ציון גבוה יחסית לקבוצה.
  • ההשוואה לשיטות אחרות: SFT לומד מהשלמות יעד, PPO לרוב דורש מודל תגמול ומודל ערך נפרדים, GRPO מוותר על מודל הערך ומשתמש בתגמולים היחסיים בקבוצה כבסיס, ו-DPO לומד מזוגות מועדף/נדחה בלי RL מקוון. RLVR לא טוב יותר תמיד, אלא מתאים למשימות עם בדיקה אמינה.
  • המסר המרכזי: הפיקוח לא נעלם אלא עובר לפונקציית התגמול. המודל ממטב בדיוק מה שהיא מתגמלת, כולל קיצורי דרך. מבדק חלש יכול לייצר מודל עם ציון גבוה שנכשל במשימה האמיתית.
  • הניסוי: הסדנה של AWS (מסלול custom-reward RLVR) על Qwen3 0.6B ו-180 דוגמאות GSM8K, חמישה מחברות Jupyter ב-SageMaker Studio שנפרסות בתבנית CloudFormation (ברירת מחדל us-west-2), ודורשות חשבון AWS עם הרשאות ל-SageMaker, IAM, VPC, S3, Lambda ו-MLflow. הפיצול בסדנה הוא 129 אימון, 36 ולידציה ו-15 מוחזקות, והמחבר מציין שלא משתמשים בו לתוצאה הגדולה יותר שבמאמר.
  • חוזה ההערכה נקבע לפני האימון: מדד ראשי exact-match, מדד משני שיעור תשובות שניתן לנתח, ואורך תשובה. צריך לרשום מודל וגרסה, גדלי קבוצות, seed, טמפרטורה ומגבלת טוקנים, כלל הפענוח ותצורת ה-job, ולהריץ את מודל הבסיס והמודל המאומן עם אותם פרומפטים והגדרות פענוח.
  • תכנון התגמול (0 עד 1): נכונות מספרית 0.6, ניתנות לפענוח 0.2, פורמט תשובה סופי נדרש 0.1, וקיום נימוק לא טריוויאלי 0.1. הסיכון שהמחבר מצביע עליו: אפשר לקבל 0.4 בלי המספר הנכון, רק עם תשובה שניתנת לפענוח, הסמן המבוקש וטקסט מספיק. לכן מציירים בנפרד נכונות ופורמט, ובודקים אם אורך התשובה עולה מהר יותר מהדיוק. הבדיקות המקומיות בודקות את ה-scorer ולא את המודל שנלמד.
  • הצינור ב-SageMaker: נתונים ב-S3, ה-scorer נרשם כ-Evaluator עם גרסאות (נוצר ממנו Lambda ולכן השם צריך להיות קצר), RLVRTrainer מאמן מתאמי LoRA, ו-MLflow מתעד מדדים. אין בחירת סוג מופע, כי SageMaker בוחר ומשחרר חישוב. לפי הסדנה האימון לוקח 15 עד 20 דקות, וצריך למדוד זמן אמיתי.
  • הערכה אחרי האימון: ההערכה המנוהלת בסדנה על MATH לא מריצה את מודל הבסיס (evaluate_base_model=False), ולכן הרצה אחת לא מצדיקה טענת לפני/אחרי. בסדנה הרגילה של AWS יש השוואה: 0.406 exact match למודל הבסיס לעומת 0.507 למכוון, לפי קבצי הדוגמה שלהם. הערכים עשויים להשתנות בין הרצות.
  • פריסה: endpoint בזמן אמת על ml.g5.xlarge עם קונטיינר DJL LMI ו-vLLM, ובדיקה של אותו פרומפט על מודל הבסיס ועל מתאם ה-RLVR. בבדיקת עשן של חמש בקשות החציון של time to first token היה 0.571 שניות לבסיס מול 0.529 ל-RLVR, וזמן תגובה כולל 1.667 מול 1.867 שניות. המחבר מדגיש שחמש בקשות אינן מאפיינות עומס. בסוף מוחקים את ה-endpoint כדי לא לשלם על קיבולת פעילה.
  • שיעורים: כל טענת דיוק צריכה להיות מעוגנת בפיצול קבוע, תשובות גולמיות ובדיקות שניתנות להרצה. ה-evaluator משמש לאימון, להערכה ולבדיקת הקצה, והתגמול הוא לוגיקת מוצר שצריכה בדיקות, ניהול גרסאות וניטור לפי רכיב.

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

הסיכום נכתב מהטקסט המלא של המייל של הגיליון. הגיליון ממומן בשותפות עם AWS, והמדריך מבוסס על סדנת AWS ולכן הוא מציג את המוצר שלהם. כל המספרים (0.406 ל-0.507, זמני ה-endpoint, זמן אימון משוער) הם טענות הגיליון או AWS ולא נבדקו כאן. עלות הרצה לא פורטה במאמר. קטעי הקוד והווידאו לא נבדקו.

RLVRGRPOSageMaker AIreward designהערכה
לגיליון המקורי ←

9 באוקטובר 2026

Train your own Jev-style decision model locally!

9 באוקטובר 2026

בקצרה: הגיליון של 10.10 מכיל שני פריטים: שישה סוגי הקשר לזיכרון סוכנים (ו-Graphiti, מסגרת קוד פתוח לגרף זמני), ווידאו שמראה אימון מקומי של מודל החלטות בסגנון Jev על Qwen3.5 0.8B, עם קפיצה בדיוק מ-37% ל-65%.

  • שישה סוגי הקשר לזיכרון סוכנים: עובדות (עם תאריכי תוקף, כך שאפשר לסגור אמת ישנה בלי למחוק), ישויות (תיאור מתוחזק שמאחד עובדות על אדם, מוצר או מערכת), אפיזודות (ההודעות המקוריות עם הניסוח המדויק, שמות שדות וקודי שגיאה), סיכומי שיחה (איך סשן הסתיים, למשל שירות שוחזר אבל שורש הבעיה לא נפתר), תצפיות (דפוסים חוזרים בין שיחות, בלי להציג מתאם כסיבתיות) וסיכומי משתמש (הקשר גם כשהמשתמש רק כותב 'היי').
  • הטענה המרכזית של הגיליון: לא בונים שישה מאגרים נפרדים. מאחסנים את ההיסטוריה פעם אחת בגרף זמני וקוראים אותה בשש דרכים. לכן גם הערכת זיכרון צריכה לבדוק שהוחזרה הצורה הנכונה של הקשר לשאלה, ולא רק טקסט קרוב.
  • Graphiti (getzep/graphiti, קוד פתוח) עוקב אחרי התפתחות עובדות ושומר את המקורות, ומרכיב כמה סוגי הקשר לבלוק אחד בתקציב קבוע.
  • אימון מקומי: לפי הגיליון אימנו מודל החלטות בסגנון Jev על בסיס Qwen3.5 0.8B. הדיוק עלה מ-37% ל-65% ב-60 צעדים (כ-10 דקות) על 4GB VRAM בלבד.
  • הווידאו (כ-15 דקות) עובר על: הקמת Unsloth Studio, בחירת מודל ומערך נתונים, אימון עם LoRA, בדיקה באפליקציה, אותו תהליך בקוד, אימון והערכה (37% ל-65%), ושמירה והרצת inference.
  • בסוף הגיליון מפנה לחלקים 3 ו-4 של קורס Agent Engineering בתשלום: ניתוב, guardrails ובקרות אישור עם LangGraph ו-Jev, ואחר כך תכנון, אימות, תכנון מחדש ותנאי עצירה. זה חלק קידומי.

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

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

זיכרון סוכניםGraphitiJevאימון מקומיLoRA
לגיליון המקורי ←

8 באוקטובר 2026

Karpathy’s Trick for Faster Local LLMs Finally Has Proper Tooling

8 באוקטובר 2026

בקצרה: מדריך על Uzu, מנוע הסקה בקוד פתוח של Mirai למכשירים מקומיים (Apple Silicon), ולמה decoding בגודל batch 1 מוגבל בזיכרון. השילוב של קוונטיזציה, speculative decoding מבוסס עץ ובדיקת עץ בלי שחזור state נותן לפי הגיליון 92 עד 117 טוקנים בשנייה על M5, מול 22 ו-25 ב-llama.cpp וב-MLX.

  • הבעיה: אפליקציה מקומית מפענחת רצף אחד על מכשיר אחד, ואין batching בין משתמשים. לכן המדד הוא latency של רצף בודד. בפענוח כל טוקן דורש מעבר מלא על המשקלים, והחישוב קטן ביחס לנתונים שנעים בזיכרון, כלומר הצוואר בקבוק הוא רוחב פס הזיכרון.
  • דוגמה מהגיליון: ל-M5 בסיסי יש 153GB לשנייה ולמודל Qwen3.5 9B ב-4 ביט יש כ-5.2GB, ולכן התקרה התיאורטית היא כ-29 טוקנים בשנייה בלי speculation. קוונטיזציה מקטינה את הבתים שנקראים אבל עדיין מריצה את המודל פעם לכל טוקן.
  • קוונטיזציה ב-Uzu: Mirai מפרסמת checkpoints בגדלים (M של 4 ביט, L של 8 ביט), מכמתת גם activations ל-int8 כי ב-M5 זו הדרך המהירה, ומפעילה Random Hadamard Transform בבלוקים של 32 כדי לפזר outliers ולהקטין שגיאת עיגול.
  • Speculative decoding: מודל טיוטה קטן מציע טוקנים והמודל הראשי מאמת אותם יחד ומקבל את הרצף התקף. תקציבי הטיוטה ב-Uzu הם 16 עד 32 טוקנים, שנותנים ליחידות המטריצה של M5 מספיק עבודה.
  • בעיית קוהרנטיות בטיוטה מקבילית וה-Weaver: טוקנים שנחזים במקביל יכולים לייצר 'a few of milk'. מאמר Trees from Marginals מציע Weaver (מתאם של 56.7M פרמטרים) שבוחר ברצף מתוך מועמדים ושומר כמה ענפים. לפי המאמר שיפור של 24.7% על DFlash ו-4.37x מול פענוח רגיל, אבל בניסוי על CUDA ו-SGLang ולא על Uzu.
  • אימות עץ בלי rollback: ב-Qwen3.5 9B, 24 מתוך 32 השכבות הן Gated DeltaNet עם state בגודל קבוע. Uzu מחשב את הענפים בלי לשנות את ה-state החי ומעדכן אותו רק לטוקנים שהתקבלו.
  • השוואה מעשית: מריצים את אותו prompt עם Uzu, MLX ו-llama.cpp עם אותה הגדרה ואותו warm-up, ומשווים לפי לקוח ה-HTTP. הגיליון מציין ש-Mirai CLI לא מאפשר לכבות speculation, ולכן זו השוואת מסלולים שלמים ולא בידוד של DFlash-Weaver. התוצאות תלויות בעומס העבודה, בחומרה ובטמפרטורה, ויש לבדוק עם ה-prompts האמיתיים ולמדוד גם איכות.

למי זה מתאים: מפתחים שבונים אפליקציות עם מודלים מקומיים על Mac או מכשירי קצה ורוצים להבין מה מגביל את מהירות הפענוח.

המספרים הם של כותב הגיליון על M5 בסיסי ולא נבדקו כאן. הסיכום נכתב מהטקסט המלא של הגיליון.

הסקה מקומיתUzuspeculative decodingקוונטיזציהApple Silicon
לגיליון המקורי ←

RAG vs. Jev + RAG, clearly explained!

8 באוקטובר 2026

בקצרה: הגיליון מסביר למה RAG רגיל לא מבדיל בין "הפסקה הכי רלוונטית" לבין "פסקה שאכן עונה על השאלה", ומציג את Jev כשער לפני ה-LLM. בנוסף: חמש שיטות אינדוקס במסדי נתונים וקטוריים.

  • RAG רגיל: מפצלים מסמכים ל-chunks, יוצרים embeddings, שומרים במסד וקטורי, שולפים top-k לפי דמיון, ולעיתים מוסיפים reranker. הבעיה: דירוג ויכולת לענות הן שתי שאלות שונות. פסקה יכולה להיות הכי קרובה ועדיין להכיל ראיה חלשה או חלקית, וה-LLM ייצור תשובה סבירה שלא נתמכת.
  • Jev + RAG: שלב השליפה נשאר כמו שהוא, אבל במקום reranker רגיל Jev שופט כל מועמד מול שאלה מוגדרת ("האם הפסקה הזו עוזרת לענות?") ומחזיר הסתברות לכל אחד. הקוד של האפליקציה מגדיר סף: מעל הסף ממשיכים ל-LLM, מתחת מוסרים מהקשר.
  • אותה בקשה יכולה לשפוט גם אם הראיות שנשארו מספיקות לתשובה. אם היכולת לענות מתחת לסף, מדלגים על ה-LLM ומחזירים "לא נמצא במסמכים". Jev לא מחליף את מודל ה-embedding, המסד הווקטורי או מודל היצירה, והשליפה עדיין קובעת תקרה, כי הוא לא יכול להחזיר פסקה שלא נכנסה לקבוצת המועמדים.
  • חמש שיטות אינדוקס וקטורי: Flat (חיפוש מדויק על הכול, עלות לינארית), IVF (חלוקה לאשכולות, פרמטר probe קובע כמה אשכולות לבדוק), HNSW (גרף רב-שכבתי, מהיר ובעל recall גבוה אך צורך זיכרון), IVF-PQ (אשכולות עם קוונטיזציה של וקטורים, חוסך זיכרון ופוגע מעט ב-recall) ו-ScaNN (מחלקות וקוונטיזציה עם חישוב מדויק מחדש למובילים).
  • הבחירה היא החלטה על מה המערכת יכולה להרשות לעצמה: Flat לדיוק, HNSW מחליף זיכרון במהירות, IVF נותן שליטה בכמות העבודה, ו-IVF-PQ ו-ScaNN מצמצמים זיכרון וחישוב באוספים גדולים.

למי זה מתאים: מפתחים שבונים RAG ורוצים להפחית תשובות מומצאות ולבחור אינדקס וקטורי.

הגיליון כולל גם קטע חסות על מודל זיהוי דיבור (לא מסוכם כאן).

RAGRerankingאינדוקס וקטוריHNSW
לגיליון המקורי ←

7 באוקטובר 2026

Chunked Prefill, clearly explained

7 באוקטובר 2026

בקצרה: הסבר קצר על chunked prefill ב-vLLM: איך מפצלים פרומפט ארוך כדי שתשובות שכבר זורמות לא "יקפאו", ומה המחיר בגודל ה-chunk.

  • כל בקשת LLM היא שני שלבים: prefill מעבד את כל הפרומפט במקביל (כבד חישובית, בונה KV cache ומפיק את הטוקן הראשון), ו-decode מייצר טוקן אחד בכל צעד (מוגבל ברוחב פס זיכרון).
  • הבעיה: בקשה A כבר מזרימה תשובה, ומגיעה בקשה B עם פרומפט של 32K טוקנים. בלי chunked prefill, vLLM מעבד את כל B במעבר אחד ו-A לא מקבלת טוקן הבא, ולכן התשובה נראית קפואה.
  • הפתרון: מפצלים את הפרומפט של B לטווחי טוקנים קטנים. מעבדים chunk אחד, נותנים לבקשות הפעילות לבצע decode, וממשיכים. אותו עבודה מתבצעת, אבל לא כבלוק אחד רציף.
  • פשרות: chunks קטנים שומרים על זרימה חלקה אבל מוסיפים תקורה (כל chunk קורא שוב חלק מה-KV cache). chunks גדולים מקצרים זמן עד הטוקן הראשון. אפשר גם לערבב prefill ו-decode באותה איטרציה כדי לנצל טוב יותר את ה-GPU.
  • אין גודל אופטימלי אחד. פרומפטים ארוכים, הרבה בקשות במקביל ויעדי סטרימינג קפדניים מעדיפים chunks קטנים, ועומסים שדורשים TTFT נמוך מעדיפים גדולים. ב-vLLM V1 הפרמטר --max-num-batched-tokens שולט בזה. chunked prefill לא מקטין את העבודה שפרומפט ארוך יוצר.

למי זה מתאים: מי שמריץ שירות הסקה עם vLLM ומתלבט בין חביון זרימה לזמן עד הטוקן הראשון.

הגיליון כולל גם הצגה קצרה של מודל Surya OCR (650M פרמטרים, 91 שפות, 83.3% ב-olmocr).

vLLMPrefillLatencyהסקה
לגיליון המקורי ←

5 באוקטובר 2026

Fine-tune Meta AI's Muse Glimmer 100% locally

5 באוקטובר 2026

בקצרה: מדריך כוונון עדין של Muse Glimmer, מודל ראייה של Meta בגודל 30B בקוד פתוח, למשימת המרת תמונות של נוסחאות ל-LaTeX עם Unsloth, QLoRA ו-LoRA. הנקודות החשובות: פורמט הצ'אט ATEM, ערוץ החשיבה, ושמירה על חוזה הפלט.

  • המודל: Muse Glimmer, כ-29.6B פרמטרים בדקודר ו-1.8B ב-ViT-G/14 לראייה, מזוקק מ-Muse Spark של Meta ומאומן נוסף על נתוני סוכנים. הוא הראשון שפתוח מ-Meta Superintelligence Labs והראשון מאז Llama 4, ברישיון Apache 2.0 (בלי הגבלות משתמשים או מותג), ודחוס שנכנס ל-GPU אחד, כך שאפשר להריץ בשרת עצמי או במכונה מבודדת.
  • חיסכון ב-KV cache: רוב השכבות מסתכלות אחורה רק 2,048 טוקנים (דפוס של שלוש שכבות חלון נע ושכבה גלובלית אחת), ו-32 ראשי שאילתה חולקים 2 ראשי KV בלבד. יחד כ-60 פעמים פחות זיכרון KV מתכנון נאיבי, ולכן הקשר ברירת מחדל של 131K (עד 262K) שימושי בחומרה מקומית.
  • פורמט ATEM: כל תור נראה כ-<|start|>{role}<|message|>...<|eot|>, ולפני התשובה המודל יכול לשלוח הודעה לעצמו (ערוץ חשיבה פרטי) ורק אז לענות בערוץ המשתמש. עוצמת החשיבה (reasoning_strength) היא ברירת מחדל high, ולכן משלמים מחיר גבוה בכל פרומפט. אצל Meta ההמלצה: high לקוד וסוכנים, medium לעוזרים פשוטים, low כשמהירות חשובה. טוקני חשיבה נספרים מול max_new_tokens, וחריגה באמצע מחשבה מחזירה תשובה ריקה. הדאטה חייב לעקוב אחרי ATEM בדיוק, כי תבנית לא תואמת פוגעת באימון.
  • חוזקות: Glimmer מוביל בשימוש בכלים של סוכנים, בעיקר ב-MCP Atlas (13 נקודות מעל Qwen3.6-27B, לפי Meta). בבנצ'מרקים של ראייה ומסמכים הוא בטווח של שתי נקודות מ-Qwen3.6-27B, לפני במדד אחד ואחרי בשלושה. בנצ'מרקים כלליים לא מודדים את המשימה שלך, ולכן כוונון.
  • למה לכוונן: במשימת math OCR הבסיס מזהה את המבנה (אינטגרל, סוגריים, שבר) אבל שובר את חוזה הפלט (עוטף בתצוגת מתמטיקה, עונה פעמיים עם הערות, כותב LaTeX קומפקטי במקום עם רווחים כבדאטה) וגם מתקשה בסמלים (ζ הופך ל-χ ו-^\dagger נעלם). בבדיקת exact-match אפילו עיצוב בלבד נכשל.
  • הגדרה: Unsloth לטעינה ב-4 ביט, LoRA והאימון, ו-Hugging Face Datasets עם unsloth/LaTeX_OCR (68,686 זוגות תמונה-LaTeX). משקולות BF16 כ-56GB, וגרסת Dynamic 4-bit מקטינה אותן ושומרת ב-16 ביט שכבות רגישות. הקטנת זיכרון נוספת: טבלת ה-embedding של הקלט (כ-26% יחד עם ראש הפלט) קפואה באימון LoRA ולכן עוברת ל-RAM של ה-CPU, וראש ה-lm_head נשאר ב-GPU. QLoRA נכנס ב-24GB ו-LoRA ב-16 ביט דורש מעל 40GB, ולכן 24GB הוא המינימום הריאלי.
  • LoRA: מקפיאים את המשקולות ומאמנים מטריצות דרגה נמוכה. עם כל הדגלים (ראייה, שפה, attention ו-MLP) מאמנים 131M פרמטרים, כ-0.44%. rank 16 כנקודת פתיחה, 32 למשימות סוכניות קשות. המלצה כללית: להקפיא קודם את מקודד הראייה, אבל כאן מאמנים את שניהם כי אי אפשר לדעת אם הטעות ζ→χ היא בראייה או בשפה, ומתמטיקה מוקלדת שונה מתמונות טבעיות. אם רוצים מתאם קטן וזול יותר, לנסות קודם שפה בלבד.
  • נתונים ותבנית: ממירים כל דוגמה להודעות (תמונה והוראה בתור המשתמש, LaTeX בתור העוזר). בתבנית התמונה היא placeholder אחד של <|patch|> שהמעבד מרחיב (תמונה 448×448 הופכת ל-256 טוקנים). בהערכה ובאימון של OCR מדלגים על ערוץ החשיבה על ידי הוספת to=user<|message|> לפרומפט ופענוח חמדני (greedy) לתוצאה קבועה, בעוד Meta ממליצה על temperature 1.0, top_p 0.95 ו-top_k 64 לשימוש פתוח וסוכני.
  • אימון ובדיקה: ה-collator מרחיב טוקני תמונה וממסך הכול חוץ מתשובת העוזר, כך שהעדכונים לא הולכים לחיזוי system והוראה זהים בכל דוגמה. כדאי לבדוק לפני הרצה כמה טוקנים מאומנים ומה הם. אחרי 30 צעדים הפורמט נכון (שורה אחת, טוקנים עם רווחים, עצירה נקייה ב-<|eot|>) אבל עדיין יש שגיאות סמלים, ובמתמטיקה שגיאה אחת פוסלת נוסחה. אפשר להחליף max_steps=30 ב-num_train_epochs=1. אימון רק על תשובות קצרות עלול להחליש חשיבה מרובת צעדים, ואם המודל גם מתכנן וקורא לכלים כדאי לערבב דוגמאות עם חשיבה.
  • שמירה: שומרים רק את המתאמים (כמה מאות MB במקום 56GB) ואפליקציית Streamlit קטנה מעלה תמונת נוסחה ומציגה LaTeX. הגיליון לא מציג כאן מספר exact-match לפני ואחרי האימון בטקסט שנקרא. הקוד זמין ב-Lightning AI Studio.

למי זה מתאים: מי שרוצה להתאים מודל ראייה פתוח לפורמט פלט ספציפי (חשבוניות, טפסים, נוסחאות) ולהבין את המלכודות של תבניות צ'אט וחשיבה.

הגיליון ארוך (כ-17K תווים) והסיכום מכסה את זרימת העבודה. קטעי קוד ותמונות לא הועתקו. מספרי הבנצ'מרק הם של Meta.

Muse GlimmerUnslothLoRAOCR
לגיליון המקורי ←

3 באוקטובר 2026

How Work is Organized Inside a GPU

3 באוקטובר 2026

בקצרה: איך GPU מארגן עבודה: מ-kernel שמופעל ועד חישובים של 32 תהליכונים במקביל, ולמה זה קובע ביצועי LLM.

  • kernel הוא פונקציה שרצה על הרבה נתונים, והפעלה שלו יוצרת grid, כל העבודה בהפעלה.
  • ה-grid מחולק ל-thread blocks. כל block נשאר על streaming multiprocessor (SM) אחד, מה שמאפשר לתהליכוני ה-block לשתף ערכים בזיכרון משותף מהיר. blocks מתוזמנים באופן עצמאי ומתפזרים על הרבה SMs.
  • כל block מחולק ל-warps של 32 תהליכונים. block של 256 תהליכונים הופך לשמונה warps. כל 32 התהליכונים ב-warp מקבלים את אותה הוראה על ערכים שונים, ולכן ענפים (if) שמפצלים את ה-warp פוגעים בביצועים: ה-GPU מריץ כל נתיב בנפרד.
  • בתוך SM יש יחידות חישוב, מתזמני warps, אוגרים וזיכרון משותף. כשה-warp ממתין לזיכרון איטי, המתזמן עובר לאחר מוכן, והמעבר זול כי המצב כבר שמור. ה-GPU לא מבטל השהיות זיכרון, הוא מסתיר אותן.
  • מסקנה: מעט blocks משאירים SMs ריקים, ומעט warps תושבים משאירים למתזמן מה לבצע בזמן עצירה. זה מסביר למה GPU דורש כמויות גדולות של עבודה דומה.

למי זה מתאים: מי שרוצה להבין ביצועי GPU ו-LLM, או מתחיל בכתיבת kernels.

הגיליון כולל גם הצגה של Lift ממעבדת datalab (חילוץ JSON ממסמכים, 90.2% דיוק שדות) וקטע על ניקוד בסגנון Jev לעומת פענוח רגיל. את החלק האחרון קראנו חלקית.

GPUCUDAWarpsביצועים
לגיליון המקורי ←

2 באוקטובר 2026

MCP Apps, clearly explained:

2 באוקטובר 2026

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

  • שרת MCP מחזיר נתונים. אפליקציית MCP מחזירה נתונים וגם ממשק אינטראקטיבי (למשל כרטיסי מלון או הוספה לעגלה) בתוך הצ'אט, והמודל יודע על מה המשתמש לחץ.
  • לפי הגיליון OpenAI, Anthropic ו-Microsoft תומכות באותו תקן, ו-Booking.com, Figma ו-Canva כבר משתמשות בו.
  • הטיעון: SEO היה על כך ש-Google ימצא את הדף שלך, AEO על כך ש-AI יצטט אותך, ו-MCP Apps על כך שהמוצר עצמו יופיע בתוך הצ'אט, ולא רק כטקסט שהמודל מחליט עליו.
  • בסרטון בונים אפליקציית MCP מקצה לקצה עם Skybridge, מסגרת קוד פתוח שהופכת אפליקציית React לאפליקציית MCP: הדגמות של Booking.com ושל חנות ב-ChatGPT, הקשר ומצב משותף, מעבר מכלי MCP לתצוגות React, סנכרון מצב הממשק ("מה יש בעגלה שלי?") ו-skill שהופך אפליקציית React לאפליקציית MCP.

למי זה מתאים: מפתחי web ומוצר שרוצים שהמוצר יוצג בתוך סוכני AI, ומכירים React.

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

MCP AppsSkybridgeChatGPTReact
לגיליון המקורי ←

1 באוקטובר 2026

Building a Production Agent Harness with LangGraph and Jev

1 באוקטובר 2026

בקצרה: הגיליון מציג את חלקים 3 ו-4 בקורס Agent Engineering: בניית הרנס לסוכן עם LangGraph ו-Jev, שמשתמש בהסתברויות של Jev כאחד מכמה אותות בקרה. בנוסף הסבר על לולאת התזמון של LLM בשרת הסקה.

  • Jev הוא מודל "System 1" שמחזיר הסתברויות מכוילות להחלטות מוגדרות, במקום לייצר טקסט חופשי. בסוכן משתמשים בו לניתוב קריאות למודלים, סיווג בקשות, הערכת סיכון של כלים, אימות ראיות וזיהוי חזרה על אותה גישה.
  • חלק 3 בונה בקרות סביב קריאות מודל וכלי: ניסיונות חוזרים, fallback, ניתוב מודלים ומגבלות קריאות, הסתרת PII, סינון injection, אכיפת הרשאות ואישור אנושי לפעולות כתיבה. חלק 4 מציב את הסוכן בתוך לולאת LangGraph: תכנון עם קריטריוני השלמה, אימות, תיקון ותכנון מחדש, זיהוי תקיעות, תקציבי ריצה וכתיבה לזיכרון רק של מסקנות מאומתות. לפרויקט 46 בדיקות.
  • מאמת בשלוש שכבות: בדיקת ראיות דטרמיניסטית שתופסת כשלים ברורים ללא מודל, Jev שמקבל או דוחה מקרים בביטחון גבוה, ו-LLM בודק עצמאי לטווח הלא ודאי.
  • הרעיון המרכזי: להחלטות שדורשות משמעות אבל יש להן מרחב תשובות סגור (ניתוב, שער, אימות) לא צריך מודל שמייצר טקסט. כלל דטרמיניסטי זול אבל תופס רק מה שקודד מראש. Jev לא מחליף הרשאות, בדיקות דטרמיניסטיות או אישור אנושי.
  • בקטע השני: לולאת התזמון בשרת הסקה. בקשה נכנסת לתור המתנה, המתזמן בונה לפני כל צעד batch לפי מגבלת טוקנים ושטח KV cache (לרוב מעדיף בקשות decode פעילות), בקשות חדשות עוברות prefill (אפשר בחלקים), בקשות פעילות עושות decode, ה-GPU מריץ prefill ו-decode באותו batch, ואחרי כל צעד בקשה שהסתיימה משחררת בלוקי KV cache ובקשה אחרת נכנסת. החלפה ברמת איטרציה היא continuous batching.

למי זה מתאים: מפתחי סוכנים שרוצים להוסיף בקרה, אימות ותקציבים ללולאת סוכן, ומי שרוצה להבין איך שרת הסקה מתזמן בקשות.

הגיליון מקדם חלקים בקורס בתשלום של הניוזלטר, והסיכום מבוסס על תיאור הגיליון ולא על קוד הקורס. כולל גם קטע חסות על Google Advent of Agents.

Agent harnessLangGraphGuardrailsContinuous batching
לגיליון המקורי ←

30 בספטמבר 2026

Jev for RAG, clearly explained!

30 בספטמבר 2026

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

  • מודל LLM נראה כאילו זוכר כי האפליקציה שולחת שוב את ההודעות הקודמות, אבל המודל עצמו חסר מצב. זיכרון קצר טווח הוא מצב העבודה בסשן (הודעות, מסמכים, פלטי כלים). זיכרון ארוך טווח נשמר בין סשנים ומתחלק לסמנטי (עובדות), אפיזודי (חוויות קודמות) ופרוצדורלי (כללים ושלבים).
  • לסוגי הזיכרון צריך מדיניות כתיבה ושליפה שונה: העדפה נשמרת עד שהיא משתנה, ופלט כלי ישן חשוב רק לסשן. המערכת מסתגלת על ידי אחסון ושליפה, לא על ידי עדכון משקולות. לפי הגיליון, בהערכה מתועדת של Oracle בת 80 תורות הקלט נשאר סביב 1,300 טוקנים לבקשה לעומת היסטוריה שטוחה שעברה 13,900 (זהו קטע חסות).
  • RAG עם Jev: שליפה היברידית (BM25 וצפוף, מאוחדים ב-reciprocal rank fusion) מחזירה כ-20 מועמדים. המטרה בשלב הזה היא recall. אחר כך שולחים ל-Jev את השאלה כמצב ושאלת כן/לא לכל מועמד ("האם C7 עוזר לענות"), וחוזרת הסתברות לכל אחד.
  • חשוב שהבקשה אחת: מימוש נאיבי קורא למודל לכל זוג שאלה-פסקה (20 קריאות ל-20 מועמדים), ו-Jev מדרג את כולם בבקשה אחת. את ההחלטה על הסף משאירים בקוד (למשל 0.70), כך שהמדיניות גלויה וניתנת לכוונון על סט הערכה.
  • שער לכל התשובה: אותה בקשה כוללת שאלה שנייה, האם אפשר לענות מהפסקאות שנשארו. אם ההסתברות נמוכה מהסף מדלגים על היצירה ומחזירים "לא נמצא במסמכים". השליפה עדיין קובעת תקרה, ו-Jev לא מחזיר פסקה שלא נשלפה.

למי זה מתאים: מפתחי RAG וסוכנים שרוצים לשפר דיוק ולהוריד תשובות שנוצרו בלי ראיה, ולתכנן זיכרון לסוכנים.

הגיליון כולל גם רשימת 12 שימושי סוכן ל-Jev. נקרא רק חלקית ולא מסוכם כאן.

זיכרון סוכניםRAGRerankingJev
לגיליון המקורי ←

29 בספטמבר 2026

Build a real-time hotel booking voice agent

29 בספטמבר 2026

בקצרה: מדריך מעשי: בניית סוכן קולי להזמנת מלון בזמן אמת עם LiveKit, Speechmatics Linden, OpenRouter, Fish Audio ו-Streamlit, כשהממשק חושף את שכבת הדיבור ואת ההשהיה. בנוסף: איך להריץ כמה מודלים קטנים על GPU אחד.

  • הצינור: הדפדפן שולח אודיו מהמיקרופון לחדר LiveKit, Speechmatics Linden מייצר תמלולים חלקיים וסופיים, OpenRouter שולח את התור הסופי ל-LLM שנבחר, ו-Fish Audio מזרים את התשובה בחזרה. זיהוי דיבור, חשיבה ויצירת קול נשארים רכיבים הניתנים להחלפה, ו-LiveKit מטפל בחדר, במדיה, בזיהוי תורות ובניתוב ספקים.
  • הגדרה: קובץ .env עם LIVEKIT_URL, מפתח וסוד, ומפתח OpenRouter ושם המודל. אין מפתחות נפרדים ל-Speechmatics ו-Fish Audio, כי שניהם רצים דרך LiveKit Inference. AgentSession מחבר את שלושת הספקים, ותמלולים חלקיים מופעלים כדי להציג טקסט מתפתח.
  • פרומפט הסוכן: לשאול רק על פרטים חסרים, לחזור על שמות, תאריכים ואסמכתאות במדויק, לשמור תיקונים (אוקטובר 16 הופך ל-18 בלי להתחיל מחדש), לא לטעון שמערכת ההזמנות האמיתית שונתה, ולהגביל תשובה ל-3 משפטים.
  • הופכים השהיה לגלויה: רושמים מתי הדיבור התחיל, מתי הגיע התמלול הסופי ומתי הסוכן התחיל לדבר, ומפרסמים לדפדפן בנושא נתונים של LiveKit. Speech→final כולל את זמן הדיבור של המתקשר ולכן אינו מדד לספק. Final→voice (יצירת LLM ותחילת TTS) הוא ההשהיה שהמתקשר מרגיש.
  • בקטע הפותח (מבוסס על בדיקה של כותבי הניוזלטר): vLLM סגר כ"לא מתוכנן" בקשה להריץ כמה מודלים קטנים על GPU אחד בשרת אחד. הפתרון המתועד הוא מופע נפרד לכל מודל וניתוב מעליו. עם SIE ארבעה מודלים (embedder, reranker, entity extractor ו-generator) רצו מאחורי שרת אחד עם טעינה לפי דרישה ופינוי LRU: 18.58 שניות כשמריצים ישירות (כולל טעינה) לעומת 1.47 שניות כשהמודלים כבר מוגשים.

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

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

סוכני קולLiveKitLatencyהגשת מודלים
לגיליון המקורי ←

28 בספטמבר 2026

System 1 vs. System 2 Agent Harnesses, clearly explained

28 בספטמבר 2026

בקצרה: ההבדל בין הרנס "System 1" (החלטות מוגבלות ומהירות) להרנס "System 2" (תכנון פתוח בלולאה), ו-HarnessRouter כשכבת תשתית אחידה בין אפליקציה לבין סוגי הרנסים. בנוסף: Beacon להעברת סשנים בין סוכני קוד, ושאלת ראיון על MoE routing.

  • System 1: האפליקציה מספקת בקשה ומצב רלוונטי, והמודל בוחר תוצאה מוגבלת (קטגוריה, ציון, מסלול, שדה). הקוד בודק ביטחון ומדיניות לפני ביצוע או הסלמה. המודל לא שולט בזרימה. מתאים לסיווג כוונה, ניתוב מודלים, שערי סיכון ו-reranking בנפח גבוה.
  • System 2: למודל יש מטרה, אילוצים ומצב נוכחי, והוא מתכנן את הצעד הבא בעוד נתב מוגן שולט באילו כלים אפשר להפעיל. כל מחזור מסתיים בפעולה סופית, בשאלה למשתמש או בתכנון נוסף. הרשאות כלים, תקציבים, תנאי עצירה וביצוע סופי נשארים בקוד. מתאים לקידוד, מחקר וחקירת אירועים.
  • ההבדל הוא בזרימת השליטה ולא בין מודל קטן לגדול, ורוב האפליקציות בפרודקשן צריכות את שניהם.
  • HarnessRouter (קוד פתוח) הוא שכבת התשתית בין אפליקציה להרנסים. בסיס System One מריץ Jev ומודלי החלטה אחרים עם פלט מוגדר וסף ביטחון. בסיסי הרנס של סוכנים מתמכים ב-Codex, Claude Code ו-Hermes. Unified Harness Protocol נותן חוזה אחד להתחלת משימות, הזרמת התקדמות, המשך סשנים, החלפת קבצים, ביטול ודיווח כשלים. הוא לא גורם להם לחשוב אותו דבר.
  • Beacon (Asymptote Labs, קוד פתוח) לוכד פעילות מ-Claude Code, Codex, Cursor, OpenCode, Cline ו-20+ הרנסים. הפקודה beacon handoff list/resume ממשיכה סשן באותו סוכן או בסוכן אחר: דרך פקודת ההמשך של הסוכן, או על ידי כתיבת תקציר (מטרה, התקדמות, קבצים ופקודות) והתחלת סשן חדש שמצביע אליו. פועל מקומית, לא מעלה דבר ולא מבטל בקשות אישור.
  • שאלת הראיון בסוף: איך MoE routing עובד בין GPUs. ראשון, הגיליון מתאר רק את ההתחלה: ה-router בוחר שני מומחים לכל טוקן, וההסבר המלא (אקטיבציות שעוברות ב-NVLink או רשת, all-to-all) מופיע בגיליון המלא.

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

הגיליון כולל חסות של Asymptote Labs ופרסום של ארטיקל נוסף.

Agent harnessSystem 1 / System 2HarnessRouterBeacon
לגיליון המקורי ←

25 בספטמבר 2026

Contrastive Language Model, clearly explained

25 בספטמבר 2026

בקצרה: CLM (Contrastive Language Model) של NVIDIA וסטנפורד: ארכיטקטורת System 1 שמטפלת בהחלטות קטנות כבעיית שליפה במקום יצירת טקסט, ולפי החוקרים מהירה עד פי 9 מ-Jev. בנוסף: ניתוב אוטומטי של בקשות בשער AI.

  • CLM לא מייצר טקסט. הוא מטפל בהחלטות קטנות וחוזרות כמו בחירת כלי, דירוג תיקון, ניתוב בקשה או בחירת הפעולה הבאה, ומציג אותן כבעיית שליפה.
  • הצעדים: מקודדים את המצב והשאלה יחד לווקטור (Qwen3-8B קפוא עם ראש הטלה קטן שמתאמנים). ראש נפרד מקודד כל פעולה מועמדת לאותו מרחב. באימון מקרבים זוג מצב-פעולה נכון ומרחיקים זוגות שגויים, עם מטריצת דמיון N×N ו-InfoNCE (כמו CLIP ושליפה צפופה), בשלושה שלבים מדורגים עד צעדים מריצות סוכן אמיתיות. בהסקה מודדים cosine similarity בין המצב לכל פעולה ו-softmax הופך לציונים, ואפשר לבחור, להציב סף או להסלים.
  • המהירות מגיעה מההפרדה: פעולות אפשר לקודד פעם אחת ולשמור במטמון, ובכל צעד מקודדים רק את המצב. בדוגמת משחק הדינוזאור (קפיצה, התכופפות, ריצה) זו קריאת מקודד אחת לצעד במקום ארבע.
  • תוצאות לפי החוקרים: CLM-8B שווה ל-Jev בהערכות של שימוש במחשב, משחקים וקריאה לכלים, בחביון נמוך עד פי 9. שווה במשחקי הדינו ומריו, נמוך מעט בקריאה לכלים ובניווט בין קישורי ויקיפדיה. היתרון גדול יותר כשהפעולות חוזרות או שקבוצת המועמדים גדלה.
  • מגבלות: אינו מייצר פעולות חדשות, ההסתברויות יחסיות למועמדים שסופקו, ותוצאות האימות החזקות דורשות כוונון למשימה. הקוד והמחקר פתוחים.
  • בקטע החסות: Auto Routing של TrueFoundry מנתב בקשות בשער ה-AI לפי מורכבות (פשוטה, בינונית, מורכבת) בעזרת היוריסטיקות, ולפי הטענה חסך 69% מהעלות מול בסיס של Opus בלבד עם 98% מהאיכות.

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

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

CLMSystem 1InfoNCEניתוב
לגיליון המקורי ←

24 בספטמבר 2026

Build a Jev Judge

24 בספטמבר 2026

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

  • הבעיה: שופט LLM מחזיר ציון או פסק דין, אבל גם כשצריך כמה מספרים הוא מייצר אותם טוקן אחר טוקן, ועלות הערכת כל ריצה גדלה מהר. Jev מקבל State ושאלות מוגדרות ומחזיר ערכים מוקלדים ישירות, ושאלות בלתי תלויות על אותו מצב נבדקות במקביל.
  • להפריד בין שופט למערכת הערכה: השופט הוא הרכיב שמפיק פסק דין, ומערכת הערכה צריכה גם דוגמאות, עקבות, רובריקות, רישום ניסויים ודרך לבדוק אי-הסכמות. כאן Jev שופט סמנטית ו-Opik (קוד פתוח) שומר וממיין את התוצאות. הקוד מטפל בתנאים מדויקים, Jev בשאלות סמנטיות ממוקדות, ואדם בחוסר ודאות.
  • הדוגמה: הלקוח מבקש החזר, הסוכן מוצא את ההזמנה ועונה "בוצע, הנפקתי החזר", אבל ב-trace אין קריאה מוצלחת להחזר. בדיקה דטרמיניסטית יודעת אם issue_refund הצליח, ושופט סמנטי קובע אם התשובה טוענת שההחזר קרה. אלה שתי משימות שונות. הפרויקט כולל עשר ריצות סינתטיות קפואות: תשובות נכונות, בדויות (חלון החזרים שהומצא), טענת פעולה שלא קרתה, התעלמות מהשאלה, וניסיון לתמרן את השופט.
  • שאלות קטנות: grounded (האם כל הטענות נתמכות בראיות), action_honest (האם טענות על פעולה שבוצעה נתמכות בתוצאות כלים מוצלחות), ועוד שאלת רלוונטיות ו-helpfulness. כל שאלה צריכה הוראות בהירות כי מזהה השאלה לא משמש בהסקה. ה-State מכיל ראיות ולא את הפסק הצפוי.
  • קריאה: הלקוח שולח state ושאלות ל-POST /v1/systemone עם timeout, ניסיונות חוזרים מוגבלים ואימות תשובה. כשל אימות אינו נחשב מעבר, ושגיאת הרשאה לא מנסים שוב.
  • איך לפרש: ערך 0.98 ב-grounded אינו "98% מהתשובה מבוססת" אלא הסתברות של Jev ל-98% שהטענה כולה נכונה, ובאזור 0.5 זו אי-ודאות. ב-Score (למשל helpfulness) מקבלים ציון ממוצע משוקלל בסקאלה 0-2 (מחלקים ב-2 לסקאלה 0-1) וערך confidence נפרד שמסכם את התפלגות הרמות ואינו הסתברות שהשופט צודק. הניתוב בדוגמה: כשלים ברורים, הצלחות ברורות, ומקרים לא ודאיים לבדיקה. הספים להמחשה ויש לאמת אותם על דוגמאות מתויגות שלכם.
  • Opik: מתאם מותאם (BaseMetric) שמפעיל את Jev פעם אחת ומחזיר כמה ציונים בשמות, יחד עם גרסת הרובריקה, המודל והתשובות הגולמיות. זה לא שילוב מקורי של Jev. ניסוי: evaluate עם dataset, replay כמשימה ו-JevSupportMetric. מצב demo משתמש בהסתברויות שנכתבו ידנית ואינו הוכחה לביצועים. הריצה החיה דורשת TYPESAFE_API_KEY וחשבון Opik, ואת הנתונים הרגישים להסיר לפני שימוש בעקבות אמיתיות.
  • מגבלות ומסקנה: ההערכה היא אחרי הריצה ולא עוצרת פעולה מסוכנת לפני ביצועה. נדרש אימות מול עקבות מתויגות, מדידת מה שהשופט מפספס, גרסה קבועה של הרובריקה בהשוואות, ובדיקת מדגם גם מהמקרים הבטוחים. אם צריך הסבר כתוב או חשיבה בכמה צעדים, שופט LLM עדיף. היתרון של Jev: שיפוטים ממוקדים וחוזרים בזול ובמהירות כדי להעריך יותר ממה שקורה.
  • בקטע הפתיחה: הקורס החינמי Building Adaptive AI Agents (DeepLearning.AI עם Oracle) על שלוש שכבות התאמה: התאמת התנהגות דרך הפקת skills מעקבות עם אישור אנושי, התאמת ידע עם גרף קוד (ייבוא, קריאות פונקציה, co-edits) והתאמת מודל בכוונון עדין.

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

הגיליון כולל חסות של Oracle ושל DeepLearning.AI בפתיחה. הקוד והמחברות לא הורצו.

JevLLM-as-a-judgeOpikהערכת סוכנים
לגיליון המקורי ←

23 בספטמבר 2026

MoE inference engineering, clearly explained

23 בספטמבר 2026

בקצרה: מדריך מקיף להגשת מודלי Mixture-of-Experts: איך token עובר דרך router, מקבץ למטריצות לפי מומחה, רץ ב-GPU אחד ואז בין כמה GPUs, ומה למדוד כשמשהו איטי. בפתיחה: מטמון סמנטי של Redis.

  • שכבת MoE מחליפה את רשת ה-feed-forward בכמה מומחים, וה-router מדרג אותם לכל טוקן. רק המומחים הנבחרים רצים, אבל ה-attention עדיין מעבד כל טוקן. ב-Qwen3-30B-A3B יש 30.5 מיליארד פרמטרים בסך הכול ו-3.3 מיליארד פעילים, ובכל טוקן נבחרים 8 מתוך 128 מומחים מנותבים. 3.3 מיליארד מעריך חישוב, לא את זיכרון המשקולות. ניתוב טוקן-למומחה בתוך שכבה שונה מבחירת מודל לבקשה שלמה.
  • מטריצות לפי מומחה: בדוגמה של 4 טוקנים ו-top-2 יש 8 הקצאות ולא 4. הרצת הקצאות מקובצות לפי מומחה יוצרת מטריצות עם 3, 2, 2 ו-1 שורות. הקיבוץ נקרא dispatch והחזרה combine, כשמזהה הטוקן נשמר ליד כל שורה וכפל במשקלי הניתוב וחיבור משחזרים את הפלט. ב-prefill המטריצות גדולות ויעילות, ב-decode עם concurrency נמוך למומחה יש שורה או שתיים. Grouped GEMM מריץ כמה מטריצות בהפעלה אחת אך לא יוצר עבודה למומחה שלא קיבל טוקן.
  • הרצה מקומית: top-k, permutation (סידור שורות ורישום מיפוי הפוך), grouped GEMM, ושחזור סדר. בבאצ'ים קטנים הזזת שורות יכולה לקחת כמו הכפל. Kernel fusion חוסך כתיבות זיכרון אך תלוי בסוג נתונים, צורת באץ' ופורמט קוונטיזציה. מומלץ למדוד נפרד ניתוב, permutation, GEMM ו-combine.
  • זיכרון: שלושה מספרים שונים: total (הצ'קפוינט), activated (נתיב של טוקן אחד) ו-resident (משקולות זמינות במערכת). אחסון 30.5 מיליארד פרמטרים ב-2 בתים הוא כ-61GB למשקולות בלבד, בלי buffers, allocator ו-KV cache. אסור להחליף 30.5 ב-3.3 בחישוב. קוונטיזציה וחלוקה בין GPUs לא משנות את מספר הפרמטרים. Expert offloading ל-CPU חוסך זיכרון GPU אבל עלול לעכב decode בזמן העברה.
  • Expert parallelism: מומחים שונים על GPUs שונים. המשקולות נשארות במקום ואילו הקצאות (וקטור הטוקן ומטא-דאטה: טוקן, מומחה יעד, GPU מקור, משקל) נעות. עם הרבה GPUs נוצר דפוס all-to-all, ו-combine מחזיר תוצאות. הערכת עומס עליונה: כמות הקצאות כפול וקטור מוסתר מלא, לפני יתרונות מקומיות, ובלי תקורת פרוטוקול. החלק הזה חוזר בכל שכבת MoE. DeepEP מציע נתיב תפוקה לבאצ'ים גדולים ונתיב חביון נמוך ל-decode.
  • Placement: NVLink/NVSwitch בתוך שרת מול InfiniBand או Ethernet בין שרתים. מיקום מומחים קובע כמה פעמים הניתוב חוצה קישור איטי, אפשר להזיז מומחה פופולרי קרוב למקורות או ליצור העתקים פיזיים. DeepSeek-V3 משתמש ב-node-limited routing כחלק מהארכיטקטורה שאומנה, ולא כדאי להוסיף הגבלה כזו אחרי אימון. צריך עקבות ניתוב ומדידות טופולוגיה. הצבת מומחים פופולריים יחד מורידה תעבורה אבל מעמיסה שרת אחד. טנזור, מומחים ומידע (data parallelism) מחלקים דברים שונים. איזון עומס ו-tail latency נמדדים לכל צעד ו-GPU.
  • אופטימיזציות: Fusion, grouped GEMM, placement ו-overlap שומרים בחירת מומחים לוגית. קוונטיזציה משנה ערכים וצריכה בדיקת איכות. הורדת top-k משנה את קבוצת המומחים ואת ההנרמול. מחקר Training-Free Halving of Activated Experts: ב-Qwen3.6-35B-A3B הורדה סטנדרטית מ-8 ל-4 מומחים עלתה 4.65 נקודות MMLU, ועם מסת ייחוס מותאמת רק 0.35. ב-Qwen3.5-397B-A17B, מ-10 ל-5 עלות 0.55. אלה תוצאות לצ'קפוינטים ספציפיים ולא כלל.
  • שיטת מדידה: לשנות משתנה אחד, לשמור צ'קפוינט, דיוק, פרומפטים והגעות, להתחיל במינימום ה-layout שנכנס ואז שרת אחד ורק אחר כך בין שרתים. למדוד TTFT, זמן לטוקן, p95, תפוקה, בתים לכל domain תקשורת ואי-פעילות. זיכרון גבוה עם חישוב נמוך מצביע על בעיית קיבולת משקולות, dispatch גבוה על טופולוגיה או גודל הודעה, ו-GPU אחד איטי על skew בניתוב או מיקום גרוע.
  • בפתיחה (חסות Redis): מטמון סמנטי שומר זוגות שאלה-תשובה, ושאלה בניסוח אחר עם אותה משמעות מחזירה את התשובה בלי קריאת LLM. Redis LangCache מטמיע את השאלה, מחפש דמיון לפי סף ומסננים, ו-miss חוזר ל-LLM. הטענה: עד פי 15 מהר ו-70% זול יותר, בהתאם לכמות החזרתיות.

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

מאמר ארוך, הסיכום מרכז את עיקריו. הנוסחאות והתרשימים לא הועתקו. הגיליון כולל חסות של Redis.

MoEExpert parallelismGPUהגשת מודלים
לגיליון המקורי ←

22 בספטמבר 2026

Build your own Jev (100% local)

22 בספטמבר 2026

בקצרה: איך משחזרים מקומית את דפוס ההסקה של Jev: במקום לייצר טקסט, מבקשים ממודל פתוח (Qwen) ציון לכל תשובה מותרת בקריאה אחת, בעזרת נקודת הקצה /v1/score של SGLang. הגיליון מדגיש שזה שחזור של מנגנון ההסקה בלבד ולא של המשקולות, האימון והכיול של Jev. בפתיחה: HarnessRouter כממשק אחד לכמה harnesses.

  • הרעיון: כשהאפליקציה כבר מכירה את כל התשובות האפשריות (טיקט שצריך להגיע ל-billing, תמיכה טכנית או גישה לחשבון), אין צורך שהמודל יכתוב משפט או JSON. מקבלים התפלגות, למשל 0.91, 0.06, 0.03, ורואים כמה חזקה ההעדפה. הקוד קובע את הכלל, למשל שהמקום הראשון עובר 0.80 ומוביל ב-0.20 לפחות.
  • ההבדל מ-structured output: structured output מבטיח אובייקט תקין (כמו {"team": "billing"}) אבל המודל עדיין מייצר סוגריים, שם שדה וערך טוקן אחר טוקן. בניקוד, התשובות מוגדרות מראש וקוראים ציון אחד לכל אפשרות בלי לייצר JSON. שתי תוצאות יכולות לבחור billing, אחת עם 0.91 ואחת עם 0.46 מול 0.44, וההתפלגות מאפשרת לנתב אוטומטית את הראשונה ולשלוח את השנייה לבדיקה. 0.91 אינו אומר שהמודל צודק 91% מהזמן, וזה דורש דוגמאות מתויגות (כיול).
  • איך זה עובד טכנית: הפרומפט נגמר ב-"Label:" עם תוויות של אות אחת (A, B, C) שהוסברו בפרומפט. המודל מייצר וקטור logits בגודל אוצר המילים לעמדה הבאה. קוראים רק את שלושת ה-logits של A, B, C ומפעילים softmax עליהם בלבד (למשל 8.2, 5.5, 4.8 נותנים כ-0.91, 0.06, 0.03). משתמשים באות אחת ולא במילים כי מילים כמו "technical support" נפרסות על כמה טוקנים וצריך ניקוד רצף. חובה לוודא ש-tokenizer נותן טוקן אחד לכל תווית (ו-"A" שונה מ-" A"), בעזרת /tokenize ובפרומפט שנבנה מתבנית השיחה של המודל.
  • צריך תשובת מילוט (OTHER או ESCALATE) כשהרשימה לא ממצה, אחרת softmax יחלק את כל ההסתברות בין אפשרויות שגויות, למשל אירוע אבטחה שמגיע לנתב שיש בו רק שלוש קטגוריות.
  • מימוש: מפעילים את SGLang עם Qwen2.5-0.5B-Instruct בפורט 30000, כותבים decide.py שמגדיר תוויות ופרומפט, מוצאים מזהי טוקנים, שולחים בקשה אחת ל-/v1/score עם label_token_ids ו-apply_softmax, וממפים חזרה לבחירות. בדוגמה: billing and payments קיבל 0.678, technical support 0.311 ו-account access 0.011. עם סף 0.70 הטיקט הזה היה עובר לבדיקה.
  • השוואת ביצועים: הכותבים בנו אפליקציה שמריצה במקביל 100 מקרים בנתיב "Jev-style" (ניקוד) ובנתיב LLM רגיל (עד 32 טוקנים עם הסבר, ופענוח התוצאה) על אותו שרת SGLang עם Qwen3-4B-Instruct-2507, בתחומי ניתוב תמיכה, סינון מועמדים ובדיקת הוצאות. הגיליון מציג את ההשוואה בסרטון ואינו מפרט כאן מספרי חביון.
  • מתי מה: לייצר כשהתוכן לא ידוע מראש, לנקד כשהקבוצה ידועה ומספיק לבחור. Structured output מתאים כשלא אפשר למנות את הערכים. השחזור אינו כולל את המשקולות, ה-RLCD או כלי ההערכה של Jev.

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

פתיחת הגיליון היא פרסום של HarnessRouter. הקוד לא הורץ, והתוצאות המספריות הן של הכותבים.

JevSGLangLogitsסיווג
לגיליון המקורי ←

21 בספטמבר 2026

Jev, Clearly Explained

21 בספטמבר 2026

בקצרה: Jev, מודל של TypeSafe AI (יצא ב-15 בספטמבר 2026) שאינו מייצר טקסט: מקבל מצב ושאלות מוגדרות מראש ומחזיר תשובה מוקלדת עם הסתברויות. הגיליון מסביר איך משתמשים בו להחלטות קטנות וחוזרות בתוך סוכן, ומתי לא. בנוסף: Beacon כשכבת זיכרון בין הרנסים.

  • הרעיון: תוכנה מקבלת אלפי החלטות קטנות (האם הטיקט דחוף, איזה מודל יטפל בבקשה, האם פקודת shell מסוכנת). שליחתן ל-LLM כללי עולה זמן וכסף ודורשת פענוח של התשובה. ב-Jev שולחים State (טקסט או JSON) ו-Questions, וכל שאלה מצהירה מראש על צורת התשובה.
  • שלושה פרימיטיבים: Choice בוחר אפשרות מרשימה ומחזיר הסתברות לכל אפשרות, Score ממקם על סקאלה סדורה (נמוך, בינוני, גבוה), ו-Noul ענה כן/לא עם הסתברות בין 0 ל-1 (השם של TypeSafe לסוג בוליאני).
  • הקוד שולט בענפים: למשל אם urgent גבוה מ-0.9 והצוות הוא engineering מעירים את התורן, אם confidence נמוך מ-0.6 שולחים לבדיקה אנושית. הציון מראה כמה צמוד היה המרוץ. דוגמה: billing ניצח 0.52 מול 0.46, לכן ניתוב אוטומטי היה פזיז. מדיניות הימנעות: לפעול אוטומטית כשהביטחון גבוה וההשלכה קטנה, לבקש אישור או מודל חזק יותר באמצע, ולהעביר לאדם כשנמוך. הספים בקוד וצריכים לשקף את מחיר הטעות.
  • נתוני החברה: חביון 70-500ms ומחיר 0.042$ למיליון טוקני קלט בלי חיוב על פלט. הטענות על עד פי 200 חביון נמוך ופי 400 עלות נמוכה מבוססות על השוואות פנימיות ולא על נתוני ייצור. החברה גם אומרת ש-Jev "לא יכול להזות": בפועל הוא לא יכול לשבור את הסכמה, אבל עדיין יכול לבחור תשובה תקינה אך שגויה בביטחון גבוה. הכיול (RLCD) צריך להיבדק על התעבורה שלך.
  • שימושים בתוך סוכן: ניתוב מודלים (מהיר מול חזק), סיווג סיכון לפני הרצת פקודה (קריאה בלבד, הפיך, הרסני, עם אינטגרציה של LangChain), ובדיקות סמנטיות אחרי ביצוע (חוזר על עצמו, עומד במדיניות). לא להחליף בדיקה קשיחה.
  • בעיות מתאימות: סיווג וניתוב בקשות, רלוונטיות של קטעי שליפה ותמיכה בציטוט, בדיקות סמנטיות בגבולות אכיפה (לא כתחליף להרשאות ו-sandbox), העשרת קורפוס ענק, וממשקים בזמן אמת. תנאי: קבוצת תוצאות סגורה, תיוג מהיר, והחלטה שחוזרת מספיק.
  • מתי לא: אינו כותב, מסכם או מסביר, לא עושה חשבון, ספירה או השוואת תאריכים, לא מחלץ ערך לא ידוע (קודם מוצאים מועמדים), והקשר לא רלוונטי פוגע בדיוק. המשקולות סגורות ויש מעט נתוני כיול עצמאיים. אם קוד דטרמיניסטי פותר, משתמשים בו.
  • תהליך פריסה: להתחיל בהחלטה אחת מוגבלת ובסיכון נמוך, לכתוב רובריקה, לאסוף דוגמאות עם תשובות כולל קצה ומתקיפות, להריץ במצב צל ליד התהליך הקיים, לשרטט דיוק מול ביטחון ולקבוע ספים, ולאוטמט קודם את הענף הבטוח. לתעד גרסאות של מודל, שאלות וספים, כי שאלות וקריטריונים הם לוגיקת תוכנית.
  • בחלק החסות: Beacon (Asymptote Labs, קוד פתוח) לוכד פעילות מסוכני קוד (Claude Code, Codex, Cursor, OpenCode, Cline ועוד 19+), מדרג ריצות עם Jev, ומוציא מהן תהליכים, תיקונים ודפוסי דיבוג שהופכים ל-skills לסוכנים עתידיים.

למי זה מתאים: מי שבונה סוכנים או צינורות LLM וצריך להחליט איפה אפשר להחליף קריאת LLM מלאה בהחלטה מוקלדת וזולה.

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

Jevהחלטות מוקלדותConfidenceBeacon
לגיליון המקורי ←

18 בספטמבר 2026

Run Any Agent Harness Under One Interface

18 בספטמבר 2026

בקצרה: איך מריצים כמה Agent harnesses (Codex, Claude Code, Hermes ועוד) מאחורי ממשק אחד: Unified Harness Protocol (UHP) כחוזה, ו-HarnessRouter כשרת קוד פתוח שמיישם אותו.

  • הבעיה: כששילוב של harness אחד נעשה ישירות, ה-backend תלוי בפורמט המשימות, זרם האירועים, מודל ה-session והתנהגות הקבצים שלו. הוספת harness אחר היא לא שינוי פרמטר, כי זה runtime נוסף שמתכנן, קורא לכלים, מנהל קבצים ומחליט מתי המשימה הסתיימה.
  • ניתוב מודלים מול ניתוב harness: ניתוב מודלים בוחר endpoint להסקה (מחיר, חביון, הקשר, זמינות, איכות) בעוד לולאת הסוכן נשארת. ניתוב harness בוחר את ה-runtime שמחזיק את כל המשימה, ויכול לשנות כלים, skills, סביבת עבודה והרשאות. ב-UHP השדה model בוחר מודל ו-metadata.harness_id בוחר harness מוגדר.
  • למה כדאי יותר מ-harness אחד: לכל אחד בחירות שונות בביצוע כלים, ניהול הקשר והרשאות. לקוחות שונים עם גישה לספקים שונים (OpenAI או Anthropic), מכסה או תקלה של ספק, והשוואת עלות, חביון ופלט של אותה משימה. המטרה אינה להחליף באמצע session אלא לא להיות תלוי ב-runtime אחד.
  • מה UHP מגדיר: חוזה HTTP בצורת OpenAI Responses API. מתחילים עם POST /v1/responses (קלט, מודל, Harness ID, מגבלות). Response הוא משימה אחת, Session מקבץ תשובות עם מצב שיחה ותיקיית עבודה משותפים, ו-harness מוגדר מחבר harness בסיס עם מודל, הוראות, skills, כלים ושרתי MCP. אירועים בזמן אמת עוברים ב-SSE עם סוג ומספר סידורי. קבצים קטנים בבקשה וגדולים בהעלאות, קבצים שנוצרו הופכים ל-artifacts, והמשך דרך previous_response_id. העברה בין harnesses היא session חדש עם הקשר מסוכם ולא המשך של ה-session הישן. הגרסה הנוכחית 2026-09-12.
  • HarnessRouter: שרת UHP לאירוח עצמי. התמונה ב-Docker כוללת Console (ממשק דפדפן), Gateway (API והגדרות) ו-Runner (מפעיל תהליכי harness בסביבות session). נדרש Docker, כ-4GB דיסק ומפתח API של ספק מודלים. הרצה: docker run עם קישור ל-127.0.0.1:3000 ונפח /data, ואז הוספת Integration עם מפתח הספק. יש 11 harnesses מובנים כולל Codex, Claude Code ו-Hermes.
  • דוגמת עבודה: שני harnesses מותאמים בשם Paper Explainer עם אותן הוראות ו-skill, שמקבלים מאמר מחקר ומחזירים index.html ו-README.md עם הדמיה אינטראקטיבית. אותו פרומפט ואותם קבצים, אבל התוכניות והמימושים יכולים להיות שונים. מהאפליקציה קוראים ל-/v1/responses עם Bearer key ושינוי metadata.harness_id בוחר harness אחר.
  • אבטחה: UHP מאחד את מחזור החיים אך לא גורם ל-harnesses להתנהג זהה. ב-sessions שונים נפרדים משתמשי מערכת ותיקיות אבל לא קונטיינרים, ולכן מפתחות ספק צריכים להיות מחוץ לסביבה שכלי הסוכן קוראים. מפתחות אפליקציה לא יגיעו לקוד דפדפן, ופריסה מחוץ ל-loopback דורשת TLS ובקרות מה-security spec.

למי זה מתאים: מי שבונה מוצר שמפעיל סוכני קוד ורוצה להחליף או להשוות runtimes בלי לשכתב את התשתית.

יש בגיליון קטע חסות של Deepgram (Flux TTS). הסרטונים לא נצפו, רק התיאור שלהם.

UHPHarnessRouterCodexClaude Code
לגיליון המקורי ←

17 בספטמבר 2026

Where does all the VRAM go during LLM inference?

17 בספטמבר 2026

בקצרה: ארבעה דליים של זיכרון GPU בזמן הסקת LLM, ולמה "המודל נכנס ל-GPU" אינו אומר "העומס נכנס". בנוסף: MCP עם Agent Skills.

  • משקולות: החלק הכמעט קבוע. מודל של 8 מיליארד פרמטרים צריך כ-16GB ב-FP16 או BF16, 8GB ב-8 ביט ו-4GB ב-4 ביט (בתוספת סקלות ומטא-דאטה). קוונטיזציה מפנה מקום להקשר ארוך ולבקשות רבות יותר, אבל לא מבטיחה מהירות גבוהה יותר כי היא תלויה בתמיכת kernels ובעלות de-quantization.
  • KV cache: החלק הדינמי שמפתיע. כל שכבה שומרת מפתחות וערכים של טוקנים קודמים. הכפלת הטוקנים או הרצפים הפעילים מכפילה אותו בערך. Grouped-query attention מקטין אותו, וקוונטיזציה של KV מקטינה בתים לאיבר בפשרה בדיוק. מנועי הגשה מנהלים אותו בבלוקים (paged allocation), ו-prefix caching משתמש חוזר כשהפרומפט זהה. לעיתים הזיכרון נראה מלא מיד בהפעלה כי המנוע שומר את רוב הנותר לבריכה הזו.
  • אקטיבציות ו-workspace: זיכרון זמני לשכבות, attention, כפל מטריצות, דגימה ו-kernel scratch. הוא נעשה שימוש חוזר ולא מצטבר לכל טוקן. שיא הצריכה בדרך כלל ב-prefill. עומס יכול להיכשל גם כשהקצאות יציבות נראות מתאימות.
  • תקורת runtime: הקשרי CUDA, kernels, ספריות תקשורת, graph capture, buffers של המתזמן ומצב המסגרת. allocators שומרים בלוקים משוחררים, ולכן nvidia-smi יכול להראות יותר מהמונים של המסגרת. פיצול זיכרון יכול להשאיר מקום כולל בלי בלוק מתאים, ולכן צריך מרווח ביטחון.
  • הנוסחה: VRAM נדרש ≈ משקולות + KV cache + שיא אקטיבציות ו-workspace + תקורה + מרווח ביטחון. זה מסביר למה מודל יכול להיטען ועדיין לקרוס אחרי הגדלת חלון ההקשר, ה-concurrency או ה-batch.
  • בקטע השני: MCP מגדיר עכשיו דרך סטנדרטית לגלות ולטעון Agent Skills משרתי MCP: התחברות, גילוי skills, בדיקת מטא-דאטה וטעינת SKILL.md רק בעת הצורך. Skills מוגשים דרך Resources, כך שקבצי תמיכה נקראים לפי דרישה. הדבר שימושי לניהול חלון ההקשר. הקטע נקרא חלקית.

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

יש בגיליון קטע חסות של Nebius (לא מסוכם).

VRAMKV cacheקוונטיזציההסקה
לגיליון המקורי ←

16 בספטמבר 2026

How to Fine-Tune LLMs in 2026

16 בספטמבר 2026

בקצרה: כוונון עדין של סוכנים ב-2026 בעזרת למידת חיזוק: GRPO כאלגוריתם, ART כמסגרת קוד פתוח, ו-RULER כשופט LLM שמחליף פונקציית תגמול ידנית. בנוסף: איך Grouped-query attention מקטין את ה-KV cache פי 8.

  • SFT מלמד את המודל מה לומר (חיקוי זוגות קלט-פלט), לא איך להצליח. לסוכנים שמחפשים, קוראים ל-API ומסיקים בכמה צעדים, צריך למידה מניסוי וטעייה: Reinforcement Fine-Tuning. הדימוי בגיליון: SFT כמו ללמוד מספר לימוד, RL כמו הכשרה בעבודה.
  • GRPO: בכל פרומפט דוגמים קבוצה של N תשובות, נותנים לכל אחת ציון, מנרמלים מול ממוצע הקבוצה, ומחזקים התנהגות שמעל הממוצע ומדכאים את שמתחתיו. אין צורך במודל נפרד שמעריך תשובות, ורק סדר הציונים משפיע ולא הערכים המוחלטים. זה האלגוריתם שמאחורי יכולות החשיבה של DeepSeek-R1.
  • ART (Agent Reinforcement Trainer): מסגרת קוד פתוח שמביאה GRPO לכל אפליקציית Python, עם תמיכה בקריאות לכלים ושיחות רב-תורניות ואינטגרציות עם LangGraph, CrewAI ו-ADK. מחולקת ללקוח (קוד הסוכן, שמקליט Trajectory של כל ריצה) ולשרת (vLLM להסקה ו-GRPO מבוסס Unsloth לאימון, עם checkpoint של LoRA שנטען אוטומטית אחרי כל צעד).
  • RULER: שופט LLM שמדרג כמה ריצות של אותו תרחיש ללא נתונים מתויגים. מבקשים "איזו מ-4 הריצות השיגה את המטרה הכי טוב" ולא "תן ציון 0-10", כי הראשון יציב יותר. הציונים (0 עד 1) משמשים ישירות כתגמולים ב-GRPO, כי GRPO צריך רק ציונים יחסיים.
  • דוגמה מעשית: מחברת שמאמנת מודל של 3B להשתמש בכל שרת MCP. נותנים כתובת שרת, והמחברת מגלה את הכלים, מייצרת משימות מתאימות ומאמנת עם RULER.
  • קטע שני: במנגנון multi-head attention לכל ראש שאילתה יש ראש KV משלו, ובמודל עם 64 ראשים נשמרים 64 סטים. Multi-query משתף ראש אחד ומקטין הכי הרבה אבל פוגע באיכות. Grouped-query באמצע: ב-Llama 3 70B כל 8 ראשי שאילתה חולקים ראש KV אחד, כך שהחלק הזה קטן פי 8, וגם הקריאה בזמן decode קטנה בכך. זו בחירת ארכיטקטורה, אי אפשר להפעיל אותה על מודל MHA דרך דגל הגשה.

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

יש בגיליון קטע פתיחה על Rowboat Spaces וקריאה לתת כוכב בגיטהאב (לא מסוכם לעומק).

GRPORULERARTGQA
לגיליון המקורי ←

15 בספטמבר 2026

Easiest Way to Run Agent Harnesses Using Local Models

15 בספטמבר 2026

בקצרה: Magnitude (קוד פתוח): כלי שבוחן את המחשב ומציע מודלים מקומיים שבאמת מעשיים להרצה, ואז מחבר אותם להרנס כמו Claude Code או Codex. בנוסף: מעקב אחר צינור LLM עם OpenTelemetry ו-Dynatrace.

  • הבעיה: בבחירת מודל מקומי המשקולות הן רק חלק מתקציב הזיכרון. אורך ההקשר משנה את ה-KV cache, קוונטיזציה משנה זיכרון ותפוקה, וה-RAM או ה-VRAM הזמינים לא אומרים אם ההסקה תהיה מהירה מספיק ללולאת סוכן, שמייצרת עומס ארוך וחוזר.
  • Magnitude: מתקינים עם npm i -g @magnitudedev/cli ומריצים magnitude setup. הכלי מפרופיל את המכונה, מריץ בדיקות ביצועים, מעריך אילו מודלים מעשיים (ולא רק נטענים), ממליץ על מועמדים ומחבר אחד מהם ל-Claude Code, Codex, OpenCode, Pi ועוד. הגיליון מפנה לסרטון הדרכה בן כמה דקות.
  • קטע החסות: דוגמת Dynatrace מראה איך לבדוק צינור LLM כ-distributed trace ולא כקריאת API אחת. בקשה אחת כוללת הטמעה, שליפה, יצירה וכלים, ומדידת זמן ה-HTTP החיצוני לא אומרת איפה האטה. האפליקציה היא יועץ נסיעות ב-Python עם נתיבים בסיסי, RAG וסוכני, על Amazon Bedrock, עם OpenTelemetry ו-Traceloop שמייצאים ל-Dynatrace דרך OTLP, ועם לוחות מחוונים ו-deployment מקומי או ל-Kubernetes קטן.

למי זה מתאים: מי שרוצה להריץ סוכן קוד מקומי ולא יודע איזה מודל המחשב שלו מסוגל להריץ בצורה שמישה.

גיליון קצר. חצי ממנו חסות של Dynatrace. סרטון ההדרכה לא נצפה, רק התיאור שלו נקרא.

Magnitudeמודלים מקומייםObservability
לגיליון המקורי ←