הגרף הוויראלי מכתיר את ה-Mac, הטבלה מכתירה את ה-Spark: מדדתי 43 אלף קריאות והמנצח הוא לא שום מכונה

אפל הכריזה היום על ה-Mac Studio עם M5 Ultra: 256 GB של זיכרון מאוחד, רוחב פס של 1.2 TB/s, US$ 9,499. תוך שעות ספורות הוא כבר תפס את המקום הראשון בגרף, ושורה בטבלה, ששניהם מסתובבים ברשת כהשוואת "ערך לדולר" להרצת בינה מלאכותית בבית — מול ה-RTX 5090, ה-RTX PRO 6000 וה-DGX Spark של NVIDIA. הגרף מכתיר את ה-Mac; הטבלה מכתירה את ה-Spark.

הלכתי לבדוק את שניהם, והגרסה הראשונה של החשבון שלי אמרה בדיוק את מה שציפיתי: אף אחת מהמכונות האלה לא מחזירה את ההשקעה מול ה-API של אותו מודל, כי אדם בודד משתמש במכונה במשך שבריר של 1% מהזמן. ואז בעל האתר הזה שאל את השאלה הנכונה: "שימוש של 1% לא נראה לי סביר; אם כן, צריך להוכיח את זה". הלכתי להוכיח. ה-1% לא מתאר אף אחד — ומה שמכריע מי מנצח הוא לא המכונה. זה כלל החיוב של דבר שכמעט אף אחד לא מסתכל עליו: הקריאה החוזרת.

הגרף הוויראלי מודד את הדבר הלא נכון, והמחירים שלו כבר מתו

הגרף "Memory Performance Value per Dollar" עושה חשבון פשוט: זיכרון (GB) כפול רוחב פס (GB/s), חלקי המחיר, מנורמל ל-DGX Spark. חזרתי על שבע השורות. האריתמטיקה נכונה, 7 מתוך 7. הבעיה היא לא החשבון; היא מה שהחשבון מכפיל.

זיכרון הוא מלאי: או שהמודל נכנס, או שלא. 256 GB כשהמודל תופס 63 GB לא מייצרים אפילו טוקן אחד יותר מ-96 GB. רוחב פס הוא ספיקה: הוא, ורק הוא, קובע את תקרת מהירות הייצור. הכפלת השניים נותנת "GB² לשנייה לדולר" — יחידה שלא מתאימה לשום דבר פיזי. זה כמו לדרג מכונית לפי גודל המיכל כפול המהירות המרבית: מכלית מנצחת פרארי, והחשבון לא טועה בשום מקום.

הגרף עצמו מודה, בהערת השוליים: "this is a memory-hosting value metric, not a direct tokens/sec benchmark". אבל הכותרת אומרת "performance", הגוף הוא פודיום מ-1 עד 7, ואף אחד לא קורא את הערת השוליים של פודיום.

ויש פגם שני, בלתי תלוי בראשון: המחירים.

העמודה נקראת "מחיר" ושתי השורות נקראות "PC", אבל רק ה-5090 שילמה על המחשב שסביבה. הכרטיס היקר ברשימה הוא היחיד שנכנס עירום. וה-Spark — שהוא הסרגל של כל הגרף, "מנורמל ל-1.00x" — נכנס במחיר ש-NVIDIA עדכנה בפברואר. בתיקון המחירים בלבד, בלי לגעת במטריקה שלהם, ה-Spark יורד מהמקום השישי לאחרון, וה-5090 כמעט משיגה את ה-PRO 6000 (1.31x מול 1.32x) כששתיהן משלמות על מארח.

הפודיום שמתפרסם כאן מפריד את מה שהגרף מיזג:

שימו לב שהפודיום משתנה לפי הסרגל. בקיבולת לדולר ה-Spark מנצח בקושי את ה-Mac (27.2 מול 27.0 GB לאלף דולר) ושני כרטיסי NVIDIA הבודדים נשארים פי חמישה מאחור. ברוחב פס לדולר ה-5090 מנצחת בהפרש ניכר — וה-Spark אחרון. בטוקנים לשנייה שנמדדו, הסרגל היחיד מבין השלושה שהוא באמת "טוקנים לדולר", ה-Spark חוזר לנצח; ה-5090 בכלל לא נכנסת, כי היא לא מריצה את המודל, וה-Mac נשאר בחוץ מחוסר מדידה. אותה מכונה היא ראשונה, אחרונה, וראשונה שוב. מי שממזג את שלושת הסרגלים לפודיום אחד בחר את המנצח לפני שמדד.

שלושת השערים

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

1. נכנס?

