מיטאפ LangTalks: Autonomous AI SDLC

ב־5 באוגוסט נקיים את מיטאפ LangTalks הבא בנושא Autonomous AI SDLC ב־AWS Experience, קומה 28 בתל אביב. זה יהיה ערב פרקטי על מה שסוכנים אוטונומיים כבר מסוגלים לבצע לאורך מחזור חיי הפיתוח, מכתיבת קוד ובדיקות ועד deployment ופעילות בפרודקשן.

בתוכנית: רועי אושרוב יציג Rapid Agentic Prototyping על AWS עם OpenClaw ו-LowKey, גל פרץ ולי טויטו יעבירו דמו חי של Event-Driven SDLC, אביעד ברמן מ-Melio ידבר על Multiplayer Software Engineering, ורז ברמן גולד מ-Overcut תשתתף בשיחה על בניית הפלטפורמות שמאפשרת לחברות את המעבר לAI SDLC.

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

מ-Agent Graphs ל-Harnesses, מודלים שעושים Overengineering, אבטחת Coding Agents, ועוד

🗓️ 17.07.26–31.07.26 | הסיכום הדו-שבועי של הדיונים בקבוצות הוואטסאפ שלנו

פרק חדש של LangTalks: ארכיטקטורות Claw

בפרק החדש ירדנו לעומק הארכיטקטורה של OpenClaw, NanoClaw ו-Hermes יחד עם גבריאל כהן, היוצר של NanoClaw.

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

להאזנה ולפוסט המלא

האם הגיע הזמן לעבור מ-LangGraph ל-Agent Harness?

1. המעבר מ-workflow ל-harness: חברים בקהילה שיתפו שבעבר השתמשו ב-LangGraph כדי לקבל גמישות ושליטה על workflows מורכבים, אבל בכלים פנימיים כמו support agents ו-RCA agents הם עוברים לפתרונות כמו Claude Agent SDK ו-Pi.

2. לא כל מערכת צריכה graph: כשיש תהליך עסקי מוגדר, state ברור והרבה שלבים דטרמיניסטיים, graph עדיין יכול להיות abstraction מצוין. כשבונים סוכן כללי שצריך לחקור, להשתמש בקבצים ובכלים ולהמשיך עד להשלמת המשימה, harness מוכן עשוי לחסוך הרבה עבודה.

3. המשיכה לפתרונות פתוחים: חלק מהעניין סביב Pi ו-Oh My Pi מגיע מהיכולת להבין מה קורה מתחת למכסה המנוע, לשנות את ה-harness ולהוסיף extensions. לעומת זאת, משתמשים ב-Claude Code סיפרו שקשה להתמודד עם שינויים, regressions ובאגים בכלי סגור.

4. DeepAgents ו-Graph Engineering: לפי שיתוף בקהילה, LangChain משקיעה יותר ויותר ב-DeepAgents בתור ה-harness שלה. במקביל, המונח Graph Engineering חזר לכותרות, כך שעדיין מוקדם להספיד את LangGraph. שותף גם המאמר From Loops to Graphs.

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

📅 הדיון המלא התחיל בתאריך: LangTalks Community 4 | 23:19 | 23.07.26
💬 15 הודעות | 👥 7 משתתפים

כשהמודל החזק ביותר כותב יותר מדי קוד

1. הבעיה שעלתה מהשטח: מספר משתמשים ב-GPT-5.6 Sol דיווחו על נטייה ל-overengineering. משימות קטנות התרחבו להרבה קבצים, validations, abstractions, parsers ו-subagents שלא היו חלק מה-scope המקורי.

2. יותר scaffolding לא תמיד עוזר: frameworks מחשבתיים ו-plugins שמכריחים את המודל לתכנן, לבדוק ולבצע review יכולים לשפר מודלים מסוימים, אבל במודל שכבר נוטה ל-overthinking הם עלולים להחמיר את הבעיה.

3. להתחיל מהמודל הנקי: אחת ההמלצות הייתה לבדוק קודם את המודל עם ה-system prompt הבסיסי של ה-harness, ורק אחר כך להוסיף rules, skills ו-workflows. הנחיות שעבדו היטב עם Sonnet או עם דור קודם של GPT לא בהכרח מתאימות למודל חדש.

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

5. ה-benchmark שחסר לנו: מעבר לשאלה אם הקוד עובר tests, צריך למדוד גם כמה קוד נוצר, כמה ממנו לא היה נדרש, האם נשמרה הארכיטקטורה, כמה tokens נצרכו ועד כמה ה-PR פשוט לתחזוקה. אחד המשתתפים השווה את אותה משימה ב-worktrees נפרדים כדי לבחון את ההבדלים בפועל.

המסקנה לא הייתה שמודל מסוים “טוב” או “רע”, אלא שחייבים להתאים את המודל, ה-harness וה-scaffolding לסוג המשימה.

📅 הדיון המלא התחיל בתאריך: LangTalks Community 4 | 16:26 | 20.07.26
💬 38 הודעות | 👥 8 משתתפים

מה צריך להיות Tool, ומה להשאיר ל-LLM?

1. מקרה המבחן: סוכן השתמש ב-tool שמחזיר מידע מ-API עם pagination. היה ידוע מראש שהוא תמיד יצטרך למשוך את כל העמודים ולאחר מכן לבצע aggregation, אבל שתי הפעולות נשארו באחריות המודל.

2. פעולה קבועה צריכה לעבור לקוד: אם תמיד צריך למשוך את כל העמודים, אין סיבה שה-agent יחליט בכל פעם אם לבצע עוד קריאה. עדיף שה-tool עצמו יטפל ב-pagination ויחזיר תוצאה מלאה.

3. לעשות aggregation קרוב לדאטה: אם ה-aggregation הוא דטרמיניסטי, כדאי לבצע אותו בתוך ה-tool. זה מפחית tokens, מקצר latency ומונע מהמודל לטעות בחיבור התוצאות.

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

5. כלל אצבע: החלטות קבועות, קריטיות או דטרמיניסטיות שייכות ל-code או ל-tool. החלטות שדורשות הבנה סמנטית, שיקול דעת או התאמה לבקשת המשתמש יכולות להישאר אצל ה-LLM.

במקרה הזה הומלץ לבנות MCP tool שמרכז את כל הפעולה, מהלך שגם יחסוך טעויות וגם יהיה יעיל יותר מבחינת זמן וטוקנים.

📅 הדיון המלא התחיל בתאריך: LangTalks Community 2 | 16:26 | 27.07.26
💬 6 הודעות | 👥 3 משתתפים

שתי תזכורות אבטחה לבוני Coding Agents

1. שבוע של Sandbox Escapes: חבר בקהילה שיתף סדרת מחקרים של Pillar Security על שבע חולשות שנמצאו ב-Agentic IDEs וב-Coding Agents, בין היתר ב-Cursor, ב-Antigravity וב-Codex CLI.

2. Sandbox הוא מימוש, לא הבטחה: המאמר הראשון בסדרה מתאר יציאה ממנגנון ה-Seatbelt של Antigravity. הלקח המעשי הוא שלא מספיק לראות את המילה sandbox בתיעוד. צריך להבין את מדיניות ה-allow וה-deny, את ההרשאות בפועל ואת הגישה לקבצים, לרשת ול-credentials.

3. Artifacts ציבוריים עלולים להיות ציבוריים באמת: בקבוצה שותפה אזהרה שלפיה Claude Artifacts שהוגדרו לשיתוף ציבורי עשויים להופיע במנועי חיפוש. במקרה כזה אפשר לעבור מה-artifact עצמו גם לפרטים אישיים או עסקיים שהוכנסו אליו.

4. הפעולה המיידית: כדאי לעבור על artifacts וקישורים ששיתפתם בעבר, להסיר שיתוף מתכנים רגישים, ולא להכניס secrets, PII או מידע פנימי לתוכן ציבורי, גם כשהקישור מרגיש “נסתר”.

5. הקו המחבר: גם sandbox וגם share link הם גבולות אבטחה שצריך לבדוק ולא להניח שהם בטוחים כברירת מחדל. ב-agents עם הרשאות אמיתיות מומלץ להשתמש ב-least privilege, approval לפעולות רגישות, audit logs והפרדת credentials מה-context של הסוכן.

לקריאה: The Week of Sandbox Escapes ו-Escaping Antigravity’s Allow-Default Seatbelt.

📍 דובר ב-2 קבוצות: LangTalks Community 2 ו-LangTalks Community 5
📅 הדיון הראשון התחיל בתאריך: 16:29 | 20.07.26
💬 5 הודעות | 👥 3 משתתפים

נושאים נוספים שעלו

• שילוב Codex ו-Claude Code: עלתה מחשבה להשתמש ב-Pi כ-harness משותף ולהעביר משימות בין Claude Code ל-Codex באמצעות summary או מידע מתוך ה-JSONL. המכשול המרכזי הוא שמנוי Anthropic Max אינו מיועד לשימוש מתוך harness חיצוני, ולכן לעיתים נשארים עם Codex בתוך Claude Code או עם הפעלה הדדית דרך ה-CLI.

• תרגום ותמלול בזמן אמת: עבור פגישות Zoom ופגישות פרונטליות הומלץ לבדוק את Fireflies. שותף גם Mila, כלי קוד פתוח לתמלול שבו חבר מהקהילה תורם, ושנחשב חזק במיוחד לעברית.

• Markdown Wiki או Vector DB לזיכרון של agent: שותף פוסט המשווה בין שתי הגישות, שאלה שהופכת רלוונטית יותר ככל ש-agent harnesses שומרים יותר ידע לאורך זמן.

• סקירה על Opus 5: שותפה סקירה מעשית על למה החלפת Model ID בלבד היא טעות, באילו משימות Sonnet עדיין עשוי להתאים יותר, וכיצד חיפוש פשוט באינטרנט התרחב להרצה של 70 agents. לקריאת הסקירה.

• פינת העברית: הקהילה ניסתה למצוא חלופה עברית ל-Vibe Coding. בין ההצעות: “יצרתי”, “בניתי”, “תכנות בזרימה”, “הגשמתי”, “וויבוובתי” ו-“לוובווב”. עדיין אין קונצנזוס, אבל לפחות השורש ו.ב.ו.ב נכנס לדיון.

תודה שקראת!

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

אפשר להעביר לחברים וחברות ולהזמין אותם להצטרף לקהילה :)

💬 להצטרף לדיוני הקהילה בוואטסאפ 🗨️

📰 להירשם לניוזלטרים הבאים 📰

פרק חדש של לנגטוקס

במילים של לי מהפוסט: “והפעם, גל ולי חולקים את הטיפים והטריקים שלנו לעבודה וקינפוג של קלוד לעבודה היומיומית. זה אחד הפרקים הכי פרקטיים שהקלטנו - ממש מדריך ל-environment engineering. לא ה-flow האופטימלי, פשוט מה שמתאים לצרכים שלנו והכלים שבנינו בחודשים האחרונים”.

טיפים לעבודה עם קלוד קוד

1. פיתוח מקבילי: עלתה שאלה חוזרת איך עובדים על שני features במקביל ללא git worktree; חבר תיאר שבלעדיו נתקעים ב-task אחד לכל repo, ומנגד ניסיון בלי worktree יצר בלגן כמו שני juniors על אותו קובץ.

2. סקיל פרקטי לדוגמה: בעקבות בקשות לקישורים ל-skills מהפרק, לי שחרר את cc-htmlfeedback — כלי שבנה לאיטרציות מהירות על planים שהוא מכין ב-HTML (לא ב-md): מסמנים טקסט על העמוד ומשאירים הערות, ואז מייצאים אותן או נותנים ל-Claude Code להחיל את התיקונים. התחיל כ-inline editor והתרחב לצרכים כמו שינוי דיאגרמה או עדכון שמשפיע על שאר המסמך.

3. עורך ו-shortcuts: דיון על warp: command+delete למחיקת שורה ו-option+delete למחיקת מילה, כולל המלצה על herdr שרץ בתוך warp כשכבה נוספת לפרודוקטיביות.

4. transcript ל-episodes: חברים ביקשו transcript ואת רשימת ה-skills מהפרק; הוצע ש-skill ייעודי שמגדיר את מבנה הפלט עדיף על תמלול גולמי מ-Gemini, שאינו מדויק ב-100%.

📍 דובר ב-5 קבוצות: LangTalks Community 3, LangTalks Community 5, LangTalks - Code Generation Agents, LangTalks - AI driven coding, LangTalks AI-SDLC

📅 הדיון המלא התחיל בתאריך: 07:52 | 29.06.26
💬 24 הודעות | 👥 10 משתתפים

QA אוטומטי

1. e2e מקצה לקצה: חבר מריץ Claude Code לכתיבת בדיקות e2e שכוללות הרמת כל ה-dockers (backend+frontend+db) וכתיבת תרחישים חיצוניים; הוא הציע גם לייצר בדיקות UI מעל Playwright עם snapshot screenshots לאישור ויזואלי אנושי, ומזהיר שהרצת QA ישיר באופן שוטף שורפת הרבה tokens.

2. Chaos ו-acceptance: עלו שימושים ב-chaos engineering (תרחישים שאינם ה-happy path), וחבר סיפר על פלטפורמת בדיקות אוטומטית שהוא בונה שמביאה test cases מותאמים לשינוי בלי לקרוא את הקוד, עם optimization משמעותי של tokens.

3. עתיד תפקיד ה-QA: לדעת חברים QA הוא “התפקיד האחרון שיישאר” — נדרש validation אנושי מינימלי שהכול תקין, במיוחד כשקצב ה-delivery גבוה; אף אחד עדיין לא פיטר QA בפועל.

📅 הדיון המלא התחיל בתאריך: LangTalks Community 4 | 21:57 | 14.06.26
💬 20 הודעות | 👥 6 משתתפים

שיפור איכות הקוד

1. הטריגר: שיתוף של פוסט “How I deleted 40 thousand lines of code with Opus 4.8 פתח דיון על האם מספר שורות הקוד מעיד על משהו – הובהר שמדובר בריפקטורינג של קוד שנכתב בעצמו על ידי מודל גנרטיבי.

2. פחות שורות = קוד טוב יותר: נטען שפחות שורות לרוב מעידות על קוד טוב יותר, ובעידן הקוד הגנרטיבי זה מדד שצוותיObservability ו-eval ל-MCP servers

   1. הכאב הייחודי: כשמריצים MCP server ב-production וה-LLM שמפעיל אותו הוא client חיצוני, אין דרך לצפות בהתנהגות המשתמש — מעבר ל-tracing קלאסי של latency/errors/tools distribution.

   2. MCP כמו API: עלתה עמדה ש-MCP הוא בעצם “API ל-LLM”, ולכן צריך test suite (דטרמיניסטי או agentic) שבודק שכל tool עושה את המצופה כולל guardrails — בדיוק כמו API רגיל.

   3. intent מול correctness: האתגר האמיתי הוא זיהוי ה-intent ובחירת ה-tool והפרמטרים הנכונים; הוצעו workarounds כמו intent כפרמטר או sampling אל ה-LLM של המשתמש, אך הוסכם שהמיקוד צריך להישאר בצד השרת.

   📅 הדיון המלא התחיל בתאריך: LangTalks Community | 10:25 | 09.06.26

   💬 12 הודעות | 👥 6 משתתפיםLangTalks Community 4 | 10:12 | 29.05.26

מעקב עלויות LLM לפי לקוח ב-Bedrock

1. proxy ותיוג: כדי לדעת כמה כל לקוח “עולה” מומלץ proxy כמו LiteLLM עם tag ייחודי לכל request; gateway גם מאפשר הגדרת budget ו-RBAC מעבר לחישוב עלות בלבד.

2. Bedrock native: AWS Billing נחשב מסורבל, אך אפשר לתייג requests ב-request metadata ב-key:value ולשאול ב-CloudWatch Insights — הרבה יותר real-time מ-billing (שמתעדכן כל 6 שעות).

3. IAM cost allocation: אופציה נוספת שיצאה ב-2026: Bedrock IAM cost allocation, שימושית במיוחד אם קיים role נפרד לכל לקוח; לחלופין Langfuse מספק dashboards מוכנים למעקב usage ועלויות.

📅 הדיון המלא התחיל בתאריך: LangTalks Community 3 | 10:53 | 08.06.26
💬 15 הודעות | 👥 7 משתתפים

נושאים נוספים שעלו

• כלי קוד ריוויו: שילוב של CodeRabbit + Codex מותאם לארכיטקטורה, כש-Claude מקומי מוודא ומתווכח עד אחוז הסכמה מסוים; אינדוקס מבוסס RAG עם פיצול קבצים לפי חוקים מאיץ גישה ב-codebase גדול. חבר נוסף המליץ על Hodor.

• פלטפורמות מוניטורינג: Langfuse self-hosted זוכה להמלצות חוזרות (עם שיפור ניכר ב-MCP/skills לאחרונה), לצד Laminar ו-Logfire של Pydantic כאלטרנטיבות ל-LangSmith היקר.

• ייעול צריכת טוקנים: ניסוי של חבר בקהילה הראה ש-skill שנטען פעמיים באותו session נכתב פעמיים ל-jsonl ומוסיף ~10k tokens בכל טעינה — אם skill תמיד נדרש, עדיף להעביר אותו ל-CLAUDE.md.

• סוכן ידע ארגוני לא-טכני: לשליפת מידע מ-DB ו-Notion למשתמשים לא-טכניים הוצע Claude Teams עם Notion MCP מובנה כפתרון זול ומהיר, או בנייה עצמית עם RAG כשהיקף הנתונים גדול.

• סוכני WhatsApp אישיים: הרצת client מסוג Baileys מ-cloud IP עלולה לגרום ל-ban; עדיף מספר נפרד (SIM ב-~10 ש”ח לחודש או Meta Business) ולא המספר האישי.

תודה שקראת!

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

💬 להצטרף לדיוני הקהילה בוואטסאפ 🗨️

📰 להירשם לניוזלטרים הבאים 📰

⭐ לראות איך הניוזלטר נוצר ⭐

תוכן הכנס עלה ליוטיוב

העלינו ליוטיוב את כל התוכן מ-LangTalks AI Engineering Conference 2026.
זה כולל 7 הרצאות, 5 דמואים לייב, ו-2 פאנלים.
הכל פתוח וחינם לצפיה - כאן. תהנו!

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

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

גבולות האוטונומיה של סוכנים

1. הצגת האתגר: חבר קהילה העלה את השאלה האם אנחנו כבר מסוגלים להפעיל סוכן AI שמקבל הנחיה כללית ופועל עליה לאורך זמן – למשל “אתה ה-VP Product של המוצר הזה, זה הצוות שלך, קדם את הדברים” – כלומר לקיחת מטרה מופשטת והבנה כיצד לקדם אותה בסביבה לא ואקומית, בדומה ל-Polsia.

2. דיון על רווחיות והשקעה: עלתה ביקורת על כך ש-Polsia מפסידה כסף, לצד טענה נגדית שרוב הסטארטאפים מפסידים בשלב הזה וזה לא מעיד על דבר. צוין גיוס של 30M$ ולפי חלק מהמשתתפים שווי של כ-250M$ עם over $20M – התחלה מרשימה לחברת אדם-אחד. אחרים תהו מה המשקיעים רואים שהם לא רואים.

