למה אסימוני פלט ב-Claude יקרים פי 5 מאסימוני קלט?

מדוע אסימוני פלט יקרים יותר מאסימוני קלט

עלות אסימוני פלט (output tokens) גבוהה פי 5 מעלות אסימוני קלט (input tokens) בכל דגמי Claude בקטלוג הנוכחי. הסיבה לכך נעוצה במבנה החישוב. קריאת הנחיה (prompt) היא מעבר יחיד על המודל. כתיבת תשובה היא מעבר אחד לכל אסימון, כאשר כל מעבר חייב להמתין לסיומו של זה שקדם לו.

יחס זה זהה בכל שורות המחירון, לכן בחירת המודל אינה משנה את החלק של אסימוני הפלט בחשבונית שלכם. אופי עומס העבודה שלכם הוא שקובע זאת. שלב של סוכן (agent) הקורא 60,000 אסימונים ומשיב ב-800 אסימונים כמעט אינו צורך משאבים על פלט. משימת כתיבה הקוראת 2,000 אסימונים וכותבת 12,000 אסימונים כמעט אינה צורכת משאבים על קלט. שני המקרים מחושבים להלן לפי התעריפים שפרסמה Anthropic באוגוסט 2026.

שלב ה-Prefill מתבצע פעם אחת, שלב ה-Decoding מתבצע פעם אחת לכל טוקן

שרת הסקה (inference server) מטפל בבקשה בשני שלבים בעלי עלויות שונות בתכלית. שלב ה-Prefill קורא את ה-prompt. שלב ה-Decoding כותב את התשובה.

שלב ה-Prefill מעבד את כל ה-prompt בבת אחת. כל טוקן ב-prompt נכנס לרשת באותו forward pass, כך שהעבודה על ה-attention וה-feed-forward הופכת למספר קטן של כפל מטריצות גדול המכסה אלפי טוקנים בכל פעם. קריאה אחת של משקולות המודל מהזיכרון משרתת את כל ה-prompt. יחידות המטריצה של המאיץ נשארות עמוסות, מה שאומר ש-Prefill מוגבל על ידי כוח חישוב (compute-bound): המגבלה היא המהירות שבה השבב מסוגל לבצע כפל.

שלב ה-Decoding אינו יכול לעבוד כך, כיוון שטוקן 2 תלוי בטוקן 1. הטוקן שהמודל הרגע הפיק הופך לחלק מהקלט לשלב הבא, ולכן השלבים אינם יכולים לרוץ במקביל. כל טוקן פלט מקבל forward pass משלו, וכל אחד מהמעברים הללו קורא את מלוא סט משקולות המודל מזיכרון בעל רוחב פס גבוה (HBM) כדי להפיק טוקן בודד. עובדה זו הופכת את ה-Decoding למוגבל על ידי זיכרון (memory-bound): המגבלה היא המהירות שבה ניתן להעביר משקולות, ולא המהירות שבה ניתן להכפיל אותן. אותה תעבורת משקולות שצרכה prompt שלם במהלך ה-Prefill, קונה לכם טוקן אחד בלבד במהלך ה-Decoding.

מערכות הגשה (serving systems) נלחמות בזה באמצעות batching. בקשות רבות עוברות Decoding יחד, כך שקריאה אחת של המשקולות מפיקה טוקן אחד עבור כל בקשה ב-batch. זו הסיבה ש-Decoding הוא בכלל בר-השגה. התקרה היא שוב הזיכרון. כל בקשה פעילה מחזיקה KV cache (מטמון מפתח/ערך, מצב ה-attention שנשמר עבור כל טוקן עד כה); מטמון זה גדל עם כל טוקן שנוצר, וכאשר הוא ממלא את המאיץ, ה-batch אינו יכול לגדול עוד.

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

מדדו בעצמכם את הפער בין הקלט לפלט

התקינו את הכלים על כל מכונת Ubuntu:

sudo apt update && sudo apt install -y curl jq moreutils

כעת, הזרימו (stream) הנחיה קצרה המבקשת תשובה ארוכה, וציינו בכל שורה את הזמן שבו היא הגיעה.

curl -sN https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{"model":"claude-sonnet-5","max_tokens":1000,"stream":true,
       "messages":[{"role":"user","content":"Count from 1 to 300, one number per line."}]}' \
  | ts -s '%.s'