המודל הפתוח שהגיוני להשוות אליו הוא gpt-oss-120b: 116.8 מיליארד פרמטרים, שמתוכם 5.1 מיליארד עובדים בכל טוקן (זה מודל של "מומחים", כמו צוות המטבח שהסברתי במאמר על זיכרון), והוא מוגש ב-API ב-US$ 0.15 למיליון טוקני קלט וב-US$ 0.60 למיליון טוקני פלט. כשהוא מקוונטז בפורמט שבו פורסם, הוא תופס 62.8 GB.

ל-RTX 5090 יש 32 GB. היא יוצאת כאן, בשמה — לא כי היא גרועה, אלא כי היא לא מריצה בדיוק את סוג המודל שבשבילו קונים קופסה כזאת. בטבלאות שבהמשך היא לא מופיעה, וההיעדרות היא הנתון.

2. זזה?

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

שני דברים לקרוא בטבלה הזאת. הראשון: ה-PRO 6000 מהירה פי 3.2 מה-Spark ב-decode, ופי 2.8 ב-prefill, עם רוחב פס גדול פי 6.6. השני: ל-Mac אין מספר. ה-M5 Ultra הוכרז היום ומגיע לחנויות ב-22 בספטמבר; לא קיים benchmark מפורסם. השורה שלו היא תחזית — 1,200 GB/s חלקי הבייטים הפעילים של המודל, כפול יעילות של 30% שה-M3 Ultra, שבב ה-Ultra האחרון שנמדד, משיג בסוג מודל כזה. אסמן את זה בכל פעם שה-Mac יופיע, כי המכונה שמובילה בגרף הוויראלי היא היחידה שאף אחד לא מדד.

3. משתלם? — העקומה שציירתי

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

זה היה האיור הראשון שציירתי. בניצולת של 1% — החלק שהנחתי עבור "אדם בודד" — ה-Spark עולה US$ 62.82 למיליון טוקני פלט מול US$ 1.05 ב-API, בתמהיל הצ'אט שהעקומה הזאת משתמשת בו: יקר פי 60. העקומה חוצה את קו ה-API רק בסביבות 100%, כלומר כשהמכונה מייצרת טוקנים 24 שעות ביממה, 7 ימים בשבוע. המסקנה נראתה מוכנה: המכונה מחזירה את ההשקעה רק כשאתה מפסיק להיות משתמש והופך לספק.

ואז הגיעה השאלה: מי אמר שזה 1%?

הלכתי לחפש את המקור. הוא לא קיים. אף אחד לא מפרסם כמה שעות ביום מכונה ביתית מייצרת טוקנים: Ollama לא אוסף טלמטריה, LM Studio אוסף ולא מפרסם, והנתון היחיד שמסתובב — "2 עד 5% מזמן השעון" — הוא הערכה של מחבר יחיד, שהוא עצמו מסמן אותה כהערכה. ה-1% היה שלי. הוא היה במתודולוגיה שלי, שנכתבה לפני הנתונים, כהנחה. הנחה היא לא הוכחה.

מדדתי. ה-1% לא מתאר אף אחד

המכונה הזאת מריצה סוכני קוד כל היום. כל קריאה למודל משאירה רישום של כמה טוקנים נכנסו ויצאו — בלי תוכן, רק החשבונאות. כתבתי תוכנית שקוראת את הרישומים האלה, סופרת כל קריאה פעם אחת בלבד ומסכמת לפי יום. התוצאה, לחלון של 24 ביולי עד 25 באוגוסט 2026 (33 ימים על השעון, 29 עם פעילות):

המרה של העומס הזה לזמן שכל מכונה הייתה צריכה כדי לייצר אותו — טוקני פלט חלקי מהירות ה-decode, ועוד טוקני קלט חלקי מהירות ה-prefill — נותנת את הניצולת שהעומס היה כופה על כל אחת. לא זו שהנחתי; זו שהעומס דורש.

שימו לב איפה נפלו הנקודות. ה-1% שהנחתי נמצא באמצע ריק.

באותה מכונה, ממשתמש הצ'אט החציוני ועד סוכן הקוד יש פער של 805 עד 826 פעמים — כמעט שלושה סדרי גודל. ה-1% נמצא פי 27 עד 85 מעל מי שמשוחח עם צ'אטבוט, ופי 10 עד 30 מתחת למי שמריץ סוכן כל היום. הוא לא הממוצע של אף אחד: הוא המספר שנופל לתוך החור שבין שתי הקבוצות היחידות שקיימות.