3. המגבלה הטכנית: נטען שכל עוד הסוכן לא יוצא מפורמט הלולאה (loop), לא נגיע ליישום אמיתי של מטרות מופשטות לאורך זמן.

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

📅 הדיון המלא התחיל בתאריך: LangTalks Community 3 | 19:31 | 29.05.26

האשמת ה-AI ואחריות בצוותי פיתוח

1. התופעה: חבר קהילה תיאר תופעה מטרידה – מפתחים לוקחים קרדיט על תוצרים, אך מתנערים מאחריות כשמשהו משתבש ומאשימים את ה-AI. “כשזה עובד – עשינו את זה ביחד; כשיש בעיה – זו אשמתו”. זה נע מהחלטות תכנון (”לא אני החלטתי, ה-AI המליץ”) ועד באגים קריטיים במערכת.

2. תרבות ארגונית כפתרון: “להצלחה אבות רבים, הכישלון יתום” – נטען שאין דבר כזה “ה-AI עשה את זה”. לכל משימה יש אחראי אנושי, וזה מתחיל כבר בראיון: מותר להשתמש ב-AI, אבל צריך לעמוד מאחורי הפתרון ולהסביר כל צעד.

3. אישיות מול טכנולוגיה: נטען שמדובר בעיקר בבעיית אישיות שאינה קשורה ל-AI – בעבר האשימו את הארכיטקט או ה-tech lead, וכעת עברו להאשים את ה-AI. שילוב של אישיות + תרבות ארגונית.

4. חוסר ownership כסימפטום: כמה משתתפים הצביעו על השורש – חוסר בעלות על הקוד או המוצר. אחד תיאר שגם אם עשה הכול (תכנון, ארכיטקטורה, דיבאג, code review) פרט לכתיבת הקוד עצמו – חמש דקות אחר כך אין לו מושג מה נעשה שם, וזה מדאיג לטווח הבינוני-ארוך, יחד עם היעלמות הלמידה של ג’וניור מסניור.

5. הזדמנות לשיפור: הוצע למסגר את זה לא כהאשמה אלא כתהליך למידה פומבי – כמו רטרו, רק שאפשר “לרדת על ה-AI” בחופשיות ולשפר את נקודות ההשקה בין אדם לסוכן. הוזכרו גם “work agreements” צוותיים שמעגנים שהאחריות על התוצר הסופי היא על מי שמגיש אותו.

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

📅 הדיון המלא התחיל בתאריך: LangTalks AI-SDLC | 15:04 | 26.05.26

ריפקטורינג, איכות קוד וקוד גנרטיבי

1. הטריגר: שיתוף של פוסט “How I deleted 40 thousand lines of code with Opus 4.8 פתח דיון על האם מספר שורות הקוד מעיד על משהו – הובהר שמדובר בריפקטורינג של קוד שנכתב בעצמו על ידי מודל גנרטיבי.

2. פחות שורות = קוד טוב יותר: נטען שפחות שורות לרוב מעידות על קוד טוב יותר, ובעידן הקוד הגנרטיבי זה מדד שצוותים צריכים לשאוף אליו – כל עוד לא מגזימים לכיוון קוד “חכם מדי”, לא קריא או לא תחזיקתי.

3. אתגרי קוד גנרטיבי: הבעיה היא ש-LLMs נוטים לייצר “הרים של קוד” שקשה לתחזק, להבין, ולהחזיר להקשר (context) בהמשך. פחות קוד כופה single source of truth. למקרים כאלה ניתן להשתמש בפקודות כמו /code-review של קלוד קוד, פקודה שנוטה לפשט את הקוד.

📅 הדיון המלא התחיל בתאריך: LangTalks Community 4 | 10:12 | 29.05.26

אלטרנטיבות ל-Langsmith לאינטגרציה עם Langchain

1. המלצה על langfuse: בתגובה לבקשה לאלטרנטיבה זולה וטובה ל-Langsmith שמשתלבת out of the box, הומלץ langfuse – זול וניתן להוסטינג עצמי – אך צוין שהאינטגרציה עם langchain/langgraph אינה חלקה כמו אצל langsmith ועשויה לדרוש התאמות.

2. חוויית משתמש ו-SDK: ה-SDK פחות אינטואיטיבי, וייתכן שיידרשו wrappers או hooks כדי להגיע לחוויה דומה; גם תצוגת ה-trace ב-UX שונה. זה כנראה המחיר של פלטפורמה אחת שתומכת בריבוי frameworks.

3. כלים נוספים: הוזכר pydantic-ai, אך הודגש שהוא לא רלוונטי למי שכבר בנוי כולו על Langchain ולא מתכוון לשנות זאת.

📅 הדיון המלא התחיל בתאריך: LangTalks Community 2 | 11:45 | 28.05.26

נושאים נוספים שעלו

• promptfoo מאפשר לבדוק יכולות AI בצורה סינתטית או דמוית פרודקשן – חשוב לבחור פילוסופיית בדיקות שמתאימה למקרי שימוש אמיתיים.

• litellm מספק פתרון לאחסון תוצאות קריאות LLM לצורך עקביות וחיסכון בעלויות; ניתן גם לשלב DynamoDB ו-S3 לאחסון מותאם.

• Second הוא פלטפורמת סוכני AI שיתופית בקוד פתוח – שווה לבדוק את הדוקומנטציה והיתרונות שלה לפרויקטים מרובי סוכנים.

• State16 Simulator מאפשר לבדוק פיזיקלית פעולות של סוכני AI, כולל שכבת Runtime Integrity שמוודאת היתכנות לפני ביצוע.

• Qdrant, Pinecone ו-Zilliz נידונו כפתרונות production ל-vector DB, עם דגש על עלויות בפריסה רחבה.

• שימוש ב-structured markdown או agentic search יכול להחליף RAG בבוטי שירות לקוחות עם בסיס ידע קטן.

“הדבר שהכי מלהיב אותי ב-AI היום הוא סוכנים בכל תהליך הפיתוח. מהאפיון, דרך QA, ועד SRE
. פידבק לא רק ממפתחים, אלא גם מנהלי מוצר ומעצבים. בפרק החדש דיברנו עם Yonatan Maor, מייסד ו-CTO של Clears.ai, על איך עושים את זה בפועל”. לי טוויטו.

להאזנה:

תודה שקראת!

אפשר להזמין אנשים נוספים:

💬 להצטרף לדיוני הקהילה בוואטסאפ 🗨️

📰 להירשם לניוזלטרים הבאים 📰

🎨 לראות איך הניוזלטר נוצר ⭐

איזה יום זה היה. LangTalks AI Engineering Conference 2026 הרגיש כמו נקודת ציון אמיתית לקהילת ה-AI Engineering בישראל. יום שלם של הרצאות, דמואים ופאנלים על מה שבאמת קורה היום בעולם ה-AI Engineering, לא ברמת הכותרות, אלא ברמת האנשים שבונים את זה בפרודקשן.

תודה ענקית לכל הדוברים, למשתתפים, לקהילה המדהימה שלנו, ולשותפים והספונסרים שעזרו להפוך את זה לאפשרי: Hetz Ventures, Nebius, Dell Technologies, Zenity, Hyro, Overcut, Yotpo, AutonomyAI, Axon911, Papaya Global, MongoDB, Aidoc, SpecificAI, Duve, Descope, Salt Security, Sap.Hi, CopilotKit, Commit ו-Clears.ai.

https://www.youtube.com/watch?v=ZPV_8cix8KM

חיבור אייג’נט ל-WhatsApp Business עם HookMyApp

1. הכאב: חיבור agent ל-WhatsApp Business דרך Meta הרשמי הוא תהליך של שבוע ויותר: פתיחת עמוד עסקי בפייסבוק, חיבור ל-Business Manager, הגדרת DNS, סריקת מסמכים לאימות עסק, ותהליך verification מול Meta — וכל טעות קטנה יכולה לחסום את החשבון.

2. הבעיה עם הפתרונות הקיימים: רוב האינטגרציות הקיימות כמו OpenClaw משתמשות ב-wrapper של WhatsApp Web על גבי חשבון WhatsApp אישי — מה שמסוכן ועלול לגרום לחסימת המספר האישי. זו הסיבה שחיפשו פתרון דרך WhatsApp Business הרשמי.

3. הפתרון: HookMyApp, שנבנה על ידי חבר הקהילה, מאפשר חיבור agent ל-WhatsApp Business דרך CLI פשוט ו-skill מוכן. ה-setup לוקח פחות מדקה, כולל sandbox מלא לשליחה וקבלת הודעות, וחינמי לשימוש אישי. הלינק: https://hookmyapp.com

4. מעבר לפרודקשן: המעבר מ-sandbox ל-production הוא פשוט להחריד — רק החלפת ערכים של environment variables. אין צורך בתהליך נפרד, בירוקרטיה נוספת, או הגדרות מחדש של כל הסביבה.

5. תמיכה מהבילדר: אור דביר, הבונה של HookMyApp, נמצא בקהילה ומציע תמיכה ישירה לכל בעיה, הצעה, או שאלה. מי שמתכנן לחבר agent ל-WhatsApp Business — כדאי לנסות את זה לפני שמתחילים מאפס.

📅 הדיון המלא התחיל בתאריך: LangTalks Community | 11:14 | 10.05.26

חולשת CVSS 10 ב-Gemini-CLI

1. הממצא: חבר קהילה גילה חולשת אבטחה קריטית ב-gemini-cli שיכלה לאפשר השתלטות מלאה על ה-repository של gemini-cli ב-GitHub — פרויקט עם כ-100,000 כוכבים.

2. מידת החומרה: גוגל נתנה לחולשה ציון CVSS של 10, הציון המקסימלי האפשרי. ציון CVSS 10 הוא נדיר ביותר ומעיד על חומרה מקסימלית — מדובר בפגיעות שיכלה לסכן את שרשרת האספקה של כל מי שמשתמש ב-gemini-cli.

📅 הדיון המלא התחיל בתאריך: LangTalks Community 2 | 15:48 | 05.05.26

עיצוב Skill Instructions לטסטים במונוריפו גדול

1. הבעיה: ב-monorepo עם הרבה אפליקציות, יש testing skill ברמת ה-root שמשותף ל-95% מהאפליקציות — אבל כל אפליקציה רוצה להגדיר דוגמת טסט קנונית משלה (canonical test example) בנתיב שלה, כמו /apps/a/good-test-example.ts.

2. הפתרון המומלץ: הגישה המועדפת: הוראה כללית ב-skill לחפש קובץ TEST_REFERENCE.MD בתוך תיקיית כל אפליקציה — למשל /apps/{app-folder}/TEST_REFERENCE.MD. כך האחריות עוברת לבעל כל אפליקציה ואין צורך לתחזק מפה מרכזית ב-root skill.
   3. סקיל deep-init: הוצע גם לבדוק את ה-deep-init skill כפתרון אלטרנטיבי — לא ה-/init המובנה, אלא pattern נפרד שמאפשר אתחול עמוק של הקשר per-app. שווה לחקור את הגישה הזו למי שעובד עם AI coding agents ב-monorepo.

📅 הדיון המלא התחיל בתאריך: AI driven coding | 13:57 | 05.05.26

סיכוני אבטחה בצ’אטבוט ארגוני

2. הסיכון: chatbot ארגוני ללא guardrails מתאימים חשוף לניצול שיכול לגרום לנזק כספי משמעותי — הדגמה חיה על Zoom’s chat ממחישה את הסיכון בצורה קונקרטית ומדאיגה.

3. הלקח המעשי: לפני deploy של chatbot ארגוני, חובה לבדוק: האם יש הגבלות על סוגי פעולות שה-agent יכול לבצע? האם יש rate limiting? האם יש מנגנון לזיהוי prompt injection? guardrails הם לא אופציונליים בסביבה ארגונית, הם חובה.

4. כלים רלוונטיים: כדאי לבחון כלים כמו LlamaGuard, Guardrails AI, או NeMo Guardrails להגנה על chatbots ארגוניים. הגדרת מדיניות ברורה של מה ה-agent מורשה לעשות — ומה לא — היא הצעד הראשון לפני כל deployment.

📅 הדיון המלא התחיל בתאריך: LangTalks Community | 11:14 | 10.05.26

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

Building in data or AI infra? The Hetz Ventures Data Program is built for you:

Apply here

Nebius is hiring! Don’t just work in tech. Shape it! For all open roles.

Apply here

Create the Dell Technologies AI Orchestration Solution – Join us as a Full-Stack
Principal Engineer: Apply here

Building a startup? Explore MongoDB for Startups and scale faster

https://www.mongodb.com/

Yotpo is hiring a Frontend Team Leader to lead AI-powered React architecture, developer tooling & next-gen UI

Apply here

aidoc is hiring an AI tech lead

Apply here

Hyro is hiring — product, analysts & engineers transforming US healthcare with AI. Apply here

Papaya Global is hiring an AI Engineer

Apply here

Axon 911 (formerly Carbyne) is hiring a Senior Software Engineer

Join our mission to save lifes
Apply here

Build the most critical security platform of our generation with the company that created the category. Join Zenity to help secure AI Agents everywhere

Apply here

Clears AI is growing and hiring for AI Fullstack Engineer and Data Science AI Engineer

Apply here

Product teams, ship to production without the wait. Try Fei Studio Playground

Stop building isolated AI agents. Start running real Agentic SDLC workflows with Overcut.

Commit AI helps R&D teams move toward agentic SDLC beyond coding assistance. Explore here

תודה שקראת!

מוזמנים להזמין אנשים נוספים:

💬 להצטרף לדיוני הקהילה בוואטסאפ 🗨️

📰 להירשם לניוזלטרים הבאים 📰

🎨 לראות איך הניוזלטר נוצר ⭐

ניפגש מחר ב-8 בבוקר בהבימה!

אתם מטורפים. הרצון שלכם להשתתף באירוע עולה על כל מה שחשבנו.
בעקבות הביקוש המטורף לא הצלחנו לאשר יותר מ1,000 מהנרשמים - השתדלנו לתת עדיפות לאיזון מגדרי וייצוג ממגוון רחב של חברות.
אם לא קיבלתם אישור, בבקשה לא להגיע. לא תוכלו להכנס🙏🏻

בנוסף שימו לב שהכניסה על בסיס מקום פנוי, ככה שלא נוכל להבטיח כניסה אחרי 9:00 גם למי שיש כרטיס.

בניית Agent לניתוח שגיאות Log אוטומטי

1. הבעיה המרכזית: הרצון לבנות agent שסורק Log.errors יום יום, מצליב עם קוד ו-DB, ושומר זיכרון על שגיאות חוזרות — נשמע פשוט, אבל הרעש בלוגים ישרוף טוקנים בלי סוף ויגרום ל-hallucinated root causes.

2. MCP כגשר: ההמלצה הבולטת שעלתה היא לחבר את ה-agent ל-MCP של כלי ה-observability הקיים (NewRelic, DataDog, CloudWatch). AWS CloudWatch MCP לדוגמה תופס logs ו-metrics ישירות — אין צורך לבנות fetching מאפס.

3. Claude Code בפרודקשן: אחד החברים מדווח שהם עובדים עם Claude Code בדיוק לצורך הזה — אבל מדגיש: בלי השקעה בפיתוח ה-skills ו-debug של ה-workflows, התוצאה היא בעיקר רעש. אחרי שעשו את ההשקעה הזו — התוצאות נהיו מדהימות.

4. ה-Harness ההנדסי קריטי: חבר קהילה אחר מסביר את הנוסחה: חלק הנדסי (deduplication של שגיאות כפולות עם שמירת count ו-distribution, ניקוי logs, הבאת context — logs לפני ואחרי, metrics, קוד, deployment) + חלק LLM. רק אחרי שה-harness מוכן — תנו ל-LLM לשחק.

5. אזהרה מ-vendor solutions: הוויכוח בין ‘קנה מוצר מדף’ ל-’בנה בעצמך’ הסתיים בהסכמה: אף vendor לא יפתור לך את בעיית ה-observability הפנימית — איך המערכת מחוברת, מה כל שירות עושה. זה עבודה שלך. ברגע שזה מסודר, גם vanilla Claude Code עושה עבודה מצוינת.

📅 הדיון המלא התחיל בתאריך: LangTalks AI-SDLC | 23:19 | 28.04.26

מודלים פתוחים עבור Claude

1. העדכון: מעכשיו Claude CoWork מאפשר להשתמש במודלים חיצוניים. ניתן להגדיר עבודה עם OpenAI, Gemma, Kimi K2, מודלים דרך OpenRouter או מודל מקומי אחר. העדכון שוחרר בשקט וללא הכרזה רשמית גדולה.

2. מה זה נותן: לשמר את חוויית המשתמש והניהול של Cowork תוך החלפת המודל במודל זול יותר, חינמי או כזה המורץ באופן עצמאי. זה מאפשר גמישות כלכלית משמעותית למשתמשים, ואפשרות להגברת הפרטיות.

3. מה לא אפשרי: זה לא אומר שקלוד הפך לחינמי, שכן המודלים המקוריים (Sonnet/Opus) נותרו בתשלום. בנוסף, קיים פער ביצועים עצום בין מודל מקומי קטן למודלי הדגל של אנתרופיק, כך שמודל קטן יתאים רק למשימות קלות. חשוב לציין שהעדכון הרשמי נוגע ל-Cowork בלבד ולא ל-Claude Code.

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

5. הרצת קלוד קוד עם מודל פתוח: משתמשי מאק יכולים כבר היום להריץ את קלוד קוד עם qwen3.6. אחד המשתתפים בדיון סיפר שזה עוזר לו במיוחד ליוז קייסים המצריכים טוקנים מרובים (כמו שימוש בדפדפן), ושיתף קישור לכלי איתו הוא עשה לזה סטאפ.
   

   📅 הדיון המלא התחיל בתאריך: LangTalks Community 4 | 11:31 | 02.05.26

RAG: טכניקות ואופטימיזציה

1. Hybrid Search + Reranking: הגישה המנצחת לפי ניסיון בפרודקשן: hybrid search של 65% לפי סימילריטי ו-35% לפי מילות מפתח, ואחריו reranker. MMR מונע מצב שכל top-k תוצאות זהות. לדיוק מקסימלי — ColBERT שומר וקטור לכל token בנפרד במקום ממוצע אחד לכל הטקסט.

2. Proposition Chunking + HyDE: אחד המשתתפים ממליץ על Proposition Chunking: כלומר LLM שבונה offline פקטים קצרים ועצמאיים מכל item ומבצע embedding רק עליהם — מפחית נויז משמעותית. HyDE מתאים כשיש vocabulary mismatch: הופך את ה-query ל’מסמך תיאורטי שיכול לענות עליו’ ואז מחפש קרבה.

3. תישאול תכני לנגטוקס: חבר קהילה שיחרר את LangRAG — מערכת לסיכום וחיפוש תוכן מתוך הפודקאסטים, הוואטסאפ, והניוזלטרים של הקהילה. המערכת כוללת פייפליין LangGraph עם פיצ’רים לאופטימיזציית תוכן ועלויות, REST API ושרת MCP שניתן לחבר לכל אייג’נט. חבר קהילה נוסף שיחרר סקיל שמשלב web search + NotebookLM ותהליך RAG על תוכן הפודקאסטים, כולל תיוגים מתאימים.

