14 באוקטובר 2026 (תאריך משוער)
How to Build Quality Gates into Agentic Coding Workflows — Nnenna Ndukwe, Qodo AI
Nnenna Ndukwe · Qodo AI · 57:45 דקות
בקצרה: סדנת Qodo: איך לבנות quality gates לאורך כל ה-SDLC כשסוכן כותב את הקוד — rules ו-skills כשכבת governance, תוכנית עבודה מפורשת עם definition of done לפני כל יישום, ודמו חי של תיקון אוטומטי שסגר את כל הבעיות ב-PR.
- הבעיה: איכות קוד נשברת בנקודות שונות לאורך ה-SDLC כשמאיצים עם סוכני קוד. הפתרון הוא לא 'עוד prompt' אלא מבנה מפורש: rules, skills ו-engineering standards שמנוהלים כשכבת context עקבית על פני repos וצוותים.
- שער איכות לפני יישום: דורשים מהסוכן תוכנית מלאה לפני שהוא נוגע בקוד — summary, repo rules רלוונטיים, תוכנית high-level, execution plan שלב-אחר-שלב, test plan, ו-definition of done מפורש כולל אילו פקודות חייבות לרוץ ומה נדחה בדרך. בדמו: 'refund workflow workshop plan'.
- Operationalizing context: שילוב של agent skills לפי שפה ופריימוורק (Python, Pydantic, typing contracts) ו-skills של audit מהקהילה (Aaron Francis): audit boundaries, drift, names, abstractions, dead code, errors — מפשטים ומשפרים קוד בזמן היישום.
- דמו חי: ה-PR הסתיים ב-fix summary שבו כל הבעיות שזוהו ב-review נפתרו אוטומטית ('All issues were resolved'). המלצה פרקטית: גם בלי כלי ייעודי, בקשו מהסוכן לנתח את מבנה הריפו של הסדנה וליישם ב-workflow שלכם; packmind.com הוא אלטרנטיבת open-source לשכבת governance כזו.
- Q&A: שאלה על ניהול context — המנחה כבר לא מנקה sessions ידנית; עם השיפורים ב-compaction הוא נותן ל-context להתכווץ לבד ורק במקרה הצורך פותח session חדש ומעתיק לתוכו את הרלוונטי. Qodo תומכת גם ב-on-prem לצוותים עם דרישות אבטחה (בנקים, צוותי Nvidia).
למי זה מתאים: מהנדסים וצוותים שמאמצים agentic coding ורוצים מסגרת governance ו-quality gates במקום vibes, כולל בארגונים מווסתים.
Agentic CodingCode QualityGovernanceQuality GatesQodoSDLC
צפייה בהרצאה ביוטיוב ←Building Self-Learning Loops for Your Agent — Fuad Ali, Arize AI
Fuad Ali · Arize AI · 38:55 דקות
בקצרה: סדנת Arize: לולאה של detect → investigate → fix → verify שהופכת סוכן ל'מתקן-עצמו'. סוכן ברקע צורך את ה-telemetry של האפליקציה, מקבץ דפוסי כשל, כותב תחקיר עם ראיות ופתרון מוצע — ואפילו פותח PR. האדם נשאר ב-code review.
- האנלוגיה המנחה: מערכות רקטות ב-SpaceX מתקנות מסלול כל מילישניה על ידי צריכת הטלמטריה של עצמן. אותו עקרון לסוכנים: סוכן שצורך את ה-telemetry של עצמו ומפעיל אותה לתיקון עצמי — זה ה-self-learning loop.
- הדמו של Signal (Arize): traces זורמים מהאפליקציה, נעשית clustering של בעיות חוזרות עם טבלת קטגוריות ומגמות לאורך זמן. דוגמה: בעיית serialization בפייתון שמשחיתה את קלט הסוכן — המערכת זיהתה, תחקירה ופתחה PR לבד, מוכן ל-review אנושי.
- מבנה התחקיר האוטומטי: overview של מה הסוכן עושה (למשל 'ממציא תוצאות'), hypothesis לגבי הסיבה, evidence מתוך traces ספציפיים, ו-proposed fix. המלצה מפורשת של המנחה: להשאיר את ה-code review לאדם, גם שאפשר טכנית להרחיק עד הסוף.
- ארבעת השלבים המעשיים: (1) Detect — להציף כשל לפני שמשתמש מדווח עליו. (2) Investigate — תחקיר מבוסס traces עם ראיות. (3) Fix — הצעת תיקון או PR. (4) Verify — לאמת שהתיקון עובד. זה ה-through-line של הסדנה.
- כלים: חבילת skills של Arize (npx skills add arize-ai/arize-skills) עם מצב אינטראקטיבי — trace analysis, dataset curation ו-evaluators; אפשר לבקש מ-Claude Code לנתח traces מול קוד הסוכן בריפו. Arize הייתה ראשונה עם LLM-as-a-judge (2023), OpenInference ו-agent evals; ההימור הבא שלהם הוא self-correcting agents.
למי זה מתאים: מהנדסי AI עם סוכנים בפרודקשן שרוצים לולאת שיפור אוטומטית מבוססת telemetry במקום לגלות על כשלים ממשתמשים.
Self-Improving AgentsTracesObservabilityArizeEvalsAgent Improvement
צפייה בהרצאה ביוטיוב ←Agent Speedrun — Elizabeth Fuentes Leone & Sandhya Subramani, AWS
Elizabeth Fuentes Leone & Sandhya Subramani · AWS · 59:55 דקות
בקצרה: סדנת AWS: בונים סוכן מאפס ועד פרודקשן ב-Bedrock AgentCore. הדגשים — hooks כבלמים לסוכן (rate limiter שעוצר לולאת כלים בורסת), ופריסה מלאה בלי לכתוב IAM policies ידנית: AgentCore מייצר הכל, כולל CloudFormation/CDK, עם observability מובנית.
- Hooks כבלמים: דמו של rate limiter hook — מגבלה קשיחה של 3 קריאות כלי. מגדירים אירועים (before invocation, before tool call), מונה שמתאפס בכל בקשת משתמש חדשה, ובדיקה שחוסמת כשחורגים. התשובה ל'הסוכן ישתולל וישרוף טוקנים': hard stop.
- בדיקות שבירה: לא מסתפקים בלבנות את המגבלה — מנסים לשבור אותה בכוונה (מורידים את הלימיט כדי להצית אותה) ורואים שה-hook חוסם ('block lookup') כשסוכן נכנס ללולאת כלים.
- פריסה בלי כאב IAM: הפריסה ל-AgentCore runtime מטפלת ב-credentials, policies והרשאות בין שירותים אוטומטית — הכל מה שהיה דורש עבודת console ידנית. מאחורי הקלעים נוצר CloudFormation stack דרך CDK (infrastructure as code בפייתון/TypeScript).
- Observability מובנית: דשבורד ב-runtime מציג sessions, traces וכמה runtimes רצים. כל session היא container נפרד; הנתונים מופיעים תוך דקה-שתיים. מפעילים את הסוכן דרך ה-SDK (boto3) ישר מהריפו.
- קצב הסדנה: 'speedrun' — מהקמת סביבת העבודה ועד סוכן חי בענן, עם צוות מנחים שעוזר במקביל. חלק ניכר מהזמן הוקדש להתנתקויות Wi-Fi, אבל כל השלבים (hooks, הרצה מקומית, deploy, invoke, traces) הודגמו end-to-end.
למי זה מתאים: מהנדסים שרוצים להעביר סוכן ממחברת מקומית לפרודקשן בענן עם בלמים ותצפית, בלי להתמקצע קודם ב-IAM.
AWSBedrock AgentCoreHooksRate LimitingDeploymentObservability
צפייה בהרצאה ביוטיוב ←The SDLC You Build Yourself — Andy Wong, Andrei Bocan & Shane Wolf, Atlassian
Andy Wong, Andrei Bocan & Shane Wolf · Atlassian · 57:49 דקות
בקצרה: סדנת Atlassian על ה-Jira coding agent (Rovo): harness עם בחירת מודל ברמה העליונה, skills וסאב-סוכנים לפי משימה, sessions מבודדות בענן (Docker) עם שינויים בזמן אמת, ו-AI reviewer שכבר תומך ב-skills. הרבה Q&A כנה על מה שעוד לא קיים, כולל smart model routing.
- הארכיטקטורה: ה-coding agent של Jira הוא harness עם בחירת מודל בראש, ומתחתיו skills — לכל skill או סאב-סוכן אפשר להקצות מודל משלו למשימה הספציפית. ההגדרה בידי המשתמש, לא קבועה מראש על ידי Atlassian.
- בכנות על routing: אין עדיין 'smart routing' אוטומטי שמנתב משימה למודל המתאים. הם עובדים על זה ב-autodev — מדדים הצלחות לפי סוג משימה כדי שתוכל לאכוף policy מבוסס נתונים, לא ניחוש.
- Sessions מבודדות: כל session של הסוכן היא סביבת ענן מבודדת (Docker). שינויים שעושים בתוך ה-session או ב-VS Code הענני משתקפים בזמן אמת; שינוי ב-IDE המקומי הוא instance נפרד. סביבת הפיתוח מבוססת Dockerfile.
- AI reviewer: תמיכה ב-skills נוספה פחות מחודש לפני הכנס — הכיוון הוא שכל רכיב ב-SDLC (כתיבה, review, אוטומציות) ניתן להרחבה עם skills מותאמים.
- אופי הסדנה: דמו אתר חי שנשאר פתוח למשתתפים למשך הכנס, שאלות רצופות מהקהל (automation מול Jira, on-prem, הקצאת סוכנים) ותשובות ישירות של צוות המוצר — כולל היכרות עם הגבולות הנוכחיים של המערכת.
למי זה מתאים: צוותי פיתוח שחיים ב-Jira/Atlassian ורוצים להבין איך ה-coding agent שלהם בנוי, מה אפשר להתאים בו, ומה עוד בדרך.
AtlassianRovoCoding AgentsSkillsSDLCModel Routing
צפייה בהרצאה ביוטיוב ←Agents That Own Their Inference — Du'an Lightfoot & Khaja Omer, Akamai Technologies
Du'an Lightfoot & Khaja Omer · Akamai Technologies · 110:10 דקות
בקצרה: סדנת Akamai (שעתיים): להפסיק 'לשכור' אינטליגנציה ולהחזיק סוכנים על GPU ייעודי משלך. מה-KV cache ועד quantization — איך מודל באמת יושב על GPU, איך מודדים ביצועים תחת concurrency, ולמה בלי evals אי אפשר לדעת שהקטנת המודל לא שברה את ה-function calling.
- המוטיבציה: סוכן הוא לולאה שמייצרת טוקנים בכל צעד (קריאת כלי, הערכת תוצאה, עדכון תוכנית) — וזה מתייקר מהר. המנחה החל לבנות סוכנים ב-2023 עם 8K טוקנים context ונתקל בשתי בעיות: עלות, ומודלים קטנים שלא מספיק חכמים או נחנקים בזיכרון GPU.
- איך מודל יושב על GPU: מודל 4B פרמטרים ב-BF16 = 8GB משקולות; כל השאר הוא KV cache — שם חייב להיכנס כל ה-context: הפרומפט, ה-system prompt, תוצאות כלים וכל טוקן שנוצר. ה-prefill קורא את כל הפרומפט לתוך ה-cache, והוא רק גדל עם כל טוקן.
- config.json הוא לא קובץ טכני שמדלגים עליו: הוא אומר ל-vLLM איך להתייחס למודל. שווה לפתוח את קבצי המודל שמורידים מ-Hugging Face ולהבין מה יש שם לפני פריסה.
- מדידה אמיתית: load test עם 256 טוקנים קלט ו-128 פלט — 714 טוקן/שניה aggregate ב-32 concurrent, אבל time-to-first-token קופץ מ-277ms ל-1,300ms בין 32 ל-64 concurrent. לפעמים נכון לעצור ב-32 ולא לדחוף יותר.
- Quantization בלי evals זו הימור: מעבר מ-BF16 ל-FP8 מכווץ את המודל אבל עלול לשבור JSON של function calls. בונים eval set בסיסי (תקינות JSON, שחיתות תשובות) מה-evaulations הפתוחים ב-Hugging Face ובודקים לפני שמאמצים.
למי זה מתאים: מהנדסים שרוצים להריץ סוכנים על תשתית משלהם (GPU ייעודי) ולהבין את הטרייד-אופס של זיכרון, latency, concurrency ו-quantization.
InferenceGPUvLLMQuantizationKV CacheSelf-Hosted ModelsEvals
צפייה בהרצאה ביוטיוב ←AI Security Engineer Foundations + Certificate — Micah Silverman, Snyk
Micah Silverman · Snyk · 120:17 דקות
בקצרה: קורס היסודות של Snyk ל-AI security engineer (שש מודולים, שעתיים): OWASP Top 10 ל-LLM, shadow AI ולמה הוא קשה מ-shadow IT, agentic sprawl — ותרגיל threat modeling על OpenClaw שמניב 37 איומים, כולל attack chains שכל חוליה בודדת בהן נראית תמימה.
- תפקיד מתהווה: 'AI security engineer' — לפעמים תואר נפרד, לפעמים שכבה על תפקיד security קיים או כיוון גידול למפתחים. הקורס מכסה שישה מודולים ומתחיל ב-OWASP Top 10 ל-LLM.
- Shadow AI קשה מ-shadow IT: הוא בלתי נראה בעיצובו — טאבים בדפדפן, פיצ'רים מוטמעים, חשבונות אישיים (כמחצית העובדים עדיין משתמשים בהם). הוא לא-דטרמיניסטי, ורק 37% מהארגונים הספיקו לגבש מדיניות governance. הדוגמאות: דליפת קוד קנייני (Samsung), עיבוד PII בכלי לא מאושר, מודל open-source עם דאטה אימון לא מגולה.
- Agentic sprawl: סוכנים יורשים OAuth tokens, מפתחות API וגישה למייל, דוקים וריפוז — אוטונומית. הדוגמה החיה: Claude Cowork מקבל שליטה בדפדפן ו'יוצר קובץ ב-Google Docs' דרך ה-UI — וככה קיבל כתיבה ל-Google Drive בלי מפתח ובלי אישור מפורש, פשוט כי המשתמש מחובר בדפדפן.
- Threat modeling בפועל: מפעילים את מטריצת האיומים ATLAS על OpenClaw ומקבלים 37 איומים — direct prompt injection, persistence דרך skills, ושרשראות תקיפה (attack chains): כל צעד בנפרד לא היה מניב נזק, אבל השרשרת כן. זו נקודת מפתח בהבנת סיכוני AI.
- המנחה גם כנות אישית: עדיין לא הריץ OpenClaw בעצמו כי אין לו מכונה 'נקייה' מספיק — דווקא הדוגמה האישית הזו (מכונה מנותקת, בלי לוגינים) היא בדיוק ההמלצה המעשית למי שרוצה להתנסות בסוכנים אוטונומיים.
למי זה מתאים: אנשי אבטחה ומפתחים שנכנסים לתחום אבטחת AI ורוצים מסגרת יסודות מסודרת — מ-OWASP ועד threat modeling של סוכנים.
SecurityOWASPShadow AIThreat ModelingAgent SecuritySnyk
צפייה בהרצאה ביוטיוב ←Vector Isn't Enough: Hybrid Search & Retrieval — Jeff Vestal & James Williams, Elastic
Jeff Vestal & James Williams · Elastic · 76:20 דקות
בקצרה: סדנת Elastic hands-on: RAG לא מת — הסוכנים פשוט לקחו על עצמם את ניהול ה-retrieval. כלל האצבע: מתחילים מ-BM25 + semantic search, ורק אם יעדי ה-relevance לא מתמלאים מוסיפים reranker. ועד agent builder: skills, tools וסוכנים שנבנים פרוגרמטית דרך API.
- הפריימינג: RAG 'נפל לרקע' לא כי הוא מת, אלא כי סוכנים מספיק מסוגלים כדי לנהל לבד את שליפת המידע וניתוחו. המודלים משתכללים, אבל תמיד צריך להזרים מידע עדכני או פרטי לתוך המודל — וזו שאלת retrieval.
- כלל אצבע מעשי מסדנת המעבדות: לקורפוס קטן-בינוני, ראו קודם מה אפשר להשיג עם שילוב של BM25 (לקסיקלי) וחיפוש סמנטי (dense vectors). אם הגעתם ליעדי ה-recall/precision — עצרו. כל שכבה נוספת עולה latency.
- שלב ההסלמה הבא: reranker model — בוחרים אחד שמתאים לקורפוס ובודקים שהוא מזיז את המחוג מספיק כדי להצדיק את העלות. יש גישה שאומרת 'קודם BM25 בלבד ואז סמנטי', אבל המנחה מעדיף dense vectors מההתחלה כדי להימנע ממורדות של tuning לקסיקלי (synonyms וכו').
- החלק האחרון — agent builder של Elastic: הכל API-driven. בונים skills, tools וסוכנים פרוגרמטית (create, tear down, scale). ההבחנה בין skill ל-tool: skill מסביר למודל איך לבצע משימה בצורה מסוימת; tool מבצע פעולה (חיפוש, הרצת workflow דטרמיניסטי, קריאה לשירות חיצוני).
- אופי הסדנה: סביבת מעבדה בענן (Instruct) שהוקצתה ל-75 משתתפים, סדרת labs מודרכים מלקסיקלי דרך סמנטי והיברידי ועד בניית סוכן עם skill משלכם — כשכל הסטאק זמין גם כ-API לבנייה תוכניתית.
למי זה מתאים: מהנדסים שבונים retrieval לסוכנים ו-RAG ורוצים עץ החלטות פרקטי: מתי מספיק BM25+וקטורים, מתי reranker, ואיך הופכים את זה לסוכן.
Hybrid SearchBM25Vector SearchRerankingElasticRAGAgent Builder
צפייה בהרצאה ביוטיוב ←The Data Context Layer for Agents — Yoni Michael & Brandon Callender, Typedef
Yoni Michael & Brandon Callender · Typedef · 106:21 דקות
בקצרה: סדנת Typedef: סוכנים לא נכשלים במשימות דאטה כי הם לא יודעים SQL — אלא כי הם לא מבינים מה הדאטה אומר, איך הוא זורם ומה נשבר כשמשהו משתנה. הפתרון: data context layer — גרף שמחלץ, מחשב ושומר את ההקשר כשהסוכן שואל אותו, במקום לגלות הכל בזמן ריצה.
- ההימור של החברה: המודל הוא לא הצוואר — ההקשר החסר הוא. context engineering למשימות דאטה מורכב בהרבה מסוכני קוד: סכמות, lineage, סמנטיקה עסקית, ומה נשבר כשמשהו משתנה.
- עקרונות מהבנייה שלהם: הקשר קטן ומדויק מנצח (AI יעיל יותר כשה-context קטן בכל משימה); לבנות את ה-tool surface בעצמכם — 'סט כלים מקורטב תמיד מנצח בופה של MCPs מהמדף' (הם שכתבו חלקים גם מה-Snowflake/Databricks MCPs כדי להתאים לצרכים); ולהשקיע ב-eval infrastructure מוקדם ותמיד — 'אי אפשר לבנות סוכן אמין בלי למדוד'.
- הארכיטקטורה: מחלצים את ההקשר, מחשבים אותו, שומרים אותו בגרף — והסוכן עושה query לגרף ביעילות. ככה עוברים מסוכן ש'קורא את הקוד' לסוכן שמסוגל 'להפעיל את מערכת הדאטה'.
- דמו hands-on (Fenic): מריצים LLM על קורפוס של פריטי Rust (kind, qualified name, docstring) ומייצרים תקציר של 'מה הפריט עושה' — ואופפים את זה לגרף. היתרון המרכזי: ידע שנוצר מראש הוא auditable. אם הסיכום שגוי, מתקנים אותו. אם הסוכן ממציא את ההסבר בזמן ריצה וטועה — תגלו את זה רק כשהקוד שהוא כותב לא עובד.
- Q&A כנה: עלויות תחזוקה של הגרף — 'הרבה מהבעיות האלה אפשר לפצל ולעשות אינקרמנטליות'; גרסה 'זהב' מבוססת main עם רענון אינקרמנטלי מקומי. לא מכריזים על פתרון קסם — מראים את הטרייד-אופס.
למי זה מתאים: מהנדסי דאטה ו-AI שבונים סוכנים מעל data platforms ומרגישים שהמודל מספיק חכם אבל הסוכן עדיין מפספס את הסמנטיקה של הדאטה.
Data EngineeringContext EngineeringKnowledge GraphAgentsTypedefEvals
צפייה בהרצאה ביוטיוב ←Lifestyles of the AI-Native — Nick Nisi & Zack Proser, WorkOS
Nick Nisi & Zack Proser · WorkOS · 61:28 דקות
בקצרה: סדנת WorkOS hands-on: להפסיק 'לטפל' בסשן אחד של סוכן ולהתחיל להפעיל צי של סוכנים. ארבעה טורים מעשיים: קוד בקול (voice coding), לולאות (loops/goals), worktrees לעבודה מקבילה, ו-hooks + verification gates שמונעים מהסוכן ללכת לאיבוד בלעדיכם.
- הטענה המרכזית: רוב המהנדסים עדיין 'מבייביסיטים' סשן אחד. ב-WorkOS (צוות של שניים שמתחזק 25+ ריפואים ב-8 שפות) מפעילים 8-12 סוכנים במקביל ב-tmux, עם כלי ניהול בשם fleet שמציג סיכום אוטומטי לכל סשן ומאפשר לקפוץ ביניהם.
- Voice coding כמכפיל כוח: הקלדה של ~90 מילים לדקה הופכת ל-~190 בדיבור, והבונוס האמיתי הוא כפילות — מנחים כמה סוכנים ברצף בלי מגע במקלדת. כלים: Whisper Flow (קל להתקנה, אבל מנוי + ענן) מול Handy (open source, תמלול מקומי על המכונה, מתאים לעבודה רגולטורית/רגישה) — ואפילו Whisper Flow בטלפון כדי 'להעביר' את הסשן איתכם להליכה.
- לולאות במקום ניטור: בונים goal (למשל 'כל חמש הבדיקות עוברות') ונותנים לסוכן לרוץ שעתיים-שלוש בלי הפרעה. שני תנאים להצלחה: תכנון מוקדם ומעמיק (מה זה 'גמרנו', מה מחוץ לסקופ) — ו-verification gates קשיחים, כי בזבוז הטוקנים מגיע מחקר לא חסום בלי שאף אחד אומר לסוכן שהוא סטה.
- עבודה מקבילה עם git worktrees: כל סוכן מקבל עותק מבודד של הריפו, פורסים עבודה של אחר-צהריים שלם לבלוקים מקבילים שמסתיימים תוך 45-60 דקות, וכל סוכן פותח PR נפרד בלי לערבב שינויים. במונו-ריפו כבד — סביבות ענן (Devin ודומיו) במקום worktrees מקומיים.
- למידה מטעויות: 'סוכן רטרוספקטיבה' שסוקר כל לולאה בסוף, מזהה איפה בזבז זמן או נתקע, וכותב זיכרון (markdown, עם הבחנה בין זיכרון קצר לארוך ו-progressive disclosure) שנטען בסשן הבא כדי שלא יחזור על אותן טעויות. ובסוף הכל — human review: הקוד מגיע לאדם רק אחרי שהסוכן הוכיח שהוא עובד ונראה נקי.
למי זה מתאים: מהנדסים שכבר עובדים עם Claude Code/Codex יומיומית ורוצים לעבור מ'סוכן אחד בטאב' לתזמורת של סוכנים מקבילים — בלי לאבד שליטה על האיכות.
Agent WorkflowsClaude CodeVoice CodingGit WorktreesParallel AgentsWorkOS
צפייה בהרצאה ביוטיוב ←Robot Demos Are Easy. Reliability Is Hard — Jason Ma, Dyna Robotics
Jason Ma · Dyna Robotics · 26:42 דקות
בקצרה: Dyna Robotics על הפער בין דמו יפה לרובוט מסחרי: מודלים גנרליסטיים מגיעים ל-80-90% הצלחה, אבל 90% אומר שסיכוי ל-10 הצלחות ברצף קטן מ-0.1%. הפתרון שלהם: reward models שמדרגים התקדמות בזמן ריצה, ו-human-in-the-loop active learning שמביא את קיפול המפיות ל-99.4% לאורך 24 שעות.
- הדילמה של התחום: מודלים גנרליסטיים (pre-training על דאטה מגוון + post-training) עושים הרבה משימות אבל לא מספיק אמינים לפריסה מסחרית; מודלים ספציאליסטיים אמינים אבל לא סקיילביליים. המטרה: גנרליסטים שגם אמינים.
- פירמידת הדאטה: דאטה מגוון מחוץ לרובוט (בני אדם עם מצלמות, דאטהסטים ציבוריים, סימולציה) + משימות מגוונות על הרובוט עצמו + דאטה איכותי מפריסות אמיתיות אצל לקוחות — יותר מ-200,000 שעות בצנרת. ארכיטקטורה: מודל reasoning ברמה גבוהה + world-action model ברמה נמוכה לתנועות עדינות בתדירות גבוהה.
- הפריצה — reward models למשימות ארוכות: מודל שצופה בווידאו של הרובוט ומדרג 0-1 את ההתקדמות למטרה. כשהרובוט מתחיל לטעות, העקומה הופכת לא-מונוטונית — וזה הדגל. כך מתקבל 'פיקוח סקיילבילי': במקום שאדם ישב ליד רובוט ב-90% הצלחה, ה-reward model תופס את כשלונות, אוספים דאטה ממוקד של error recovery, ומאמנים מחדש. כמה סבבים כאלה — והמודל מכליל התאוששות גם ממצבים שלא נאספו עבורו.
- התוצאה המסחרית: Dyna-1 מקפל מפיות ב-99.4% הצלחה במשך 24 שעות (כולל שינויי תאורה לאורך היום, וכולל התאוששות ממשיכת כמה מפיות בבת אחת או הפילת הערימה כולה). פריסות אמיתיות: מסעדות בארה"ב, כביסה בסקרמנטו (קיפול מגבות), ופתיחת פחיות Red Bull באירועים. קריטריון 'grade 5 fold' מול 'grade 3' ממחיש שבעולם האמיתי יש הגדרת איכות קשיחה — לא 'נראה טוב בסרטון'.
- הכללה בין אתרים: רסיפי דאטה שמאפשר לשלוח רובוט לאתר לקוח חדש בלי איסוף דאטה נוסף (דמו ב-CoRL 2025 בקוריאה — קיפול חולצות ישירות מהדוכן). מסקנת Q&A: pre-training גנרלי קריטי גם למשימה אחת — חלק מההתאוששות מטעויות מגיע מאינטרפולציה של התנהגויות recovery ממשימות אחרות; מודל שאומן רק על משימה אחת מפספס את הידע הפיזי הזה.
למי זה מתאים: חוקרי רובוטיקה ו-ML, וכל מי שרוצה להבין למה 'סרטון רובוט מרשים' ו'רובוט שעובד אצל לקוח' הם שני עולמות שונים — ומה הסטאק (דאטה, reward models, active learning) שגורר ביניהם.
RoboticsFoundation ModelsReward ModelsActive LearningManipulationDyna Robotics
צפייה בהרצאה ביוטיוב ←World Models Need Causality, Not Pretty Pixels — Christopher Manning, Moonlake
Christopher Manning · Moonlake · 51:36 דקות
בקצרה: כריס מנינג (סטנפורד/Moonlake) בהרצאה כפולה: 20 דקות של היסטוריית AI מ-1956 ועד שייקי הרובוט, ואז הטענה המרכזית — וידאו גנרטיבי יפה (Genie 3, Marble) הוא לא world model. כדי שסימולציה תשרת רובוטיקה אמיתית צריך סמנטיקה וקאוזליות: מודל עולם נוירו-סימבולי שהחלקים הנשלטים בו בנויים מקוד, עם לולאת אימות מול המציאות.
- חצי ראשון — סיפור: מ-Dartmouth 1956 (ושאנון, הגיבור האישי שלו), דרך הפרספטרון של רוזנבלט ותרגום מכונה ב-1954 ('המחשב יחליף מתרגמים אנושיים' — הייפ שחוזר על עצמו), מעבדת ה-AI של סטנפורד מ-1963, עגלת סטנפורד ורובוט שייקי — שהיה לו world model לוגי פנימי לתכנון, רעיון שהוגדר כבר ב-1943 על ידי קנת' קרייק.
- הטענה: ללמוד מדיניות ישירות בעולם האמיתי (כמו חוות זרועות של Google X) דורש ~10,000 שעות טלס אופ — דרך איטית ולא סקיילבילית. התשובה ההיסטורית והנכונה: world model פנימי מופשט שמאפשר סימולציה ותכנון לפני פעולה.
- הביקורת על הדור הנוכחי: Genie 3 ו-Marble מייצרים 'פיקסלים יפים' — סימולציה של תצפיות בלי הסמנטיקה שמאחוריהן. אפשר לטייל בתוך עולם של Marble, אבל אי אפשר לעשות כלום עם הקומקום והקופסה. 'רוב ה-visual AI נשפט לפי הפיקסלים — אבל פיקסלים לא מייצגים קאוזליות'.
- הגישה של Moonlake: מפרידים רקע (ברמת Marble) מאובייקטים ניתנים למניפולציה; כשתצפית חלקית (קופסת תה סגורה) — משלימים מחקר בסגנון RAG מהרשת כדי לדעת מה בפנים; והחלקים הנשלטים נבנים מקוד — loop engineering בסגנון Claude Code: כותבים קוד שמרנדר אובייקטים, משווים למציאות, מתקנים סטיות. בנוסף משתמשים במנועי פיזיקה (שאלה מהקהל: 'אנחנו מכירים פיזיקה' — צמיגות, חיכוך).
- למה זה משנה: סימולציה מאומתת עם קוד היא הדרך לסגור את פער ה-sim-to-real בלי לכתוב פיזיקה ידנית — 'neural optimization שמכווץ את הפער אוטומטית'. התיקון למארק אנדריסן: תוכנה אכלה את העולם הווירטואלי, אבל לא את הפיזי — סימולציות מאומתות הן הדרך שהתוכנה תאכל גם אותו. יישומים: אוטומציה של תהליכי ייצור מוידאו קצר, רובוטיקה הומנואידית, חלל.
למי זה מתאים: חוקרי רובוטיקה ו-world models, וכל מי שמתלבט אם וידאו גנרטיבי מספיק טוב כבסיס לתכנון ופעולה — ורוצה מסגרת חלופית עם קאוזליות ואימות.
World ModelsSimulationNeuro-SymbolicRoboticsEmbodied AIHistory of AI
צפייה בהרצאה ביוטיוב ←Robotics Has Been Stuck for 70 Years — Deepak Pathak, Skild AI
Deepak Pathak · Skild AI · 28:18 דקות
בקצרה: דיפק פאת'ק (Skild AI): סרטוני רובוטים מרשימים קיימים משנות ה-50 — ה-MIT copy demo מ-1960 וטלאופ מ-1957 נראים בדיוק כמו הדמואים של היום. רובוטיקה תקועה כי טיפלו בה כבעיית חומרה במקום כבעיית 'מוח כללי'. הפתרון שלהם: מוח אומני-בודי (any robot, any task, one brain), pre-training על דאטה סקיילבילי ומגוון + post-training על טלאופ, ו-flywheel של דאטה מפריסות.
- הפרדוקס שמניע את ההרצאה: Moravec — 'קשה זה קל, קל זה קשה'. מדליה באולימפיאדת מתמטיקה נפתרה, טיפוס מדרגות לא. הדוגמה החיה: backflip וקונג-פו קלים לרובוט (הוא צריך להכיר רק את גופו — fully observed), מדרגות קשות כי צריך ראייה והסתגלות לגובה/רוחב לא ידועים — ולכן כמעט לא רואים סרטוני מדרגות אצל מתחרים.
- למה אין scaling ברובוטיקה: GPT-3 עבד מ-30 טריליון טוקנים; טלאופ נותן דוגמה בדקה — כל אוכלוסיית ארה"ב לא תגיע לסקייל הזה במאה שנה. שלושת הצירים של דאטה: סקיילביליות, מגוון, וקרבה לזוויות המפרקים של הרובוט. סימולציה סקיילבילית אבל דלת מגוון; סרטוני אנשים סקיילביליים ומגוונים אבל רחוקים מהרובוט; טלאופ קרוב ואיכותי אבל מועט. אין תשובה אחת — משלבים.
- המתכון: pre-training על דאטה סקיילבילי ומגוון ואיכותו נמוכה (סימולציה + סרטוני אנשים), post-training על טלאופ איכותי ומועט — אותה צורה כמו מודלי שפה. ומעל הכל: flywheel של deployment data, שאפשרי רק עם מוח אומני-בודי, כי אף פעם לא פורסים רובוט אחד בצורה אחת לנצח.
- למה קיפול כביסה קל (והקהל נופל בפח): סובלנות לטעות עצומה — אף אחד לא חושב כשהוא מקפל. קשה לרובוטיקה קלאסית עם מודלי פיזיקה ידניים, קל ל-deep learning. מה שקשה באמת: AirPod מזויף מ-Temu (בלי מגנט!) עם parallel gripper, או הכנת חביתה על סטאפ של $4,000 עם מצלמה בלבד — end-to-end מהמצלמה ישר למנועים, בלי state machine, מפחות מ-10 שעות דאטה, עם 'חלומות' שהרובוט מייצר במודל העולם שלו כדי להכפיל את הלמידה.
- פריסות ובטיחות: אוטומציה של הרכבת GPUs במפעל החדש של NVIDIA ביוסטון (כבר חי, GTC live demo) בסביבה מבולגנת ולא-מנורמלת — הרובוטים לא צריכים כלוב; משלוחי חבילות מהמשאית לדלת; ו-zero-shot transfer להומנואידים שלא אומנו עליהם — כולל רובוט שהרגל נשברת לו ומתאושש תוך מילישניות ('רובוט תלת-רגלי הוא פשוט רובוט חדש'), כי הצורה לא משנה למוח אומני-בודי.
למי זה מתאים: חוקרי רובוטיקה ו-ML, משקיעים/בוני סטארטאפים שרוצים הבחנה מפוקפקת בין דמו מרשים לקשה באמת, וכל מי שרוצה להבין איך נראית תשתית דאטה ל'GPT של רובוטיקה'.
RoboticsFoundation ModelsSim2RealTeleoperationHumanoidsSkild AI
צפייה בהרצאה ביוטיוב ←The Dark Arts of Skill Engineering — Paul Bakaus, Impeccable
Paul Bakaus · Impeccable · 64:53 דקות
בקצרה: פול בקאוס (יוצר jQuery UI ו-Impeccable) עם תשע לקחים מעבר לפרומפט בבניית skills: למה רשימת איסורים ('אל תשתמש ב-Inter') רק מזיזה את ה-slop לצבע הבא, איך scripts שמדפיסים הוראות ל-stdout מצייתים טוב יותר מכללים בפרוזה, hooks שחוסמים כתיבת קוד גרוע לפני שהוא נכתב, ואיך נראה eval harness אמיתי ל-skill — כולל ablation testing לכל שורת חוק.
- הבעיה: 'slop הוא מטרה נעה'. התחילו עם הגרדיאנטים הסגולים של Tailwind, עברנו ל-'claude beige' עם italic serif ו-eyebrow text. רשימת איסורים לא עובדת: 'never use Inter' פשוט שולח את המודל לפונט הבא במרחב הלטנטי. החציון הוא כוח המשיכה של המודל — 250 שורות של פרוזה מטופחת לא משנות את זה.
- compound engineering: ה-skill שומר מצב בין סשנים (למשל critiques קודמים כקבצים בתיקיית ה-skill), כולל העדפות משתמש ('לא מסכים עם הביקורת על הפונט') — והריצות מצטברות במקום להתחיל מחדש. שימושי גם לריפקטורינג רב-סשני: skill שמטפל בקובץ אחד בכל סשן וצובר הקשר.
- הטכניקה המרכזית: scripts בתוך ה-skill (כמו context.mjs של Impeccable) שבודקים את מצב הריפו ומדפיסים ל-stdout הוראות מובנות ('אין product.md — הנה בדיוק מה לעשות'). מסתבר שהמודל מציית לפלט של script הרבה יותר מאשר לכלל קבור בפרומפט. החסרון: שובר prompt caching (פלט דינמי) — מתאים לסשנים אינטראקטיביים, פחות לריצות חוזרות גדולות.
- hooks שחוזרים מכות: design lint פסיבי שרץ על כל עריכה — כי 'guardrail פסיבי מנצח פקודה שאף אחד לא זוכר להריץ'. הבדלים בין מודלים: למודלים חלשים (composer ב-cursor) צריך pre-tool-use hook שחוסם את כתיבת הקובץ מראש, לא post-hook שמתלונן אחרי. וחובה: מנגנון ignore-rules גרנולרי, אחרי שיש false positives.
- harness engineering במקום prompting: לנצל יכולות של ה-harness עצמו — Impeccable מחבר את הדפדפן הפנימי של Codex לשרת פיתוח עם live poller (SSE) שמאפשר picker ויזואלי ווריאנטים בעמוד, והאירוע חוזר ל-thread דרך סיום ה-poller (שוב טריק ה-stdout). ובונוס: eval harness שמשחזר את כל ה-harnesses (Claude/Codex/Gemini), LLM שמשחק 'משתמש', mixture-of-judges לדירוג, 20 נישות × כמה מודלים × 5-10 ריצות לכל ריליס, הרצה מול מתחרים — ו-ablation testing: לכל שורת חוק יש XML tag ייחודי, מסירים אותה ובודקים אם משהו השתנה.
למי זה מתאים: מי שכותב skills ל-Claude Code/Codex/Cursor ומרגיש שהפרומפט הפסיק להספיק — ורוצה להפוך skill לחצי-תוכנה: סקריפטים, hooks, שמירת מצב ו-evals.
SkillsPrompt EngineeringHooksHarness EngineeringEvalsDesign Systems
צפייה בהרצאה ביוטיוב ←Total Recall: Agent Memory and Harness Engineering — Ignacio Martinez, Oracle
Ignacio Martinez · Oracle · 60:47 דקות
בקצרה: סדנת Oracle hands-on (GitHub Codespaces) על agent memory ו-agent harness: המודל הוא החלק הקפוא של ההיגיון — ה-harness מעל ה-data layer הוא מה שבשליטתכם. מבנה של שבע שכבות ל-harness מינימלי, טיפוסי זיכרון (קצר/ארוך/משותף), למה context rot הורס שיחות ארוכות, ורכיב ה-context card שמרכז תקציר, עובדות והעדפות.
- הפריימינג: מתוך חמש שכבות ה-agent stack (אפליקציה, דאטה, מודל, תשתית, compute) — ארבע הולכות והופכות קומודיטי. מה שבשליטתכם באמת הוא ה-data layer, ושם חי ה-harness: gateway/MCP, זיכרון, שכבה סמנטית, retrieval, context, tools.
- טיפוסי זיכרון: קצר (ephemeral — כמו todo list של סוכן קוד), ארוך (episodic — שיחות קודמות; procedural — וורקפלואים שהצליחו ונרצה לשחזר), ומשותף (sub-agent מול parent). למה לא פשוט context ענק: context rot — מטריצת ה-attention גדלה ריבועית, וכל פריט נוסף גונב קשב מהאחרים; 'אחרי שמונה שעות שיחה תרצה לתת לי מכה'. לכן שומרים את ה-context קטן ומכוון.
- הפתרון המנוהל שלהם (OAMP — Oracle Agent Memory Package): קריאה אחת שמייצרת 'context card' — נושאים לאוריינטציה, תקציר שמכווץ את ה-thread ומצהיר על הכוונה הנוכחית, עובדות/העדפות/זיכרונות, מעקב אחרי שאלות פתוחות, והודעות אחרונות להקשר מקומי. הכרטיס לא נכנס ישירות למודל — ה-harness משתמש בו כדי להזין את המודל.
- השכבה הסמנטית כ-'Umwelt' (לפי יאקוב פון איקסקיל): העדשה שדרכה הסוכן תופס מציאות. הערך האמיתי: ללכוד את ה-'Unsaid' — הידע הארגוני שלא אומרים בקול (איך הדאטה ממודל, מה המטאדאטה, איך מריצים שאילתות) — בדיוק מה שעובד חדש היה צריך שיסבירו לו.
- מהסדנה עצמה: agent loop מינימלי (observe, reason, act) שחייב להיות failure-resistant ולא לצאת מהלולאה; 'משתנה היסטרזיס' לסבלנות — 8-12 קריאות tool מקסימום למודל מהיר לפני ויתור, ו-routing: בעיה קשה ל-frontier, קלה ל-SLM פתוח ('העתיד: mixture of small experts'). וחידוד של toolbox: תיאורי tools דומים מדי? משפרים אותם עם LLM כדי להגדיל separability בחיפוש הווקטורי. (גם פיץ' מוצרי: converged database עם in-database embeddings — לשקול בהקשר הספק.)
למי זה מתאים: מהנדסי AI שבונים סוכנים מעל דאטה ארגוני ומתחילים להרגיש את גבולות ה-context window — ורוצים מבנה מסודר לזיכרון ולשכבות ה-harness.
Agent MemoryHarness EngineeringContext EngineeringRAGOracleWorkshop
צפייה בהרצאה ביוטיוב ←Large Clusters for Small Models — Daniel Svonava, Superlinked
Daniel Svonava · Superlinked · 25:07 דקות
בקצרה: דניאל סבונבה (Superlinked): מודלים קטנים כבר לא טיפשים — Qwen 27B בערך ברמת GPT 5.1 לפרט משימות, ובמקום API אחד גדול עוברים ל'צי' של מודלים ייעודיים. אבל אז צריך להגיש אותם: טופולוגיית cluster בקוד פתוח (Apache 2.0) עם תור מרכזי שעובדים מושכים ממנו — ומכפילה את התפוקה פי שניים.
- הטענה: פרונtier מגיע לתשואה פוחתת, והמודלים הקטנים מדביקים את הפער. הכוונה ל'קטן': נכנס ב-GPU אחד מלפני 2-3 דורות (L4, A100, RTX Pro) — זמין וזול. התנאי: לא להתייחס אליו כמודל גנרי, אלא לפרק את העבודה למשימות ולבחור לכל אחת את המודל הייעודי (דוגמה: סוכן סקירת חוזים עם תשעה מודלים שונים; מודל OCR לאימותים בווייטנאמית ינצח כל מודל כללי במשימה שלו).
- הבעיה שהוא פותר: serving עצמי. vLLM/SGLang מהמדף לא מכווננים לשילוב מודל-חומרה ספציפי, ו-Bedrock מציע קטלוג מיושן ובלי בעלות על fine-tunes. הפתרון שלהם (Apache 2.0, 'מה-control plane ועד מה שרץ על ה-GPU'): gateway קל שלא מנתב מראש אלא מעורפל metadata ודוחף לתור מרכזי (NATS JetStream, ~מיליון בקשות/שנייה), וה-workers מושכים ומרכיבים לעצמם batches אופטימליים.
- למה מושכים ולא דוחפים: router מלמעלה לא יכול למלא תורים מקומיים 'בדיוק נכון'. בתור מרכזי כל worker מנבא את עלות ה-batch שלו — ושולפים יותר מדי? במכונות multi-GPU יש תור מקומי שמאפשר 'להחזיר' בלי נסיעת רשת. התוצאה: כפל תפוקה לכל ה-cluster.
- המספרים: מודלי embeddings על GPU אחד — מאות אלפי טוקנים לשנייה בלטנטיות של עשרות מילישניות בודדות (מול מאות מילישניות ומחיר גבוה בהרבה ב-endpoints מנוהלים) — 'אם מתחילים במקום כלשהו, embeddings זה no-brainer'. גם NER, multi-vector ו-generation ייעודית: אלפי טוקנים/שנייה, וסקיילינג לינארי במספר ה-GPUs.
- פרקטיקות: runtimes מגוונים (PyTorch עם auto-research loop לאופטימיזציה, Candle כקל-משקל — 10% מגודל האימג' אבל עוד לא תופס את הביצועים, SGLang כ-baseline שה-sidecar שלהם ב-Rust מנצח בבאצ'ינג); לא worker-pool פר-מודל אלא packing של כמה מודלים על GPU עם lazy loading ו-eviction לפי לחץ זיכרון; ו-auto-research loops גם להוספת מודלים חדשים וגם לביצועים — תוצר לדוגמה: LoRA בעלות 80 סנט ששיפר retrieval על טקסטים משפטיים בגרמנית ב-18%.
למי זה מתאים: מהנדסי פלטפורמה ו-ML ששוקלים self-hosting של מודלים קטנים ורוצים ארכיטקטורת serving מוכיחה — במיוחד מי שמשלם היום על embeddings/annotation ב-endpoints מנוהלים.
Small ModelsInferenceSelf-HostingServing InfrastructureOpen SourceSuperlinked
צפייה בהרצאה ביוטיוב ←Paving the Road to Production: Governed Enterprise AI Agents — Harish Gaggar, Credit Karma
Harish Gaggar · Intuit Credit Karma · 29:27 דקות
בקצרה: מסגרת ארגונית מלאה להפעלת סוכני AI בפרודקשן: MCP gateway לאימות וניתוב, MCP servers מותאמים עם בקרת כלים, LangGraph עם HITL, ניהול זיכרון, tracking ו-eval, חסימת PII, ו-context optimizer שחוסך 70-90% טוקנים.
- הבעיה: סוכנים נכשלים בפרודקשן כי חסרות בקרות תשתית. צריך gateway לאימות, MCP servers עם כלים מאושרים, מערכת tracking/eval, ניהול זיכרון, חסימת PII, ו-context optimizer. הדובר מציג שש מסגרות שמרכיבות את ה-ecosystem.
- Dev portal: מרשמים סוכן עם use case, framework (LangGraph), שפה וסקילים. הפורטל יוצר repository עם כל המסגרות, workload identity, memory DB, tracking tables ו-secret management. אחרי PR ואישור, CI/CD בונה, סורק ומפרס ל-Kubernetes.
- MCP gateway: כל קריאה מסוכן או IDE עוברת דרך gateway מרכזי לאימות (JWT + Redis session) וניתוב ל-MCP server הנכון. ה-gateway מונע גישה ישירה לendpoints. אין דרך לעקוף אותו.
- ניטור: לוגים תפעוליים ל-ELK/Loki, traces ל-Tempo דרך OpenTelemetry, מטריקות ל-Prometheus. אגרגציה ב-Grafana. שאלות כמו 'מה ה-P95 של כלי מסוים' או 'אילו 401s היו ב-10 דקות האחרונות' נענות מהמערכת.
- זיכרון: כל שאילתה יוצרת thread עם run ID. כל צומת ב-LangGraph שומר checkpoint. בפיתוח SQLite, בפרודקשן Cloud Spanner (GCP) או שווה ערך. אפשר לשלוף היסטוריה מלאה: כלים שהופעלו, צמתים, מטאדטה.
- Tracking ו-eval: שש טבלאות לכל סוכן — job tracking, quality checks (8 לכל ריצה), eval scores (0-1), quality metrics מפורט, tool invocations, trajectory. אגרגציה של 100 סוכנים מאפשרת dashboard ROI להנהלה.
- PII blocking: מסגרת שמזהה סוגי מידע רגישים ברמות חומרה שונות. מעל 90% חומרה — חסימה מיידית לפני שהמידע מגיע ל-LLM, לזיכרון, ל-tracking או לtracing.
- Context optimizer: לפני שהקונטקסט מגיע ל-LLM, הוא עובר עיצוב, pruning (בחירת payload לפי מגבלת טוקנים), re-ranking לרלוונטיות, dedup וקומפרסיה. בדמו: 24,000 טוקנים ירדו ל-2,400 (90% חיסכון). בדרך כלל 70-78%.
למי זה מתאים: מהנדסי תשתיות AI וארכיטקטים ארגוניים שבונים פלטפורמת סוכנים ורוצים בקרות governance, אבטחה ותצפיתיות מהיום הראשון.
MCP GatewayLangGraphEnterprise AIPIIContext OptimizationGovernance
צפייה בהרצאה ביוטיוב ←I Spent Two Years Building the Median — Hariprasad Sudharshan
Hariprasad Sudharshan · 36:11 דקות
בקצרה: כשכולם שוכרים את אותם מודלים, המוצרים מתכנסים לאותו פתרון — 'המדיאן'. הדובר בנה שנתיים מוצרים שהיו זהים למתחרים בלי שאף אחד העתיק. הפתרון: תקציב חדשנות מודע — למצוא את הדבר האחד שהמודל לא יכול לספק ולהשקיע בו הכול.
- העולם עדיין רץ על תוכנה דטרמיניסטית — לא AI. AI הוא 'גלגל שיניים הסתברותי' שמייצר תוכנה דטרמיניסטית. התפקיד שלו: להאיץ פיתוח של תוכנה קיימת ולכתוב תוכנה שלא הייתה אפשרית בגלל תקציב.
- המודל הוא הספורטאי, ה-harness הוא מערכת האימונים. להשוות Claude Code מול Cursor זה לא להשוות מודלים — זה להשוות ג'מייקה מול ארה"ב. הציונים ב-LMArena הם יחסיים, לא מוחלטים. 87 נקודות Elo לא אומרות שמודל אחד 'חכם יותר' ב-87 נקודות.
- המדיאן: כשכולם שוכרים את אותו מודל ואותו harness, המוצר מתכנס לפתרון הזהה. הדובר בנה מחשבון ומצא מאות זהים — אף אחד לא העתיק. 'אותו cookie cutter, אותו בצק'. הבעיה אינה AI slop אלא convergence.
- Build-first reflex: כשבנייה הייתה יקרה, חיפשנו לפני שבנינו. היום קל יותר לפתוח סוכן קוד מאשר לחפש פתרון קיים. התוצאה: מערכת RAG ה-4,000. הסוכן בונה מה שביקשת, לא מה שצריך.
- תקציב חדשנות: לפני שמתחילים לבנות, למנות את הדבר האחד שהוא truly novel. אם אין — זה תרגיל למידה, לא מוצר. לסקור את החדשנות כמו שסוקרים הוצאות. המודל נותן את העיצוב הטוב האחרון בחינם; העבודה שלך מתחילה אחרי שהוא אומר 'done'.
- ארבעה כללים: (1) היה opinionated — דעה היא החדשנות הזולה ביותר שהמודל לא יכול לספק. (2) prompt-to-production הוא מסלול מדיאן — לגיטימי לצריכה פנימית. (3) כשהסוכן אומר 'done', העבודה האמיתית מתחילה. (4) מנהלים: שלוש שאלות — מי כבר עשה את זה? מה יש לנו שאין לאחרים? איפה המוצר יחיה (distribution)?
- דוגמה אישית: המחשבון שלו השתנה ממדיאן לכלי ייחודי שמחשב את העלות האמיתית של הרצת מודל פתוח בתוך הארגון מול API חיצוני — 10 שכבות בין open weights ל-token generation שאף אחד לא חישב.
למי זה מתאים: מנהלי מוצר, יזמים ומובילי הנדסה שבונים עם כלי AI ורוצים להבין למה המוצר שלהם זהה למתחרים ולמצוא דרך לבלוט.
Product StrategyAI DevelopmentNoveltyMedian ProblemLeadership
צפייה בהרצאה ביוטיוב ←Hiring Employable Agents + Startup Battlefield Finals — Howie Liu, HyperAgent
Howie Liu · Airtable / HyperAgent · 47:00 דקות
בקצרה: מנכ"ל Airtable מציג חזון מוצרי לסוכני AI: מ-completions דרך chatbots ל-'claws' (סוכנים always-on עם heartbeat) ועד תזמור בין סוכנים. לאחר מכן, תחרות Startup Battlefield עם שלושה פיטצ'ים: Kamad (סוכנים למסחר בסחורות), Foundry, ו-comment.io (מונטיזציה ליוצרי תוכן).
- ספקטרום פורמ-פקטור של AI: completions (השלמת טקסט) → chatbots (ChatGPT) → agents (מודל שרודף על עצמו עם כלים פתוחים) → 'claws' (סוכנים always-on עם heartbeat שמתעוררים לבד) → תזמור בין סוכנים (agent-to-agent). כל קפיצה מותאמת למודלים החכמים יותר.
- HyperAgent (מוצר בתוך Airtable) מיישם את הפילוסופיה ההוריזונטלית של Airtable לסוכנים. דוגמה: עסק גינון שמנהל end-to-end דרך סוכנים — מציאת לקוחות, הצעות מחיר, ניהול פרויקטים. המשתמשים הטיפוסיים אינם חברות טכנולוגיה אלא עסקים מסורתיים.
- החלק השני הוא Startup Battlefield: Kamad בונה שכבת ביצוע סוכנית למסחר בסחורות פיזיות ($17T בשנה). state machine קניינית (CFC) שמנהלת סוכנים מומחים לאימות, ביצוע וסליקה. לקוח ראשון מדובאי מזיז מאות מיליונים בשנה.
- comment.io: פלטפורמה שמנתחת קהל של יוצרי תוכן, מזהה pain points שהקהל מוכן לשלם עליהם, ובונה מוצרים שפותרים אותם. אפס יוצרים עזבו כי כולם רווחיים. זוכה בפרס הראשון.
- Foundry: runner-up. Kimode: second runner-up.
למי זה מתאים: מנהלי מוצר ויזמים שחושבים על פורמ-פקטור של מוצרי AI, ומי שמעוניין לראות פיטצ'ים של סטארטאפים צעירים בתחום הסוכנים.
Product StrategyAgentsAirtableStartup CompetitionHyperAgent
צפייה בהרצאה ביוטיוב ←Hill-Climbing Skills: Improve Agents Without Changing the Model — Shubhankar Srivastava, Browserbase
Shubhankar Srivastava · Browserbase · 51:00 דקות
בקצרה: לולאת 'auto browse' שמשפרת סוכני בראוזר בלי לגעת במודל: סוכן 'עושה' שגולש וסוכן 'מורה' שמנתח traces ומייצר skills לשימוש חוזר. הדמו: הזמנת טיסה ב-Google Flights ומסעדה ב-OpenTable. עלות ~$30-100 ללולאה, מומרת ל-skill שחוסך עבודה חוזרת.
- הבעיה: סוכני בראוזר נתקעים (dragging, anti-bot, CAPTCHA) וכל ריצה מתחילה מאפס. המודלים חכמים אבל לא לומדים מ-traces בפרודקשן. 'גאונים שאף פעם לא לומדים'.
- הפתרון — auto browse: שני סוכנים בלולאה. 'עושה' (doer) גולש עם CLI של Browserbase. 'מורה' (teacher) מנתח את ה-traces, מזהה מה השתבש, ומייצר skill — קובץ markdown עם הוראות ספציפיות לאתר (JavaScript tricks, אלמנטים, תהליכי עבודה).
- Skills נשמרים ומשמשים בריצות הבאות — הסוכן לא מתחיל מאפס. אפשר לשתף skills דרך browser.sh או להשתמש בהם ישירות ב-Claude Code / Codex עם /auto-browse.
- השראה מ-auto research של Karpathy: לולאה שמנסה שוב ושוב, מנתחת traces, ומשתפרת. מותאם לבעיות עם תוצאה verifiable וסביבה replayable.
- עלות: ~$30-100 ללולאה מורכבת. אפשר להשתמש ב-Sonnet (זול) עם יותר איטרציות במקום Opus (יקר) עם פחות — אותה תוצאה, פחות כסף. העלות מומרת ל-skill שחוסך עבודה עתידית.
- אבטחה: שלוש שכבות הגנה — query firewall בכניסה, skill review לפני פרסום, network/action restrictions ברמת התשתית. Browserbase safe mode שולט באילו URLs ופעולות מותרות.
- Cron jobs עם managed agents: הרצת skill מתוזמנת, ניטור הצלחה/כישלון, הפעלת healing loop אוטומטי כשאתר משתנה או anti-bot מתעדכן.
למי זה מתאים: מהנדסי AI שבונים סוכני בראוזר או אוטומציה web ורוצים לשפר reliability בלי fine-tuning. גם רלוונטי למי שמתעניין ב-self-improving agents.
Browser AgentsSelf-ImprovementSkillsReliabilityBrowserbaseAuto Research
צפייה בהרצאה ביוטיוב ←Parameter Golf with AutoResearch — Vayum Arora, Zhengyao Jiang, Dixing Xu & Dhruv, Weco AI
Vayum Arora, Zhengyao Jiang, Dixing Xu, Dhruv · Weco AI · 34:13 דקות
בקצרה: סדנה על Auto Research: הסוכן Aiden של Weco AI ניצח את תחרות Parameter Golf של OpenAI (אימון LLM מתחת ל-16MB תוך 10 דקות) עם 7 רשומות leaderboard, פי 2 מהאדם השני, ו-3.7x יותר חסכוני במחשוב. הסדנה מלמדת tree-based search, observability וsteerability ב-auto research loops.
- Auto research = לולאת try-and-error אוטונומית: נותנים לסוכן קוד + סקריפט eval, והוא מנסה רעיונות, שומר מה שמשפר, וזורק מה שלא. Karpathy הפיץ את הרעיון; השימושים התפשטו לאימון מודלים, הנדסת backend, אופטימיזציית inference.
- Parameter Golf: תחרות של OpenAI — אמן LLM הכי טוב תחת 16MB (משקלים + קוד) ו-10 דקות אימון. 1,036 משתתפים, 248 PRs, ~$250K compute. רק 47 PRs מוזגו.
- Aiden (סוכן של Weco): 7 רשומות leaderboard (פי 2 מהאדם השני), H-index הגבוה ביותר (435 PRs בנו על העבודה שלו), וכל זה ב-4% מהcompute הכולל — 3.7x יעילות עלות מהממוצע.
- שלושה עמודי תווך לauto research בפרודקשן: (1) tree-based search — כל ניסיון הוא צומת בעץ עם ציון, רעיונות מצטברים. (2) observability — אפשר לפתוח כל צומת ולראות diff מדויק וסיבת שינוי הציון. (3) steerability — הזרקת רעיונות אנושיים תוך כדי ריצה, חלוקת תקציב לענפים.
- דוגמה מהתחרות: הסוכן plateaued 5 ימים. אדם מהקהילה שלף tokenizer חדש. תוך 8 שעות הסוכן מזג אותו עם הרעיונות שלו והשיג את הקפיצה הגדולה ביותר — שיתוף פעולה אדם-סוכן.
- תחרות חיה בסדנה: Flappy Bird עם 4 עולמות (רגיל, פער נע, רוח, מעורב) על hidden validation set. הפרס: Nintendo Switch.
למי זה מתאים: מהנדסי ML/AI שרוצים להפעיל auto research loops על בעיות עם eval verifiable, ומי שמתעניין באופטימיזציה אוטונומית של מודלים.
Auto ResearchModel TrainingOptimizationTree SearchCompetitionWeco AI
צפייה בהרצאה ביוטיוב ←Burn Your Flags: Interactive CLIs for Agents — Mark Lummus & Navinkumar Patil, PayPal
Mark Lummus, Navinkumar Patil · PayPal · 53:43 דקות
בקצרה: סדנת PayPal על למה CLIs אינטראקטיביים נכשלים בשקט עם סוכנים (סוכן רואה redraw loop, לא שאלה) ואיך לתקן: tmux, IPC side channels, ו-context injection. הכלים הישנים חוזרים — אבל צריך לעצב אותם מחדש לקורא חדש: הסוכן.
- הבעיה: סוכנים shell out ל-Bash, אבל CLIs אינטראקטיביים עם arrow-key prompts נכשלים בשקט — הסוכן רואה redraw loop, לא שאלה. ה-harness מאבד UI state. אין שגיאה, אין התראה, פשוט כישלון שקט.
- למה לא סתם flags: flags טובים לתהליכים פשוטים וצפויים. אבל כשהתשובות תלויות ב-context, API responses, או אירועים בזמן אמת — flags מתפוצצים. סוכן יכול ללכת על decision tree; תסריט אוטומציה לא.
- שלוש גישות לתיקון, מהפשוט למתקדם: (1) tmux — screen scraping, מאפשר לסוכן לראות את הטרמינל. (2) IPC side channels — כמו REST API ל-CLI: קריאת state ושליחת input ב-JSON מובנה במקום terminal UI. (3) context injection — הזנת מידע מובנה (JSON) שהסוכן צריך, כולל מצבי edge כמו 'נגמר החלב שיבולת שועל, מה לעשות'.
- המסגרת: accessibility לסוכנים. כמו שיש accessibility לבני אדם עם מוגבלויות, צריך accessibility לסוכנים — אותה משמעת, קורא חדש.
- תרגיל הסדנה: תיקון Bris Barista 9000 (CLI להזמנת קפה) לעבודה עם סוכנים. המנצח (משתמש ללא רקע תכנותי שפשוט אמר לסוכן 'figure it out') זכה ב-Mac Mini.
- המסקנה המפתיעה מהמשתתפים: הרבה פשוט הפנו את הסוכן לבעיה ונתנו לו לפתור. ההמלצה: תנו context טוב, side channel, ו-tmux.
למי זה מתאים: מפתחי CLI וכלים לסוכנים, platform engineers, ומי שבונה infrastructure שסוכנים צריכים לצרוך.
CLIAgent ToolsAccessibilitytmuxIPCPayPal
צפייה בהרצאה ביוטיוב ←Build with Perception Agents — Emile Baizel & Shruti Arora, Amazon AGI Lab
Emile Baizel, Shruti Arora · Amazon AGI Lab · 55:43 דקות
בקצרה: סדנת Amazon AGI Lab: סוכני תפיסה (perception agents) שמבינים מסכים כמו בני אדם — לא רק לוחצים על אלמנטים אלא מבינים מה הם רואים. כולל Chrome extension לאנוטציה, agent bridge לסוכני קוד, ו-UI verification skill. בנוי על Amazon Nova Act.
- Amazon AGI Lab: צוות מחקר ומוצר שבונה סוכני knowledge work. שלושה עקרונות: שיתוף פעולה (סוכן כחבר צוות, לא קופסה שחורה), תפיסה (הבנת הסביבה החזותית), ואמינות (אימון בסביבות מדומות עם RL).
- Amazon Nova Act: שירות AWS לאוטומציה של בראוזר בשפה טבעית. מילוי טפסים, חיפוש וחילוץ, קניות, QA. כולל playground ללא קוד, MCP server, human-in-the-loop, ומודל computer use מותאם אישית.
- סוכני תפיסה: לא רק computer use (לחיצה על כפתורים) אלא הבנה של המסך כמו שאדם רואה אותו. הסוכן מבין layout, תוכן חזותי, וcontext — לא רק DOM elements.
- הסדנה: Chrome extension לאנוטציה של דפי web (מסמנים שינויים חזותיים), agent bridge שמעביר את האנוטציות לסוכן קוד (Claude Code, Kiro), ו-UI verification skill שמוודא שהשינויים באמת נראים נכון.
- תרגיל מעשי: שינוי עיצוב דרך אנוטציה חזותית → הסוכן מיישם → verification skill בודק. הרצה על אתר אמיתי עם דיווח מפורט של מה הסוכן ראה והחליט.
למי זה מתאים: מפתחים שרוצים לבנות סוכני UI שמבינים מסכים, ומי שמתעניין באוטומציה של workflows חזותיים בדפדפן.
Perception AgentsNova ActBrowser AutomationUI VerificationAmazonComputer Use
צפייה בהרצאה ביוטיוב ←AI Security Engineer Foundations + Certificate — Javier Garza, Snyk
Javier Garza · Snyk · 117:34 דקות
בקצרה: הכשרת אבטחה מלאה (6 מודולים): OWASP Top 10 ל-LLMs, shadow AI, AI threat modeling, אבטחת agent skills ו-MCP, secure coding עם AI, ו-red teaming. מועבר על ידי מומחה אבטחה מ-Snyk עם דמואים חיים.
- OWASP Top 10 ל-LLMs (2025): prompt injection (מקום 1), sensitive information disclosure, supply chain, data/model poisoning, improper output handling. דמו של Gandalf (gandalf.lakera.ai) — משחק שמלמד prompt injection בשכבות קושי עולות.
- Shadow AI: 80% מהארגונים ללא מדיניות sanctioned AI. 60-80% מהעובדים משתמשים בכלים לא מאושרים. עובדים שולחים נתונים למחשבים פרטיים דרך chat. הכלים בלתי נראים לסריקות אבטחה קיימות.
- AI BOM (Bill of Materials): מלאי של כל נכסי ה-AI בארגון — מודלים, datasets, agents, pipelines. שונה מ-SBOM כי הוא nondeterministic, משתנה עם retraining, וכולל סיכונים ייחודיים (poisoning, hallucinations).
- AI threat modeling: להשתלב מוקדם בתכנון. מודלי AI הם רכיבי אבטחה first-class. triggers אוטומטיים (webhooks) שמפעילים סריקה כשמשהו משתנה — למשל שינוי ב-Terraform file שהסוכן יצר.
- אבטחת MCP ו-agent skills: פרוטוקול MCP פותח שטח תקיפה חדש. כלים שמחוברים לסוכנים צריכים secret management, הרשאות מינימליות, ובקרה על מה שהסוכן רשאי לעשות.
- טיפ מעשי: verbose logging של כלי agentic לקובץ + כלי ניטור שמזהה התנהגות לא רצויה (למשל גישה לsecret storage). המשתמש לא תמיד רואה מה הסוכן עושה ברקע.
למי זה מתאים: מהנדסי אבטחה, מפתחים שבונים עם AI, ומי שאחראי על governance של כלי AI בארגון. גם מתאים למי שרוצה הסמכת AI Security Engineer.
SecurityOWASPPrompt InjectionShadow AIAI BOMThreat ModelingMCP Security
צפייה בהרצאה ביוטיוב ←SonarQube + OpenAI: Agentic Development — Killian Carlsen-Phelan, Sonar
Killian Carlsen-Phelan · Sonar · 41:58 דקות
בקצרה: סדנת Sonar + OpenAI: שלוש עובדות על סוכני קוד — 'done' = משימה + ראיות, containment ≠ correctness, וחוזה feedback בתוך הלולאה. לאחר מכן דמו מעשי: SonarQube plugin ל-Codex עם secrets detection, find-and-fix, ו-agentic analysis שמוודא קוד אחרי כל עריכה.
- שלושה עקרונות לסוכני קוד אמינים: (1) 'Done' = משימה הושלמה עם ראיות (diff, test results, analysis) — לא רק 'fixed'. (2) Containment (sandbox) לא מוכיח נכונות — צריך שכבות הגנה מרובות. (3) חוזה feedback (skills, hooks, MCP) שייך בתוך הלולאה, לא מחוצה לה.
- כשלים נפוצים בסוכני קוד: context חלקי, תיקון מקומי שמפר invariant גלובלי, ו-benchmarks שהסוכן עצמו יצר (self-fulfilling). הביקורת העצמית של הסוכן אינה oracle — הסוכן והverifier מדידים דברים שונים.
- הדמו: SonarQube plugin ל-Codex. התקנה דרך marketplace, authentication, ואינטגרציה מלאה. שלושה כלים: secrets detection hook (חוסם API keys לפני שהם מגיעים לקובץ), list issues (צפייה בבעיות מהטרמינל), find-and-fix (תיקון אוטומטי עם אימות).
- Agentic analysis: hook שרץ אחרי כל עריכה של הסוכן ומנתח את הקוד שנכתב ב-server. אם יש בעיה — הסוכן ממשיך לתקן עד שעובר. Context augmentation: מזין rules וarchitecture לסוכן לפני שהוא כותב קוד.
- דוגמה חיה: זיהוי SQL injection (taint analysis מ-source ל-sink), חסימת OpenAI API key בקוד, ותיקון אוטומטי עם אימות שהבעיה נפתרה.
למי זה מתאים: מפתחים שמשתמשים ב-Codex או כלי קוד AI ורוצים שכבת אבטחה ובקרת איכות אוטומטית. גם רלוונטי לצוותי DevSecOps.
SonarQubeCode QualitySecurityOpenAI CodexCI/CDSecrets Detection
צפייה בהרצאה ביוטיוב ←Let Your Agent Cook: Using Skills to Evaluate and Improve Your App — Ankur Duggal, Arize
Ankur Duggal · Arize · 36:04 דקות
בקצרה: סדנת Arize: איך להפוך מ-'shipping by vibes' ללולאת שיפור מבוססת traces וevals. הדמו: Claude Code מנתח traces מפרודקשן, מזהה דפוסי כשל (44% סיכומים גרועים, תשובות מומצאות), בונה evals, ומריץ experiments לאימות תיקונים.
- הבעיה: רוב הצוותים שולחים סוכנים 'by vibes' — בודקים ידנית, מקווים שזה עובד. בלי evals, לא יודעים מה שבור בפרודקשן. אבל evals קשים לבנייה כי סוכנים לא דטרמיניסטיים.
- Traces קודם: בלי traces לא רואים מה הסוכן עושה. agent.run + query = קופסה שחורה. Traces חושפים: אילו כלים נקראו, איזה LLM calls, אילו מסמכים נשלפו. דוגמה: סוכן החזיר 'order status' כשהלקוח שאל על 'refund' — כלי שגוי.
- הלולאה: traces → זיהוי דפוסי כשל → בניית evals → תיקון → הרצת experiments → אימות. הדמו: Claude Code קורא traces מ-Arize, מזהה 44% סיכומים גרועים + תשובות מומצאות + כלים כפולים, ובונה evals ספציפיים.
- איטרציות על בעיה אמיתית: שאילתות על מניות קוריאניות נכשלו. הסוכן בנה dataset, ניסה תיקון ראשון (נכשל — הכלי עצמו היה מיושן), תיקון שני (90% הצלחה). כל שלב מתועד עם experiment comparison.
- 'Out of the box eval = out of the box results.' evals גנריים (bad summary, tool call correctness) נותנים baseline, אבל הבעיות הספציפיות של הסוכן שלך נמצאות רק ב-traces שלך. אין benchmark אוניברסלי — תלוי במקרה השימוש.
למי זה מתאים: מהנדסי AI שבונים סוכנים בפרודקשן ורוצים להפסיק לשלוח by vibes ולהתחיל לולאת שיפור מבוססת נתונים.
EvalsTracesObservabilityArizeAgent ImprovementProduction Monitoring
צפייה בהרצאה ביוטיוב ←Continuously Improving Agents with Langfuse — Annabell Schäfer & Lotte Verheyden, ClickHouse
Annabell Schäfer & Lotte Verheyden · ClickHouse (Langfuse) · 44:23 דקות
בקצרה: סדנת Langfuse: לולאת ה-AI Engineering לשיפור מתמשך של סוכנים. החלק האונלייני — tracing ומוניטורינג בפרודקשן עם evaluators אוטומטיים (LLM-as-judge וקוד) שרצים על traces חיות, ומשם בניית datasets לניסויים אופלייני ושילוב ב-CI/CD.
- הבעיה: סוכנים לא דטרמיניסטיים — המערכת יכולה להיראות בריאה (סטטוס ירוק) בזמן שהתשובות או הפעולות של הסוכן שגויות או לא איכותיות. זה מה ש-AI engineering בא לפתור, בניגוד להנדסה מסורתית.
- לולאת ה-AI Engineering בחמישה שלבים, מחולקת לשני חלקים: אונליין (tracing + monitoring) ואופליין (datasets, experiments, evaluations). Langfuse עצמה open source, model-agnostic ו-framework-agnostic.
- דמו חי: הגדרת evaluator מבוסס קוד (Python או TypeScript) שרץ על observations חיות בפרודקשן — לדוגמה זיהוי 'all caps' בהודעת משתמש כסיגנל לתסכול. ה-evaluator מכוון ל-JSON path ספציפי בהודעה, מחזיר ציון בוליאני, ואפשר לעשות test run לפני execute.
- חוץ מ-evaluators אוטומטיים: dashboards ו-human feedback. אפשר לתפוס מילות גידוף, שמות מותג שנכתבים לא נכון, אי-הסכמות של משתמשים — ולהפוך את המקרים המעניינים לדוגמאות ב-dataset.
- המסר המרכזי: זה לא one-off. צריך לתחזק datasets לאורך זמן מדוגמאות פרודקשן, להריץ experiments על השינויים, לשלב ב-CI/CD ולשלוח בביטחון בלי רגרסיות. הסדנה המלאה (8 צעדים) זמינה בחינם ב-langfuse.com/workshop, כולל skill לסוכן קוד שמקים את ה-tracing.
למי זה מתאים: מהנדסי AI שמריצים סוכנים בפרודקשן ורוצים מעקב, evaluators אוטומטיים ותהליך שיפור מתמשך במקום בדיקות ידניות.
ObservabilityTracingEvalsLangfuseProduction MonitoringAI Engineering Loop
צפייה בהרצאה ביוטיוב ←Build a Platform and Watch It Burn — Michael Forrester, Accenture & Whitney Lee, Datadog
Michael Forrester & Whitney Lee · Accenture & Datadog · 52:35 דקות
בקצרה: סדנת תקיפה חיה: בונים IDP עם 34 רכיבים (כולל guardrails), משחררים עליו 'burrito bot' בלי מעצורים, ונותנים למשתתפים לפרוץ אותו סבב אחר סבב — ואז מקשיחים את המערכת. מסכמים עם רובריקה של שלוש שאלות: מתי בכלל לשים AI ב-workflow.
- נקודת הפתיחה: המם של Chipotle — מודל 'מועיל' פתר למשתמש בעיית linked list רק כדי שיוכל להזמין בוריטו. סוכן שלא נעול כמו שצריך גורם נזק תדמיתי, פיננסי ונזק לדאטה — גם בלי הפסקת שירות.
- המערכת: פלטפורמת IDP אמיתית עם 34 רכיבים משולבים (Kubernetes, Datadog, AI guardrails), ועליה burrito bot — סוכן צ'אט בלי שום guardrails שהמשתתפים מוזמנים 'לפרוץ' דרך שאלות על הכלים שלו, הזמנות וניסיונות injection.
- מבנה הסדנה בסבבים: מתחילים ממערכת פתוחה לחלוטין, ומתקדמים לסבב מוקשח שבו guardrails של תשתית פעילים אבל guardrails של AI צריך להפעיל ידנית לפי הוראות בטרמינל — למשל output sanitization. כל משתתף מקבל אשכול משלו דרך provisioning.
- אזהרה כפולה מהמנחים: דמו חי עם LLM כמעט תמיד מפתיע — גם את המנחים עצמם. וה-requirements הלא-פונקציונליים מעולם ה-CI/CD וה-SDLC (observability, hardening, filtering) תקפים במלואם גם כאן.
- הרובריקה המסכמת — שלוש שאלות לפני שמכניסים AI ל-workflow: (1) האם זו מערכת חסומה עם גבולות וממשקים ידועים (עדיף API)? (2) האם זה משתלם? (ציטוט: ה-CFO של Nvidia אמר שכ-70% מהעבודות ש-AI עושה היום אפשר לעשות עם בני אדם בזול ובאמינות גבוהה יותר). (3) האם יש פלט שניתן לאימות, כמו Terraform או Python? אם אתה צריך 'לפרק איך ה-LLM חושב' כדי לדעת שזה נכון — זה סימן רע.
למי זה מתאים: מהנדסי פלטפורמה ו-AI ששוקלים לשלב סוכנים בתשתית ארגונית ורוצים להבין איפה סוכנים נשברים ואיך מגנים עליהם.
SecurityGuardrailsPlatform EngineeringIDPKubernetesRed Teaming
צפייה בהרצאה ביוטיוב ←From Zero to Leaderboard: Agent Evaluation — Wolfram Ravenwolf, Weights & Biases
Wolfram Ravenwolf · Weights & Biases (CoreWeave) · 52:30 דקות
בקצרה: סדנת W&B: איך לבנות evaluation אמין לסוכנים ומודלים מאפס ועד leaderboard. המסר המרכזי — תוצאת benchmark תלויה בשש שכבות של בחירות (benchmark, harness, sandbox, סוכן, מודל, הגדרות inference), וכל בחירה לא מתועדת הופכת את הציון לחסר משמעות.
- למה אי אפשר לסמוך על ציון בודד: גם עם temperature 0 התוצאות לא דטרמיניסטיות — שגיאות עיגול floating point, אופטימיזציות ביצועים ועוד. וגם seed קבוע (42...) לא הוגן: למודלים מסוימים 'מזל' עם seed מסוים יותר מאחרים.
- שש שכבות שחייבים לנעול ולתעד לפני פרסום תוצאות: איזה benchmark (בדמו: Terminal Bench), איזה harness ובאיזו גרסה (Harbor), אילו sandboxes, איזה סוכן (Terminus 2), איזה מודל (GLM 5.2) ואילו הגדרות. בלי זה, אחרים לא יודעים מה בעצם נמדד.
- מלכודת OpenRouter: כברירת מחדל כל קריאה יכולה ללכת ל-provider אחר — בריצה של 89 משימות חצי ירוצו על תשתית אחת וחצי על אחרת. חובה לנעול provider אחד כשמשווים מודלים.
- אחרי כל ריצה: לעבור ידנית על השגיאות. תווים חוזרים או דליפת טוקנים של prompt template לתשובה = בעיית tokenizer או inference server, לא בעיית מודל. בלי retry policy, שגיאת תשתית אחת הורסת ציון. מודלים חדשים משתפרים תוך שבוע כי מנוע ה-inference מתעדכן — אותה בדיקה נותנת ציון אחר.
- המלצה מעשית: לבנות קונפיגורציית benchmark ניתנת לשחזור משלך, לפרסם אותה עם התוצאות, ולשתף פעולה. W&B נותן חשבון חינם עם קרדיטים ל-inference וגישה ל-sandbox כדי להתחיל.
למי זה מתאים: מהנדסי AI שמעריכים סוכנים או מודלים ורוצים שה-benchmarks שלהם יהיו ניתנים לשחזור ולהשוואה הוגנת, לא סתם מספר לפרסום.
EvalsBenchmarksReproducibilityW&BAgent EvaluationInference
צפייה בהרצאה ביוטיוב ←Teaching Agents to Search with NVIDIA Data Designer — Dhruv Nathawani, NVIDIA
Dhruv Nathawani · NVIDIA · 55:30 דקות
בקצרה: סדנת NVIDIA: להפוך התנהגות סוכן רצויה לבעיית דאטה. NeMo Data Designer (open source) בונה pipelines של דאטה סינתטי; מקרה הבוחן — ללמד מודל חיפוש agentic: מייצרים 'חידות חיפוש' מ-grounding ב-Wikidata, מייצרים מסלולי חיפוש עם Tavily, מעריכים, מאמנים ובודקים על benchmark.
- הפריימוורק: לוקחים התנהגות סוכן שרוצים (כאן: חיפוש) ומהנדסים דאטה לשם כך — pipeline שלם: seed entities מ-Wikidata (כל ריצה נותנת 'hops' שונים, grounding מגוון), יצירת שאלות קשות שהתשובה להן לא זמינה ישירות באינטרנט, מסלולי חיפוש, הערכת הדאטה, אימון מודל ומדידה על benchmark סטנדרטי.
- הכלים שצריך: מכונה עם GPU, מפתח Tavily (1000 קרדיטים חינם), Data Designer (open source מלא) והנוטבוקים מה-GitHub repo שהוצג בסדנה. כל הכלים של הצוות ב-NVIDIA — כולל NeMo — פתוחים לגמרי.
- פרטי האימplementation: ה-system prompt מגדיר 'expert search agent' שמחזיר JSON עם תשובה סופית, URLs תומכים והצדקה קצרה, עם הנחיות שימוש בכלי — למשל הגבלה על מספר קריאות החיפוש כדי שהסוכן לא ישרוף תקציב על שאלה פשוטה.
- למה שאלות קשות: אם התשובה נמצאת בבלוק טקסט אחד שכבר באינטרנט, החיפוש טריוויאלי. מעצבים את החידות כך שדורשות חיפוש אמיתי רב-שלבי — בדיוק ההתנהגות שרוצים ללמד.
- כלים נוספים שהוצגו: NeMo Anonymizer לאנונימיזציה של לוגים ודאטה רגיש (כולל מפתחות API שהוזנו בטעות לסוכנים) לפני שימוש, NeMo Safe Synthesizer לדאטה סינתטי בטוח, ו-datasets של personas שנבנו ממפקדי אוכלוסין (PGM על דאטה דמוגרפי) להתאמה למדינות שונות.
למי זה מתאים: מהנדסי AI שרוצים לאמן מודלים/סוכנים להתנהגויות ספציפיות (חיפוש, text-to-SQL וכו') וצריכים pipeline לדאטה סינתטי איכותי.
Synthetic DataNVIDIA NeMoData DesignerAgent TrainingSearch AgentsOpen Source
צפייה בהרצאה ביוטיוב ←Rebuilding CI for AI-Scale Commit Volume - Gautam Korlam, SonarSource
Gautam Korlam · SonarSource · 19:19 דקות
בקצרה: כש-AI מייצר יותר קוד, CI וסקירת קוד הופכים לצוואר בקבוק. ההרצאה מציעה בדיקות שילובי שינויים, קיצור build, סקירה לפי סיכון ורשומת ביקורת שמחברת בדיקות ואישור ל-commit המדויק. היא כוללת קידום של כלי הספק.
- PR שעובר בדיקות לבדו עדיין יכול לשבור את main בשילוב עם שינוי אחר. הדובר מתאר תור מיזוג שפיתח ב-Uber: בדיקת שילובים צפויים במקביל, הוצאת שינוי בעייתי מהתור, ומיזוג רק של שילוב שנבדק. הבעיה היום היא גם קצב יצירת שינויים: תורים שתוכננו לבני אדם לא בהכרח עומדים בקצב סוכנים.
- קיצור CI: caching של תוצרי build, פחות ביטול cache בגלל שינויים בקומפילציה, sharding והרצות במקביל. הדובר מספר על ירידה מכעשר דקות לפחות מדקה בבדיקות אינקרמנטליות אחרי חימום. זו תוצאה מצוותו, לא הבטחה לכל מאגר. העברת בדיקות אחרי מיזוג מוזכרת כאפשרות, אבל צריך להחליט מה מסוכן מדי לדחות.
- צוואר בקבוק נוסף הוא תיקון וסקירה: כשל CI דורש קריאת logs, תיקון, commit והרצה נוספת, ואז הערות סקירה יכולות להתחיל את המחזור מחדש. הוא מציע בדיקות מוקדמות יותר וסקירת AI ראשונית כדי שבני אדם יתרכזו בשינויים רגישים. לפי נתוני הספק, ל-13% מה-PRs היה כשל CI מתועד; בסיס המדידה לא פורט.
- דוגמת בדיקות DB במקביל: שימוש בבסיס משותף בלי הגנות מספיקות יצר סכנת זליגה בין בדיקות. הדובר אומר שהכלי של החברה זיהה את הבעיה והציע תיקון לפני מיזוג. זו הדגמת ספק, לא בדיקה עצמאית של איכות הכלי.
- אישור לפי סיכון: תיעוד או שינויים פנימיים פשוטים יכולים לעבור מדיניות אישור אחרת משינויים בתשלומים או בהזדהות. חשוב להפריד בין כותב השינוי למאשר, ולציין מתי נדרש אישור אנושי. בדיקות ירוקות לבדן לא מוכיחות עמידה בדרישות העסק או הרגולציה.
- רשומת ביקורת נשמרת גם כשהלוגים הזמניים נמחקים: מי יצר את ה-PR, מי הפעיל את הסוכן, ה-session המקורי, ה-commit המדויק שנבדק, דוח הבדיקות, איך נסגר כל finding, מי אישר ומה הוחרג ולמה. צריך לוודא שהקוד שמוזג הוא הקוד שבאמת נבדק, ולא שינוי מאוחר יותר.
למי זה מתאים: מובילי תשתיות פיתוח וצוותים עם הרבה PRs, במיוחד במערכות רגישות שבהן צריך להסביר מי בדק ואישר.
CIתורי מיזוגסקירת קודביקורת
צפייה בהרצאה ביוטיוב ←The Cost of Accessibility in AI - Jemima Abu, CAIS
Jemima Abu · CAIS · 10:02 דקות
בקצרה: נגישות היא דרישה למוצר שאנשים יכולים להשתמש בו, גם כשהקוד נכתב ב-AI. Jemima Abu מראה איך סקיל מתאים ורכיבים סמנטיים יכולים לצמצם בנייה מיותרת ותיקונים, בלי לטעון שניסוי קטן מוכיח חיסכון קבוע.
- ניסוי מקומי: אותו prompt ליישום עיצוב Figma, פעם בלי סקיל נגישות ופעם איתו. הדוברת מדווחת על 58% פחות עלות ועל כשליש מהזמן עם הסקיל, ומדגישה שזה ניסוי יחיד ללא סביבה מבוקרת, ולכן אי אפשר להסיק ממנו שנגישות תמיד זולה יותר.
- קוד קיים הוא דוגמה שהסוכן מעתיק. אם הוא מלא בעיות נגישות, הסוכן עלול לשמר אותן. בנוסף, בלי הנחיות הוא יכול להמציא רכיבים ב-JavaScript במקום להשתמש בהתנהגות HTML קיימת, ולהוסיף יותר קוד ובדיקות.
- נגישות צריכה להיכנס בתכנון, בעיצוב וב-QA, לא רק בסוף באמצעות ARIA labels. תיקון מאוחר עשוי לדרוש שינוי מבנה וקוד. הטענה שאין משתמשים בטכנולוגיות מסייעות עלולה לנבוע מכך שהם כבר לא מצליחים להשתמש במוצר.
- הצעדים שהדוברת מציעה: הגדרת דרישות לפי הפלטפורמה, בדיקת קוד קיים ותיקון בעיות, רכיבים חוזרים או design system, וסקיל נגישות חובה כשמייצרים UI. היא מזכירה Modern Web Guidance של Chrome כמקור להעדפת יכולות HTML ו-CSS על פני מימוש מותאם.
- כללי מינימום לסקיל: HTML סמנטי לפני ARIA, תפעול מקלדת לכל פעולה שאפשר לבצע בעכבר, תוויות ברורות לקוראי מסך ובדיקה של הפלט מול הכללים. אלה נקודת התחלה בלבד. הדוברת אומרת במפורש שעדיין חייבים בדיקות ידניות ושכלי אחד לא מבטיח אתר נגיש.
למי זה מתאים: מפתחי UI, מעצבים ואנשי QA שעובדים עם סוכני קוד ורוצים לשלב נגישות מההתחלה.
נגישותHTML סמנטיסקיליםבדיקות UI
צפייה בהרצאה ביוטיוב ←How to Actually Tokenmaxx and Save Millions - Alvin Pane, OutRival
Alvin Pane · OutRival · 11:12 דקות
בקצרה: מדד ההצלחה אינו כמה טוקנים צורכים אלא כמה עבודה טובה מקבלים תמורתם. הדובר מציע למדוד שונות של המערכת הקיימת, לצמצם פרומפטים בעזרת חיפוש, לנסות מודל קטן ואז לבדוק איכות בהשוואה מזווגת ובקטגוריות רגישות.
- מתחילים בתצפיתיות: כל ניסיון קריאה נרשם כחלק ממשימה, עם גרסת פרומפט, הגדרות מודל, טוקנים, זמן, עלות, כלים וניסיונות חוזרים. כך מוצאים את העבודה היקרה ולא רק את הקריאה הבודדת.
- Ceiling test: מריצים את מערכת הפרודקשן כמה פעמים על אותם קלטים כדי למדוד כמה היא חולקת על עצמה. הדובר אומר שמועמד זול חלק על הבסיס בכ-18%, אבל הבסיס עצמו חלק על עצמו בכ-7%. אי-הסכמה עם תוצאה היסטורית אינה בהכרח טעות, וגם הבסיס אינו אמת מוחלטת.
- סדר הפעולות: prefix caching, צמצום הפרומפט ואז התאמת גודל המודל. מגדירים חוזה קלט ופלט ופונקציית ניקוד, ונותנים לאופטימייזר לחפש הוראות קצרות יותר. אפשר גם להעביר routing או חילוץ נתונים למודל זול ולהשאיר נימוק מורכב למודל גדול. הדובר מזכיר DSPy ו-GEPA בתעתיק משובש.
- חיסכון בטוקנים עוד לא מתיר פריסה: מודלים קטנים יכולים להוסיף כשלים והתאמת-יתר. ב-shadow deployment משווים בסיס מול בסיס, מועמד מול מועמד ומועמד מול בסיס על אותם קלטים. ההשוואות הפנימיות עוזרות להפריד שינוי התנהגות מרעש של הרצות חוזרות.
- בודקים ידנית מדגם של הבדלים: האם המועמד טוב יותר, הבסיס טוב יותר, או שתי תשובות קבילות לקלט עמום. בדוגמת HarborBite הדובר נותן 443 נסיגות ו-2,463 שיפורים, אבל זו דוגמה סינתטית ולא תוצאה שאפשר לייחס לחברת לקוח.
- כלל פריסה מוצע: השוואה מזווגת, קיבוץ הרצות חוזרות של אותה שיחה, ורווח סמך לשיפור נטו. אם הגבול התחתון אינו מעל אפס, אין מספיק ראיות לטענת שיפור. בודקים גם קטגוריות קריטיות בנפרד, כי ממוצע טוב יכול להסתיר כשל חשוב. אחרי פריסה ממשיכים למדוד.
למי זה מתאים: מהנדסי AI שבוחנים צמצום פרומפטים או החלפת מודל בלי לאבד איכות במשימות פרודקשן.
עלות טוקניםDSPyGEPAevalsשונות
צפייה בהרצאה ביוטיוב ←Your Fridge Is a Valid Payment Device - Eleonora Drykina & Nina Žižakić, In The Pocket
Eleonora Drykina & Nina Žižakić · In The Pocket · 25:02 דקות
בקצרה: מקרה RAG במערכת תשלומים בלגית: לשמור את מבנה ספרי הכללים והטבלאות, לשלב חיפוש סמנטי ומדויק, ולאפשר לסוכן להרחיב מפסקה לסעיף או למסמך. התשובה צריכה מקור מדויק וגבול ברור בין ידע כללי לכללים שהמסמכים באמת קובעים.
- היקף לפי הדוברות: כ-270 PDFs, כ-6,000 עמודים וכ-3,000 טבלאות, עם הפניות רבות בין מסמכים. נדרשים מקורות ברמת סעיף ועמוד. ידע כללי על מהו בנק קביל, אבל אין להשלים עמלות או כללי תשלום ממערכות אחרות. הכותרת על מקרר היא פרט מתוך ספר הכללים, לא מדריך לתשלום במקרר.
- פירוק ושחזור: מחלצים פסקאות, מצרפים עד כ-2,000 תווים ולא חוצים טבלה. נתיב סעיף ואינדקס chunk מאפשרים להרכיב מחדש סעיף מסודר. metadata כולל מסמך, עמוד, סעיף, סיכום מסמך ותגים עסקיים. אין חפיפה בין chunks במימוש המתואר.
- טבלאות צריכות טיפול נפרד: חילוץ טקסט שטוח עלול לאבד תאים מאוחדים ואת הקשר שורה-עמודה. הן ממירות ל-CSV וחוזרות על ערכי תאים שנפרשים על כמה שורות, כדי שהסוכן יוכל לשייך את העמלה לתנאי הנכון.
- חיפוש היברידי: dense לשפה ולמשמעות, BM25 למזהים וקודים. 50 תוצאות מכל מסלול מאוחדות עם RRF ל-30, ולאחר דירוג נוסף נשלחות 10. בהערכת retrieval על 63 שאלות הן מדווחות על שיפור hit rate מ-92% ל-97%. זו מדידה קטנה של איתור מקור, לא של נכונות תשובה מלאה.
- ארבע רמות כלי: חיפוש, סעיף מלא, מסמך מלא קטן ורשימת ספרים. מסמך גדול מכ-100 אלף טוקנים מחזיר רשימת סעיפים במקום תוכן מלא; שם סעיף שלא נמצא מחזיר חלופות. לפני קריאה שישית הסוכן מתבקש לבדוק אם הוא מביא מידע חדש או חוזר על חיפוש שלא הצליח.
- UX וזמן: מדווחות על חציון 38 שניות לתשובה. תשובה כולה באובייקט מובנה יצרה מסך ריק עד סוף ההפקה. לכן עברו ל-Markdown מוזרם בזמן אמת, והוסיפו כרטיסי מקור מובנים אחרי התשובה. לוגים פשוטים ב-Azure Table Storage מכילים שאלות, כלים, תשובות ואירועי שימוש; השיחה מוגבלת ל-20 הודעות הקשר.
- הערכה: כ-86 בדיקות מקצה לקצה ב-Promptfoo, rubric למדרג LLM ובדיקת מסמך מקור. שאלות מגיעות גם משתי סדרות בדיקות משתמשים. חמש מתוך 12 תוצאות שהשתנו לא חזרו בהרצה נוספת; במקרה אחר תאריך שנחשב הזיה היה כתוב במקור. צריך לבדוק גם רעש של שופט וגם תוויות benchmark שגויות.
- שימוש ראשוני לפי הצוות: כ-900 שאלות, מעל 100 שיחות וכ-34 משתמשים פנימיים. הם מנסים להסיק שביעות רצון מתודות, החלפת נושא או שאלה חוזרת כאשר משוב מפורש דל. זה proxy לא ודאי, לא ראיה שהמשתמש אישר דיוק. התוכנית לפתיחה ללקוחות חיצוניים היא תוכנית של הצוות בזמן ההרצאה.
למי זה מתאים: מפתחי RAG על מסמכי מדיניות, טבלאות וכללים פיננסיים שרוצים מקורות מדויקים ויכולת הרחבת הקשר.
RAGטבלאותחיפוש היברידימקורותPromptfoo
צפייה בהרצאה ביוטיוב ←