דלגו לתוכן
גיליון 001·חי·20:20 IL
→ יומן/2026-10-30·10 דק׳

Factory Droid 1.0: קריאת כלים פרוגרמטית, משמעת prompt cache, וטענות ה-benchmark שצריך לקרוא בזהירות

הפוסט של Factory מ-29 באוקטובר על Droid 1.0 אומר שכלי Script נותן למודל להריץ מאות קריאות כלים בבקשה אחת. מה הוא אומר על קריאת כלים פרוגרמטית, בקשות ידידותיות ל-cache, אוטונומיה מוגבלת, ומספרי ה-benchmark של הספק שהוא לא נותן לכם לשחזר.

מאת Harel Asaf·בונה בינה מלאכותית·תל אביב

Factory פרסמה את "Droid 1.0: Building a Frontier Harness" ב-29 באוקטובר. הפוסט הוא כתיבה הנדסית של ספק, והחלק הכי שמיש הוא לא ה-leaderboard. זה העיצוב: לתת למודל לכתוב תוכנית שקוראת לכלים, לשמור את הבקשה append-only כך שה-prompt cache נשאר חם, ולשים כללי זיהוי-תקיעה בלולאה במקום במודל.

קראתי את כל הפוסט. לא קראתי את עמוד המתודולוגיה שהוא מקשר, לא הרצתי את Droid, ולא בדקתי אף benchmark. כל מספר למטה הוא של Factory, מהבדיקות שלה, ו-Factory מוכרת את המוצר.

מה Factory טוענת בראש

  • Droid הוא ה-agent harness של Factory, "everything around the model: the prompts, the tools, how tool results come back, and the loop that runs it all".
  • "On the same tasks, Droid outperforms the native harnesses built for their models up to 20% more efficiently."
  • ב-Terminal-Bench 4 עם GPT-6.1 Sol, Droid מקבל 3.5 נקודות יותר מ-Codex בעלות נמוכה ב-12%, ו-6.6 עד 12.6 נקודות יותר מ-OpenCode ו-Devin. עם Claude Opus 5.5, הוא מקבל 3.0 עד 7.6 נקודות יותר מ-Cursor, OpenCode, Devin ו-Claude Code, בעלות נמוכה עד 24%.
  • הפוסט מציין ש-Cursor לא מוצג עבור מודלי OpenAI כי אין לו גישה אליהם.
  • ב-Claude Opus 5.5, Droid לוקח 26% פחות זמן לכל משימה שעברה מ-Claude Code ומשתמש ב-17% פחות tokens. ב-GPT-6.1 Sol, הוא משתמש ב-12% פחות tokens מ-Codex תוך שהוא לוקח 10% יותר זמן.

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

קריאת כלים פרוגרמטית

בלולאה סטנדרטית, המודל קורא לכלים ישירות וכל פלט מצורף להקשר שלו. עם programmatic tool calling (PTC), לפי הפוסט, הסוכן כותב תוכנית שמפעילה את הכלים, ואז מריץ אותה מקצה לקצה בהפעלה אחת. Factory עשתה את זה ברירת המחדל ב-Droid 1.0 משלוש סיבות מוצהרות: חלון הקשר נקי יותר, פחות בקשות מודל, ולולאות ובדיקות אמינות יותר כי הן רצות דטרמיניסטית בקוד.

הפוסט נותן קרדיט לעבודה מוקדמת: CodeAct (Wang ועמיתיו, 2024) על פעולה דרך קוד, ואומר ש-Cloudflare ו-Anthropic הביאו את הרעיון לייצור בסוף 2025 וש-Codex הביא אותו לסוכני קוד השנה. לא בדקתי את הטענות האלה.

איך Droid עושה את זה. כלי Script שבו המודל כותב JavaScript שרץ ב-sandbox בלי גישת קבצים, רשת או מערכת משלו. לפי הפוסט:

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