📅 הדיון המלא התחיל בתאריך: LangTalks Community 4 | 12:11 | 27.04.26

נושאים נוספים שעלו

• אנתרופיק פרסמה postmortem רשמי על באגים שהצטברו באפריל 2026 ומאשרת שתוקנו — אם חוויתם בעיות עם Claude Code בחודש האחרון, שווה לקרוא.

• עבור מערכת של כמה עשרות microservices שונים, גישת central repo עם claude.md + MCP + Vector DB/RAG היברידי עדיפה על Confluence בלבד — agents צריכים גישה structured ולא רק חיפוש טקסטואלי.

• מחקר עם ~10,000 queries מראה שמודלים קטנים (SLMs) מדויקים יותר ממודלים גדולים במשימות fact extraction מ-context — כי הם ‘מציתים’ פחות מזיכרון ויותר מהטקסט הנתון.

• ניתן לשמור CLAUDE.md ו-AGENTS.md מסונכרנים עם symlink ל-SUPER.md אחד — פתרון אלגנטי לעבודה עם מספר AI coding agents מאותו repo.

פרק חדש בפודקאסט: FinOps for AI

“האם צריך להגביל את תקציב הטוקנים של מפתחים? השאלה הנכונה היא לאן הכסף הולך ואיך מודדים אם זה משתלם. בפרק החדש של LangTalks דיברנו עם Yizhar Gilboa, על FinOps לעולם ה-AI”. לי טויטו.

תודה שקראת!

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

💬 להצטרף לדיוני הקהילה בוואטסאפ 🗨️

🗞️ להירשם לניוזלטרים הבאים 📰

🎨 לראות איך הניוזלטר נוצר ולפרגן בסטאר ⭐

הכנס השנתי של לנגטוקס כבר מעבר לפינה

הכנס יתקיים ב-4 במאי בתיאטרון הבימה.
ההרשמה החינמית כרגיל דרך Luma.
האירוע יתחיל ב-8:00 להרשמה וארוחת בוקר. התוכן יתחיל ב-9:00.

פרקטיקות ניהול של Skills או Rules בסקייל גדול

1. הבעיה המרכזית: כיצד מנהלים rules ו-skills של AI coding בצוותים גדולים? מישהו שאל איך נמנעים מ-context pollution, כפילויות, וחוסר עקביות בפורמט כשיש הרבה contributors שונים שמוסיפים rules.

2. Context Registry: אחד המשתתפים בדיון תיאר ארכיטקטורה של centralized context registry ב-marketplace repo, עם CI build step שמבצע bundling לפלאגינים לפי קובץ קונפיגורציה — single source of truth שנועד לזהות ולמנוע כפילויות. נתמך גם ב-Claude Code וגם ב-Cursor.

3. Layered Plugin Architecture: פתרון הכולל שכבות. core layer שמחולק לכל המפתחים (mandatory, auto-installed), ומעליו group plugins ו-tech-stack plugins ספציפיים. Code owners מוגדרים לכל skill/rule כדי לשמור על אחריות ברורה.

4. Hooks לוולידציה ו-LangFuse לאבלואציה: משתתף אחד סיפר על שימוש ב-hooks מסוג UserPromptSubmit, PreTool ו-PostTool לטובת וידוא הקונסיסטנטיות ובחירת כלים נכונה. משתתף אחר העלה את LangFuse ככלי לאבלואציה רכה יותר: השוואת פרומפטים, מטרות ו-tools, יכולה להקל על הערכת החיוניות של הוספת skill או subagent מסוים.

5. Agentic Eval Loop לשיפור Skills: הוצע להשתמש ב-autoresearch של Karpathy, מתוך מחשב לייצר feedback loop אוטומטי אפקטיבי סביב כל סקיל: להריץ את הסקיל, לתת ציון לאאוטפוט דרך מטריקות קבועות, להזין את התוצאות חזרה לטובת שיוף הסקיל, וחוזר חלילה, עד הגעה ליציבות מול אותן מטריקות איכות.

📅 הדיון המלא התחיל בתאריך: AI driven coding | 17:07 | 19.04.26

ניהול MCPs בארגון

1. הבעיה: פיצוץ קונטקסט. משתתף אחד דיווח שהגיע ל-120K טוקנים רק מ-MCPs מוגדרים. כשמגדירים 50-60 MCPs בארגון, כל ה-tools נטענים לקונטקסט ומכבידים על כל session, גם כשרוב הכלים לא רלוונטיים למשימה.

2. ENABLE_TOOL_SEARCH: אחד המשתתפים הציע פתרון עבור קלוד קוד: לוודא הגדרה של ENABLE_TOOL_SEARCH. קלוד ישתמש ב-search tool כדי לגלות tools רלוונטיים on-demand, כך שרק tools ספציפיים נכנסים לקונטקסט.

3. Plugin Marketplace: בנוסף, private plugin marketplace תומך גם ב-Claude Code וגם ב-Cursor מאותו repo.

4. פיצול MCPs לפי Use Case: אחד המשתתפים בדיון המליץ לפצל MCPs בין plugins שונים לפי use case, כך שלא כל מפתח יצרוך את כל הכלים. ארכיטקטורת שכבות (core + group + tech-stack) מאפשרת לכל צוות לקבל רק את ה-MCPs הרלוונטיים לו.

📅 הדיון המלא התחיל בתאריך: AI driven coding | 12:32 | 19.04.26

כיצד Cursor מציג Reasoning מסונן ב-UI

1. השאלה: Raw או Filtered: אחד החברים שאל איך כלים כמו Cursor מציגים reasoning נקי ואסתטי למשתמש, ללא חשיפת שמות tools גולמיים או הוראות מה-system prompt — האם זה raw reasoning, פלט מסונן, או סיכומי ביניים של ה-agent?

2. אנתרופיק לא חושפת הכל: מישהו הזכיר נקודה מאחת ההרצאות של Karpathy, לפיה אנתרופיק לא חושפת את תהליך החשיבה הפנימי המלא — מה שמוצג הוא fragments נבחרים מהתהליך. ב-Claude Code זה נראה גולמי יותר, אבל בממשקי chat זה מסונן.

3. התהוות ה-best practice: אחד המשתתפים בדיון ציין את הבחירה להכניס תגיות שיעטפו חלקים מהפלט. חבר אחר ציין best practice לפיו מציגים את ה-reasoning על tool calls בנפרד מהתוצאות עצמן — ולא כוללים את ה-tool response הגולמי בתצוגה.

📅 הדיון המלא התחיל בתאריך: LangTalks Community 2 | 16:36 | 16.04.26

נגישות AI Primitives בסביבות Enterprise

1. הבעיה: Security vs. Accessibility: אחד החברים התייעץ כיצד לנגיש skills, sub-agents ו-instructions לסביבות ארגוניות עם הגבלות התקנה — האם לאחסן פנימית (עם עלות תחזוקה) או להפנות למקורות ציבוריים (עם סיכוני typosquatting כמו ‘azore-skills’ במקום ‘azure-skills’).

2. APM + JFrog Artifactory: חבר קילה סיפר שהוא מפתח מערכת APM — ראשי תיבות של AI Package Manager — כלי קוד פתוח לניהול הפצת AI primitives. חבר קהילה נוסף תרם תמיכה ב-JFrog Artifactory כ-registry. הארכיטקטורה:
   internal repo ← Artifactory/security scanning ← הפצה דרך APM.

3. גישות נוספות: משתתף אחד סיפר שהוא הטמיע marketplace פנימי על פלטפורמת OpenWebUI לשיתוף skills ו-agents בארגון. משתתף אחר הציג גישת team-ai-directives הכוללת rules, personas, דוגמאות, MCP definitions ו-local skills — הכל ב-repo אחד.

📅 הדיון המלא התחיל בתאריך: LangTalks AI-SDLC | 09:50 | 07.04.26

נושאים נוספים שעלו

• agentic-swarm-bench הוא כלי קוד פתוח שמקליט ומשחזר עומסי עבודה אמיתיים של agents (40K–400K טוקנים) כדי לייצר בנצ’מרקינג מציאותי של LLM stacks — פותר את הפער בין benchmarks סטנדרטיים לביצועי production.

• SkillsBench בודק אמפירית אילו prompting skills משפרים ביצועי LLM ואילו רק מבזבזים context window.

• Prompt compression בפרודקשן היא לרוב לא הפתרון הנכון אם המטרה היא הפחתת עלויות. הבעיה בדרך כלל אינה בגודל הפרומפט אלא בארכיטקטורה. גישה יעילה יותר להפחתת עלויות, לדוגמה, יכולה להיות התאמת מודלים זולים יותר למשימות נקודתיות.

• לשמירת credentials של Claude Code בין rebuilds של dev container, כדאי להשתמש ב-persistent volume עבור תיקיית claude.

• Git worktrees עם קלוד קוד: Warp terminal פותח worktree חדש בטאב אוטומטית, ו-Cursor תומך ב-worktrees.json שמגדיר גם את הסטאפ של הפרויקט בכללותו (copy .env, npm install) — כל worktree מופיע כענף נפרד, מה שמקל על ניהול תהליכי פיתוח במקביל.

פרק חדש בפודקאסט: Scaling LLMOps

“תתחילו תמיד עם המודל הכי חזק. תוכיחו שזה עובד, ורק אז תתעסקו עם אופטימיזציה. בפרק 66 של LangTalks דיברנו עם Avi Lumelsky על איך עושים LLMOps בסקייל”. לי טוויטו.

תודה שקראת!

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

💬 להצטרף לדיוני הקהילה בוואטסאפ 🗨️

📰 להירשם לניוזלטרים הבאים 📰

🎨 לראות איך הניוזלטר נוצר ולפרגן בסטאר ⭐

הכנס השנתי של לנגטוקס מתקרב

הכנס השנתי של LangTalks מתקיים ב-4 במאי בתיאטרון הבימה.
כרגע אין שינוי למרות המצב הבטחוני, ההרשמה החינמית כרגיל דרך Luma.

דליפת קוד המקור של Claude Code

1. מה קרה: ב-31 במרץ, ריפו עם קוד המקור של Claude Code הועלה ל-GitHub ושותף ברחבי הקהילה. הריפו המקורי הוסר תוך שעתיים על ידי Anthropic, אך העתקים רבים כבר נמשכו ונשמרו – כולל העלאה מחדש לפלטפורמות חלופיות ויצירת port ל-Python ו-Rust.

2. אמיתי או April Fools?: בגלל הקרבה לאחד באפריל, חלק מהחברים חשבו שמדובר במתיחה. אחרים אישרו שהקוד אמיתי, בין היתר בהסתמך על ציוצים ברשתות חברתיות. הקהילה אף ערכה בנושא. הרוב הבינו שזה אמיתי.

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

4. ניתוח טכני: Claude Code מסופק כ-binary מקומפל – כך שעד כה מי שרצה לקרוא את הקוד היה יכול לעשות decompile. האירוע נעוץ בכך שהדליפה חשפה את הקוד באופן נגיש יותר, וכללה גם חלקים מסוימים מעבר ל-binary המקורי לא נמצאו סודות גדולים – כמו שאמר אחד החברים: “מה שהודלף זה בהחלט לא המוח שלו, אולי הציפורניים”. עם זאת, הוסכם שמדובר בעבודת הנדסה שמוכיחה שכשמשלבים research ו-engineering באיזון הנכון, מקבלים אייג’נט כתיבת קוד מצוין. כבר נוצרה דוקומנטציה חיצונית פתוחה שמסבירה את הקוד, ורוב מי שניתח אותו פשוט הזין אותו ל-Claude Code עצמו וביקש ממנו לספר על עצמו. חבר אחד ניסח את זה באירוניה – “למה לקרוא לזה דליפה ולא שחרור הקוד בפורמט שלא צריך לבקש מ-AI לקרוא את ה-JS מתוך node_modules?”

5. קוד המקור עצמו: אחד החברים שיתף קובץ zip המכיל את הדליפה כולה. הקובץ עדיין נגיש בהודעה הנמצאת בקבוצה LangTalks Community 2, בתאריך 31.03.26, בשעה 23:40.

📅 הדיון המלא התחיל בתאריך: LangTalks Community 2 | 22:45 | 31.03.26

כלי GraphRAG פרטי ל-Wiki של קוד

1. הרעיון: אחד החברים הציג כלי (CLI/NPM) שסורק את ה-repo ומייצר אוטומטית Wiki מפורט של כל הארכיטקטורה, הלוגיקה ואופן הפעולה של הקוד – בסגנון Google Code Wiki ו-Devin. הכלי שומר על פרטיות מלאה: כל המידע נשאר בתוך ה-repo ללא תלות בשירותים חיצוניים.

2. Context Engineering ברמת ה-Repo: בשונה מכלים שמריצים prompt על קובץ ומייצרים Readme, כאן מדובר ב-Context Engineering ברמת הפרויקט כולו. הכלי לא רק מזריק טקסט – אלא מבין את המבנה, התלויות והקשרים בין חלקי הקוד. הקהילה ביקשה deep dive על הארכיטקטורה.

3. סקיילינג ואתגרים: עלו שאלות על התנהגות הכלי על codebases גדולים (מיליוני שורות קוד, עשרות repos). הוסבר שהכלי לא עובד ב-one shot נאיבי אלא בגישה חכמה יותר, והציע לחברי הקהילה לשלוח repos גדולים לבדיקה. הטיפול בעדכונים שוטפים (כשהקוד משתנה) עדיין בפיתוח.

4. השוואה לכלים קיימים: הושוו כלים כמו RepoSwarm ו-SocratiCode. ההבדלים העיקריים: zero config (המודל מבין הכל בעצמו), אחסון נייטיבי ב-repo, ואינטגרציה עם Cursor. חבר נוסף שיתף POC של Agent בשם “שמעון” שפותח בחברתו למטרה דומה.

5. עניין קהילתי גבוה: עשרות חברים ביקשו לנסות את הכלי, הועלתה הצעה להרצאה ולהקלטת פרק, וצוין שגרסה יציבה צפויה תוך כשבועיים.

📅 הדיון המלא התחיל בתאריך: LangTalks Community 4 | 19:13 | 24.03.26

אוטומציה מרובת-סוכנים ואופטימיזציית עלויות

1. ארכיטקטורת CLI חדשה: הוצג CLI שמפצל משימות קוד לארבעה sub-agents (חיפוש, תכנון, כתיבה, בדיקה) – כל אחד רץ על מודל זול אחר, ומתקשרים ביניהם ב-JSON. כך אפשר להוזיל עלויות של מטלות מסוימות מ-$1-3 לכ-3 סנט.

2. סינכרון בין סוכנים: ה-agents עצמם מבודדים, והסנכרון נעשה ע”י Reviewer שמקבל את כל ה-diffs ובודק שאין סתירות. אין מודעות הדדית בין הסוכנים עצמם.

3. פידבק מהקהילה: הועלו שאלות על הבדלים מול subagents מובנים, שימוש במודלים חזקים לתכנון, והתעניינות בקוד פתוח. לינק: usemint.dev.

📅 הדיון המלא התחיל בתאריך: LangTalks Community 4 | 14:45 | 02.04.26

כלים ו-best practices ל-Eval של סוכנים

1. פלטפורמות Eval: הוזכרו braintrust, langsmith (כולל datasets), OpenAI tracing, וכלי קוד פתוח (eval-view). כל אחד מתאים לארכיטקטורה אחרת – חלקם מתמקדים ב-observability, אחרים ב-CI.

2. גישה מבוססת Invariants: הומלץ לבדוק state changes לאורך ה-trace, להתמקד ב-invariants (מה שה-agent חייב לעשות), ולא להעניש על צעדים מיותרים. ב-langgraph ניתן לבדוק שינויים במצב לאורך הדרך.

3. שיקולי vendor lock-in: langsmith נותן מעקב עמוק אך נוטה לנעול ל-langchain; ניתן לעקוף זאת עם decorators. הדיון כלל השוואות בין tracing של langsmith ל-OpenAI.

📅 הדיון המלא התחיל בתאריך: LangTalks Community 4 | 18:51 | 30.03.26

נושאים נוספים שעלו

• אירוע אבטחה ב-liteLLM: התגלתה פגיעות supply chain בספריית liteLLM בפייתון – חבילות חדשות הושפעו, כולל nanobot-ai. חשוב לבדוק תלויות ולעדכן גרסאות.

• Google Gemma 4: שוחררו ארבעה מודלים open-weight תחת Apache 2.0. דגם 31B מדורג שלישי בעולם בין מודלים פתוחים. נדון ב-LangTalks Community 2, LangTalks Community 3. פוסט בנושא.

• ניהול Threads מקביליים ב-Claude Code: שיתוף workflow לניהול באגים ומשימות מקביליות – שימוש ב-Linear כשכבת זיכרון, פתיחת sub-tasks, ו-branching. הוזכרו כלים כמו Spec Kitty.

• Remote Control ב-Claude Code: חברים דיווחו על בעיות בהפעלת פיצ’ר ה-remote-control, שיתפו workarounds ובדיקות גרסאות.

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

• MCP Resources לעומת Skills: deep dive טכני על ההבדלים בין Resources ל-Skills ב-MCP, עם דגש על עדכון דינמי וסנכרון.

• כלי הקלטה לדמואים: המלצות על Screen Studio ו-OpenScreen, כולל טיפים לנגישות ב-Mac.

• Loki Agent: שוחרר כקוד פתוח לפרוטוטייפינג מהיר בסביבת Amazon sandbox.

• עבודה עם מספר חשבונות Claude במקביל: שיתוף alias ל-bash עם CLAUDE_CONFIG_DIR, וכלי cctx. יש מגבלות עם MCP/plugins.

פרק חדש בפודקאסט: AI SRE

“והפעם אנחנו מארחים את Asaf Savich לשיחה על איך אפשר לפתח סוכן שייקח מכם את העבודה השחורה של ה-On Call. פרק מרתק שנוגע באתגרים של ניתוח כמויות עצומות של לוגים, ואיך לעשות zoom in מדויק למקור הבעיות”. גל פרץ.

להאזנה:

תודה שקראת!

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

💬 להצטרף לדיוני הקהילה בוואטסאפ 🗨️

📰 להירשם לניוזלטרים הבאים 📰

🎨 לראות איך הניוזלטר נוצר ולהציע פיתוחים 🎨

הכנס השנתי של לנגטוקס מתקרב

• הכנס השנתי של LangTalks מתקיים ב-4 במאי. כרגע אין שינוי למרות המצב הבטחוני, ההרשמה (החינמית) כרגיל: דרך Luma.

אורקסטרציית אייג’נטים לצוותי פיתוח שלמים

1. האתגר: מפתחים רבים מחפשים פתרון קוד פתוח לאורקסטרציה של צוות agents שלם – product, design, פיתוח, testing – שיתפקד כצוות פיתוח אוטונומי על פרויקט fullstack. הדרישה: continuous loops שמניעים את הפרויקט קדימה, רצוי עם תמיכה ב-Codex.

2. הכלים שעלו בשטח: חברי הקהילה שיתפו כלים שהם משתמשים בהם בפועל: spec-kitty לניהול spec-driven development, get-shit-done שזכה להמלצות חמות כפתרון שעובד מצוין בפרויקטים אמיתיים (”הריפו היחיד שמתעדכן יותר פעמים ביום מ-Claude”), ו-babysitter – פרויקט ישראלי לניטור ואורקסטרציה של agents.