ts -s מוסיף לכל שורה את מספר השניות שחלפו מאז תחילת הפקודה. יש שני דברים שכדאי להסיק מהפלט הזה. השורה הראשונה של content_block_delta היא הזמן עד לקבלת ה־token הראשון, וכל שלב ה־prefill התרחש בתוכה. כל שורה לאחר מכן היא צעד קטן של פענוח (decoding), והחותמות ממשיכות לעלות עד ש־message_stop מגיע.

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

curl -sN https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d "$(jq -n --rawfile doc ./long-document.txt \
       '{model:"claude-sonnet-5", max_tokens:16, stream:true,
         messages:[{role:"user", content:("Answer in one word. Is this document about networking?\n\n" + $doc)}]}')" \
  | ts -s '%.s'

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

כל תגובה שאינה מוזרמת (non-streaming) מסתיימת במספרים שלפיהם אתם מחויבים בתשלום.

{
  "usage": {
    "input_tokens": 41283,
    "output_tokens": 6,
    "cache_creation_input_tokens": 0,
    "cache_read_input_tokens": 0
  }
}

תעדו את כל ארבעת השדות עבור כל בקשה. output_tokens כולל חשיבה מורחבת, לכן מודל שחושב לפני שהוא עונה מחייב על החשיבה הזו לפי תעריף הפלט. כדי לתמחר הנחיה לפני השליחה, POST /v1/messages/count_tokens מקבל את אותו גוף בקשה, מחזיר את {"input_tokens": N} מבלי להריץ את המודל, והוא ללא עלות. זהו אינו החלק היחיד ב־API שאינו עולה דבר, וכדאי לבדוק אילו חלקים ב־Claude API אינם מחויבים בתשלום לעולם לפני שמתקצבים פרויקט ראשון.

עלויות השימוש ב-Claude למיליון טוקנים נכון לאוגוסט 2026

[
  {
    "label": "Haiku 4.5",
    "input_usd": 1,
    "output_usd": 5,
    "output_multiple": 5
  },
  {
    "label": "Sonnet 5 (to 31 Aug)",
    "input_usd": 2,
    "output_usd": 10,
    "output_multiple": 5
  },
  {
    "label": "Sonnet 5 (from 1 Sep)",
    "input_usd": 3,
    "output_usd": 15,
    "output_multiple": 5
  },
  {
    "label": "Opus 5",
    "input_usd": 5,
    "output_usd": 25,
    "output_multiple": 5
  },
  {
    "label": "Fable 5",
    "input_usd": 10,
    "output_usd": 50,
    "output_multiple": 5
  }
]

העמודה האחרונה מציגה את יחס הפלט לקלט, והערך בה הוא 5 בכל שורה. עבור Haiku 4.5, התעריף הוא $1 לקלט ו-$5 לפלט. עבור Opus 5, התעריף הוא $5 ו-$25. המודל היקר ביותר, Fable 5, מתומחר ב-$10 לקלט ו-$50 לפלט, ומומלץ לקרוא מה מקבלים בתמורה לתעריפי Fable 5 לפני שמבטלים את השורה הראשונה. מעבר בין דגמים בטווח מכפיל את שני הצדדים באותו גורם, כך שהעלות הכוללת משתנה אך היחס בין הקלט לפלט נשאר זהה.

המודל Sonnet 5 מופיע פעמיים כיוון שתעריף ההשקה שלו עומד לפוג. עד ה-31 באוגוסט 2026, התעריף הוא $2 לקלט ו-$10 לפלט. החל מה-1 בספטמבר 2026 יחול התעריף הסטנדרטי של $3 לקלט ו-$15 לפלט, המהווה עלייה של 50% בשני הצדדים. כל הדוגמאות המחושבות להלן משתמשות בתעריפי אוגוסט.

התעריפים משתנים, ודף זה אינו המקום לבדוק אותם. claude.com/pricing הוא המקור הרשמי והעדכני. מה שנותר קבוע גם לאחר שינויי מחירים הוא שיטת החישוב.