המספרים של Factory על זה:

  • סשן לדוגמה, תיקון unit test נכשל עם GPT-6.1 Sol: קריאות ישירות לקחו 10 קריאות מודל ו-56.8 שניות, גרסת ה-Script 5 קריאות מודל ו-41.6 שניות, עבור אותן 15 קריאות כלים.
  • מצב Script חותך את עלות Droid ב-15% על Claude Opus 5.5. הפוסט אומר שרוב ה-Scripts קטנים, והחיסכון מתרכז ב-12.5% שעושים שש קריאות כלים ומעלה.
  • שני Scripts מהסשנים של Factory עצמה: ניקוי Linear שהזיז 151 issues (312 קריאות כלים) לקח 2 בקשות מודל ובערך 61,000 tokens, מול הערכה של 36 בקשות ובערך 3.1M input tokens עם קריאות ישירות. סריקת CI של 5,384 jobs לקחה 2 בקשות במקום הערכה של 59 עד 187.

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

מצב Script דולק כברירת מחדל לרשימת מודלים, כולל GPT-6.1 Sol, GPT-6.1 Terra, Claude Opus 5.5 ו-Kimi K3, לפי הפוסט.

בחירות עיצוב שהפוסט מפרט

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

משמעת prompt cache

ספקים שומרים בקשות ב-cache לפי קידומת, אז כל שינוי מוקדם מבטל את כל מה שאחריו. לפי הפוסט, הבקשות של Droid היו כבר append-only חוץ מגילוי כלים, כי הגדרות הכלים יושבות קרוב לראש. Droid עכשיו מצרף כלים שהתגלו לאחרונה לסוף הבקשה.

Factory מדווחת: בייצור הבקשה הטיפוסית קוראת 98% מה-input שלה מה-cache, ו-98.6% מהבקשות הן append-only מוחלט. מוניטור משווה כל בקשה לקודמת ומזכיר מה שבר את ה-cache. מספרי הבדיקה שלה לחלק מהבקשה הבאה שנקרא מה-cache: 99.1% אחרי שינוי git status, 99.8% אחרי rollback של סשן, 96.5% עם סוכן-משנה שני מאותו סוג, ו-100% אחרי טעינת כלי חדש בבדיקת לפני-ואחרי על Azure.

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

פרומפט בסיס קטן יותר

Factory אומרת שהבקשה הראשונה הצטמצמה מ-20,887 input tokens ל-13,055, הפחתה של 37%, בין Droid 0.170.0 ל-0.250.0. רוב זה בא מכלים: 11 הגדרות כלים שנשלחו מראש הפכו ל-2, עם כלים בשימוש נדיר שנטענים לפי דרישה. הפוסט אומר ששני השחרורים רצו על מודלים שונים, אז ה-tokenizers שונים, ונותן גם ספירת תווים (57,035 ל-36,802, ירידה של 35%). פרומפט המערכת עצמו גדל ב-31%.

אוטונומיה מוגבלת

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

  • בזרמי Anthropic מנוהלים של Factory, 4 דקות של שקט נחשבות זרם שנשמט ומנסים שוב.
  • תגובה שפוגעת במגבלת זמן קשיחה מקבלת לכל היותר שני נסיונות.
  • שלושה תורים ברצף בלי פלט נראה, ו-Droid עוצר. שלוש קריאות כלים זהות מקבלות דחיפה, ושש עוצרות את הלולאה. חזרות שמחזירות תוצאות חדשות, כמו polling על build, יכולות להמשיך.
  • סיכומי compaction מקבלים עכשיו מקום ל-16,000 tokens, עלייה מ-8,000, כי לפי הערכת Factory שליש או יותר מילאו את המגבלה הישנה.

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

ה-Agent Factory

Factory מתארת לולאה פנימית שבה סוכנים לומדים כשלי benchmark וחיכוך משתמשים, מציעים שינויים עם היפותזה מוצהרת, ובודקים כל אחד על כל מודל מושפע, ושבה מהנדסים סוקרים את הראיות ומחליטים מה משתקע. היא אומרת שאוטומציה עוקבת אחרי יותר מ-20 מודלים. דוגמה אחת שהיא נותנת חותכת לשני הכיוונים: מיספור כל שורה של קבצים שנקראו חתך את עלות Opus ב-22% על משימה אחת אבל העלה עלות ב-8% על GLM וב-32% על Kimi, אז זה שותקע כאפשרות שהמודל מבקש.

מספרי מהירות