3. ההבחנה החשובה: עלתה נקודה קריטית בדיון – יש להבדיל בין כלים ליצירת agents עבור מוצרים (כמו Langflow) לבין כלים שמשתמשים ב-agents לבניית תוכנה עצמה. הצורך כאן הוא בקטגוריה השנייה: AI שבונה software, לא software שמריץ AI.

4. לאן השוק הולך: הדיון משקף מגמה ברורה – המעבר מ-”agent בודד שכותב קוד” ל-”צוות agents שמנהל פרויקט”. זו שאלה שתהפוך מרכזית יותר ככל שהכלים יבשילו, ושווה לעקוב אחרי הפרויקטים שהוזכרו.

📅 הדיון המלא התחיל בתאריך: LangTalks Community 4 | 16:34 | 16.03.26

מודלים open-source לקוד ברשתות פרטיות: מה עובד ומה נדרש

1. השאלה: מפתחים שצריכים להריץ מודלי קוד ברשת פרטית ארגונית חיפשו את השילוב הטוב ביותר של מודל + CLI.

2. ההמלצות: minimax 2.5 הפתיע לטובה – מהיר משמעותית מ-Sonnet/Opus, זול פי 10-20, ולהפתעת המשתמשים גם תפס skills ו-subagents טוב יותר. הקונצנזוס: המודלים החדשים מ-Moonshot, Z.ai, Alibaba ו-minimax “פחות או יותר שווים – ולרפרנס, הם בערך ברמה של Opus 4.5”.

3. הסטאפ הנדרש: אפשר להשתמש בכל מודל דרך Claude Code עם Ollama, אבל למודלים cutting-edge צריך H100 (”GPU חזק”, כפי שהוסבר לחבר קהילה שלא הכיר). לרשתות פרטיות, Ollama הוא הפתרון המעשי – מאפשר hosting עצמי של מודלים ללא תלות ב-API חיצוני.

4. Bottom line: מי שמחפש אלטרנטיבה חסכונית ומהירה למודלי הפרמיום, minimax 2.5 שווה ניסוי רציני. מי שצריך להישאר ברשת פרטית – Ollama + מודל open-source על GPU מתאים.

📅 הדיון המלא התחיל בתאריך: LangTalks - AI driven coding | 10:59 | 07.03.26

הנגשת הערכת LLMs לרופאים: ארכיטקטורה ובחירת כלים

1. האתגר: איך מאפשרים לרופאים (כן, לא מפתחים) להריץ LLMs על דאטה קליני היסטורי, לבדוק פרומפטים ולמדוד ביצועים – בלי לבנות הכל מאפס?

2. הארכיטקטורה המוצעת: הכנת דאטה ב-CSV, אפליקציית ניסויים לרופאים, LLM Chain עם preprocessing → classification → postprocessing, שימוש ב-Langfuse לניהול גרסאות פרומפטים ותוצאות, ומנוע הערכה עם מדדים סטנדרטיים.

3. ויכוח מעניין על כלים: הקהילה העלתה נקודה חשובה – accuracy, recall ו-F1 לא מספיקים להערכת LLMs. הוצע להשתמש ב-GEval כשיטת הערכה איכותית, ולבדוק את DeepEval כפלטפורמה. בנוסף, נעשתה הבחנה חדה בין experiment tracking (MLflow, Weights & Biases) לבין prompt management (Langfuse) – שני צרכים שונים שדורשים כלים שונים.

4. תובנה מעשית: Langfuse לא נותן פתרון מלא ל-chains – מי שבונה pipeline הערכה רציני צריך להשלים עם כלי experiment tracking ייעודי. שווה לבנות את הארכיטקטורה מראש עם שני הכלים במקביל.

📅 הדיון המלא התחיל בתאריך: LangTalks Community 4 | 18:23 | 16.03.26

Braintrust.dev מול Langfuse: חוויות מהשטח

1. מי שמשתמש, מרוצה: חברי קהילה שעובדים עם Braintrust.dev דיווחו על שימוש נרחב: eval pipelines, הרצת ניסויים, שמירת פרומפטים ו-traces של agents מכל הסביבות, סינון לפי פרמטרים, ויצירת datasets ישירות מהפלטפורמה.

2. ההשוואה ל-Langfuse: משתמשים שהשוו ציינו ש-Braintrust מציע יותר יכולות ב-evals וביצירת datasets. השאלה שנותרה פתוחה: האם זה שווה את המחיר? מי שמתלבט – כדאי לבקש demo.

3. הרקע הרחב: בהמשך לדיון, עלו גם Inspect AI ו-DeepEval כאלטרנטיבות. DeepEval קיבל ציון חיובי על כך שהוא מבוסס pytest – מה שהופך את הפיתוח לטבעי יותר עבור מפתחים שכבר עובדים עם Claude.

📅 הדיון המלא התחיל בתאריך: LangTalks Community 3 | 18:57 | 12.03.26

נושאים נוספים שעלו

• DGX Spark + Ollama: משתמשים הריצו Ollama על NVIDIA DGX Spark עם מודלים של עד 120B פרמטרים. Claude Code בתוך Docker היה איטי מאוד (10 דקות ל-init) – ההמלצה: להריץ ישירות על השרת, ולשקול llama.cpp או vLLM לאופטימיזציה.

• Debug Skill ל-Claude Code: כלי ישראלי שמאפשר ל-Claude Code לעבוד עם debugger אמיתי במקום לזרוק print statements לכל מקום. “הייתי חולה מזה ש-Claude Code כל הזמן מזבל עם prints”.

• Data Israel: פרויקט שמחבר AI לדאטאסטים רשמיים של הלמ”ס והממשלה – במקום ש-AI ימציא מספרים, הוא שולף נתונים אמיתיים ומייצר תשובות, גרפים וטבלאות.

• Traceloop נרכשה ע”י ServiceNow: ברכות מהקהילה לצוות. אירוע מעודד לסצנת ה-AI הישראלית.

• Promptfoo (נרכשה ע”י OpenAI) מומלצת כ-vendor לפנטסטינג של פתרונות agentic.

• Cognetivy: פרויקט קוד פתוח עם שכבת זיכרון ל-agents, עדכונים שוטפים, והשוואה לפריימוורקים מתחרים.

• כלי transcription לעברית: Timeless, Fathom ו-Whisper דרך Claude Code נותנים מענה סביר להמרת שיחות עברית לטקסט.

• מדידת פרודוקטיביות מפתחים: getdx.com ו-git-ai הוזכרו ככלים למעקב אחר workflow ואיתור bottlenecks.

• Agents לציות לכללי עסקיים: דיון על שימוש ב-agents לבדיקת עמידה ב-brand guidelines – מספר חברי קהילה כבר מריצים את זה בפרודקשן.

פרק חדש בפודקאסט: AI coding metrics

“אני חייב למדוד כל פרויקט שאני מוביל. בלי דאטה קשה מאוד לשפר. אבל ב AI coding זה לא טריוויאלי. ארגונים בארץ משקיעים בכלים כמו Claude Code, Cursor, GitHub Copilot כ-300$ בחודש למפתח (תודה לDennis Nerush על הסקר בקהילה של LangTalks AI R&D Leads), ויש תחושה שדברים זזים מהר יותר, אבל אין דאטה שמוכיח את זה (והCFO שואל שאלות...).
והאמת - חלק גדול מהחברות בארץ לא מודדות אפילו DORA לפרודוקטיביות של מפתחים. גם בלי קשר ל-AI. אז לשאול איך מודדים אימפקט של סוכנים זה קפיצה גדולה.
בפרק הזה דיברנו עם Liad Elidan על הנושא“. - מתוך הפוסט של לי טוויטו.

להאזנה:

תודה שקראת!

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

הצטרפות לקבוצת הוואטסאפ

הרשמה לניוזלטר

הכנס השנתי של לנגטוקס מתקרב

• הכנס השנתי של LangTalks מתקיים ב-4 במאי. ההרשמה חינמית כרגיל: הרשמה דרך Luma.

• אפשר להגיש הצעות להרצאות דרך Sessionize (נסגר בימים הקרובים - הזדמנות אחרונה להגשה).

• 🔥 קריאה מיוחדת – Live Coding על הבמה: אנחנו מחפשים מישהו יוצא דופן שיבנה משהו אמיתי על הבמה, בלייב, מול 1,000 מהנדסים. לא מצגת, לא דמו מוכן מראש – אלא סשן בנייה חי עם סביבת AI coding שלכם. מי שמרגיש שזה בשבילו: הגשה כאן (פתוח עד השבוע הבא).

הפילוסופיה של CLI-First ועתיד האייג’נטים

• הרעיון: הדיון התחיל מפוסט שטען שכל שירות צריך להיות CLI-First. אחד המשתתפים הרחיב את הכיוון: בעתיד לא נצטרך אפליקציות בכלל – אייג’נט אישי יבנה עבורנו דשבורד מותאם אישית, יתנהל מולנו בכל ערוץ (WhatsApp, ChatGPT, וכו’), ויעשה את העבודה בלי שנצטרך לדעת לכתוב קוד. עלה גם הצורך בסטנדרט חדש שיאפשר גילוי הדרגתי של יכולות ב-CLI, בדומה למה ש-skill עושה לקבצי MD.

• אתגרי האימוץ: מנגד, הועלו ספקות רציניים לגבי קצב האימוץ בציבור הרחב. “רוב האנשים בעולם עדיין לא יודעים מה זה ChatGPT, וממש לא מה זה agents”, ציין אחד המשתתפים. גם אם לנו כמפתחים זה נשמע פשוט – “סתם לכתוב הודעה בוואטסאפ” – בפועל רוב המשתמשים עדיין לא שם. התגובה הייתה שבטווח הקצר צריך לפתח את שני הערוצים במקביל – backend קודם, ואז גם ממשק CLI וגם UI מסורתי – בדיוק כמו שתמיד עבדנו עם backend ו-frontend בנפרד. אבל הכיוון ברור: דור Alpha ודור Beta יגדלו לתוך זה.
  

  📅 הדיון המלא התחיל בתאריך: LangTalks Community | 10:36 | 20.02.26

המרת מאמרים אקדמיים מ-PDF ל-Markdown

• האתגר: חבר קהילה חיפש פתרון להמרת מאמרים אקדמיים מורכבים – כולל טבלאות, נוסחאות מתמטיות ותרשימים – מ-PDF ל-Markdown, תוך שמירה על מבנה המאמר. מדובר בתזה של כ-150 עמודים, והמטרה היא לא סתם קריאה אלא בניית קוד סביב המאמר: מימוש אלגוריתמים שמוצגים כ-pseudo-code, חיבור בין תיאורים מופשטים לשלבים טכניים, ויצירת הבנה עמוקה של כל מה שכתוב.

• הכלים שעלו: docling (שצוות אחד מתנסה בו), landingai, reducto, ו-llamaparse – כולם שירותים שמבצעים המרה ל-Markdown ממסמכים מורכבים. ההמלצה המרכזית שחזרה שוב ושוב: קודם כל להמיר את ה-PDF ל-Markdown, ורק אז להזין ל-LLM. בלי השלב הזה, המודלים מתקשים לעבד מסמכים ארוכים בצורה מדויקת.

• Claude Code עם מיליון טוקנים: אחת התגובות המעניינות הייתה ההצעה להשתמש ב-Claude Code עם חלון הקונטקסט החדש של מיליון טוקנים – מה שמאפשר “לעכל” מאמרים שלמים ולממש קוד סביבם. התברר שהגישה זמינה כבר עם מנוי Max ולא רק דרך API Key או Tier 4. חבר קהילה אחר שיתף שהוא עובד במקביל עם Cursor שמריץ Opus מתחתיו, וגם שם רואה חלון של מיליון טוקנים בקריאה אחת.

• שיתוף קוד ודגשים טכניים: שותפו לינקים לקוד עובד – ריפו ב-GitHub ו-notebook ב-Colab שמדגים את תהליך ההמרה. הוזכר גם טריק להמרה ל-Markdown לפני הקריאה לאייג’נט. נקודה חשובה: עבור מאמרים שנמצאים ב-arxiv, האתר כבר המיר הכל ל-HTML אוטומטית, כך שלא צריך להתמודד עם PDF בכלל – אבל עבור תזות ומאמרים שלא שם, הכלים האלה הכרחיים.
  

  📅 הדיון המלא התחיל בתאריך: LangTalks Community 3 | 12:25 | 19.02.26

  סקרייפינג לקבוצות פייסבוק: כלים ושיקולי אבטחה

• הצורך: חבר קהילה חיפש דרך לעשות scraping לפוסטים ותגובות בקבוצות פייסבוק סגורות (שהוא חבר בהן), לפי מילות מפתח – אולי דרך computer use + AI שרץ מקומית, בלי להיחסם.

• הכלים שהומלצו: התגובות זרמו מהר. Openclaw – אם כי עלתה הערה שהוא “לא בדיוק SOC2 מבחינת אבטחה”. vetric.io – חברה ישראלית שקיבלה המלצה חמה (”אנשים מעולים”). Nimbleway – עם הצעה להפניה אישית. ו-tavily.com – אם כי נשאלה שאלה האם הם באמת תומכים בקבוצות פייסבוק ספציפית. בנוסף שותפו לינקים ל-פוסט בלינקדאין ו-סרטון בעברית שמדגימים גישות נוספות.

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

  
  📅 הדיון המלא התחיל בתאריך: LangTalks Community | 09:47 | 04.02.26

קלוד קוד: סקילים, פלאגינים ופיתוח פיצ’רים

• שיתוף סקילים: חברי קהילה שיתפו סקילים שימושיים שהם משתמשים בהם ביומיום – סקיל לניתוח PRים ב-GitHub, סקיל לעבודה עם git worktree, ו-CLI של Atlassian. הוזכר גם פלאגין frontend-designer שקיבל שבחים על כך שהוא “באמת חזק ועושה הבדל עצום באאוטפוט ובהבנה של frontend”.

• פיתוח backend חכם: משתמש שאל על גישות לפיתוח פיצ’רים ב-backend בצורה חכמה – לא כלי ספציפי, אלא שיטות עבודה. התשובות הפנו לכלים כמו feature-dev, spec-kit ו-open spec – כלים שמאיצים את תהליך הגדרת הדרישות והפיתוח בצורה מובנית. עלה גם שהשימוש ב-plan עם מספר איטרציות חוזרות נמצא יעיל במיוחד להוספת פיצ’רים.

  
  📅 הדיון המלא התחיל בתאריך: LangTalks Community 2 | 07:57 | 19.02.26

תווים סיניים באסיסטנט בעברית: סיפור דיבוג

• הבעיה: צוות שפיתח אסיסטנט אישי בעברית על בסיס GPT נתקל בבאג מוזר – מדי פעם המודל החזיר תו סיני במקום אות עברית. ה-pipeline מורכב משני פרומפטים (הראשון מייצר JSON באנגלית, השני מוציא תוצאה בעברית), עם screenshot כקלט.

• כיווני הפתרון: הוצע להשתמש ב-logit bias – פרמטר ב-API של OpenAI שמאפשר להקטין את ההסתברות של טוקנים ספציפיים. אם יש תו סיני או שניים שחוזרים על עצמם, זה יכול לפתור את הבעיה. הוצע גם לבדוק את ה-encoding של הקלט ולשחק עם ערכי temperature ו-top_p. אבל התובנה המעניינת ביותר הייתה שבמודלים מולטימודליים (vision+text), יש לפעמים bias לכיוון צורות מורכבות כמו תווים סיניים – אולי הרכיב המולטימודלי במודל מייצר את ההטיה הזו על הפלט. הפתרון: לציין במפורש בפרומפט שהטקסט ב-screenshot הוא בעברית ובאנגלית בלבד. חבר קהילה אחר שיתף שגם ב-Claude נתקלו בתופעה דומה, ושינוי ה-temperature פתר אותה.

  
  📅 הדיון המלא התחיל בתאריך: LangTalks Community 3 | 08:03 | 22.02.26

נושאים נוספים שעלו

• Echoo.ai – אפליקציית Mac לפרומפטים inline: Echoo היא אפליקציה חינמית ל-Mac שמאפשרת לשלוח prompt לכל מודל (cloud או מקומי) ולקבל תוצאה inline, בכל מקום על ה-Mac. כבר עברה 1,000 הורדות. יש גם מדריך לקבלת API Key חינמי של Gemini.

• קוד ריוויו מולטי-מודלי נגד self-bias: עלתה שאלה האם צריך לעשות code review עם מודלים שונים (Cursor, Codex, Gemini) כשכותבים קוד עם Claude. התשובה: כן – למודל יש bias כלפי הקוד שלו עצמו, ולכן ריוויו על ידי מודל אחר נותן ערך מוסף אמיתי.

• rentahuman.ai – marketplace שבו AI שוכר בני אדם: rentahuman.ai – קונספט מפתיע שבו אייג’נטים של AI שוכרים בני אדם לביצוע משימות בעולם האמיתי. כמו שאחד החברים ניסח: “חשבנו שה-AI הוא רק כלי... מסתבר שאנחנו הכלי של ה-AI.”

• Skyll – טעינה דינמית של skills לאייג’נטים: ספריית Skyll שמאפשרת לאייג’נטים לטעון skills בצורה דינמית. חברי הקהילה התלהבו: “זה גאוני” ו-”זה העתיד”.

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

• ollama launch – פקודה חדשה להרצת Claude Code / OpenCode / Codex: פוסט שמציג את הפקודה ollama launch שמאפשרת להגדיר ולהריץ סוכני קוד בקלות.

  ---

  תודה שקראת!

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

  אפשר להעביר לחברים וחברות, ולהזמין אותם להצטרף לקהילה :)

הצטרפות לקבוצת הוואטסאפ

הרשמה לניוזלטר

הכנס השנתי של לנגטוקס מתקרב

הירשמו חינם:

https://luma.com/slude1kk?utm_source=LangTalks_newsletter

מחברת NotebookLM עם כל הפרקים של LangTalks 🤯

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

Clawdbot: העוזר האישי שרץ על המחשב שלך

1. מה זה בכלל?: Clawdbot (ששינה את שמו ל- OpenClaw, אחרי שאנתרופיק תקפו משפטית וטענו שזה נשמע יותר מדי כמו “Claude”), הוא עוזר AI אישי בקוד פתוח שרץ לגמרי על המחשב המקומי. בניגוד ל-ChatGPT או Claude שרצים בענן, Clawdbot מותקן על המכונה שלכם ומקבל גישה ישירה למערכת הקבצים, הדפדפן, המייל, היומן ואפילו מכשירי סמארט-הום. הוא לומד את ההעדפות של המשתמש לאורך זמן בזכות זיכרון מתמשך בין סשנים.

2. למה ההייפ: הפרויקט צבר מעל 100,000 כוכבים ב-GitHub תוך חודשיים. כתבות ב-bizportal וב-TheMarker סקרו אותו. מה שמייחד אותו הוא שהוא יכול ליזום פעולות בעצמו — בניגוד ל-Claude Code שמחכה לפקודה, ל-Clawdbot יש Heartbeat Engine ו-cron jobs שמאפשרים לו להתעורר, לבדוק מידע, ולשלוח לכם הודעה כשצריך. אפשר לתקשר איתו דרך WhatsApp, Discord, Slack ועוד.