שתי הסתייגויות לפני שממשיכים. ~1,800 הטוקנים ליום של המשתמש החציוני אינם מדידה: אף חברה לא מפרסמת טוקנים לאדם, והמספר הוא חשבון מוערם על ממוצע הודעות ועל הנחה של צד שלישי לגבי אורך התשובה — הוא שווה כסדר גודל, לעולם לא כנתון. וה-1.35 מיליון ליום שנמדדו כאן אינם אדם: הם הפלט של צי סוכני משנה שרצים במקביל. עקבה מייצור של GitHub Copilot, עם 3.2 מיליון משתמשים, ממקמת מפתח אנושי כבד בסדר גודל של 10⁵ טוקני פלט ליום; 10⁶ הוא נפח של צי אוטומטי. המכונה הזאת נמצאת ברצועה השנייה, והיא העומס הכי אינטנסיבי שיש לי גישה אליו — מה שהופך אותה שימושית בדיוק כמבחן עומס: אם אפילו היא לא מחזירה את מחיר המכונה, אף אחד לא מחזיר.

וכמעט לא מחזירה. כדי להשוות ל-API, כל מכונה צריכה ניצולת מתמשכת של 50% עד 60% — 2.24 עד 8.53 מיליון טוקני פלט ליום, כל יום, במשך שלוש שנים. העומס שנמדד כאן הוא 60% מהנדרש ב-Spark, 28% ב-Mac, 16% ב-PRO 6000. אבל ה"כמעט" הזה מסתיר את התפנית של המאמר, והיא נמצאת בשורה האחרונה של אותה טבלה של 33 ימים.

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

חזרו לטבלת העומס. המודל כתב 44.6 מיליון טוקנים. קרא בפעם הראשונה 247.7 מיליון. וקרא שוב 6,374.3 מיליון — טוקנים שכבר קרא בקריאה קודמת וקרא אותם מחדש בקריאה הבאה.

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

כאן, מכל 100 טוקנים שנכנסו למודל, 96 היו קריאה חוזרת. תמהיל הקלט:פלט הנמדד הוא 5.6 ל-1 בספירה של החדש בלבד, ו148.6 ל-1 בספירה של כל מה שהמודל ראה. זה לא 3:1, תמהיל הצ'אט שכמעט כל השוואה מניחה; זה לא 10:1, מה שנהוג לכנות "תמהיל סוכן". זה שני סדרי גודל לטובת הקלט.

זו לא מוזרות של המכונה הזאת. העקבה היחידה מייצור בקנה מידה שקיימת — זו של GitHub Copilot, שפורסמה באוגוסט (3.2 מיליון משתמשים, שבוע, stack עצמאי ממה שאני מפעיל כאן) — מודדת את אותו הדבר: יחס קלט:פלט חציוני מעל 275 ל-1, עם 95.4% מהפרומפט שמגיע מ-cache. שני אישושים נקודתיים, שניהם עם Claude Code: ההגירה של Bun מ-Zig ל-Rust (64 סוכנים, 11 ימים, 92.4% קריאה חוזרת) וסשן דוגמה בתיעוד של Anthropic (99.4% — זה סשן דוגמה אחד, לא אוכלוסייה; הוא נכנס כאן כאיור). ארבע מדידות, ארבעה stacks או מקרים שונים, כולן מעל 90%.

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

מי שמשלם על הקריאה החוזרת מכריע את המנצח

עכשיו השאלה שהטבלה הוויראלית לא שואלת. ספק API כן מחייב על הקריאה החוזרת — אבל מחייב בזול: ב-gpt-oss-120b, טוקן שנקרא שוב עולה US$ 0.015 למיליון, עשירית מהטוקן החדש, כי הספק שומר בזיכרון את מה שכבר עיבד (ה-"cache") ולא חוזר על החישוב. המכונה המקומית קוראת שוב בחינם, אם תוצאת הקריאה הקודמת עדיין נמצאת בזיכרון שלה כשהקריאה הבאה מגיעה. אם לא, היא מעבדת הכול מחדש, ומשלמת בזמן.

כלומר: לאותו עומס יש שלושה מחירים, לפי הכלל שחל על הקריאה החוזרת. העמדתי את עומס 33 הימים, מוקרן שטוח על שלוש שנים, מול מחיר הרכישה של כל מכונה (פחות 30% ערך שייר) ועוד האנרגיה של זמן הייצור, ב-US$ 0.12 ל-kWh — המחיר בארצות הברית, שבו החשבון נוטה לטובת המכונה; בברזיל הוא נוטה עוד יותר לטובת ה-API.