סייג אחד אינו מופיע במחירון. התיעוד של Anthropic מציין כי Claude 4.7 ודגמים מאוחרים יותר משתמשים ב-tokenizer חדש, המייצר כ-30% יותר טוקנים עבור אותו טקסט בהשוואה ל-tokenizer של Sonnet 4.6 ודגמים קודמים. השוואת מחירים למיליון טוקנים בלבד עשויה להציג את המודל החדש כמשתלם יותר באופן מטעה, שכן אותו מסמך מתורגם ליותר טוקנים במודל זה. בצעו השוואה לפי עלות למשימה מוגמרת, ובדקו את ה-prompts האמיתיים שלכם מול המודל שבו אתם מתכננים להשתמש בפועל. המאמר מה שווה מיליון טוקנים של Claude בטקסט אמיתי מפרט כיצד נפח זה נראה בפועל.

מתי הופכת העלות של פלט למרכיב הדומיננטי בחשבונית שלך?

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

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

[
  {
    "label": "100:1",
    "input_share_pct": 95.2,
    "output_share_pct": 4.8
  },
  {
    "label": "75:1",
    "input_share_pct": 93.75,
    "output_share_pct": 6.25
  },
  {
    "label": "20:1",
    "input_share_pct": 80,
    "output_share_pct": 20
  },
  {
    "label": "10:1",
    "input_share_pct": 66.7,
    "output_share_pct": 33.3
  },
  {
    "label": "5:1",
    "input_share_pct": 50,
    "output_share_pct": 50
  },
  {
    "label": "1:1",
    "input_share_pct": 16.7,
    "output_share_pct": 83.3
  },
  {
    "label": "1:6",
    "input_share_pct": 3.2,
    "output_share_pct": 96.8
  }
]

ביחס של 100 ל-1, הפלט מהווה 4.8% מההוצאה, וצמצום ה-prompt הוא הפעולה היחידה שמשתלמת. ביחס של 5 ל-1 שני הצדדים שווים. ביחס של 1 ל-6, הפלט מהווה 96.8% וה-prompt הוא טעות עיגול בלבד. רוב האנשים מעריכים לא נכון את היחס שלהם, לכן כדאי להפיק נתונים מהלוגים לפני שמבצעים אופטימיזציה כלשהי.

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

קחו צעד אחד של סוכן שליפה: 60,000 אסימוני (tokens) קלט של מסמכים שנשלפו והיסטוריית שיחה, ותשובה של 800 אסימונים. זהו יחס של 75 ל-1, דבר שהוא נורמלי לכל תהליך שקורא לפני שהוא כותב.

[
  {
    "label": "Haiku 4.5",
    "input_cost": 0.06,
    "output_cost": 0.004,
    "total_cost": 0.064
  },
  {
    "label": "Sonnet 5 (Aug)",
    "input_cost": 0.12,
    "output_cost": 0.008,
    "total_cost": 0.128
  },
  {
    "label": "Opus 5",
    "input_cost": 0.3,
    "output_cost": 0.02,
    "total_cost": 0.32
  },
  {
    "label": "Fable 5",
    "input_cost": 0.6,
    "output_cost": 0.04,
    "total_cost": 0.64
  }
]

הפלט מהווה 6.25% מהקריאה הזו בכל מודל, כיוון שהיחס קבוע לאורך כל מחירון השירות. הקריאה עולה $0.32 ב-Opus 5, $0.128 ב-Sonnet 5 לפי התעריף של אוגוסט, ו-$0.064 ב-Haiku 4.5. מאתיים צעדים כאלו ביום ב-Opus 5 עולים 64$ ליום.

מנוף ההשפעה ברור ברגע שמבינים את החלוקה. קיצור התשובה מ-800 אסימונים ל-400 חוסך כ-3% מעלות הקריאה. הסרה של 20,000 אסימונים של הקשר לא רלוונטי מה-prompt חוסכת כשליש מהעלות. צמצום אורך הפלט בסוכן שמתבסס על קריאה מרובה הוא כמעט מאמץ מבוזבז. לאן הולכים האסימונים של סוכן תכנות בפועל מפרק מה ממלא את ה-prompt הזה מלכתחילה.

עומס עבודה מסוג יצירה: הנחיה קצרה, טיוטה ארוכה

כעת נהפוך את היחס. תדריך של 2,000 אסימונים (tokens), טיוטה של 12,000 אסימונים, יחס של 1 ל-6.