3. דרישות הרצה: רץ על Mac, PC, Raspberry Pi, או שרת ענן. צריך API key של מודל שפה (כמו Anthropic או OpenAI). אין מנוי — הכל קוד פתוח, אתם מביאים את ה-key שלכם.

4. אזהרות אבטחה: בקהילה הוזהר שהתקנה על מחשב אישי מצריכה זהירות. חלק מהמשתמשים רכשו מחשב נפרד (כמו Mac Mini) או מריצים בסביבה מבודדת על AWS. יש פקודה מובנית לבדיקת אבטחה ואפשרות להגדיר whitelist, אבל הכלי מומלץ בעיקר למשתמשים טכניים.

5. אלטרנטיבה: הוצג AgentZero כאלטרנטיבה בטוחה יותר, שרץ על Docker מקומי ומאפשר חיבור למודל מקומי דרך Ollama — ללא חשיפת המחשב האישי.

📅 הדיון המלא התחיל בתאריך: LangTalks - Code Generation Agents | 14:37 | 26.01.26

Claude Code, Ollama ואפשרויות לוקליות חדשות

1. תאימות לאנתרופיק: Ollama הוסיפה תאימות ל-Anthropic API, מה שמאפשר להריץ את היכולות האייג’נטיות של Claude Code מול מודלים מקומיים. החדשות האלה עוררו התלהבות אצל חלק מהחברים בקהילה (“החדשות הכי טובות ששמעתי השבוע”), ומצד שני נתקלו בתגובה צוננת אצל חברים אחרים (“לדעתי OpenCode טוב יותר בכל מקרה”).

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

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

4. מודלים מומלצים: משתמשים חיפשו מודלים שיכולים להתקרב לביצועים של Sonnet 4.5, במיוחד להרצה ב-Ollama או RunPod. הוזכר Kimi k2.5 כמודל חזק, אך אחד שדורש חומרה מתקדמת. הובהר שאין עדיין מודל לוקאלי שמגיע לביצועים של Sonnet 4.5, במיוחד ביכולות של skills.

📅 הדיון המלא התחיל בתאריך: LangTalks - AI driven coding | 21:22 | 21.01.26

DeepAgents מול LangGraph Custom: עלות וארכיטקטורה

1. השוואת גישות: הדיון התמקד בהבדלים בין deepagents (ספריית LangChain) לבין בניית agentic workflow מותאם אישית ב-LangGraph, בעיקר בהיבטי עלות וסקייל.

2. חיסכון בעלויות: הומלץ להימנע משימוש ב-agents בכל flow, ולהפעיל agent רק כש-LLM רגיל לא פותר את הבעיה. כך ניתן לחסוך משמעותית בעלויות וב-latency.

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

📅 הדיון המלא התחיל בתאריך: LangTalks Community 2 | 18:37 | 26.01.26

🧰 נושאים נוספים שעלו

• בחירת פריימוורקים למערכות מולטי-אייג’נט: דיון ער על בחירה בין Vercel SDK, LangGraph, Google SDK ו-Agno. ההמלצה: LangGraph עדיף לתהליכים מחזוריים, LangChain ל-DAGs פשוטים.

• Cursor Plugin Marketplace: משתמשים דנו ב-marketplace החדש של Cursor ובתחושת ריבוי פיצ’רים (feature fatigue) בכלי פיתוח AI.

• העברת Agents ל-Production עם Bedrock AgentCore: פתרון של Amazon להרצת agents ב-Micro-VMs מבודדים, ניהול זיכרון קצר וארוך טווח, ושימוש ב-MCP לחיבור מאות כלים בגישת multi-agent.

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

• Claude Code על אנדרואיד: צוינו דרכים לעבוד עם Claude Code מהטלפון, דרך חיבור SSH.

שני פרקים חדשים בפודקאסט

• מה הקשר בין הזיכרון של המוח שלנו לזיכרון של ה-LLM שלנו? ד”ר מיתר זמר מתארחת ומספרת על הנוירולוגיה של המוח האנושי. להאזנה.

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

תודה שקראת!

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

אפשר להעביר לחברים וחברות, ולהזמין אותם להצטרף לקהילה :)

הצטרפות לקבוצת הוואטסאפ

הרשמה לניוזלטר

שילוב בין פלטפורמות סוכנים לפלטפורמות מודלים

1. המוטיבציה העסקית: המשתתפים דנו בפתרון שמאפשר להשתמש ב-OpenAI Agents SDK (עם יכולות של structured output, כלים, streaming, ואינטגרציה עם UI) תוך ניתוב המודלים ל-Anthropic או AWS Bedrock במקום OpenAI. המוטיבציות העיקריות: גמישות ספקים והימנעות מ-vendor lock-in, דרישות אבטחה ותאימות (ארגונים שצריכים Bedrock עם audit logs ו-compliance), אופטימיזציית עלויות, וביצועים מותאמים למשימות ספציפיות.

2. שימוש ב litellm-proxy: המשתתפים תיארו ארכיטקטורה מרובת שכבות עם OpenAI Agents SDK במצב streaming, תוך שימוש ב-litellm-proxy כ-layer מתווך בין שירות האסיסטנט לבין Bedrock ו-Anthropic.

3. בעיה קריטית בהרצת כלים: הכלים שה-agent מקבל לא פועלים כראוי כשעובדים מול Anthropic/Bedrock דרך ה-proxy, למרות שבשימוש ישיר מול OpenAI הכל עובד חלק. נמצא issue דומה ב-repo הרשמי של OpenAI Agents SDK, אך הוא סומן כ-’not planned’ ללא פתרון מהצוות.

4. זרימת נתונים ופלט JSON: הועלו שאלות טכניות לגבי streaming של structured output: האם המערכת חייבת להמתין ל-JSON שלם בכל קריאה, או שאפשר להחזיר פלט חלקי? התגובות הראו שהמערכת מעבירה את ה-JSON תו אחר תו, אך אין סטנדרט מוגדר לפינה הזו. המשתתפים ציינו שעם OpenAI ה-streaming מחזיר גם טקסט וגם props נוספים ב-JSON, אך עד שה-JSON לא שלם, הוא לא valid לשימוש.

5. פתרונות וכלים עוזרים: הומלץ להשתמש ב-partial-json-parser כדי להתמודד עם JSON לא שלם במהלך streaming - הספרייה מאפשרת parsing של JSON חלקי במקום להמתין לסיום מלא.

6. הבדלים ב-Proxy Layer: הוסבר שההסתברות הגבוהה ביותר לבעיה היא בשכבת התרגום של ה-proxy. קיימים הבדלים מהותיים בפורמט ה-JSON בין איך שה-SDK של OpenAI עובד כ-default לבין מה ש-Anthropic מצפה לקבל ומשדר. ההמלצה החד-משמעית: לא להשתמש ב-SDK של OpenAI ישירות עבור Anthropic, שדורש מבנה נוקשה ב-toolcalls, אלא להריץ דרך litellm כדי שהוא יתרגם את המבנה טוב יותר.

📅 הדיון המלא התחיל בתאריך: Code Generation Agents | 16:27 | 21.12.25

ניהול זיכרון וקונטקסט של סוכני כתיבת קוד

1. האתגר המרכזי: משתמשים העלו את הצורך לאפשר ל-agents כמו Cursor ו-Windsurf לזכור משימות קודמות, החלטות שנעשו, וקונטקסט מדיונים קודמים - מצד אחד מבלי לבזבז טוקנים וזמן על הזנת מידע שכבר עלה בעבר, ומצד שני מבלי להעמיס יותר מדי מידע על הסוכן. עלתה שאלה: האם יש פיצ’ר מסוים, או best practice מסוים, שנועד כדי לפתור את זה?

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

3. כלים ופתרונות ייעודיים: OpenSpec - פתרון קל משקל שמרכז את כל איפיון המשימה בתיקיה ייעודית; agents.md - פורמט גנרי לניהול קונטקסט באופן שיתאים לסוכנים מסוגים שונים; claude-mem - תוסף עבור Claude Code שעוקב אחר פעולות הסוכן, יוצר סיכומים סמנטיים של הקונטקסט, ומאפשר גישה לקונטקסט הזה בסשנים עתידיים, כך שהסוכן יכול לזכור החלטות קודמות, תיקוני באגים, ושינויים ארכיטקטוניים; בנוסף, צוין שהסוכן של opencode, בגרסה העדכנית שלו, מתמודד יפה בעצמו עם משימת ניהול הקונטקסט.

4. גישות ידניות ומגבלות: המשתתפים דנו בטכניקות כמו לבקש מה-LLM לכתוב סיכום שינויים לקובץ ייעודי (למשל CHANGELOG.md או CONTEXT.md) ואז להתייחס לקובץ הזה בפעם הבאה, אך עלה ספק עד כמה הסוכן באמת מתייחסת לקבצים כאלה. הרעיון של “long-term memory” - יצירת רכיב תשתיתי בו הסוכן מתחזק מסמכים ומעדכן אותם אוטומטית לפי פיצ’רים וכללים חדשים - הוזכר כאפשרות מבטיחה, אך דורש פיתוח ייעודי ולא קיים בצורה מספיק גנרית כפתרון מדף.

📅 הדיון המלא התחיל בתאריך: AI driven coding | 19:36 | 07.12.25

דפוסי שימוש של Sub-Agents

1. שימוש ב-Sub-Agent לקוד ריוויו: אחד המשתתפים יוצר כלי שמריץ קוד ריוויו על ה-branch המקומי עם קונטקסט נקי, מבלי להוסיף לקונטקסט של הסוכן הנוכחי. הוא הגדיר custom command עם הנחיה להריץ agent של Cursor דרך CLI, לאסוף את התוצאות, לעבד אותן ולהפיק תובנות. זו דרך אלגנטית לבודד אחריות ולמנוע זיהום קונטקסט.

2. אינטגרציה מותאמת של MCP: משתמש אחר הדביק בקבוצה קוד MCP מלא שמאפשר להריץ sub-agent עצמאי או כמה במקביל. הקוד כולל שני כלים: sub_agent (משימה בודדת) ו-parallel_sub_agents (מספר משימות במקביל), עם הגדרת inputSchema מפורטת, תמיכה ב-force mode לאישור אוטומטי של שינויים, בחירת מודל, וניהול משימות דרך spawn של cursor-agent עם פרמטרים מותאמים. הקוד כולל טיפול מלא ב-stdout/stderr, promise-based execution, והתמודדות טובה בשגיאות.

3. אתגרי Observability עם Sub-Agents: הועלה נושא טכני חשוב - אינטגרציה של כלי observability (כמו Langfuse) עם sub-agents. בעוד שאין תמיכה רשמית ב-Langfuse עבור Claude Agent SDK, הפתרון הוא לעטוף ב-Langfuse spans את האיוונטים שה-SDK פולט. זה דורש בניית transformer לכל סוג איוונט ש-Claude Code פולט והמרתו ל-spans. השאלה שנשארה פתוחה: האם זה יכול לעבוד גם עם Sub-Agents? זהו אתגר משמעותי כי כל sub-agent פועל באופן עצמאי, ויש צורך ליישם פתרון לא פשוט אשר מכווין את הלוגים שהם מייצרים אל מקום בו המערכת יכולה לאגד ולנטר אותם.

📅 הדיון המלא התחיל בתאריך: Code Generation Agents | 11:35 | 25.12.25

עריכת בדיקות לרכיבי UI בעזרת סוכני קוד

1. האתגר: עבודה על פרויקטים עם קומפוננטות frontend, מציאת באגים והבנה כיצד לתקן אותם, זיהוי רגרסיות בממשקים ויזואלים, וכיו”ב. למרות השימוש ב-playwright, או browsermcp, החוויה יחסית לא יציבה, איטית, ומתסכלת. עלה צורך בהגדרת best practices לבניית תשתית קוד שמאפשרת testing מהיר של features חדשים, regression tests, ואולי שימוש ב-mock generators כדי לא לבזבז טוקנים וקריאות ל-LLM.

2. BMAD לבדיקות UI: באחד הדיונים שהוזכרו בניוזלטר הקודם, BMAD צוין בתור framework מומלץ לסביבות מרובות agents עם workflow אדפטיבי. הפעם, עלה ש-BMAD הוסיף תמיכה ב-UX testing עם Playwright ושכבה נוספת לבדיקות GUI. זה מתאים במיוחד לארגונים שמחפשים פתרון מסודר לבדיקות UI בסביבת agent-based development.

3. אינטגרציה עם Chrome Devtool MCP: הוצע לחבר את מנגנון הבדיקות ל-chrome devtool MCP שיהיה אחראי על בדיקות ה-GUI – הוא יפתח דפדפן, יריץ את ה-flow, ויכול גם להקליט את כל הבדיקה ולבצע ריצה מחזורית עד השלמת התיקון. זהו פתרון מתקדם לאוטומציה מלאה של בדיקות GUI שמנצל את יכולות ה-MCP של chrome devtools.

📅 הדיון המלא התחיל בתאריך: Code Generation Agents | 13:00 | 22.12.25

🧰 נושאים נוספים שעלו

• לסמוך על ה-Guardrails של המודל או ליישם בעצמנו: דיון בין יוצרי agents על האם לסמוך על ההגנות המובנות של מודלים להגנה מפני prompt injection מזיק, או ליישם פתרונות מותאמים. המסקנה: רוב המשתתפים ממליצים לא לסמוך על guardrails של המודל בלבד, אלא ליישם הגנה גם על הקלט (למצבי early exit) וגם על הפלט. פתרון מתקדם שהוצג: agent ביניים שמבצע prompt resynthesizing (כתיבה מחדש של הבקשה).

• בניית ערוץ חדשות אוטומטי: משתמש שיתף פרויקט צד שבונה ערוץ חדשות הפועל באופן אוטומטי לחלוטין - ללא עורכים, כתבים או בני אדם בתהליך. המערכת עוקבת אחר מאות ערוצי Telegram בשפות שונות, מזהה אירועים בזמן אמת, מבצעת clustering של הודעות שמדברות על אותו נושא, ומארגנת אותן לסיפורים מתמשכים. הכל רץ על desktop מקומי עם 5 microservices ב-Docker, שתי GPUs, ומודלים לוקאליים ללא עלויות API. הפרויקט מתועד בבלוג.

• מודל OCR לעברית: dots.ocr מומלץ כמודל OCR (זיהוי טקסט בתמונות) פתוח ומתאים לעברית, במיוחד לפרויקטים שדורשים עיבוד מסמכים או תמונות בעברית.

• מקור למידה מומלץ: Hamel’s blog הוא מקור מצוין לפרקטיקות והמלצות בתחום evals (מדידה והערכה) לביצועים של אפליקציות AI.

פרק חדש בפודקאסט

והפעם: מדברים עם אלעד גרנות על נושא שהולך לככב הרבה בכותרות של 2026: Small Language Models. מתי נכון להשתמש ב-SLMs, אילו אתגרים זה פוגש, ולמה גם אם אתם “רק” בונים אפליקציות אג’נטיות, חשוב שתכירו את הכלי הזה ותדעו מתי להשתמש בו.

להאזנה.

תודה שקראת!

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

אפשר להעביר לחברים וחברות, ולהזמין אותם להצטרף לקהילה :)

הצטרפות לקבוצת הוואטסאפ

הרשמה לניוזלטר

מתודולוגיות עבודה Agent-Based

1. פירוק של Agent-Based Development: הוצגה מתודולוגיה מפורטת הכוללת ארבעה סוכנים: Spec agent (ניהול דרישות ואיפיון), Context agent (מיפוי קוד קיים ואבחון נקודות תורפה), Code agent (כתיבת קוד בסיסי מבלי לגעת בארכיטקטורה), ו-Review agent (ביצוע code review ממוקד edge cases ו-scale). צורף פוסט בנושא.

2. דיון על BMAD: עיקר הדיון סבב סביב BMAD – זהו framework לסביבות מרובות agents תוך שמירה על סטנדרטיזציה ו-workflow אדפטיבי (לפחות בגרסה 6). על פי הדוברים, BMAD מומלץ לארגונים גדולים שמעוניינים בתהליך מסודר, שמתמודד עם אתגרי ההטמעה וה-overhead הניהולי.

3. התנסות בארגונים: משתמשים בשטח שיבחו את BMAD v6 בזכות ה-adaptive workflow וסוכן ה-analyst, ועלתה המלצה ספציפית למנהלי מוצר. ל-PMs.

4. השלכות לארגונים גדולים: נשאלה השאלה על קושי באימוץ — ארגונים עם תהליכים כבדים מתמודדים עם הזזת ה’גבינה’ (התרגלות להרגלים חדשים), וצוין שמעבר כזה דורש תכנון ארוך טווח וליווי צמוד.

5. מקורות השראה לסביבת העבודה: דובר על שפע של agents שנוצרו ונוסו בהצלחה בסביבות שונות. בהקשר זה, שותף ריפו עם רשימת סוכנים מומלצים: A list of Claude Code agents.

📅 הדיון המלא התחיל בתאריך: Code Generation Agents | 18:08 | 17.11.25

ניהול גרסאות במערכות Multi-Agent

1. האתגר בפרודקשן: נשאלה שאלה מארגון שמנהל מערכת עם מעל 10 agents שמופעלים על ידי צוותים שונים – איך מתמודדים עם שינויים ב-APIs בין agents, דוקומנטציה עקבית, ו-backward compatibility בין הגרסאות של האייג’נטים השונים?

2. אסטרטגיות backward compatibility: גישה שהוצעה - agent שמתעדכן יודע מי קורא לו ומה הקורא מצפה לקבל (אם דואגים שהוא תמיד יהיה מודע לגרסה הקודמת שלו). כך, אותו agent יכול לטעון tools או prompts שונים ולהישאר תואם לאחור. האחריות מוטלת על ה-agent המשתנה, לא על הקורא.

3. השוואה למיקרוסרוויסים: האתגר דומה מאוד לעולם המיקרוסרוויסים – כשצוותים שונים מנהלים agents שונים, קשה לתאם releases או לנתב traffic לגרסה ספציפית. הוצעה גישה של schema registry (כמו ב-Kafka) שבודקת ב-CI/CD שהגרסה החדשה לא שוברת חוזים קיימים.

4. הבדל בין pipeline ל-multi-agent: הובהר שהפתרון לא מיועד ל-pipeline (שם יודעים מי קורא למי), אלא למערכת שבה כל agent יכול לדבר עם כל agent אחר – מה שמצריך גישה מתוחכמת יותר לניהול גרסאות ו-APIs.

📅 הדיון המלא התחיל בתאריך: AI driven coding | 19:46 | 24.11.25

מקרה מבחן מהשטח: סקיילינג קלוד קוד בארגון

1. ניסיון בפריסה רחבה של Claude Code: שיתפו ניסיון של חברה מסוימת לחשוף את Claude Code באופן רחב ל-300 מפתחים, תוך מזעור הצורך בידע מוקדם של כל מפתח לגבי תצורה, כלים וקונטקסט – ושימוש בסוב-אג’נטים (subagents) לאוטומציה של העברת עדכונים.