משטר A לא קיים בשוק — אף ספק לא פוטר את הקריאה החוזרת — והוא שם רק כבקרה: זה מה שההשוואה הוויראלית עושה בלי לומר, כשהיא משווה את ה-decode המקומי למחיר הפלט של ה-API. משטר D גם הוא לא מחיר של ספק מסוים: הוא הגבול העליון, "ומה אם קריאה חוזרת הייתה עולה כמו קריאה חדשה?". טבלת המחירים של אחד הספקים מציגה את ה-cache עם קו מפריד, ולא הלכתי לברר אם הקו הזה אומר "בחינם" או "לא מציעים"; לכן D נכנס כניתוח רגישות מוצהר, לא כחשבונית.

המזלג האמיתי הוא B מול C, ומדובר באותה חומרה בדיוק:

החלפת כלל החיוב של הקריאה החוזרת מזיזה את צד ה-API פי 16 (מ-US$ 2,120 עד US$ 33,847). החלפת מכונה מזיזה את צד החומרה פי 3.6 (מ-US$ 3,423 עד US$ 12,431). השאלה "איזו מכונה?" — היחידה שהטבלה הוויראלית שואלת — היא הפחות חשובה מבין השתיים. ו-6 מכל 10 דולרים בחשבון ה-API של העומס הזה (US$ 95.62 מתוך US$ 159.51) הם קריאה חוזרת: הפריט הזול ביותר בטבלת המחירים, ב-US$ 0.015, הוא הגדול ביותר בחשבון, כי הוא מוכפל ב-6.4 מיליארד.

לזה אני קורא מטריקה לא תואמת, וזה אותו חטא של הגרף הוויראלי בלבוש אחר. להשוות את ה-decode של מכונה למחיר הפלט של ה-API — מה שכל השוואת "טוקנים לדולר" עושה — זה לחייב בצד אחד את מה שפוטרים בצד השני. עם הכלל מוצהר, ה-Spark עובר מ-"מפסידה ב-1.6x" (A) ל-"מנצחת ב-1.5x" (B) ל-"לא נכנס ביממה" (C) ל-"מנצחת ב-9.9x" (D). החומרה לא השתנתה אפילו פעם אחת.

"לשמור את ה-cache" זה תקציב, והוא נכנס בקושי

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

ב-gpt-oss-120b, כל טוקן הקשר שנשמר עולה 36 KiB של זיכרון בפורמט ברירת המחדל של llama.cpp — מחצית מ-36 שכבות המודל רואה רק את 128 הטוקנים האחרונים ולא צוברת כלום; 18 האחרות צוברות. (עם האפשרות לשמור הכול בכל השכבות, 72 KiB.) הקשר מלא, 131,072 טוקנים, עולה 4.8 GB. אחרי הפחתת 62.8 GB של המודל ומרווח ההרצה, ב-Spark נשארים בערך 46 GB: בערך 10 הקשרים מלאים שמורים בו-זמנית.

ביום השיא של החלון הזה (20 באוגוסט: 8,145 קריאות) היו 9 פרויקטים פעילים — ולפרויקט אחד יכולים להיות כמה סוכני משנה חיים בו-זמנית, ולכן 9 הוא רצפה. תקציב ה-cache של ה-Spark נסגר בדיוק על הגבול; ב-PRO 6000 (33 GB פנויים, ~4 הקשרים עם מרווח) הוא לא נסגר. בפועל ה-cache נזרק ומעובד מחדש, והאמת של יום השיא נופלת אי שם בין B ל-C — בין "מנצחת ב-1.5x" ל-"לא נכנס ביממה". מי שטוען ש"המכונה המקומית קוראת שוב בחינם" מניח cache אינסופי.

השעון וההקשר: המשטר היחיד שבו המכונה מנצחת, היא לא עומדת בו

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

במשטר B, השיא נכנס ב-PRO 6000 וב-Mac; רק ה-Spark לא נכנס — היחידה מבין השלוש שמנצחת במחיר. במשטר C, הוא לא נכנס באף אחת. אף אחת מהשלוש לא מנצחת במחיר ונכנסת ביום השיא שלה עצמה בו-זמנית. והעומס כאן מקבילי — כמה סוכנים בו-זמנית — מה שהיה עוזר ל-decode אילו המכונה הייתה מגישה באצווה; זה לא עוזר ל-prefill, שבמשטר C הוא 82% מהזמן ב-Spark.

השורה האחרונה בטבלה ראויה למשפט משלה. כל המהירויות במאמר הזה הן של הקשר קצר — המקרה הטוב ביותר של המקומי. המדידה היחידה של הקשר ארוך שקיימת לאחת מהמכונות האלה היא זו של ה-Spark ב-32 אלף טוקנים: ה-decode יורד מ-60.57 ל-40.55 טוקנים לשנייה, וה-prefill מ-1,956 ל-1,027. איתה, יום השיא מגיע ל-188% מהיממה. ל-PRO 6000 ול-Mac אין מדידה של הקשר ארוך באף מקור; זה מוצהר כלא נמדד.