[
  {
    "label": "Haiku 4.5",
    "input_cost": 0.002,
    "output_cost": 0.06,
    "total_cost": 0.062,
    "batch_total_cost": 0.031
  },
  {
    "label": "Sonnet 5 (Aug)",
    "input_cost": 0.004,
    "output_cost": 0.12,
    "total_cost": 0.124,
    "batch_total_cost": 0.062
  },
  {
    "label": "Opus 5",
    "input_cost": 0.01,
    "output_cost": 0.3,
    "total_cost": 0.31,
    "batch_total_cost": 0.155
  },
  {
    "label": "Fable 5",
    "input_cost": 0.02,
    "output_cost": 0.6,
    "total_cost": 0.62,
    "batch_total_cost": 0.31
  }
]

הפלט מהווה 96.8% מחשבון זה. Opus 5 עולה $0.31 לטיוטה, לעומת $0.062 ב-Haiku 4.5. פער של פי חמישה זה נובע כמעט כולו מצד הפלט, וזה בדיוק המקום שבו מודל זול יותר חוסך לכם הכי הרבה.

העמודה האחרונה מציגה את אותה משימה דרך ה-Batch API, המעניק הנחה של 50% על קלט ופלט. העלות של Opus 5 יורדת ל-$0.155 לטיוטה. עיבוד Batch מחזיר תוצאות בתוך 24 שעות במקום באופן מיידי, לכן הוא מתאים להפקת דוחות ליליים וסיווג בכמויות גדולות. הוא אינו מתאים למשימות שבהן אדם יושב וממתין לתוצאה.

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

הנחות על מטמון קלט, ועל קלט בלבד

מטמון הנחיות (Prompt caching) שומר קידומת של ההנחיה שלכם בשרת ומחייב בתעריף חלקי של עלות הקלט עבור קריאה חוזרת שלה. נכון לאוגוסט 2026, המכפילים הם 1.25x מתעריף הקלט הבסיסי לכתיבת מטמון ל-5 דקות, 2x לכתיבת מטמון לשעה, ו-0.1x עבור קריאת פגיעה (hit).

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

בצעו את אותו שלב סוכן ב-Opus 5, כאשר 55,000 מתוך 60,000 אסימוני הקלט מוגשים ממטמון חם.

[
  {
    "label": "No cache",
    "input_cost": 0.3,
    "output_cost": 0.02,
    "total_cost": 0.32
  },
  {
    "label": "55k prefix cache read",
    "input_cost": 0.0525,
    "output_cost": 0.02,
    "total_cost": 0.0725
  }
]

הקריאה יורדת מ-$0.32 ל-$0.0725. שורת הפלט אינה משתנה: $0.02 לפני, $0.02 אחרי. המטמון מקצץ את החשבון ומשנה את הרכבו. הפלט היווה 6.25% מאותה קריאה. כעת הוא מהווה יותר מרבע ממנה, מה שמשנה את סדרי העדיפויות לביצוע אופטימיזציה.

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

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

1. הגדר את max_tokens לפי אורך הפלט ב-p95, ולא לפי המקסימום של המודל.
2. נתב שלבים מפורטים למודל זול יותר.
3. בצע Batch לכל משימה שאף אחד לא ממתין לתוצאותיה.
4. מחק הנחיות שמנפחות את התשובות.

max_tokens הוא תקרה קשיחה, והגדרתו על ערך גבוה אינה עולה דבר כשלעצמה, שכן החיוב מתבצע לפי טוקנים שנוצרו ולא לפי התקרה. תפקידו של גבול נדיב הוא להסיר מגבלה מתשובה שמשתבשת. חלץ את התפלגות ה-output_tokens מהלוגים שלך, הגדר את התקרה מעט מעל האחוזון ה-95, וטפל ב-stop_reason: "max_tokens" בקוד על ידי המשך התגובה או ניסיון חוזר. קטיעה שאתה מזהה עולה פחות מ-4,000 טוקנים של מלל מיותר שאתה משלם עליו וזורק. חשיבה מורחבת מגיעה גם היא ל-output_tokens, לכן הגדר את התקציב הזה על סמך אותן ראיות.

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

Batching הוא המנוף היחיד שמעניק הנחה על פלט. 50% הנחה על שני הצדדים, תוצאות בתוך 24 שעות, וכל משימה מתוזמנת מתאימה לכך.