2. מפגש Zoom ייעודי ודיון על multirepo: הוצעו מפגשי Zoom פתוחים ללמידת הפרקטיקה ברמת עומק, כולל שאלות על ניהול multirepo ושילוב טכנולוגיות מגוונות (BE/FE) – הגישה דומה בין backend, shared libs ו-front.

3. שיתוף ידע ומעורבות קהילתית: הוזמנו הצעות והצטרפות לקהילת LangTalks להרחבת שיתוף הידע סביב סקיילינג של שיטות עבודה אוטומטיות וקונטקסט ארגוני.

📅 הדיון המלא התחיל בתאריך: AI driven coding | 07:16 | 20.11.25

RAG לספרים

1. שאלת הפתיחה: חבר קהילה ביקש טיפים ליישום RAG על ספרים – מה עובד, מה לא, והאם כלים כמו Google File Search יכולים לעזור כנקודת התחלה.

2. רפרנס מרכזי – פרויקט Harry Potter: הופנה לפרויקט הדגל של ניר דיאמנט, עם פוסט מפורט ב‑Medium והרצאה ביוטיוב על RAG מורכב.

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

4. אסטרטגיית Chunking רב‑שלבית: הוצעה היררכיה של embedding - סיכומי פרקים - chunks בינוניים - ציטוטים ספציפיים (high‑res), כדי לאזן בין הקשר רחב לדיוק גבוה.

📅 הדיון המלא התחיל בתאריך: LangTalks Community | 10:38 | 22.11.25

🧰 נושאים נוספים שעלו

• גרפים: כשבונים Knowledge Graph אפשר לבחור בגישה סמנטית שמייצגת ידע כעובדות ומשמעויות (RDF – Resource Description Framework) או בגישה ישומית שמייצגת ישויות וקשרים עם מאפיינים (LPG – Labeled Property Graph), והבחירה משפיעה אם הגרף נועד להבין משמעות ולבצע הסקה או פשוט לתמוך באפליקציות מהירות וסקייל.

• פתרונות Open Source לניטור: פרויקטים כמו Hud.io ושרת MCP ל-OpenTelemetry צוברים תאוצה כמענה לצורך במעקב על ביצועי agents בסביבות ייצור.

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

• מפגשי Hands-On: הקהילה מביעה רצון באירועי העמקה מעשיים בנושאי scaling, ניהול agents וכלים של observability.

תודה שקראת!

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

אפשר להעביר לחברים וחברות, ולהזמין אותם להצטרף לקהילה :)

הצטרפות לקבוצת הוואטסאפ

הרשמה לניוזלטר

תשתיות קוד פתוח לבניית Agents

1. הצורך בארכיטקטורה חזקה וחינמית: אחד החברים ביקש המלצות על פרויקט LangGraph איכותי כנקודת פתיחה. הוא הסביר שלדעתו ReAct (כולל LangGraph) לא נותן תוצאות טובות מספיק עבור agent עם MCP, בעוד ש-Claude Agent SDK מרגיש לו מגביל יתר על המידה וכל עניין ה-tool activation/deactivation עובד לא מספיק טוב, ובעלויות גבוהות.

2. המשתנים שמכריעים ביצועי agent: הביצועים כמעט אינם תלויים בפריימוורק אלא בכמות הכלים, איכות הפרומפטים, ובחירת ה-LLM המתאים. ההמלצה היא לבחון היטב את ההגדרות האלו ולבצע התאמות אינדיבידואליות. הוצגה תבנית בסיסית ל-agent מסוג LangGraph ReAct עם תמיכה ב-MCP, אך הודגש שאין פתרון one-size-fits-all. תמיד דרושה התאמה לדומיין.

3. תלות בדומיין: מניסיונם של המשתמשים, ההגדרה של “תוצאה סבירה” משתנה מאוד בין תחומים – למשל משימות קוד דורשות agent שמסוגל לארגן תכנית כרונולוגית ולבצע צעדים הדרגתיים. חשוב למצוא ארכיטקטורה שניתן להרחיב ולשפר אותה לאורך זמן.

4. המלצות נוספות – deepagents ולוגיקה מבוזרת: ניתנה המלצה חמה על deepagents של LangChain – פרויקט קוד פתוח מתקדם עם ארכיטקטורת agents גמישה ושכבת הפשטה מצוינת, שמאפשרת לבחור ולשנות רכיבים מבלי להסתבך בתשתית עצמה. אפשר לקבל ממנו הרבה השראה למימושים בארץ.

5. גישה לבניית sub-agents והפרדה דינמית של הקשר: אחד המשתתפים שיתף ארכיטקטורה מבוססת LangGraph שבה בכל node מבוצע סינון נוסף: בכל שלב מסננים מידע לא רלוונטי ורק בסוף השלב נותנים ל-agent הגמר לעבוד על סט נקי ורלוונטי בלבד. המתודולוגיה מתאימה לסביבות פרודקשן, במיוחד בפרויקטים עם מידע רב.

🗓️ הדיון המלא התחיל בתאריך: 05.11.25 | 20:05 | LangTalks Community 2

מודלים טובים לעברית + שימוש בכלים

1. שילוב עברית עם Tool Use במודלי שפה: הקבוצה בחנה אילו מודלים יודעים להתמודד היטב עם שפה עברית וגם לבצע tool calling בצורה יציבה.

2. ניסיון מהשטח: Gemini, GPT-5 וגם Sonnet: הובלטו Gemini ו-GPT-5 כמועמדים מובילים לדיאלוגים בעברית ומשימות Tool Use, לצד Sonnet במקרים מסוימים. עם זאת, הובלט שאין תשובה חד-משמעית והבחירה תלויה בפרומפט וסוג המשימה.

3. חשיבות שפת ההוראות לעומת input המשתמש: אחד המשתתפים הדגיש שההוראות למודל כתובות באנגלית ורק הקלט של המשתמש בעברית – כך שאין לראות בביצועים בעברית ערובה לטיפול טוב ב-instructions מורכבות. חשוב לבדוק היטב באיזה שלב טמונה הבעיה.

🗓️ הדיון המלא התחיל בתאריך: 31.10.25 | 15:13 | LangTalks Community 3

symlinks ונתיבי קבצים ניטרליים ב-repos צוותיים

1. ערך השימוש ב-symlink: מפתחים שונים עובדים עם מבני תיקיות שונים במחשב האישי, מה שיוצר תלות בנתיבים אישיים בתוך סקריפטים ו־config. שימוש ב-symlink מאפשר להגדיר נתיב לוגי אחיד שהסקריפטים מצביעים אליו, בעוד שכל מפתח מפנה את ה-symlink לנתיב האמיתי שלו. כך כולם שומרים על סביבת עבודה אישית — בלי לשבור את הסקריפטים ובלי להכניס נתיבים פרטיים ל-repo.

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

3. פחות תחזוקה, יותר גמישות: כשמבנה הפרויקט משתנה, או כשמפתח חדש מצטרף, אין צורך לעדכן קבצי config או לשבור סקריפטים לכולם. כל מפתח פשוט מעדכן את ה-symlink שלו פעם אחת — וזהו. הגמישות הזו מפחיתה תלות בתשתית המקומית, מגינה על ה-repo משינויים מיותרים ולמעשה יוצרת שכבת הפשטה שמייצבת את סביבת העבודה של הצוות כולו.

🗓️ הדיון המלא התחיל בתאריך: 27.10.25 | 18:56 | LangTalks - AI driven coding

סיכום מיטאפ LangTalks בנושא AI Driven SDLC

1. מדידה חכמה ו-AI Guilds כמנועי שינוי: החברות המצליחות לא מסתפקות ב-adoption rates בלבד – הן מודדות קורלציה בין טוקנים לקוד שנכנס לפרודקשן, בוחנות מי מג’נרט הרבה אבל לא ממרג’ ומנסות להבין למה. במקביל, הן מקימות AI Guild כדרך היחידה שעובדת להפצת ידע וכלים אורגנית בין צוותים (בעיקר סביב קודינג, אבל לא רק). בלי מדידה אין שיפור, ובלי גילדה אין העמקה.

2. סוכנים אוטונומיים – לא רק למפתחים: החלק המשמעותי והמפתיע הוא שאנשי מוצר, מעצבים ואנליסטים מסוגלים כיום לפתוח PRs למשימות לא מורכבות בעזרת AI agents. זו לא רק בעיה טכנולוגית אלא שינוי תרבותי שמרחיב את מעגל התורמים לקוד הפרודקשן.

3. חשיבה מחדש על SDLC – מעבר לקודינג: החברות שמצליחות לא מסתכלות רק על coding. הן מיישמות AI בכל שלבי מחזור החיים: Code Review, Design Review, כתיבת specs, ניתוח דרישות ומחקר הקוד. המסר המרכזי מהמפגש: בעתיד הלא רחוק כמעט כל הקוד ייכתב על ידי AI, אבל רק החברות שיעבדו נכון את המסלול הזה יגיעו לשם לפני המתחרים. בהשתתפות 200 מנהלי פיתוח, פאנליסטים מ-Gloat, monday.com ו-fintastic, וחסות AWS ו-Sap.Hi.

4. הצטרפות לקבוצת הוואטסאפ החדשה שלנו בנושא: כאן.

📖 נושאים נוספים שעלו 📖

• בדיקות אוטומטיות לקוד שנוצר ב-AI: הגישה המומלצת: unit tests אוטומטיים + contract tests לכל PR שנוצר על ידי agent, במקום לסמוך על code review ידני בלבד.

• אופטימיזציית עלויות טוקנים: שימוש ב-prompt caching (Claude), response streaming, ובחירה דינמית בין מודלים (Haiku לטאסקים פשוטים, Sonnet למורכבים) יכולים לחסוך עשרות אחוזים מעלויות ה-LLM.

• Security scanning לקוד AI-generated: כלים כמו Semgrep ו-Snyk יכולים לזהות בעיות אבטחה (SQL injection, XSS, secrets בקוד) שה-LLM יוצר לפני שנכנס לפרודקשן.

• Brownfield migration strategy - כשמטמיעים AI בפרויקט קיים: התחילו מ-specs ו-documentation generation, עברו לtests, ורק אז לקוד. לא להפך.

  ---

תודה שקראת!

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

אפשר להעביר לחברים וחברות, ולהזמין אותם להצטרף לקהילה :)

הצטרפות לקבוצת הוואטסאפ

הרשמה לניוזלטר

ארכיטקטורת Multi-Agent וניהול MCP Gateway

1. אתגר הארכיטקטורה: צוות תיאר מערכת עם 3 סוכנים (Master לניתוב, Data למסד נתונים, וסוכני אפליקציה), והתלבט האם להוסיף יכולות כסוכנים נפרדים או לשלב בקיימים.

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

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

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

5. כלים מומלצים לניהול: התייחסות ל-agentgateway.dev, kgateway.dev, ו-Rube מאת Composio כפתרונות לניהול הרשאות, logging והרחבה של gateways.

6. ניתוב קוגניטיבי מתקדם: לניתוב חכם שבו הסוכן הראשי מחליט על איזה sub-agent להפעיל, צוותים מתנסים בקטלוגי metadata קוגניטיביים כמו Euno ו-DBGPT.

7. אסטרטגיית הצמיחה: להתחיל פשוט עם MCPs לכל תחום, ואז להתפתח לעבר gateways חכמים לאחר שהארכיטקטורה הבסיסית יציבה ועובדת.

🗓️ הדיון המלא התחיל בתאריך: LangTalks Community 3 | 08:31 | 20.10.25

OpenSpec: כלי Spec מובנה לפרויקטים Brownfield

1. היתרון המרכזי: OpenSpec מספק פלט וזרימת עבודה מובנים ליצירת specification, מבלי לכתוב ידנית prompts שמבקשים פורמטים מסוימים.

2. פרויקטים קיימים: תוכנן במיוחד עבור brownfield projects (קודבייסים קיימים) ולא רק greenfield, מה שמבדל אותו מכלים כמו spec-kit של GitHub.

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

4. אוטומציה של תהליך: מאוטמט את הזרימה האגנטית המלאה - יצירת spec, סקירה, שינויים, ויצירת קוד, ללא צורך בפרומפטים מותאמים.

5. מגבלות Plan Mode: מצב התכנון המקורי של Claude Code מייצר פלט לא מובנה שאינו מגורסה, וצריך בקשות ידניות לפורמטים מסוימים.

6. חוויות מעורבות בקהילה: חלק מהמפתחים מדווחים שSpec-driven development עובד מצוין לחתיכות קטנות, אך יכול “להשתבש” ב-features גדולים ללא קשר לאיכות ה-spec.

7. העתיד של הכלי: OpenSpec עשוי להפוך ל-Claude Skill בעתיד, אך זרימת העבודה המובנית ו-versioning חשובים יותר מפרטי היישום.

🗓️ הדיון המלא התחיל בתאריך: LangTalks - AI Driven Coding | 18:44 | 23.10.25

Skills של Claude: תכונה חדשה מול Subagents

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

2. ההבדל מ-Subagents: ההבחנה המדויקת עדיין לא ברורה לחלוטין - Subagents בדרך כלל יש להם מופע מודל משלהם ולולאת חשיבה, בעוד Skills נראים כמו prompt templates ארוזים.

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

4. פוטנציאל הפחתת Subagents: עשוי להפחית את הצורך בארכיטקטורות subagent מותאמות עבור דפוסים נפוצים כמו code review, testing, ותיעוד.

5. שאלות פתוחות: הקהילה עדיין בוחנת האם Skills יכולים להחליף תזמור subagent מורכב או שהם כלי משלים, ומה מקרי השימוש המיטביים לכל גישה.

🗓️ הדיון המלא התחיל בתאריך: LangTalks - AI Driven Coding | 20:08 | 16.10.25

דפדפן Atlas של OpenAI: משוב ראשוני

1. השקה ראשונית: OpenAI הכריזה על Atlas, דפדפן עם יכולות סוכן מובנות, זמין כרגע ל-Mac בלבד.

2. מצב סוכן מסורבל: משתמשים מוקדמים מדווחים שה-agent mode “די מסורבל” במצבו הנוכחי, עם חוויית משתמש שדורשת שיפור.

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

4. קריאה לסטנדרטים חדשים: הקהילה מבקשת “לפתח web עבור סוכנים ולהפסיק לנתח תמונות” - צורך בפרוטוקולים ו-APIs ידידותיים לסוכנים במקום automation מבוסס ראייה.

🗓️ הדיון המלא התחיל בתאריך: LangTalks Community | 21:05 | 21.10.25

📖 נושאים נוספים שעלו 📖

• אסטרטגיות Fullstack עם Claude Code: דפוסים מתקדמים כוללים symlinks בין repos של FE/BE, אינטגרציית Playwright MCP לבדיקות חיות, והגדרת הסוכן לוודא את עבודתו בזמן אמת. תובנה מרכזית: ארכיטקטורה טובה עם conventions חזקות = תוצאות סוכן טובות יותר.

• Dynamic Reasoning ב-AI Agents: התאמת רמת החשיבה באופן דינמי לפי מורכבות המשימה - גישות כוללות classifier model קטן לניתוב, AWS Bedrock prompt router, ודפוס sub-agent של Claude SDK שמאציל למודלים שונים לפי הצורך.

• אופטימיזציית עלויות ל-Chatbots: אסטרטגיות מעשיות לסביבת production - שימוש במודלים מרובים לסוגי משימות שונות, prompt caching לתוכן חוזר, batch processing כשאפשר, ובחירת מודל לפי דרישת המשימה. לעברית: Claude Sonnet 4 נותר המומלץ.

• השוואת Gemini מול GPT ב-ReAct Agents: ג’מיני לעיתים מציג חשיבה גולמית כ-”REASON: ...” למשתמש הקצה, בניגוד ל-GPT שמטפל ב-ReAct בעקביות. קורה בעיקר אחרי 3-4 אינטראקציות. הפתרון: parsing ו-validation בצד הלקוח לפני הצגה.

• Claude Haiku 4.5: שוחרר מודל חדש עם דיווחים על הפחתת עלויות משמעותית ושיפור מהירות למשימות פשוטות יותר, זמין דרך Claude Code, Anthropic API, AWS Bedrock, ו-Vertex AI.

מיטאפ LangTalks

החלטנו לארגן את המיטאפ AI-Driven SDLC הכי מושקע שהיה בארץ.

ההרשמה נפתחה עכשיו, מספר המקומות מוגבל.

להרשמה: כאן.

פרקים חדשים בפודקאסט

החודש הוצאנו פרק חדש על Context Engineering,

ופרק נוסף על n8n (אורח: שי שטרית).

להאזנה: כאן.

תודה שקראת!

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

אפשר להעביר לחברים וחברות, ולהזמין אותם להצטרף לקהילה :)

הצטרפות לקבוצת הוואטסאפ

הרשמה לניוזלטר

ניהול Sub-Agents בקלוד קוד

1. תכנון ההיררכיה בין הסוכנים:

   דובר על ההתלבטות בין יצירת agent ראשי (supervisor/engineering manager) ב-Claude Code שמנהל את הקשר והעברת הפעולות בין sub-agents, לעומת ניהול ישיר של כל קונטקסט על-ידי הסוכן הראשי ללא היררכית ביניים. רוב המשתתפים נטו להעדיף agent ראשי יחיד, וציינו כי רק במקרים בהם דרושות הרשאות רבות או שישנן הגבלות מיוחדות, יש הצדקה להגדרת supervisor ייעודי.

2. אורקסטרציה באמצעות slash commands:

   עלתה המלצה להשתמש ב-slash commands ב-Claude (לדוגמה ‎/testingflow), כדי להריץ פלואו מוגדר מראש, בין אם עבור סוכנים מרובים או עבור שלבים מרובים של סוכן יחיד. כך ניתן לעטוף הליכים חוזרים (כמו בדיקות) ולשתף אותם כ-reusable workflows.

3. Hooks לניטור IO של sub-agents:

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

4. רעיונות לאוטומציה של בדיקות E2E:

   נשאלה שאלה אודות פיתוח צוות סוכנים שמבצע בדיקות end-to-end מלאות בעזרת AI. החברים הביעו פליאה שעדיין אין מוצר מספיק מוכר העונה על הצורך הזה, וציינו שיש מקום רב לחדשנות בשוק זה – בהיבטים של ניהול קונטקסט, תהליכים אוטומטיים על גבי ממשקי משתמש מורכבים, ויכולת סקיילינג.

5. משאבים והעמקה בפרקטיקות בניית Agents:

   שותף מאמר שמרכז עקרונות של בניית מערכות agentic עם AI. לקריאה.

🗓️ הדיון המלא התחיל בתאריך: 31.08.25 | 14:48 | LangTalks – Code Generation Agents

השוואת AI Coding Agents

1. הצגת הבעיה:
   משתתף העלה את הקושי בהשוואה אמיתית בין סוכנים שונים – לרוב ההתרשמות מבוססת על תחושה ולא על נתונים. המטרה הייתה למצוא שיטה מסודרת למדוד יכולות, אמינות ומהירות בין agents.

2. ניסיון השוואה לדוגמה:
   במהלך הדיון שותף בלוג שסקר והשווה בין סוכנים מובילים (Devin, Codex, Cursor ואחרים).