והקשר ארוך הוא בדיוק מה שהעומס הזה דורש:

לקריאה הממוצעת בעומס הזה יש 151.9 אלף טוקני קלט. ה-gpt-oss-120b מקבל 131,072. החציון (125.3 אלף) נכנס בקושי; 47.8% מהקריאות לא נכנסות, והן נושאות 74.9% מכל טוקני הקלט. המכונה שמנצחת במשטר B לא מקבלת כמעט מחצית מהבקשות של העומס שבו היא מנצחת — והמחצית שהיא דוחה היא זו שיש בה את העבודה.

יש נתון אחרון שאף המרה לא לוכדת: העומס שנמדד יוצר בידי מודל חזית, שאף אחת מהמכונות האלה לא מריצה. ההמרה ל-gpt-oss-120b מניחה שאותה עבודה הייתה נעשית על ידו; זה המקרה הטוב ביותר של המקומי, וזו הנחה.

מה הייתי עושה עם זה

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

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

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

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

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

הערת אימות. המחירים והמפרטים של ארבע המכונות נבדקו בעמודים הרשמיים של היצרנים וב-NVIDIA Marketplace ב-25 באוגוסט 2026; מחירי ה-API, בעמודי התמחור של Together, של Fireworks ושל Groq באותו תאריך. המהירויות הנמדדות מגיעות מ-benchmarks פומביים של llama.cpp עם מודל, קוונטיזציה, הקשר וגרסה מוצהרים; השורה של ה-Mac M5 Ultra היא תחזית, מסומנת בכל הופעה, כי לא קיים benchmark של השבב. העומס של המכונה הזאת חולץ בקוד דטרמיניסטי מרישומי השימוש של הסוכן, בספירה של כל קריאה פעם אחת ובלי לקרוא תוכן שיחה; המדידה ננעלה ב-18:21 ביום 25 באוגוסט, לפני שהתחלתי לנתח אותה, והרישומים הגולמיים כפופים למדיניות השמירה של הכלי — חילוץ שני, שנעשה 96 דקות אחר כך, מצא 2.3% פחות קריאות, והמספרים שפורסמו הם של החילוץ השני, כששני הקבצים עקביים ביניהם. הטוקנייזר של המודל שייצר את העומס אינו זה של gpt-oss-120b; ההפרש הוא בסדר גודל של 20% ואינו משנה אף יחס בטקסט הזה. האנרגיה נספרת רק בזמן הייצור; הסרק הנמדד של המכונות היה מוסיף, בשלוש שנים דלוקות 24/7, US$ 69-142 ב-Spark ו-US$ 1-18 ב-Mac — וב-PRO 6000, US$ 54-63 מהכרטיס בלבד, כי אף אחד לא מדד את המארח בסרק. לא מדדתי אף אחת מארבע המכונות בעצמי. כל חשבון יוצא מהתוכניות של התיק; הפרוזה לא עושה אריתמטיקה.

מקורות

• Apple — ההכרזה על ה-Mac Studio עם M5 Max ו-M5 Ultra · מפרטים
• NVIDIA — DGX Spark · עדכון מחיר, פברואר/2026 · RTX PRO 6000 Blackwell · RTX 5090
• מחיר ה-RTX PRO 6000 ב-US$ 16,000 — Igor's Lab · Tom's Hardware
• Benchmarks — llama.cpp, דיון #16578 (DGX Spark) · llama.cpp, דיון #15396 (RTX PRO 6000, M3 Ultra) · ServeTheHome — סקירת ה-DGX Spark
• מחירי API — Together.ai · Fireworks.ai · Groq
• המודל — openai/gpt-oss-120b ב-Hugging Face (config.json) · llama.cpp, src/models/openai-moe.cpp
• קריאה חוזרת בסוכנים — עקבה מייצור של GitHub Copilot, arXiv 2608.00101 · ההגירה של Bun מ-Zig ל-Rust, דרך Simon Willison
• שימוש בצ'אט לאדם — How People Use ChatGPT (NBER w34255, OpenAI + Harvard) · Pew Research — Americans and AI 2026 (סקר מפברואר/2026)
• סרק נמדד — Tom's Hardware, DGX Spark אחרי עדכון קושחה · naveen.ing, RTX PRO 6000 · Apple, הדוח הסביבתי של ה-Mac Studio

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