המנוף האחרון הוא זה שאנשים נוטים לדלג עליו. ביטויים כמו "היה יסודי" או "הסבר את הנימוקים שלך" קובעים את אורך הפלט שלך בכל קריאה שתבצע אי פעם. החלף אותם במבנה הרצוי: "ענה לכל היותר בשלושה משפטים", או "החזר רק את אובייקט ה-JSON, ללא הקדמה". פרומפט מערכת שמוסיף 300 טוקנים לכל תשובה עולה פי חמישה מאותם 300 טוקנים בפרומפט עצמו. שמירה על עלויות של סוכן פעיל תחת שליטה מכסה את צד הניטור, וכדאי להכריע ב-האם ה-API או מנוי קבוע זולים יותר עבור דפוס העבודה שלך לפני שאתה משקיע שבוע בכוונון הוצאות לפי טוקן שמנוי היה סופג. עבור מפתח בודד, זה מסתכם לרוב בשאלה האם Claude Pro בעלות של 20 דולר לחודש ומגבלות השימוש הנלוות אליו מכסים את העבודה שהיית מודד אחרת. אם אתה כבר מגיע למגבלות האלה באמצע סשן, הבנה על איזה חלון אתה ממתין קודמת לכל, כי הפתרון משם הוא מודל קטן יותר, הקשר (context) קל יותר, קרדיטים נוספים לשימוש, או העברת העבודה ל-API המדוד. אם ה-API המדוד מתברר כבית זול יותר לעבודה זו, מעבר לתוכנית קטנה יותר או ביטולה משאיר את החודש שכבר שילמת עליו בתוקף, כך שהמעבר לא עולה לך דבר ביציאה. אם התוכנית שאתה שוקל מול Pro היא זו של ChatGPT ולא ה-API המדוד, השוואת שני מסלולי המנויים זה לצד זה מראה איזה מהם יוצא זול יותר עבור עבודת תכנות. אם השאלה נשאלת עבור צוות ולא עבור מפתח בודד, שים לב ש-Claude Enterprise משלב תשלום לכל משתמש עם טוקנים הנמדדים לפי אותם תעריפי API, כך שכל מנוף בדף זה עדיין תקף לחצי המדוד של החשבונית.

FAQ

מדוע אסימוני פלט (output tokens) יקרים יותר מאסימוני קלט (input tokens)?

יצירתם דורשת זמן רב יותר של המאיץ לכל אסימון. הנחיה (prompt) מעובדת במעבר קדימה (forward pass) יחיד על פני כל התוכן, כך שקריאה אחת של משקלי המודל מכסה אלפי אסימונים והחומרה מוגבלת על ידי תפוקת הכפל. תשובה מופקת אסימון אחר אסימון, כאשר כל אסימון דורש מעבר קדימה משלו שקורא שוב את מלוא משקלי המודל, ולכן החומרה מוגבלת במקרה זה על ידי רוחב הפס של הזיכרון. Anthropic מתמחרת פלט בפי חמישה מקלט לאורך כל הקטלוג הנוכחי, מ-Haiku 4.5 ועד Fable 5.

האם מטמון הנחיות (prompt caching) מוזיל את אסימוני הפלט?

לא. מטמון הנחיות חל על קלט בלבד. נכון לאוגוסט 2026, קריאה מהמטמון עולה 0.1x מתעריף הקלט הבסיסי, וכתיבה למטמון עולה 1.25x עבור משך זמן של 5 דקות או 2x עבור משך זמן של שעה אחת. הפלט מחויב בתעריף מלא בכל קריאה, ללא קשר לפעולת המטמון. זו הסיבה שמטמון משנה את מבנה החשבונית שלך כמו גם את גודלה: ברגע שצד הקלט מצטמצם, הפלט הופך לחלק המשמעותי ביותר בעלות.

האם max_tokens גבוה עולה לי כסף אם התשובה שחוזרת קצרה?

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

כיצד אמצא את יחס אסימוני הקלט לפלט שלי?

תעדו את input_tokens, output_tokens, cache_read_input_tokens ו-cache_creation_input_tokens מתוך האובייקט usage של כל תגובה, ולאחר מכן חלקו את הסכומים לאורך שבוע. מעל יחס של 5 אסימוני קלט ל-1 אסימון פלט, הכסף שלכם מושקע בהנחיה, לכן שמרו במטמון את החלק היציב וקצצו את השאר. מתחת ליחס זה, הכסף שלכם מושקע בתשובה, לכן הגבילו את אורכה והעבירו את השלבים שמייצרים את רוב הפלט למודל זול יותר או ל-Batch API.