3. הצעות לפתרונות:

   • יצירת benchmark tasks אחידים (refactor, unit tests, בניית מודול).

   • שימוש במדדים כמו איכות פתרון (עם קריטריונים מוגדרים), זמן תגובה, רמת אוטונומיה.

   • המשתתפים הציעו להקים מערך מבחנים אחיד שיאפשר בחינה אובייקטיבית ועקבית.

🗓️ הדיון המלא התחיל בתאריך: 02.09.25 | 20:27 | LangTalks - AI Driven Coding

ניהול פרומפטים בעזרת BAML

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

2. משוב חיובי:
   אנשים שהתנסו בכלי המליצו עליו, במיוחד על הפלאגין ל- VS Code, שתואר על ידי אחד החברים בתור כלי ‘מציל חיים’, במיוחד עבור צוותים המנהלים במשותף תהליכים מורכבים המערבים קריאות מרובות ל-LLM. היו שהצביעו על שיפורים משמעותיים ב-structured output הניתנים להשגה באמצעות הכלי הזה.

3. אלטרנטיבות:

   לצד BAML הוצעו גם כלים דומים כמו DSPY. משתתפים מסוימים אמרו שהם בחרו דווקא לא להשתמש בכלי נפרד שכזה, כדי לא להעמיס עוד ‘שפה’ על המערכת, שעלולה לסבך תהליכי tool calling.

🗓️ הדיון המלא התחיל בתאריך: 05.09.1988 | 13:22 | LangTalks Community

📖 נושאים נוספים שעלו 📖

• פתרונות עבור inbound call agents לפרודקשן: הומלצו הכלים vapi.ai, elevenlabs, ובמיוחד pipecat, שמאפשר הרבה גמישות אבל מצריך יותר השקעה.

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

• קובץ CLAUDE.md במונורפו - עלתה בקשה לכלי שמייצר את קובץ ההנחיות של קלוד קוד באופן אוטומטי לכל תיקיה\אפליקציה במונורפו, שנענתה בהפניה ל sidekickdev.com.

מיטאפ LangTalks בנושא AI Driven Coding

נפגשים מחר!

פרק חדש בפודקאסט: Agents בסקייל

• עתיד ניהול ההרשאות בעולם שבו אייג’נטים עושים פעולות כמו בני אדם. אורח: אור וייס. להאזנה.

תודה שקראת!

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

אפשר להעביר לחברים וחברות, ולהזמין אותם להצטרף לקהילה :)

הרשמה לניוזלטר

הצטרפות לקבוצת הוואטסאפ

707 ימים.

רשמים ראשונים מ-GPT-5 והשוואות לדור הקודם

1. ביצועים מול מהירות – הפשרה הגדולה:
   משתמשים שניסו את GPT-5 דיווחו על ביצועים מרשימים במשימות Full-Stack מורכבות, כולל הבנת הקשר רחב וביצוע שינויים ב-9 קבצים במהלך אחד. המודל פתר תקלות שתקעו משתמשים ימים, אך המהירות האיטית הייתה נקודת כאב שפגעה בחוויה היומיומית.

2. איכות מול מתחרים עדכניים:
   בהשוואה ל-Claude Sonnet ו-Opus עלו תחושות מעורבות: חלק דיווחו על חוסר בהבנת קונטקסט רחב לעומת Sonnet, אחרים דווקא מצאו אותו פותר באגים ש-Opus לא פתר. הקונצנזוס: מדובר בשיפור הדרגתי, לא קפיצה דרמטית.

3. שינויים בזמינות מודלים ואימוץ הדרגתי:
   אצל חלק מהמשתמשים OpenAI השאירה רק ‎gpt-5 / gpt-5-thinking. עלתה תחושת “instruct” מוגזמת – צייתנות יתר וחוסר יוזמה לקיצור דרכים – שהשפיעה לרעה על משימות מסוימות.

4. הגדרות מתקדמות ותמיכה ב-LangChain:
   GPT-5 תומך בפרמטרים חדשים (כמו ‎verbosity ו-reasoning_effort). ההגדרה ב-LangChain דרשה עדכון גרסאות. הקהילה שיתפה קטעי קוד וטיפים לאופטימיזציה.

5. תגובות שוק וציפיות קדימה:
   למרות הייפ גבוה, GPT-5 נתפס רק כעוד צעד בסדרה. רבים ממתינים לשיפורים במהירות ובעלות לפני אימוץ מלא.

🗓️ הדיון המלא התחיל בתאריך: 30.08.25 | 19:45 | LangTalks – AI driven coding

סיווג כוונות בצ'אטבוטים

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

2. פתרונות מבוססי מודלים קטנים ויעילים
   הקהילה המליצה על modernBERT עם SetFit כסיווג כוונות יעיל וחסכוני, תוך התחשבות באורך ההקשר ובמולטימודליות. בנוסף, לטיפול במקרי התעללות הודגשה אפשרות השימוש בכלים ייעודיים כמו LlamaFirewall, במקום הסתמכות בלעדית על LLM קלאסי.

3. גישות ארכיטקטוניות חלופיות
   הוצגו אלטרנטיבות כמו Semantic Router מבוסס embeddings, ארכיטקטורה של Agent ראשי עם סוכנים משניים, וכן גישות coalition למצבים מורכבים שבהם לא ברור מראש לאיזה Agent לנתב את השיחה.

🗓️ הדיון המלא התחיל בתאריך: 25.08.25 | 11:49 | LangTalks Community 2

כלי אופטימיזציה והערכה של פרומפטים

1. כלים מובנים של ספקי מודלים:
   גם OpenAI וגם Anthropic מציעים כלים מובנים לשכתוב ואופטימיזציה של פרומפטים. הכלים אינם מחזירים ציון מספרי או פידבק ישיר, אלא מציעים ניסוחים משופרים שנחשבים best practices. כך ניתן ללמוד דפוסי ניסוח מומלצים ולשפר את איכות הפרומפטים לאורך זמן.

2. מטריקות איכות אלטרנטיביות:
   מעבר לכלים הרשמיים, מומלץ לשלב LLM נוסף בתהליך כדי לבחון ולהעריך את איכות הפרומפטים. גישה זו מאפשרת לבנות קריטריונים מותאמים-תחום (Domain-Specific), לבצע ביקורת צולבת, ולוודא שהפרומפטים אכן משרתים את מטרות הפרויקט.

3. זמינות ונגישות:
   הכלים זמינים ישירות בממשקי הפלטפורמות של הספקים (למשל, מסך Optimize Prompt ב-OpenAI או כלי האופטימיזציה של Anthropic). הם קלים לשימוש, אינם דורשים התקנה או קונפיגורציה מיוחדת, ומאפשרים למפתחים להתחיל להתנסות באופן מיידי.

🗓️ הדיון המלא התחיל בתאריך: 16.08.25 | 15:20 | LangTalks – AI driven coding

מערכות מתקדמות לחילוץ נתונים

1. אתגרי סקייל וביצועים:
   בנייה של כלי ענן שמבצע מאות ואף אלפי שאילתות דורשת תכנון זהיר של התשתית. בין הפתרונות שעלו בדיון: ‏n8n כחלופת No-Code, ‏Apify לחילוץ מובנה של נתונים, ו-Twilio או DuckDuckGo כאלטרנטיבות ל-Tavily לצורך חיפושים ברשת.

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

3. פתרונות קיימים וחלופות מעשיות:
   הומלצו כלים ושירותים כמו nimbleway.com להתמודדות עם חיפושים גדולים, ‏Perplexity API לשאילתות כלליות, ו-Google Maps Scrapers שנמצאים ב-GitHub או ב-Apify. הדגש המרכזי היה על התמודדות עם Rate Limiting, ניהול פרוקסים, ועקיפת מנגנוני Anti-Bot.

🗓️ הדיון המלא התחיל בתאריך: 16.08.25 | 15:20 | LangTalks – AI driven coding

📖 נושאים נוספים שעלו 📖

• בעיות פלט ב-Claude Code: קושי בגלילה/קריאה של פלטים ארוכים; הוצעו פתרונות כמו שמירה ל-Markdown לשיפור תיעוד וקריאות.

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

• רכיבי MCP-UI חדשים: הבדלים בין MCP-UI ל-AG-UI – סטנדרטיזציה של שכבות אינטראקציה ו“מלחמות סטנדרטים”.

• Vibe-Log – כלי מעקב חדש: גישה מוקדמת לפלאגין חינמי/קוד פתוח ל-Claude Code למעקב אחרי פרויקטי קוד ויצירת דוחות מותאמים. לינק לריפו.

מיטאפ LangTalks על AI Driven Coding

נפתחה ההרשמה למיטאפ הקרוב בנושא AI Driven Coding. מומלץ להירשם בהקדם – המקומות נתפסים במהירות.

• 🔗 להרשמה: כאן

• 📋 אג'נדה: כאן

  בנוסף, מוזמנים גם להזמין כאן סדנת LangTalks מיוחדת הממוקדת בדיוק בנושא הזה.

פרק חדש בפודקאסט: Agents בסקייל

• אדם הלל-כהן שיתף חוויות מהשטח על בניית והשקת האייג'נט האוטונומי Suna, שהגיע ל-100,000 משתמשים.

תודה שקראת!

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

אפשר להעביר לחברים וחברות, ולהזמין אותם להצטרף לקהילה :)

הרשמה לניוזלטר

הצטרפות לקבוצת הוואטסאפ

695 ימים.

פיצ’ר Sub-Agents בקלוד קוד

1. ההכרזה: שחרור Sub-Agents ב-Claude Code יצר התלהבות משמעותית. חברי הקהילה הדגישו את הפוטנציאל של הפיצ’ר הזה בשביל להזרים agentic coding טוב יותר. הפיצ’ר הזה שונה מהפונקציונליות הקודמת של Agent Tool, כי הוא מאפשר הגדרה מרוכזת יותר של ‘אופי’ ותפקיד לסוכנים שונים, עבור משימות-משנה ספציפיות, ישירות בתוך Claude Code.

2. התפתחות אחת מעבר ל-rules: אנשים השוו בין sub-agents לבין גישות מוקדמות יותר כמו קבצי ה-mdc של קרסר, או כלים אייג’נטיים מסורתיים. תואר כיצד Sub-Agents מאפשרים בידוד קונטקסט לכל משימת-משנה, ביצוע מקבילי, ושליטה עדינה ומדויקת יותר בהקצאת כלים למשימות - מה שמוביל אל מצב של פחות זיהום קונטקסט, ושיפור מידת ה-agency של תהליכי העבודה.

3. אקוסיסטם קוד פתוח ופרויקטים קשורים: הדיון התייחס לפרויקטים כמו simulatedev - שמטרתם לתעדף את פרדיגמת ה Sub-Agent על פני עבודה עם סוכנים רגילים, ואולי לכסות יוז קייסים של desktop ואורקסטרציה של multi-agent. הוזכרו גם השוואות ישירות עם פתרונות agentic אחרים כמו Kimi K2, תוך ציון היבטים של עלות ומהירות.

4. חסרונות: עלות ושימוש במשאבים - משתמשים סיפקו משוב לגבי השימוש הפוטנציאלי התלול בטוקנים. לפי דיווחים, עד פי 15 בהשוואה לעבודה עם סוכן יחיד. זה מהווה סכנה במיוחד בתרחישים של pay-as-you-go. חברי הקהילה הוזהרו שכדאי לנטר באופן מוגבר צריכת משאבים במקרים שמתנסים עם הפיצ’ר הזה, במיוחד כשנותנים לסוכנים משימות מורכבות.

5. דיווחים מהשטח: חברים שניסו את הפיצ’ר הזה ציינו גם את הצורך להתחיל session חדש בקלוד קוד כדי לגשות לפקודות חדשות (כמו agents/). חלק הביעו חששות לגבי שימוש במסגרת מינוי אישי חודשי של 20 דולר, שכנראה יגמר מהר יחסית במקרה כזה. למרות זאת, הקהילה הביעה עניין נלהב באימוץ רחב יותר ובפוטנציאל העתידי של הגישה הזו.

🗓️ הדיון המלא התחיל בתאריך: 24.07.25 | 21:15 | LangTalks - AI driven coding

לופים אינסופיים ב-LLMs

1. בעיית ה-Token Looping: חברי הקבוצה מדווחים על מקרים בפרודקשן שבהם LLMs - במיוחד Gemini 2.5 (Pro/Flash) ו-GPT-4.1 - נתקעים בחזרה על מילה או רצף תווים, כגון '\u0000' או פריטים ממוספרים כמו '1.', עשרות אלפי פעמים עד חריגה מאורך ההקשר, מה שגורם לשגיאת `finish_reason == "length"`. התוצאה היא צריכה מוגזמת של tokens וחוויית משתמש רעה.

2. הפחתה באמצעות Temperature ו-Prompt Engineering: נצפתה הפחתה מסוימת על ידי העלאת ה-temperature של המודל (מ-0 כלפי מעלה), אשר נראה מפחית את תדירות באג החזרה. דרך עקיפה נוספת ששותפה הייתה התאמת ה-system prompt (למשל, איסור מפורש על תווי unicode), אשר עזרה לעקוף את הבעיה במקרים מסוימים.

3. לא מוגבל ל-Unicode: הדיון הבהיר שהבעיה אינה בלעדית ל-unicode tokens; חזרה אינסופית יכולה לקרות עם טקסט שנראה לכאורה לא מזיק כמו פסקאות ממוספרות או סימני פיסוק חוזרים, מה שמציע בעיה בסיסית רחבה יותר ב-sampling/decoding או בנתוני אימון המודל.

4. תובנות מחקר ומגבלות במרחב הפתרונות: מאמר מחקר מספק טקסונומיה לבעיית fallback/repetition והצעות מעשיות. עם זאת, המחקר מסיק שהתנהגויות fallback הן מובנות ל-LLMs מאומנים מראש נוכחיים, כך ששינויי prompt או fallbacks פשוטים לא פותרים לחלוטין את הבעיה השורשית. הפחתות חלקיות אפשריות אך מניעה הרמטית עדיין לא ניתנת להשגה.

🗓️ הדיון המלא התחיל בתאריך: 07.07.25 | 12:13 | LangTalks Community 2

החלפת מודלים בפרודקשן

1. ניהול הוצאת מודלים משימוש והערכות: טיפול בהוצאת מודלי LLM משימוש בסביבות פרודקשן - במיוחד עם OpenAI - דורש החלפת מודלים סדירה והערכה מחדש של ביצועי המערכת, שלעתים קרובות כוללת כוונון prompt מחדש. חלק מהמהנדסים ציינו שאפשר להימנע מהתקורה הזאת דרך שימוש במודלים self-hosted.

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

3. תשתית Agents: הדיון חקר את הפשרות של שימוש ב-LangChain לתיאום agents לעומת היצמדות ל-Agents SDK הנייטיבי של OpenAI. לגמישות החלפת מודלים טהורה (למשל, מ-OpenAI ל-Gemini), מהנדסים הציעו להציג שכבת proxy - כמו litellm או כלי abstraction כמו BAML - המאפשרים תאימות API מבלי לעבוד מחדש על לוגיקת הליבה של הסוכן.

🗓️ הדיון המלא התחיל בתאריך: 20.07.25 | 16:16 | LangTalks Community

📖 נושאים נוספים שעלו

• DeepWiki נגיש ישירות דרך שכתוב URL בכל repository GitHub ציבורי לניתוח codebase מיידי, עם אינטגרציית MCP המאפשרת שאלות ותשובות וחיפוש קוד הקשרי עבור זרימות עבודה GenAI.

• שילוב MCP, SDKs ומסמכי API נותר אתגר פתוח; מהנדסים מעדיפים export פשוט ל-markdown או sync MCP לגישת agents מעשית.

• לפתרון בעיות הרשאות directory של Claude Code, משתמשים המליצו על 'add_dir' או הדגל '--add-dir' במקום שימוש ב'--dangerously-skip-permissions'.

• DSPy, Google ADT ו-Langfuse הם כלים מומלצים באופן פעיל עבור prompt engineering מבוסס API, המציעים שכבות abstraction בין כוונת המשתמש וגיבוש prompt.

• דיון על frameworks של agents למשימות אוטומציה פשוטות של LLM הדגיש את agno ו-mastra (TypeScript) כאלטרנטיבות מתפתחות כאשר CrewAI נכשל בהשלמת משימות.

• כאשר web scrapers עובדים מקומית אך לא בפלטפורמות ענן, יש לבדוק הגנות anti-bot וקונפיגורציות browser/headless מוקדם בדיבוג.

• תבניות Jinja2 ושיטות עבודה מומלצות לגרסאות prompt חלות הן בתוך codebases והן בעת שימוש בכלים כמו LangChain; יש לבחור אסטרטגיית אחסון שתתאים לזרימת העבודה ולצרכי השיתוף שלכם.

• אינטגרציית Bedrock + LangChain (שגיאת ValidationException הדורשת הודעת משתמש כתור אחרון) נותרת בעיה ידועה; דרכי עקיפה כמו role-casting של הודעות קיימות אך עלולות לגרום להתנהגויות לא צפויות.

• קצב השחרורים של LangChain ושינויים שבורים הם נקודת כאב חוזרת; practitioners ממליצים לבדוק כל שדרוג לתאימות, מכיוון שהקפדה על semver אינה עקבית.

• צוותי מוצר מומלצים לתכנן זרימות עבודה LLM עם proxies או abstraction - כמו litellm - כדי להבטיח גמישות vendor וחוסן תפעולי.

🎨 חדש: קבוצה לדיונים על AI driven coding 🔬

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

Join our group: AI Driven Coding

פרקים חדש של פודקאסט LangTalks

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

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

תודה שקראת!

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

אפשר להעביר לחברים וחברות, ולהזמין אותם להצטרף לקהילה :)

הצטרפות לקבוצת הוואטסאפ

הרשמה לניוזלטר

669 ימים.

קלוד קוד: פיצ’רים ותכונות בולטות

1. תוסף רשמי ל-VS Code: ההרחבה החדשה של Claude Code במרקטפלייס חצתה כבר ‎120 K‎ התקנות ומציעה תצוגת Diff מובנית לצד הקוד, כך שאפשר לאמת שינויים לפני Merge.

2. קונטקסט יעיל: Claude Code יכול “לבלוע” ריפו שלם (עד 200K טוקנים), קבצי לוג ענקיים או Stack-Trace מורכב בבקשה אחת. זה מאפשר ניתוח עומק ללא העתק-הדבק מתיש. כמו כן, הוא מיידע ומזהיר מראש כאשר הקונטקסט עומד להתמלא, ומאפשר לייצר סיכום של השיחה בפקודה אחת, המצמצם את הקונטקסט ומאפשר את המשך השיחה.

3. Diff-View אינטראקטיבי עם קיצורי-מקלדת: ההרחבה מוסיפה חלון השוואה מובנה בתוך VS Code; בכל פעם שמבקשים מ-Claude הצעת תיקון, התיקון מופיע בפאנל Diff וניתן לאשר או לדחות בלחיצה.

4. הגדרת Hooks: ה-Hook הוא בעצם פקודת Shell או סקריפט שמוגדר ב- .claude/settings.toml כך שירוץ אוטומטית אחרי איוונטים שונים ב-Lifecycle של Claude Code. למשל, הגדרת ESLint hook מאפשרת להריץ בדיקות סטיילינג וסינטקס ב-JavaScript מיד לאחר שה-LLM יצר קוד, וכך לחסום קוד לא תקני מוקדם ככל האפשר. מעבר לכך, Hooks נותנים שליטה ודטרמיניזם למשתמש (ולארגון) בכך שהם מבטיחים שפעולות חיוניות יבוצעו תמיד, במקום לסמוך על החלטת ה-LLM להפעיל את הפקודות.