זמן חציוני ל-first paint ירד מ-1,839 ל-488 ms וזמן לפרומפט ראשון מ-1,876 ל-618 ms בין שחרורי 25 באוגוסט ו-20 באוקטובר, לפי הפוסט. זמן יציאה חציוני בייצור ירד מ-648 ל-30 ms, וסשנים חולקים תהליך daemon בכ-20 MB כל אחד במקום כ-350 MB לתהליך.

מה הפוסט לא אומר לכם

  • מתודולוגיית ה-benchmark. הפוסט מקשר עמוד שלא קראתי.
  • איך harnesses של מתחרים קונפגו, ואם כל אחד קיבל את אותו מאמץ כוונון.
  • שום תוצאה מגורם בלתי תלוי.
  • כמה Droid עולה. הפוסט נותן עלות יחסית, לא מחיר.
  • מקרי כשל למצב Script, כמו תוכניות גרועות שמריצות הרבה קריאות שגויות. ל-sandbox אין גישת קבצים, רשת או מערכת, אבל קריאות כלים בתוכו עדיין יכולות לפעול.

מה הייתי בודק

אלה הצעות שלא בדקתי.

1. לבדוק את הלולאה שלכם לשבירות cache. לרשום אם משהו בבקשה שלכם משתנה לפני הסוף בין תורים.

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

3. להחליט מה תוכנית רשאית לעשות בלי סקירה. Script שמריץ מאות קריאות יכול גם להריץ מאות קריאות שגויות. לחשוב על אישור לכלים הרסניים.

4. להוסיף מגבלות ברמת הלולאה. קריאות זהות חוזרות ותורים שקטים זולים לספירה.

5. לקרוא את עמוד המתודולוגיה לפני שאתם משתמשים בפערי ה-benchmark בהחלטה.

6. להריץ משימות משלכם. הפרש של 3 עד 7 נקודות על benchmark אחד עלול לא להופיע על הקוד שלכם.

מה לא הייתי מסיק

  • ש-Droid הוא ה-harness הטוב ביותר. ההשוואות הן של Factory, ועל מודל אחד הוא היה איטי יותר ממתחרה לפי המספרים שלה.
  • ש-PTC תמיד זול יותר. הפוסט אומר שהחיסכון מתרכז במיעוט של Scripts, ובסיסי הקריאות-הישירות שלו הם הערכות.
  • ששיעור קריאת cache של 98% תקף לעומס העבודה שלכם.
  • ש-Script ב-sandbox בטוח. ה-sandbox מגביל את התוכנית, לא את הכלים שהיא קוראת להם.

שאלות נפוצות

מהי קריאת כלים פרוגרמטית?

לפי Factory, הסוכן כותב תוכנית שמפעילה את הכלים ומריץ אותה בהפעלה אחת, במקום לקרוא לכל כלי בתור מודל נפרד.

אילו מודלים משתמשים במצב Script כברירת מחדל?

הפוסט מפרט GPT-6.1 Sol, GPT-6.1 Terra, GPT-6 Astra, GPT-6 Sol, GPT-5.6 Sol, Claude Fable 5.1, Claude Fable 5, Claude Opus 5.5, Claude Opus 5 ו-Kimi K3.

כמה מצב Script חוסך?

Factory אומרת 15% מהעלות על Claude Opus 5.5, עם חיסכון מרוכז ב-Scripts שעושים שש קריאות כלים ומעלה.

מה append-only אומר לבקשה?

תוכן חדש הולך לסוף, כך שהספק יכול לנצל מחדש את הקידומת ב-cache. Factory אומרת ש-98.6% מבקשות הייצור שלה הן append-only מוחלט.

איך Droid עוצר סוכן תקוע?

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

האם תוצאות ה-benchmark בלתי תלויות?

לא. הן מהבדיקות של Factory עצמה. לא קראתי את עמוד המתודולוגיה.

האם Droid קוד פתוח?

לא ראיתי את זה בפוסט. בדקו את האתר של Factory.

מקורות

כולם נקראו ב-30 באוקטובר 2026.

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

קריאה נוספת

יומן הבנייה

לעקוב אחרי העבודה.

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

עקבו ב-RSS