🗓️ הדיון המלא התחיל בתאריך: 21.06.25 | 10:05 | LangTalks - AI Driven Coding

אוטומציה להנדסת פרומפטים: DSPy

1. ראשי התיבות והרעיון: DSPy (Declarative Self-improving Python) הוא פרויקט קוד-פתוח של Stanford המחליף כתיבה ידנית של פרומפטים, בכתיבת מודולים של Python. הקומפיילר של DSPy ממיר אותם אוטומטית לפרומפטים מיטביים ומכוּנָן במשפט אחד על-פי מטריקה נבחרת.

2. שיפור ביצועים מדיד: מדווחים על עלייה של 10 %–15 % בדיוק במטלות של סיווג, QA ואפילו של פתרון בעיות מתמטיקה, כאשר ה-Optimizer של DSPy מייצר מאות ניסוחי-פרומפט ובוחר את המצטיינים לפי Accuracy/F1.

3. פערים וחוסר בשלות: הודגש שחסרה תמיכה רשמית ב-async/streaming, ניהול תלויות וחוזי-פלט קשיחים ואמינים (Output Contracts), וכן חוסר אינטגרציה מובנית למסגרות agents כמו LangGraph או CrewAI – למרות קיום Roadmap בה מוזכרים כיוונים עתידיים כאלה.

4. פילוסופיית “Classic ML”: הפלואו של Compile → Fit ב-DSPy מזכיר אימון מודל ML מונחה-מטריקה: מגדירים Dataset + Metric והמערכת מטייבת את הפרומפטים. בעולם של Agents, שבו מקובל לבנות שלדי-פרומפט עשירים (Roles, Memory, Tools), יורד הערך של אופטימיזציה עיוורת (אופטימיזציה ללא מספיק ידע על הקונטקסט המנטלי או הלוגי) – פער משמעותי שעלה בדיון, ומביא איתו בין השאר סיכון ל over-fitting.

5. שאלות פתוחות: במקרים ליניאריים וברורים, DSPy חוסך שעות של שיוף פרומפטים ומאפשר קפיצה בביצועים, אך הקהילה עדיין מצביעה על חוסרים כמו:
   • תמיכה ב-multi turn agents.
   • מנגנון JSON-Schema Validator להבטחת contract adherence בזמן ריצה.
   • כלי A/B-Testing ו-latency metrics למדידת שיפור אמיתי בפרודקשן.

🗓️ הדיון המלא התחיל בתאריך: 27.06.25 | 14:30 | LangTalks Community 2

עיבוד מקבילי ב-LangGraph: ניסיונות ופתרונות

1. רקע: הוצגה התבנית map-reduce ב-LangGraph כדרך טובה לפרק מסמך גדול, לעבד ענפים במקביל ואחר-כך לאחד את התוצאות – מה שמאפשר האצה משמעותית של פייפליינים כבדים.

2. אתגר: כאשר מקביליות מוגדרת רק דרך Nodes, יש מקרים שבהם הענפים רצים בטור. שימוש בכלים (tools) או הגבלת semaphores נחשב אמינים יותר.

3. Send: הפקודה Send מוגדרת כ-Trigger הרשמי לפיצול עומסים – היא מאפשרת שליחת הודעה זהה לכמה Nodes ומאפשרת איחוד תוצאות בסיום, בצורה טבעית ל-LangGraph.

4. Rate-Limit: הוצע לעטוף כל שלוחת Send ב-Semaphore פנימי כדי למנוע חריגות ממגבלת הבקשות של ספק ה-LLM – פתרון שזכה לתמיכה.

🗓️ הדיון המלא התחיל בתאריך: 24.06.25 | 17:59 | LangTalks - Code Generation Agents

ניהול מגבלות טוקנים

1. פער הערכה: tiktoken מדייק כשמדובר בטקסט פשוט בלבד. הודעות עם function calls או תמונות עלולות לחצות את ה - Context Window ולגרום לשגיאות לא צפויות.

2. ניטור דינמי: כיוון שאין ספרייה אחידה לכל סוג הודעה, מפתחים משתמשים ב-Logging של ‎usage.total_tokens‎ ובונים בעזרתו בסיס-ידע אמפירי לצריכת API באופן דינמי, שמכוונן בזמן ריצה את תהליך ההגבלה והניהול של מגבלות הטוקנים.

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

🗓️ הדיון המלא התחיל בתאריך: 02.07.25 | 08:45 | קהילת LangTalks Community 2

📖 נושאים נוספים שעלו

• Aider: עוזר Pair-Programming מבוסס LLM בקוד פתוח, תומך ב-100+ שפות תכנות.
• OpenEvolve: פרויקט קוד פתוח לבניית סוכנים וזרימות עבודה אדפטיביות.
• חולשת אבטחה ב-MCP: אחד החברים בקהילה זיהה פרצת אבטחה משמעותית ב-MCP Inspector של אנתרופיק.

🎨 חדש: קבוצה לדיונים על AI driven coding 🔬

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

Join our group: AI Driven Coding

🤖 פורסם הריפו של Software Engineering Agents 🛠️

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

פרק חדש של LangTalks

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

תודה שקראת!

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

אפשר להעביר לחברים וחברות, ולהזמין אותם להצטרף לקהילה :)

הצטרפות לקבוצת הוואטסאפ

הרשמה לניוזלטר

648 ימים.

בניה ואימות של Remote MCP Servers

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

2. ארכיטקטורת Remote MCP Server והעלאה לענן: בניית שרת MCP שמקבל בקשות מ־agent במחשב האישי ושולח אותן לענן לעיבוד. Cloudflare שימשה דוגמא מובילה בזכות תיעוד מפורט ודוגמאות קוד מלאות (server ו-client) ב-GitHub, כך שאפשר לפרוס תוך דקות ב-edge network שלהם. חלופות כגון Google Cloud Run מאפשרות פריסה מהירה של קונטיינרים בענן, בלי צורך בהגדרות רשת מורכבות, ולעיתים מסתכמות ב-10 דקות עבודה.

3. אסטרטגיות Authentication ואינטגרציה עם OAuth 2.1: שימוש ב-OAuth 2.1 כדי לוודא שרק סוכנים מורשים יוכלו לשלוח ולקבל נתונים. הנפקת וביטול bearer tokens ו-IAM tokens בעלי תוקף מוגדר מראש (time-bound), למניעת שימוש זדוני ב-tokens. האתגר העיקרי הוא לנהל חידוש tokens בשוטף (refresh) מבלי לשבש חיבור קיים.

4. שיקולי Security ו-Fallbacks: בגרסאות הראשונות של MCP נדרשו מימושים מותאמים אישית לניהול IAM tokens קצרים. בגרסאות האחרונות נוספו מנגנוני fallback עם bearer tokens פשוטים יותר, כדי לשמור על המשכיות בעבודה גם אם נכשלה אימות ה-IAM.

🗓️ תאריך: 02.06.25 | ⏰ שעה: 18:46 | 🏠 קבוצה: LangTalks Community

בנייה ושיפור של כלי MCP עבור Cursor ו-Claude Code

1. מימוש Human-in-the-Loop MCP: מאפשר לסוכן להשעות פעולה ולהציג חלון התערבות למפתח כשיש חוסר וודאות. אם אין תגובה בתוך 90 שניות, התהליך ממשיך אוטומטית — כך משמרים שילוב אוטומציה ופיקוח אנושי. קישור למימוש.

2. אינטגרציה של Brave MCP ו-Context7: בעזרת Brave MCP אפשר לקבל יכולת חיפוש אונליין בזמן אמת, כדי לספק לסוכנים את המידע הכי עדכני. Context7 מאפשר להזריק לסוכן תיעוד וספריות קיימות, בלי לצאת מסביבת הקוד.

3. MCP Sampling: מדובר באחת האופרציות שפרוטוקול MCP מאפשר built-in. שרת MCP יכול לשלוח קריאת mcp_sampling, כולל פרמטרים מגוונים שה-MCP client מכיר כחלק מהפרוטוקול, וכך לבקש מספר דגימות שונות לאאוטפוט (samples) ממודל השפה. השרת אוסף את התשובות, מעבד, ויכול להשתמש בהן כחלק מתרחיש עבודה מורכב של מספר סוכנים, או כחלק ממימוש של human-in-the-loop.

📅 תאריך: 02.06.25 | ⏰ שעה: 10:03 🏠 קבוצה: LangTalks – AI driven coding

Cursor לעומת אלטרנטיבות

1. מודלי תימחור: קרסר מציע מנוי קבוע של 20 $ לחודש, עם חיתוך (chunking) כדי לשלוח רק את חלקי ההקשר הרלוונטיים. Cline גובה תשלום על פי מספר ה-tokens שמעובדים, מה שעלול לדרוש מעקב קפדני כדי למנוע עלויות גבוהות.

2. ניהול קונטקסט: קרסר תומך ב-workspaces וב-multi-repo, ומציע agent modes עם חוקים מותאמים אישית (Cursor Rules). Claude Code לעומתו זאת מבוסס על תכנון מובנה ופקודות כמו /code-review, עם אפשרויות וידוא (validation) מובנות.

3. שילובי כלים: מפתחים משלבים Claude Code לתכנון ראשוני, Cursor למימוש ו-memory banks לשימור הקונטקסט לאורך זמן. כלים נוספים כמו Roo ו-Cline מצטיינים בשיחות שדורשות long-context ושימור זיכרון בעבודות גדולות.

📅 תאריך: 03.06.25 | ⏰ שעה: 14:16 🏠 קבוצה: LangTalks - Code Generation Agents

בעיות בפרומפטים של אנתרופיק

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

2. בעיות טכניות: הפרומפטים של אנתרופיק משתמשים בכלים שמוכנסים hard-coded במקום להשתמש בפרוטוקולים מתקדמים כמו A2A או MCP שמאפשרים ניהול דינמי של הכלים. זה אומר שהמערכת פחות גמישה ופחות יכולה להתאים עצמה למצבים שונים.

3. לקחים מעשיים למפתחים: מהניתוח עלה שמפתחי מערכות אייג'נטיות צריכים לשמור על פשטות ולא להסתבך יותר מדי. גם נמצא שהשימוש בתגי XML (כמו <כותרת>) בפרומפטים עוזר מאוד לקריאות ולמעקב אחר החלקים השונים, במיוחד כשהפרומפטים ארוכים.

📅 תאריך: 17.06.25 | ⏰ שעה: 10:30 | 🏠 קבוצה: LangTalks Community

ניהול הרשאות ושיתוף מידע בין אייג'נטים

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

2. פרוטוקול A2A: ההמלצה המרכזית הייתה שימוש בפרוטוקול A2A (Agent-to-Agent Communication) המיועד בדיוק לשיתוף מידע מבוקר בין אייג'נטים. הפרוטוקול מאפשר הגדרת הרשאות מדויקות ברמת הנתונים, ניהול זהויות של אייג'נטים, ושליטה גרנולרית על סוגי המידע שכל אייג'נט יכול לקבל או לשתף.

3. תשתית אסינכרונית למערכות מורכבות: כפתרון משלים הוצע שילוב של Kafka או פתרון message broker דומה לניהול תקשורת אסינכרונית בין האייג'נטים. הגישה הזו מתאימה לטבע הפיתוח האסינכרוני של מערכות אייג'נטים מודרניות, מאפשרת ניהול תורים יעיל, עיבוד מבוזר, ושמירה על ביצועים גבוהים גם במערכות עם עומסים גבוהים.

📅 תאריך: 10.6.25 | ⏰ שעה: 17:17 | 🏠 קבוצה: LangTalks Community

📖 נושאים נוספים שעלו 📖

• מדריך מקיף לבניית אייג'נטי AI: חבר בקהילה פרסם בגיטהאב ריפו עם 24 מדריכים מפורטים לבניית אייג'נטים ברמה מקצועית, המכסה 11 תחומים שונים מניהול זכרון ועד אבטחה, והגיע לכמעט 1,000 כוכבים ביום אחד. קישור לריפו.

• קלאודפלר כתבה ספריה נטו עם קלוד: החברה פרסמה ספריית OAuth 2.1 שנכתבה כמעט לגמרי על ידי קלוד, ותיעדה את כל תהליך הפיתוח דרך הודעות קומיט מפורטות.

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

• פרק חדש של פודקאסט LangTalks! והפעם, עם שחר כרמל שמדבר על פיתוח מונחה AI, הידוע בשמו "Vibe Coding". קישור לפרק.

תודה שקראת!

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

אפשר להעביר לחברים וחברות, ולהזמין אותם להצטרף לקהילה :)

הצטרפות לקבוצת הוואטסאפ

הרשמה לניוזלטר

624 ימים.

ראג מבוסס אייג’נטים

1. Agentic RAG: צוותים הולכים וזונחים את ה-chunk-retrieval הישן ועוברים ל-multi agent pipeline שבו סוכן chat מפצל משימות ל-retrieval ול-doc-reader ייעודיים. השיטה משדרגת דיוק ומפחיתה צורך בשינויים בקוד בכל פיצ’ר חדש.

2. Whole Docs: דווח על מקרה בו כ-90% מהשאילתות בפרודקשן נפתרות ע״י הזרמת whole documents שנבחרו עם metadata filters, ורק אם זה נופל רז עוברים ל-vector similarity. הגישה מקצרת זמני תגובה וגם חוסכת כסף בענן.

3. Planning & Reasoning: אחרי ששלב ה-retrieval כבר “כמעט מושלם”, צוואר-הבקבוק עובר ל-planning ול-multi-hop reasoning. כלים כמו open-agent-platform מקבלים אהבה כי הם מפשטים את הבניה ואת הדיבאגינג של פלואו מורכב.

4. Observability: חלוקה לשכבות של סוכנים משפרת תחקור ומבודדת תקלות, כך שאפשר לראות בדיוק איפה זה נשבר לפני שהלקוח שם לב. רוב האצבעות מופנות לשכבת ה-vector DB בכל פעם שצועקים “RAG is dead”.

5. Q-A DBs: עלו גם רעיונות לפלואים אלטרנטיבים כמו Q-A databases או answer-search agents שמדלגים לגמרי על embeddings ומחפשים תשובה מוכנה במסמכים. זה זהב כשיש לכם FAQ ענק וכל שאלה כבר נענתה בעבר.

🗓️ תאריך: 29.05.2025 | ⏰ שעה: 08:01 | 🏠 קבוצה: LangTalks Community 2

ניהול פרומפטים בסקייל גבוה

1. Repo vs Gateway: כשיש רק כמה prompts משאירים אותם בריפו, אבל ברגע שהכמות מתפוצצת מקימים LLM-gateway שמחזיק גרסאות ל-prompts ול-templates. זה פותח אפשרות למעצבים ולעורכי-תוכן לערוך טקסט בלי לחכות לדיפלוי.

2. Langfuse vs LangSmith: מחלקים מחמאות ל-Langfuse על UI ו-tracing חלק, בזמן ש-LangSmith נתפס יציב אך קצת כבד. מי שרוצה לחסוך דולרים ב-SaaS בונה פתרון קליל בעצמו ומרוויח גמישות מלאה.

3. Hot-Fixes: ה-gateway מונע clashes בין קוד ל-prompt ומאפשר לכל צוות לבצע hot-fix לטקסטים תוך דקות. זה חוסך ים תסכול בסבבי on-call ומחזיר שליטה לאנשי product.

📅 תאריך: 19.05.2025 | ⏰ שעה: 08:02 🏠 קבוצה: LangTalks Community 2

סוכני קוד א-סינכרונים

1. Jules: כלי חינמי של Google, בשם Jules, מצטרף ל-OpenAI ול-Microsoft, ומאותת ש-async code agents הם ה-next big thing. הקהילה מחכה לבנצ׳מרקים רשמיים כדי לראות מי באמת מוביל במרוץ.

2. openevolve: כולם מרגישים צורך ב-fan-out/merge tool, ולכן צץ הריפו openevolve שמפזר משימה לכמה agents וממזג תוצאות אוטומטית. זה פתרון זמין וזריז עד שהספקים השונים יציעו פתרונות דומה בצורה יותר מובנית.

3. Real-Tasks: חברי הקהילה לא מסתפקים בבנצ׳מרקים יבשים—הם מריצים את הסוכנים על פרויקטים אמיתיים: למשל, אחד המשתתפים תיאר איך Jules הקים MCP server ב-Python, פיצל 23 קבצים, שלח Pull-Request אוטומטי ועבר 78 % מהטסטים כבר בריצה הראשונה; משתתף אחר נתן ל-openevolve להמיר מודול React ישן ל-TypeScript ולייצר מעל 400 unit-tests תוך מספר שעות.

📅 תאריך: 21.05.2025 | ⏰ שעה: 08:32 🏠 קבוצה: LangTalks - Code Generation Agents

אכיפת Structured Output

1. Key-Loss Bug: שמו לב ש-GPT-4o ו-Claude לפעמים מדלגים על keys חשובים ב-JSON ומשאירים אובייקט חצי ריק. התופעה קופצת ישר ב-QA ומכאיבה בפרודקשן, במיוחד בטפסים רגולטוריים.

2. Schema Enforcement: הגישה הפופולרית היא לעבוד עם OpenAI JSON schema או Claude XML tags ולעטוף ב-pydantic validation. נראה שזה באמת מצמצם תקלות ונותן ביטחון לצוותי הפיתוח.

3. json_mode: הומלץ להפעיל schema רק כשבאמת צריך, בדומה ל-function-calling; עם LangGraph אפשר להשתמש ב-json_mode לקבל אותו אפקט בלי קונפיג כבד. זה מחזיק את הקוד נקי.

📅 תאריך: 25.05.2025 | ⏰ שעה: 11:55 | 🏠 קבוצה: LangTalks Community 2

📖 נושאים נוספים שעלו 📖

• דילמות OCR: עלה ש- Mistral OCR זול ומהיר אבל מפזר פסקאות, Docupanda מדויק ויקר, Tesseract עדיין מלך בסריקות קשות, ו-Document AI של Google מתבלבל בטבלאות—בחרו כלי לפי סוג המסמך, לא לפי הייפ.

• פריצת-דרך ב-Formal Proofs: מחקר Neuro-Symbolic חדש שילב verifier עם analogy retrieval והקפיץ דיוק של formal-proofs פי ארבע; יש ריפו פתוח לשחק איתו בסופ״ש.

• פערי Tracing: מפתחים מחפשים דוגמאות חיות לחיבור Langfuse ו-LangGraph ומגלים חור בתיעוד—תזכורת לכמה קריטי observability כשעוברים לארכיטקטורת סוכנים.

• פרק חדש של פודקאסט LangTalks! איך לבחור את הסטאק הנכון לפיתוח סוכנים. קישור לפרק.

תודה שקראת!

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

אפשר להעביר לחברים וחברות, ולהזמין אותם להצטרף לקהילה :)

הצטרפות לקבוצת הוואטסאפ

הרשמה לניוזלטר

607 ימים.