📘 תיעוד 145

הגדרת מודל

הגדירו באיזה מודל Claude Code משתמש, רמות מאמץ, הקשר מורחב, וחלון הדחיסה האוטומטית

#מודלים זמינים

עבור הגדרת model ב-Claude Code, אפשר להגדיר אחד מאלה:

• כינוי מודל
• שם מודל
  • Anthropic API: שם מודל מלא
  • Amazon Bedrock: ARN של פרופיל הסקה
  • Microsoft Foundry: שם פריסה
  • Agent Platform של Google Cloud: שם גרסה

להנחיה איזה מודל ואיזו רמת מאמץ מתאימים לסוגי עבודה שונים, ראו בחירת מודל Claude ורמת מאמץ ב-Claude Code בבלוג.

[!NOTE]

ANTHROPIC_BASE_URL משנה לאן נשלחות הבקשות, לא איזה מודל עונה עליהן. כדי לנתב את Claude דרך שער LLM, ראו שערי LLM.

#כינויי מודל

השתמשו בכינוי מודל כדי לבחור הגדרות מודל בלי לזכור מספרי גרסה מדויקים:

הכינויים opus, sonnet ו-haiku נפתרים לגרסה החדשה ביותר ב-Anthropic API, ולגרסה מוקדמת יותר אצל חלק מהספקים האחרים:

אלא אם מגדירים את ANTHROPIC_DEFAULT_FABLE_MODEL, כינוי fable נפתר ל-Fable 5.1, למעט בסשנים של שער אפליקציות Claude, שבהם fable ו-best נפתרים ל-Fable 5.

שער שאינו מוגדר לשרת את claude-fable-5-1 דוחה בקשות למודל הזה. כדי להשתמש ב-Fable 5.1 דרך שער שמשרת אותו, בחרו אותו באמצעות /model claude-fable-5-1.

במקום שבו opus או sonnet נפתרים למודל ישן יותר, מודלים חדשים יותר זמינים על ידי בחירה מפורשת של שם המודל המלא, או על ידי הגדרת ANTHROPIC_DEFAULT_OPUS_MODEL או ANTHROPIC_DEFAULT_SONNET_MODEL.

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

כינויים מצביעים על הגרסה המומלצת עבור הספק שלכם ומתעדכנים עם הזמן. כדי לנעוץ גרסה מסוימת, השתמשו בשם המודל המלא, לדוגמה claude-opus-5-5, או הגדירו את משתנה הסביבה המתאים, כמו ANTHROPIC_DEFAULT_OPUS_MODEL.

[!NOTE]

Sonnet 5.5 דורש את Claude Code בגרסה v2.1.284 או מאוחר יותר, ו-Opus 5.5 דורש v2.1.280 או מאוחר יותר. אם בקשה לאחד מהם מגרסה ישנה יותר נכשלת, ראו Claude Code אינו תומך במודל זה. השתמשו ב-v2.1.293 או מאוחר יותר עם Haiku 5.5. הריצו claude update כדי לשדרג.

#עבודה עם Fable

Claude Fable 5.1 ו-Claude Fable 5 הם המודלים המסוגלים ביותר ב-Claude Code, ומתאימים למשימות שגדולות מישיבה אחת. הם מחזיקים סשנים אוטונומיים ארוכים, חוקרים לפני שהם פועלים, ומאמתים את עבודתם בתדירות גבוהה יותר ממודלים קטנים יותר. Fable 5.1 הוא המהדורה החדשה יותר.

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

• Fable 5.1: הריצו /model fable, או הפעילו עם claude --model fable. בסשנים של שער אפליקציות Claude, שבהם הכינוי נפתר ל-Fable 5, הריצו במקום זאת /model claude-fable-5-1.
• Fable 5: בחרו אותו לפי מזהה המודל. ב-Anthropic API, הריצו /model claude-fable-5 או הפעילו עם claude --model claude-fable-5. אצל ספקים אחרים, השתמשו במזהה מודל Fable 5 של הספק שלכם, או נעצו אותו באמצעות ANTHROPIC_DEFAULT_FABLE_MODEL.

אם אתם מתחברים ל-Anthropic API ישירות, והגדרות המשתמש שלכם מחזיקות את claude-fable-5 או את claude-fable-5[1m] כמודל, לדוגמה כי בחרתם את Fable בבורר /model לפני v2.1.257, Claude Code משנה את הערך השמור הזה לכינוי fable או fable[1m] בפעם הראשונה שאתם מריצים את v2.1.257 או מאוחר יותר. שורת המודל בהפעלה מציגה (auto-updated) פעם אחת. ערך claude-fable-5 בהגדרות פרויקט, בהגדרות מקומיות או בהגדרות מנוהלות נשאר כפי שהוא.

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

כדי להפיק את המרב מ-Fable:

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

[!NOTE]

Fable 5.1 דורש את Claude Code בגרסה v2.1.257 או מאוחר יותר. אם בקשה אליו מגרסה ישנה יותר נכשלת, ראו Claude Code אינו תומך במודל זה. הריצו claude update כדי לשדרג. לזמינות תחת אפס שמירת נתונים, ראו זמינות מודל תחת ZDR.

ב-Anthropic API, מודל Fable מופיע בבורר /model, אלא אם availableModels או הגבלות מודל של הארגון מוציאים אותו. כשהארגון שלכם אינו יכול להשתמש ב-Fable כלל, לדוגמה תחת אפס שמירת נתונים, השורה נשארת בבורר באפור, עם הערה שמסבירה למה.

#Fable וקרדיטי שימוש

לפי התוכנית ודרגת המושב שלכם, שימוש ב-Fable יכול להיות מחויב לקרדיטי שימוש במקום להימשך מהמגבלות הכלולות בתוכנית. כשזה קורה, בורר /model מציג "Requires usage credits" בשורת Fable. כדי לנהל קרדיטי שימוש, ראו הוספת קרדיטי שימוש למנוי.

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

• כשאתם בוחרים מודל Fable באמצעות /model, אתם נשארים עם המודל הנוכחי שלכם.
• באמצע סשן, Claude Code ממשיך את התור על מודל ברירת המחדל שלכם.

אחרי שאתם בוחרים להמשיך ב-Fable באמצעות קרדיטי שימוש, Claude Code אינו מציג את הבקשה שוב.

בסשן שבו Remote Control מחובר, בסשן רקע, או בסשן של חבר צוות בצוות סוכנים, ייתכן שאף אחד אינו ליד המסוף, ולכן Claude Code מחזיק את בקשת ההסכמה באמצע הסשן עד למועד dialogExpiry, חמש דקות כברירת מחדל. אם אף אחד לא ענה עד המועד, Claude Code מסיים את התור בלי לשלוח את הבקשה, ומוסיף הודעה לתמליל, שגם לקוח Remote Control מציג. בחירת המודל שלכם אינה משתנה, ו-Claude Code מבקש הסכמה שוב בהודעה הבאה שלכם.

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

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

בסשן שיישום אחר מארח דרך Agent SDK, השאלה אם הבקשה מופיעה תלויה ביישום הזה. אם היא מופיעה ואף אחד אינו עונה לפני אותו מועד dialogExpiry, Claude Code מסיים את התור בלי לשלוח את הבקשה.

במצב לא אינטראקטיבי עם הדגל -p, וביישום Agent SDK שאינו מציג את הבקשה, Claude Code לעולם אינו מבקש הסכמה. כשבקשת Fable שם תחויב לקרדיטי שימוש, Claude Code מחייב אותה בלי לשאול.

#הגדרת המודל

אפשר להגדיר את המודל בכמה דרכים, לפי סדר עדיפות:

1. במהלך הסשן: השתמשו ב-/model <alias|name> כדי להחליף מיד, או הריצו את /model בלי ארגומנט כדי לפתוח את הבורר. ראו מתי Claude Code מבקש לאשר את ההחלפה
2. בהפעלה: הפעילו עם claude --model <alias|name>
3. משתנה סביבה: הגדירו ANTHROPIC_MODEL=<alias|name>
4. הגדרות: הגדירו לצמיתות בקובץ ההגדרות באמצעות השדה model
5. ברירת מחדל לסשנים חדשים: הגדירו ANTHROPIC_DEFAULT_MODEL=<alias|name>

/model שומר את הבחירה כברירת המחדל לסשנים חדשים על ידי כתיבת השדה model בהגדרות המשתמש. בבורר:

• Enter: מחליף מודל ושומר כברירת המחדל
• s: מחליף מודל לסשן הזה בלבד ומשאיר את ברירת המחדל ללא שינוי. כדי להשתמש במקש אחר, קשרו מחדש את modelPicker:thisSessionOnly

הקלדה ישירה של /model <name> מתנהגת כמו Enter. כדי להחליף לסשן הזה בלבד, פתחו את הבורר עם /model ולחצו s בשורת המודל.

בתוכנית Enterprise, כשאתם מחוברים עם חשבון claude.ai ושומרים ברירת מחדל עם /model, Claude Code גם רושם את הבחירה בחשבון הזה. זה דורש Claude Code מגרסה v2.1.280 ואילך.

• כשהמנהל לא הגדיר מודל ברירת מחדל לארגון, אפשרות Default יכולה להיפתר למודל שנרשם, וכשזה קורה, שורת Default בבורר מציגה את שם המודל הזה.
• אם הגבלות מודל מדירות את המודל שנרשם או שהוא לא זמין לחשבון, והמנהל לא הגדיר מודל ברירת מחדל לארגון, אפשרות Default נפתרת כאילו לא נרשם דבר.
• אם בוחרים Default או opusplan ב-/model, הבחירה שנרשמה לא משתנה.

אם מחליפים מודלים עם /model, ההחלפה מגיעה גם אל subagents שיורשים את המודל של השיחה הראשית, מפני ש-Claude Code פותר את המודל שלהם לפי המודל שהסשן משתמש בו כש-Claude מפעיל אותם. עברו ל-Opus לפני ש-Claude מאציל מחקר או הרצות בדיקה לאחד מהם, והעבודה הזו רצה גם על Opus. כדי להשאיר subagent מותאם על מודל קטן יותר, הגדירו model בהגדרה שלו.

אם מגדירים מודל עם /model במצב לא אינטראקטיבי, עם הדגל -p, הבחירה חלה על הסשן הנוכחי בלבד ולא נשמרת כברירת המחדל. /model במצב הזה דורש Claude Code מגרסה v2.1.205 ואילך. הגדרות פרויקט והגדרות מנוהלות עדיין גוברות וחלות מחדש בהפעלה הבאה. מודל ברירת מחדל לארגון שהמנהל הגדיר כך שידרוס את בחירת המשתמש חל מחדש גם הוא בהפעלה הבאה.

ב-v2.1.144 עד v2.1.152, /model חל על הסשן הנוכחי בלבד ו-d בבורר שמר ברירת מחדל.

הדגל --model ומשתנה הסביבה ANTHROPIC_MODEL חלים רק על הסשן שמפעילים איתם. כדי להריץ מודלים שונים במסופים שונים בו זמנית, הפעילו כל אחד עם דגל --model משלו במקום להחליף עם /model.

מחירים בבורר /model מופיעים כש-Claude Code מתקשר עם Anthropic API, ישירות או דרך שער LLM שמתווך אותו, והמחיר בשורה הוא המחיר של המודל שהשורה בוחרת. אצל ספקים צד שלישי כמו Amazon Bedrock ובשער אפליקציות Claude, הספק או השער קובעים מה משלמים, ולכן שורות הבורר לא מציגות מחיר. המחיר הוא תווית תצוגה בלבד: הוא לא משפיע על איזה מודל שורה בוחרת ועל מה שהספק מחייב. לפני v2.1.206, Claude Platform on AWS וסשנים של שער הציגו מחירי מחירון של Anthropic, ושורה יכלה להציג את המחיר של מודל שונה מהמודל שהיא בחרה.

סשנים שממשיכים, שהופעלו עם claude --resume, --continue, או בורר /resume, שומרים את המודל שהיה בשימוש כשהתמליל נשמר. אם המודל ששוחזר הוצא משימוש או מוחרג על ידי availableModels, הסשן עובר לסדר העדיפות הרגיל. אצל ספקים שמשתמשים במזהי פריסה ייחודיים לספק במקום מזהי מודל של Anthropic, כמו Amazon Bedrock, Google Cloud's Agent Platform ו-Microsoft Foundry, מודל התמליל לא משוחזר בכלל והסשן פותר את המודל דרך סדר העדיפות הרגיל.

אם הגדרת model היא haiku, סשן שנשמר על מודל Haiku ממשיך על המודל ש-haiku נפתר אליו עכשיו. לדוגמה, ברגע ש-haiku נפתר ל-Haiku 5.5, סשן שנשמר על Haiku 4.5 ממשיך על Haiku 5.5.

מודל שבוחרים להפעלה החדשה עם --model או ANTHROPIC_MODEL עדיין גובר על המודל ששוחזר. החל מ-v2.1.195, כך גם משתנה ממשפחת ANTHROPIC_DEFAULT_OPUS_MODEL. גם ANTHROPIC_DEFAULT_MODEL יכול, לפי התנאים שמפורטים בסעיף שלו.

כשהמודל הפעיל בהפעלה מגיע מהגדרות פרויקט או מהגדרות מנוהלות ולא מהבחירה שלכם, כותרת ההפעלה מציגה איזה קובץ הגדרות קבע אותו. הריצו /model כדי לדרוס. הגדרת הפרויקט או ההגדרה המנוהלת חלה מחדש בהפעלה הבאה. בפלטפורמות שמשבצות את Claude Code ומגדירות CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST, תצורת המודל של המארח גוברת על הגדרות מודל מנוהלות, ורשימת ההיתר המנוהלת availableModels נשארת בתוקף אלא אם המארח מספק רשימה משלו. חריגים לעדיפות הגדרות מנוהלות מציין אילו מפתחות ומשתנים המארח דורס.

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

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

כשמחליפים מודלים דרך המתודה setModel() של Agent SDK, דרך אפליקציה כמו אפליקציית שולחן העבודה, או ממכשיר שמחובר דרך Remote Control, Claude Code בודק את הערך בזמן ההחלפה:

• Agent SDK או אפליקציה: עם Claude Code מגרסה v2.1.268 ואילך, אלא אם Claude Code מקבל מזהה מודל באופן מקומי, כמו באפשרות מודל מותאם, הוא מאשר את המזהה מול הספק בפעם הראשונה שהסשן עובר אליו. האישור רץ אצל כל ספק, ומזהה שהספק לא מציע נדחה בהחלפה במקום להיכשל בבקשה הבאה.
• Remote Control: ב-Anthropic API, Claude Code בודק את הערך באופן מקומי ולא שולח בקשה.

ראו המודל אינו מזהה מודל מוכר והמודל לא נמצא להודעות.

אם מגדירים את המודל עם הדגל --model, משתנה הסביבה ANTHROPIC_MODEL, או הגדרת model, Claude Code לא בודק אותו מראש, וערך עם שגיאת הקלדה מייצר יש בעיה עם המודל שנבחר בבקשה הראשונה.

כשלמודל המבוקש יש תאריך הוצאה משימוש מתוזמן או שהוא ממופה מחדש אוטומטית לגרסה חדשה יותר, Claude Code מציג אזהרה שמציינת את המודל המבוקש. סשנים אינטראקטיביים מציגים אותה כהודעת הפעלה. מ-v2.1.182, אותה אזהרה נכתבת ל-stderr במצב לא אינטראקטיבי כשמשתמשים בפורמט פלט הטקסט שהוא ברירת המחדל. הבדיקה מכסה גם model שמוגדר בfrontmatter של subagent. אזהרת stderr מושתקת עבור --output-format json ו-stream-json. קראו את המודל בפועל מהשדה modelUsage של הודעת התוצאה.

לדוגמה, התחילו סשן על Opus:

claude --model opus

ואז החליפו מודלים מתוך הסשן:

/model sonnet

דוגמה לקובץ הגדרות:

{
    "permissions": {
        "allow": ["Bash(npm run lint)"]
    },
    "model": "opus"
}

#הגדרת מודל ברירת מחדל לסשנים חדשים

הגדירו ANTHROPIC_DEFAULT_MODEL=<alias|name> כדי לבחור את המודל שעליו הסשנים מתחילים כברירת מחדל. דורש Claude Code מגרסה v2.1.236 ואילך.

Claude Code מתחיל סשן חדש על המודל של המשתנה רק כשאף אחד מאלה לא בוחר מודל:

• הדגל --model
• ANTHROPIC_MODEL
• ערך model בכל קובץ הגדרות, כולל הבחירה ששומרים עם /model
• מודל ברירת מחדל לארגון

בחירה ששומרים עם /model גוברת על המשתנה גם בהפעלות מאוחרות יותר. כש-ANTHROPIC_MODEL מוגדר במקום זאת, Claude Code חוזר למודל של המשתנה הזה בהפעלה הבאה, בלי קשר למה שנשמר עם /model.

Claude Code גם פותר את אפשרות Default למודל של המשתנה, אלא אם חל מודל ברירת מחדל לארגון. כשאפשרות Default נפתרת למודל של המשתנה, שורת Default בבורר /model מציגה את התווית Set by ANTHROPIC_DEFAULT_MODEL.

Claude Code מתעלם מהמשתנה במקרים האלה, ואפשרות Default נפתרת כאילו לא הגדרתם אותו:

• הגדרתם אותו ל-default, inherit, opusplan, או haiku
• enforceAvailableModels מופעל
• הגבלות המודל של הארגון מדירות את המודל
• המודל לא זמין לחשבון

כשסשן חדש היה מתחיל על המודל של המשתנה, סשן שממשיכים עם claude --resume, --continue, או בורר /resume מתחיל עליו גם כן. Claude Code לא משחזר את המודל שנשמר בתמליל של הסשן הזה. אחרת Claude Code לא משתמש במשתנה כשממשיכים סשן.

#סשן חדש מתחיל על מודל שונה מזה שבחרתם

כשבוחרים מודל עם /model והסשן הבא מתחיל על משהו אחר, אלה הסיבות הרגילות:

• בחרתם אותו לסשן אחד. לחיצה על s בבורר, הפעלה עם --model, והרצה של /model במצב לא אינטראקטיבי חלות כולן על הסשן הנוכחי ומשאירות את ברירת המחדל השמורה כמו שהיא.
• משהו בעדיפות גבוהה יותר מגדיר את המודל. ערך model בהגדרות פרויקט או בהגדרות מנוהלות, ANTHROPIC_MODEL במעטפת, או ברירת מחדל לארגון שהמנהל הגדיר כך שתדרוס בחירות משתמש, חלים שוב בכל הפעלה. הבחירה ב-/model עדיין שמורה: היא מדורגת נמוך יותר. כשהגדרות פרויקט או הגדרות מנוהלות קובעות את המודל, כותרת ההפעלה מציינת את הקובץ.
• Claude Code לא הצליח לשמור את הבחירה. /model כותב את model אל ~/.claude/settings.json. אם אי אפשר לכתוב לקובץ הזה, למשל כי כלי אחר מייצר אותו או מקשר אותו לעותק לקריאה בלבד, המודל שנבחר נשאר לסשן וההפעלה הבאה קוראת את הערך הישן. הגדירו model בכלי שמייצר את הקובץ, או הפכו את הקובץ לניתן לכתיבה. ראו שינוי שעשיתם ב-Claude Code אובד בסשנים חדשים.
• המשכתם סשן. סשן שממשיכים עם claude --resume או --continue בדרך כלל שומר את המודל שהיה בשימוש במקום ברירת המחדל הנוכחית.

#הגבלת בחירת מודל

מנהלים יכולים להשתמש ב-availableModels בהגדרות מנוהלות או במדיניות כדי להגביל אילו מודלים משתמשים יכולים לבחור. רשומות מתאימות למשפחת מודלים כמו sonnet, לקידומת גרסה כמו claude-sonnet-4-5, או למזהה מודל מלא כמו claude-sonnet-4-5-20250929. קידומת גרסה מתאימה גם למזהי מודל מאוחרים יותר שמרחיבים אותה במקטע נוסף, כך ש-claude-fable-5 מתיר גם את Fable 5 וגם את Fable 5.1, בעוד ש-claude-fable-5-1 מתיר רק את Fable 5.1. כדי לחסום מודל שהרשימה מתירה, או כדי שכל רשומת מזהה מודל תתיר רק את הגרסה שהיא מציינת, ראו חסימת מודלים או גרסאות מסוימים.

בפלטפורמות שמשבצות את Claude Code ומגדירות CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST, תצורת המודל של המארח גוברת על הגדרות מודל מנוהלות, בעוד שרשימת היתר availableModels מנוהלת נשארת בתוקף אלא אם המארח מספק רשימה משלו. חריגים לעדיפות של הגדרות מנוהלות מציין אילו מפתחות ומשתנים המארח דורס.

כאשר availableModels מוגדר, רשימת ההיתר חלה בכל מקום שבו משתמש יכול לציין מודל:

• מודל הסשן הראשי: /model, הדגל --model, משתנה הסביבה ANTHROPIC_MODEL, ההגדרה model, ANTHROPIC_DEFAULT_MODEL, והמודל שמוחזר בעת חידוש סשן
• פענוח כינויים: משתני הסביבה ANTHROPIC_DEFAULT_OPUS_MODEL, ANTHROPIC_DEFAULT_SONNET_MODEL, ANTHROPIC_DEFAULT_HAIKU_MODEL ו-ANTHROPIC_DEFAULT_FABLE_MODEL לא יכולים להפנות כינוי מותר למודל שמחוץ לרשימה
• מצב מהיר: /fast מסרב להחליף מצב כאשר זה יעביר במשתמע למודל Opus שמחוץ לרשימה, עם ההודעה "is not in your organization's allowed models"
• מודלים של סוכן משנה ושל חבר צוות: שדה model ב-frontmatter של סוכן משנה, פרמטר model של כלי ה-Agent, מודלים של חברי צוות בצוות סוכנים, CLAUDE_CODE_SUBAGENT_MODEL, ובגרסה v2.1.197 ומוקדמות יותר, בורר המודלים באשף /agents
• מודלים של מיומנויות ופקודות: ה-frontmatter של model במיומנויות ופקודות
• מודל יועץ: ההגדרה advisorModel שהוגדרה והדגל --advisor
• מודל סוכן רקע: המודל שנבחר בבורר השיגור

ב-Anthropic API ובClaude Platform on AWS, כינוי של משפחת מודלים, opus, sonnet, haiku או fable, מפוענח למודל הרגיל שלו כאשר רשימת ההיתר מתירה את המודל הזה. כאשר רשימת ההיתר חוסמת את המודל הזה, Claude Code מחליף בגרסה החדשה ביותר של המשפחה שרשימת ההיתר מתירה ומציג הודעה שמציינת גם את המודל המבוקש וגם את המודל שהוחלף. עם ["sonnet", "claude-opus-4-6"], לדוגמה, גם /model opus וגם --model opus בוחרים את Claude Opus 4.6, ה-Opus המותר החדש ביותר. לפני v2.1.205, כינוי שהגרסה שפורסמה החדשה ביותר שלו הייתה מחוץ לרשימה נדחה או הוחלף כמו כל בחירה חסומה אחרת, גם כאשר הרשימה התירה גרסה ישנה יותר.

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

Claude Code מטפל בכל בחירה חסומה אחרת לפי המקום שבו המודל הוגדר:

• /model: Claude Code דוחה את המעבר עם שגיאה

• דגל --model, ANTHROPIC_MODEL, או ההגדרה model: Claude Code מחליף את הערך בעת ההפעלה עם אזהרה שמציינת גם את המודל המבוקש וגם את המודל שהוחלף, והסשן מתחיל על מודל ברירת המחדל

• ANTHROPIC_DEFAULT_MODEL: Claude Code מתעלם מהמשתנה

• דריסה של סוכן משנה או חבר צוות: Claude Code מריץ את סוכן המשנה או את חבר הצוות על מודל גיבוי במקום להכשיל את הבקשה. ראו בחירת מודל לגיבוי של סוכן משנה וציון חברי צוות ומודלים לגיבוי של חבר צוות.

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

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

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

• ההגדרה advisorModel: היועץ מושבת לסשן

• הדגל --advisor: Claude Code יוצא עם שגיאה בעת ההפעלה. בסשן רקע, הוא מתחיל את הסשן בלי היועץ במקום לצאת

• CLAUDE_CODE_AUTO_MODE_MODEL: Claude Code מתעלם מהמשתנה ובוחר את המודל לבקשות מסווג מצב אוטומטי שלו כאילו לא הגדרתם אותו

Claude Code מסתיר מודלים שהוחרגו מבורר /model. האם מזהה מודל שאתם רושמים מקבל גם שורה משלו משתנה לפי הספק:

• Anthropic API, Claude Platform on AWS, Claude apps gateway, או LLM gateway שמוגדר דרך ANTHROPIC_BASE_URL: מזהה מודל של Anthropic שאתם רושמים ושאין לו שורת בורר מובנית מופיע כשורה מתויגת משלו. Claude Code מוסיף שורה כזו לגרסאות Opus, Sonnet ו-Haiku, כמו גרסה ישנה יותר שהרשימה מקבעת. אם תגדירו replaceBuiltInOptions במערך modelPicker, השורה הזו לא מופיעה. לפני v2.1.199, מזהה כזה היה ניתן לבחירה רק על ידי הקלדת /model <id>.
• Amazon Bedrock, Google Cloud's Agent Platform, או Microsoft Foundry: אלא אם מזהה מודל שאתם רושמים מתחיל ב-anthropic., Claude Code לא מוסיף לו שורה, בין אם זה מזהה מודל של Anthropic ובין אם זה מזהה ייחודי לספק. מזהי מודל של Mantle נושאים את הקידומת הזו. כדי להציג גרסה רשומה שאין לה שורה מובנית, הוסיפו אותה גם למערך modelPicker, שמקבל מזהים בפורמט של הספק שלכם.

שינויי מודל ש-Claude Code מבצע בשמכם נבדקים באותו אופן:

• שרשראות מודלי גיבוי: רשומות שמחוץ לרשימת ההיתר מושמטות
• שדרוגי מצב תכנון: ב-Anthropic API וב-Claude Platform on AWS, שדרוג כמו opusplan למודל שהוחרג משתמש בגרסה המותרת החדשה ביותר של משפחת השדרוג. אצל ספקים עם מזהי מודל ייחודיים לספק, וכאשר אין גרסה מותרת, השדרוג מדולג והתכנון ממשיך על מודל הסשן
• גיבוי מודל אוטומטי: גיבוי שהיעד שלו הוחרג לא רץ, ולכן הבקשה שסומנה מסתיימת בסירוב
• מסווג מצב אוטומטי: כאשר רשימת ההיתר מחריגה את מודל המסווג ברירת המחדל, בקשות מסווג שהיו משתמשות במודל הזה רצות על מודל הסשן, או על מודל Opus בסשנים של Fable. אצל ספקים שאינם Anthropic API, גיבוי ה-Opus הזה רץ על המודל שהגדרתם ב-ANTHROPIC_DEFAULT_OPUS_MODEL או אחרת על Opus 5, בלי לבדוק מול רשימת ההיתר. נדרש Claude Code v2.1.210 או מאוחר יותר
• מצב מהיר: הפעלת מצב מהיר נדחית כאשר המודל שהסשן היה רץ עליו אחר כך נמצא מחוץ לרשימת ההיתר
• גיבוי זמינות ב-Amazon Bedrock וב-Google Cloud's Agent Platform: כאשר החשבון שלכם מאבד גישה למודל באמצע סשן, המעבר למודל אחר מדלג על מודלים שהוחרגו. בדיקות מודל ההפעלה בAmazon Bedrock ובGoogle Cloud's Agent Platform מדלגות על מודלים שהוחרגו רק כאשר הגדרות מנוהלות מגדירות גם את enforceAvailableModels

{
  "availableModels": ["sonnet", "haiku"]
}

#כיסוי משטחים

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

• סשני ענן, כולל אלה שאתם מתחילים מאפליקציית Desktop, רצים על מכונות וירטואליות שמנוהלות על ידי Anthropic כברירת מחדל: הגדרות שנפרסות למכשיר שלכם לא מגיעות אליהם, ולכן מסרו את רשימת ההיתר דרך הגדרות מנוהלות בשרת. סשנים שהארגון שלכם מנתב לסביבה באירוח עצמי רצים על המחשוב שלכם וגם קוראים את קובץ ההגדרות המנוהלות בתמונת ה-runner. איך Claude Code משלב מקורות מנוהלים מציין מתי הקובץ הזה חל. החלפת מודל באמצע סשן בסשן ענן נדחית כאשר המודל המבוקש מוחרג על ידי רשימת ההיתר. כאשר רשימת availableModels בהגדרות המנוהלות בשרת שלכם אינה ריקה, השרת דוחה בקשה להתחיל סשן ענן ב-claude.ai/code או מאפליקציית Desktop על מודל שהרשימה מחריגה.
• סשנים של Claude Tag רצים בסביבות ענן אבל לא מקבלים הגדרות מנוהלות בשרת. בסביבה באירוח עצמי, הם עדיין קוראים את קובץ ההגדרות המנוהלות בתמונת ה-runner. כדי להגדיר את המודל לסשנים האלה, ראו בחירת המודל להיקף במדריך הניהול של Claude Tag.
• Cowork, לשונית העבודה הסוכנית באפליקציית Claude Desktop, מריץ את הסשנים שלו על Claude Code אבל, לפי התכנון, לא מקבל הגדרות מנוהלות בשרת ממסוף הניהול של claude.ai. כאשר רשימת availableModels בהגדרות המנוהלות בשרת שלכם אינה ריקה ומשתמש בוחר מודל שמחוץ לה, השרת דוחה את המודל הזה לסשן Cowork מרוחק. קובץ הגדרות מנוהלות חל על סשני Cowork כאשר הוא נמצא במקום שבו הסשן רץ. סשני Cowork מרוחקים רצים על מכונות וירטואליות שמנוהלות על ידי Anthropic, שבהן קובץ שנפרס למכשיר אינו נמצא.
• סשנים אצל ספקי צד שלישי כמו Amazon Bedrock, Google Cloud's Agent Platform, Microsoft Foundry ו-Claude Platform on AWS לא מקבלים הגדרות מנוהלות בשרת, ולכן מסרו את רשימת ההיתר שם דרך MDM או קובצי הגדרות מנוהלות.
• מסירה ממסוף הניהול דורשת גם שהסשן ימשוך עם התחברות כשירה לארגון שלכם או עם אסימון OAuth שהונפק עבורו. עבור ציים שמאמתים עם מפתחות API, בין אם הוגדרו ישירות ובין אם נוצרו על ידי סקריפט apiKeyHelper, מסרו את רשימת ההיתר דרך MDM או קובצי הגדרות מנוהלות.
• לשונית Desktop Code מארחת גם סשני SSH, שקוראים את קובץ ההגדרות המנוהלות מהמארח המרוחק שעליו הם רצים. ראו הגדרות מנוהלות ב-Desktop.
• בוררי המודלים ב-claude.ai ובאפליקציית Desktop מסתירים או מאפירים מודלים שהוחרגו על ידי רשימת ההיתר של הארגון שלכם. מצב הבורר הוא נוחות למשתמשים. הוא לא אוכף את רשימת ההיתר.

#התנהגות מודל ברירת המחדל

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

עם availableModels: [], בחירות מודל בשם חסומות ול-enforceAvailableModels אין השפעה.

#אכיפת רשימת ההיתר עבור מודל Default

הגדירו enforceAvailableModels: true לצד availableModels שאינו ריק בהגדרות מנוהלות כדי להרחיב את רשימת ההיתר לאפשרות Default. זה דורש Claude Code v2.1.175 או מאוחר יותר.

{
  "availableModels": ["sonnet", "haiku"],
  "enforceAvailableModels": true
}

עבור חבר שאין לו מודל שנרשם בחשבון שלו, אפשרות Default מפוענחת לברירת המחדל של סוג החשבון, או למודל ברירת המחדל של הארגון כאשר מנהל הגדיר אחד. כאשר המודל הזה אינו ברשימת ההיתר, אפשרות Default מפוענחת לרשומת availableModels הראשונה שמציינת מודל מותר וזמין, ושורת Default בבורר /model מציגה את המודל הזה. זה חל בכל מקום שמגיעים לברירת המחדל: הפעלת סשן, בחירת Default ב-/model, מילת המפתח "default" בשרשראות מודלי גיבוי, והגיבוי שנעשה בו שימוש כאשר בחירה שהוחרגה מושמטת. מודל שנרשם בחשבון של חבר נבדק גם מול availableModels. הגדרת המודל שלכם מתאר איך אפשרות Default מתייחסת אליו.

enforceAvailableModels ממפה מחדש את אפשרות Default רק כאשר availableModels אינו ריק. כאשר availableModels אינו ריק אבל אף רשומה לא מפוענחת למודל מותר וזמין, האכיפה מדולגת עם אזהרה שנראית רק תחת --debug. שמרו לפחות רשומה אחת שזמינותה מובטחת ברשימה כדי להימנע מזה.

פרסו את שני המפתחות יחד במקור המנוהל בעל הדירוג הגבוה ביותר שאתם מוסרים. כברירת מחדל Claude Code קורא רק את המקור הזה, ולכן מתעלמים מזוג שמוצב בקובץ הגדרות מנוהלות כאשר מסוף הניהול מוסר הגדרות כלשהן. במיזוג שמופעל בהצטרפות באיך Claude Code משלב מקורות מנוהלים, Claude Code עדיין מתעלם ממפת modelOverrides ממקור שמדורג מתחת לזה שמגדיר את availableModels.

#שליטה במודל שהמשתמשים מריצים

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

כדי לשלוט במלוא חוויית המודל, שלבו את ההגדרות האלה:

• availableModels: מגביל אילו מודלים בשם המשתמשים יכולים לעבור אליהם
• enforceAvailableModels: מרחיב את רשימת ההיתר availableModels לאפשרות Default, כך ש-Default לא יכול להתפרש למודל מחוץ לרשימה
• deniedModels ו-availableModelsMatch: חוסמים גרסאות מסוימות שרשומה ב-availableModels הייתה מתירה אחרת
• model: קובע את בחירת המודל ההתחלתית כשסשן מתחיל
• ANTHROPIC_DEFAULT_SONNET_MODEL / ANTHROPIC_DEFAULT_OPUS_MODEL / ANTHROPIC_DEFAULT_HAIKU_MODEL / ANTHROPIC_DEFAULT_FABLE_MODEL: שולטים למה הכינויים sonnet, opus, haiku ו-fable מתפרשים, ואיזו גרסה ברירת המחדל לפי סוג החשבון משתמשת בה

הדוגמה הזו מתחילה משתמשים על Sonnet 4.5, מגבילה את הבורר ל-Sonnet ול-Haiku, ומוודאת ש-Default מתפרש למודל ברשימת ההיתר ולא לברירת המחדל של הדרגה:

{
  "model": "claude-sonnet-4-5",
  "availableModels": ["claude-sonnet-4-5", "haiku"],
  "enforceAvailableModels": true,
  "env": {
    "ANTHROPIC_DEFAULT_SONNET_MODEL": "claude-sonnet-4-5"
  }
}

בלי enforceAvailableModels או בלוק ה-env, משתמש שבוחר Default בבורר מקבל את ברירת המחדל בזמן ריצה ולא את הגרסה שמוצמדת ב-model. שתי ההגדרות מכסות היקפים שונים: enforceAvailableModels גורם ל-Default לציית לרשימת ההיתר, בעוד שבלוק ה-env מצמיד לאיזו גרסה כינוי מותר כמו sonnet מתפרש. השתמשו ב-enforceAvailableModels לבד כשהגבלה של משפחות מודלים מספיקה. הוסיפו את בלוק ה-env כשצריך גם להצמיד גרסה מסוימת.

#התנהגות מיזוג

כשההגדרות המנוהלות ש-Claude Code מחיל מגדירות את availableModels, הרשימה הזו לבדה חלה, מלבד פלטפורמת מארח שמספקת רשימה משלה: רשומות בהגדרות משתמש, פרויקט או מקומיות לא יכולות להרחיב אותה, ו-Claude Code אף פעם לא ממזג את availableModels בין מקורות מנוהלים. איך Claude Code משלב מקורות מנוהלים אומר איזו רשימה של איזה מקור חלה. אחרת, רשימות מהגדרות משתמש, פרויקט ומקומיות מחוברות ומסולקות כפילויות כמו הגדרות מערך אחרות. לפני Claude Code v2.1.175, רשומות מהיקפים בעלי עדיפות נמוכה יותר מוזגו לתוך הרשימה המנוהלת במקום להיות מוחלפות על ידה.

בתוך הרשימה האפקטיבית, רשומה שמנקבת מודל מסוים במשפחה, בין אם קידומת גרסה ובין אם מזהה מודל מלא, משביתה את רשומת התו הכללי של אותה משפחה. לדוגמה, עם ["sonnet", "claude-sonnet-4-5"], משתמשים יכולים לבחור רק את מזהי המודל ש-claude-sonnet-4-5 תואם, לא כל מודל Sonnet.

#מזהי מודל Mantle

רשומות ב-availableModels שמתחילות ב-anthropic. מתווספות לבורר /model כאפשרויות מותאמות. זו חריגה מהתאמת הכינויים שמתוארת בהצמדת מודלים לפריסות צד שלישי. כשנקודת הקצה Amazon Bedrock Mantle מופעלת, Claude Code מנתב את הרשומות שתואמות את פורמט Mantle לנקודת הקצה הזו. ההגדרה עדיין מגבילה את הבורר לרשומות שברשימה, ומזהה Mantle מכיל שם משפחה, ולכן הוא נחשב לרשומה מסוימת ומשבית את התו הכללי של אותה משפחה: לצד כל מזהי Mantle, רשמו את קידומות הגרסה או המזהים המלאים שאתם רוצים להשאיר ניתנים לבחירה. ראו התנהגות מיזוג.

#חסימת מודלים או גרסאות מסוימים

רשומה ב-availableModels כמו claude-opus-5 מתירה גם מהדורות מאוחרות יותר שמרחיבות אותה, כמו Opus 5.5, ברגע ש-Claude Code תומך בהן. שתי הגדרות מנוהלות מאפשרות לעכב מהדורה, ושתיהן דורשות Claude Code v2.1.283 או חדש יותר:

• deniedModels: רשמו את המודלים לחסימה. מודל שברשימה נחסם גם כש-availableModels מתיר אותו, והמפתח עובד גם בלי רשימת היתר בכלל. מהדורה שאף רשומה לא חוסמת נשארת מותרת
• availableModelsMatch: הגדירו אותו ל-"exact" כך שכל מזהה מודל ב-availableModels מתיר רק את הגרסה שהוא מנקב. גרסה חדשה יותר של מזהה מודל שברשימה נשארת אז חסומה עד שתוסיפו אותה לרשימה

גרסאות מוקדמות יותר מתעלמות משני המפתחות, אז הגדירו גם את requiredMinimumVersion כדי למנוע מהגרסאות האלה להתחיל.

הדוגמה הזו מתירה מודלי Opus ו-Sonnet וחוסמת את Opus 5.5 בכל איות, כולל מזהים מתוארכים ומזהים ספציפיים לספק:

{
  "availableModels": ["opus", "sonnet"],
  "deniedModels": ["claude-opus-5-5"]
}

מודל חסום, בין אם deniedModels מנקב אותו ובין אם רשימת "exact" משמיטה אותו, מטופל כבחירה חסומה בכל מקום שבו רשימת ההיתר חלה. הוא מוסתר מבורר /model, ו-/model <name> דוחה אותו. אם מנקבים מזהה מודל חסום עם --model, ANTHROPIC_MODEL או ההגדרה model, Claude Code משמיט אותו בהפעלה ומתפרש לאפשרות Default במקום. אם הוק או בקשת רקע מנקבים מודל ש-deniedModels חוסם, כמו שדה model של הוק סוכן, הבקשה הזו רצה על המודל של הסשן במקום.

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

1. הגרסה המותרת החדשה ביותר מאותה משפחה
2. המודל המותר החדש ביותר מכל משפחה בעלות נמוכה יותר בתורה: Sonnet, ואז Haiku
3. הרשומה הראשונה ב-availableModels שמנקבת מודל מותר

אם אף אחד מאלה לא מותר, סשן שמתחיל על אפשרות Default מסרב להתחיל עם שגיאה שמנקבת את המפתח לתיקון. רשימת "exact" משפיעה על אפשרות Default רק כשרשימת availableModels המנוהלת מנקבת לפחות מודל אחד או משפחה אחת.

Claude Code קורא את שני המפתחות מהגדרות מנוהלות בלבד. אם מגדירים אחד מהם בהגדרות משתמש, פרויקט או מקומיות או עם --settings, Claude Code מתעלם ממנו עם אזהרה.

#הגבלות מודל של הארגון

מנהלי ארגון בתוכניות Claude Enterprise מגבילים אילו מודלים חברים יכולים להריץ על ידי השבתת מודלים בודדים בקונסולת הניהול של claude.ai. ההגבלה הזו נמסרת עם הזכאויות של החשבון כש-Claude Code מאמת, בנפרד מכל רשימת availableModels בהגדרות, והשרת אוכף את אותה הגבלה באופן עצמאי כשסשן נוצר. דורש Claude Code v2.1.187 או חדש יותר.

ההגבלה חלה כשחבר נכנס או משתמש במפתח ה-API שלו. אישורים בהיקף ארגון, כמו מפתחות שירות של הארגון, לא קשורים למשתמש, ולכן ההגבלה לא חלה עליהם.

ב-Claude Console אין בקרת הגבלת מודל. ארגונים בלי תוכנית Claude Enterprise, כולל אלה שחבריהם מאמתים דרך Anthropic API, מגבילים מודלים עם availableModels בהגדרות מנוהלות במקום, ומוסיפים enforceAvailableModels כדי לכסות את אפשרות Default. כיסוי משטחים אומר איך כל משטח מקבל ואוכף את ההגדרות האלה.

מודל מוגבל מוסתר מבורר /model. בחירה שלו לפי שם עם --model, משתנה הסביבה ANTHROPIC_MODEL או ההגדרה model מציגה את ההודעה Model "<name>" is restricted by your organization's settings. Using <model> instead. והסשן מתחיל על מודל מותר. הקלדת /model <name> למודל מוגבל נדחית עם Model '<name>' is restricted by your organization's settings. Run /model to choose a different model. והסשן שומר את המודל הנוכחי שלו.

כינוי משפחת מודלים כמו opus מתפרש למודל הרגיל שלו כשהארגון מתיר אותו. כשהארגון מגביל את המודל הזה, Claude Code מחליף בגרסה החדשה ביותר של המשפחה שהארגון מתיר, עם אותה הודעת החלפה. /model <alias> נדחה רק כשכל גרסה של המשפחה שלו מוגבלת. כינוי שמוגדר עם --model, ANTHROPIC_MODEL או ההגדרה model עדיין מוחלף בהפעלה במקרה הזה. לפני v2.1.205, כינוי משפחה הוחלף או נדחה לפי הגרסה החדשה ביותר שפורסמה בלבד, גם כשגרסה ישנה יותר הייתה מותרת.

ההגבלות חלות על כל הארגון או לפי תפקיד:

• השבתת מודל ברמת הארגון מסירה אותו לכל חבר.
• הרשאות גישה ברמת תפקיד מעניקות מודלים שונים לתפקידים מותאמים שונים, וחבר שמחזיק כמה תפקידים יכול להשתמש בכל מודל שאחד מהתפקידים שלו מעניק.
• מודלי Haiku תמיד זמינים ואי אפשר להשבית אותם, כך שלכל חבר נשאר לפחות מודל אחד שמיש.
• שינוי גישה נכנס לתוקף בבקשות חדשות בתוך כדקה. בורר /model משקף אותו בפעם הבאה שסשן מתחיל.

שתי ההגבלות חלות יחד: מודל ניתן לבחירה רק כשהוא מותר על ידי availableModels ולא מוגבל על ידי הארגון. הגבלות הארגון מגיעות לסשנים על Anthropic API ופריסות LLM gateway בלבד. אצל כל ספק אחר, השתמשו ב-availableModels במקום.

#מודל ברירת מחדל של הארגון

מנהלי ארגון בתוכניות Claude Enterprise יכולים להגדיר מודל ברירת מחדל לחברי Claude Code מקונסולת הניהול של claude.ai, לכל הארגון או לפי תפקיד מותאם. כשאחד מוגדר, אפשרות Default מתפרשת למודל הזה. דורש Claude Code v2.1.196 או חדש יותר.

שורה Default בבורר /model מציגה את שם ברירת המחדל של הארגון עם התווית Org default. התווית נקראת Org default בין שהמנהל הגדיר את ברירת המחדל לכל הארגון ובין שלתפקיד שלכם. ברירת מחדל של תפקיד מכסה חברים באותו תפקיד מותאם וקודמת לברירת המחדל של כל הארגון. כשכמה מהתפקידים שלכם מגדירים ברירות מחדל שונות, המודל בעל היכולת הגבוהה ביותר חל.

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

• הדגל --model ומשתנה הסביבה ANTHROPIC_MODEL
• ערך model בהגדרות מנוהלות או שמסופק דרך --settings
• ערך model בהגדרות המשתמש, הפרויקט או המקומיות שלכם, כולל מודל ששומרים עם /model

מנהלים יכולים גם להגדיר את ברירת המחדל של הארגון כך שתעקוף בחירת משתמש. כשעקיפה פועלת, היא קודמת לערך model בהגדרות משתמש, פרויקט ומקומיות, כך שמודל ששומרים עם /model חל לסשן הנוכחי וברירת המחדל של הארגון חוזרת בהפעלה הבאה. כשהבחירה שלכם שונה, /model מציג Your organization's default (<model>) applies on restart. הדגל --model, ANTHROPIC_MODEL, הגדרות מנוהלות ו---settings עדיין קודמים גם כשעקיפה פועלת.

כדי להגביל אילו מודלים חברים יכולים לבחור, השתמשו בהגבלות מודל של הארגון או ב-availableModels במקום.

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

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

ברירת המחדל של הארגון עוברת את בדיקות ההגבלה האלה לפני שהיא מאומצת:

• עם התאמת קידומת ברירת המחדל, availableModels לבדו לא חל על ברירת המחדל של הארגון, כך שברירת מחדל של ארגון מחוץ לרשימת ההיתר עדיין חלה. כשגם enforceAvailableModels מוגדר, ברירת מחדל של ארגון מחוץ לרשימת ההיתר ממופה מחדש גם לרשומה הראשונה ברשימת ההיתר
• ברירת מחדל של ארגון שהגבלות מודל של הארגון שוללות לחשבון שלכם מוחלפת במודל המותר החדש ביותר במשפחה שלה, או במשפחה בעלות נמוכה יותר כשכל גרסה שלה מוגבלת
• לברירת מחדל של ארגון ש-deniedModels או רשימת "exact" חוסמים, ראו חסימת מודלים או גרסאות מסוימים
• ברירת מחדל של ארגון שלא זמינה לחשבון שלכם בכלל מדולגת, ואפשרות Default מתפרשת כפי שהייתה בלי ברירת מחדל של ארגון

החל מ-v2.1.199, כשברירת המחדל של הארגון היא משפחת מודלים שונה מברירת המחדל הרגילה של סוג החשבון שלכם, בורר /model שומר שורה נפרדת למשפחה הרגילה הזו, כך שעדיין אפשר לעבור אליה לסשן. ב-v2.1.196 עד v2.1.198 השורה הזו חסרה מהבורר.

ברירת המחדל של הארגון מגיעה רק לסשנים שמאומתים עם Anthropic API. כדי להגדיר ברירת מחדל בכל מקום אחר, כולל פריסות LLM gateway, השתמשו במפתח model בהגדרות מנוהלות במקום.

#מגבלות מאמץ של הארגון

הארגון שלכם יכול להגביל את רמת המאמץ בשתי דרכים. בתוכנית Claude Enterprise, מנהלי ארגון מגדירים מגבלות מאמץ לפי תפקיד, כמתואר בהמשך. בכל תוכנית ואצל כל ספק, כולל Amazon Bedrock, Agent Platform של Google Cloud ו-Microsoft Foundry, ההגדרה המנוהלת maxEffortLevel מגבילה מאמץ אצל הלקוח במקום. כששתיהן חלות על מודל, התקרה הנמוכה יותר חלה.

מנהלי ארגון בתוכניות Claude Enterprise יכולים להגדיר רמת מאמץ מרבית לכל מודל עבור כל תפקיד מותאם, לצד הגבלות מודל של הארגון ברמת תפקיד. דורש Claude Code v2.1.195 או חדש יותר.

• רמות מעל התקרה לא מוצעות בבורר /effort, וניקוב רמה גבוהה יותר עם --effort או /effort רץ בתקרה במקום. אם מתחילים הרצת --print בטקסט רגיל עם --effort מעל התקרה, אזהרה ב-stderr מנקבת את הרמות שביקשו ואת אלה שהוחלו. בסשנים אינטראקטיביים, עם פלט json או stream-json, או בסוכני רקע, האזהרה הזו הולכת ליומן הניפוי במקום.
• התקרות הן לכל מודל, כך שהחלפת מודלים יכולה לשנות אילו רמות זמינות.
• כשכמה מהתפקידים שלכם מעניקים את אותו מודל, התקרה הכי פחות מגבילה חלה.

מגבלות מאמץ נמסרות יחד עם הגבלות מודל של הארגון ומגיעות לאותם סשנים.

#התנהגות מודל מיוחדת

#הגדרת המודל default

ההתנהגות של default תלויה בסוג החשבון:

• Pro, Max, Ultra, Team, Enterprise ו-Anthropic API: ברירת המחדל היא Opus 5.5
• Claude Platform on AWS, Amazon Bedrock ו-Google Cloud's Agent Platform: ברירת המחדל היא Opus 5.5
• Microsoft Foundry: ברירת המחדל היא Sonnet 4.5

לפני v2.1.280, default הוכרע ל-Sonnet 5 ב-Pro וב-Team Standard, ול-Opus 5 ב-Max, Ultra, Team Premium, Enterprise, ב-Anthropic API, ב-Claude Platform on AWS, ב-Amazon Bedrock וב-Google Cloud's Agent Platform החל מ-v2.1.219. לפני v2.1.219, default הוכרע ל-Opus 4.8 ב-Anthropic API, ב-Max, ב-Ultra, ב-Team Premium וב-Enterprise pay-as-you-go החל מ-v2.1.154, וב-Claude Platform on AWS, ב-Amazon Bedrock וב-Google Cloud's Agent Platform החל מ-v2.1.207. לפני v2.1.207, default הוכרע ל-Opus 4.7 ב-Claude Platform on AWS ול-Sonnet 4.5 ב-Amazon Bedrock וב-Google Cloud's Agent Platform.

כשמנהל הגדיר מודל ברירת מחדל של הארגון, default מוכרע למודל הזה במקום ברירת המחדל לפי סוג החשבון שלמעלה. נדרש Claude Code v2.1.196 או חדש יותר. default יכול גם להיות מוכרע למודל שהגדרת עם ANTHROPIC_DEFAULT_MODEL, לפי התנאים שמפורטים בסעיף שלו, או למודל שנרשם בחשבון שלך.

כששום דבר לא נרשם בחשבון שלך, הגדרות מנוהלות אוכפות את רשימת ההיתר עבור מודל Default, וברירת המחדל לפי סוג החשבון אינה ב-availableModels, default מוכרע ל-Default שנאכף במקום ברירת המחדל לפי סוג החשבון שלמעלה. כשגם ברירת מחדל של הארגון וגם אכיפה חלות, ברירת המחדל של הארגון מחליפה קודם את ברירת המחדל לפי סוג החשבון, ואחר כך האכיפה חלה עליה: ברירת מחדל של הארגון שנמצאת ברשימת ההיתר נשמרת, ואחת שמחוץ לרשימה מוכרעת ל-Default שנאכף.

מודלי Fable אינם ברירת המחדל לפי סוג החשבון בשום תוכנית או ספק. בחירה באחד מהם עם /model שומרת אותו כמודל שנבחר בהגדרות המשתמש, כך שהפעלות מאוחרות יותר מתחילות עליו. לשינוי החד פעמי ש-Claude Code מבצע לבחירת Fable 5 שמורה ב-v2.1.257, ראה עבודה עם Fable.

#הגדרת המודל opusplan

כינוי המודל opusplan מספק גישה היברידית אוטומטית:

• במצב תכנון: משתמש ב-opus לחשיבה מורכבת ולהחלטות ארכיטקטורה
• במצב ביצוע: עובר אוטומטית ל-sonnet ליצירת קוד וליישום

זה משלב את החשיבה של Opus לתכנון עם היעילות של Sonnet לביצוע.

שלב Opus במצב תכנון משתמש באותו חלון הקשר כמו הגדרת המודל opus, ושלב הביצוע משתמש באותו חלון כמו sonnet. כש-opus ו-sonnet מוכרעים למודלים שרצים עם חלון ההקשר של 1M כברירת מחדל, כמו שהמודלים הנוכחיים עושים ב-Anthropic API, שני השלבים רצים איתו. כדי לבקש הקשר של 1M לשני השלבים במקום שבו הם לא רצים כך, הגדר את המודל ל-opusplan[1m], למשל עם /model opusplan[1m]. הגדרה עם /model דורשת Claude Code v2.1.265 או חדש יותר. בגרסאות מוקדמות יותר, השתמש בדגל --model או בהגדרת model.

כש-availableModels מחריג את Opus החדש ביותר אבל מתיר גרסה ישנה יותר, למשל ["sonnet", "claude-opus-4-6"], opusplan משתמש ב-Opus המותר החדש ביותר לתכנון, ונשאר על Sonnet רק כשכל Opus מוחרג. הפעלת Haiku שבדרך כלל הייתה משודרגת ל-Sonnet במצב תכנון משתמשת באותו אופן ב-Sonnet המותר החדש ביותר, ונשארת על Haiku רק כשכל Sonnet מוחרג. לפני v2.1.205, מצב תכנון נשאר על מודל ההפעלה בכל פעם שהגרסה החדשה ביותר של משפחת השדרוג הוחרגה, גם כשרשימת ההיתר התירה גרסה ישנה יותר.

ההחלפה בגרסה מותרת ישנה יותר חלה ב-Anthropic API וב-Claude Platform on AWS. ב-Amazon Bedrock, ב-Google Cloud's Agent Platform, ב-Microsoft Foundry וב-Mantle, שהפריסות שלהם משתמשות במזהי מודל ייחודיים לספק, מצב תכנון נשאר על מודל ההפעלה בכל פעם שמודל השדרוג מוחרג.

לגישה היברידית שבה Claude מחליט באמצע המשימה מתי להתייעץ עם מודל שני, במקום לעבור בגבול התכנון, ראה את כלי היועץ.

#שרשראות מודל גיבוי

כשהמודל הראשי עמוס, לא זמין, או מחזיר שגיאת שרת אחרת שאינה ניתנת לניסיון חוזר, Claude Code יכול לעבור למודל גיבוי במקום שהבקשה תיכשל. שגיאות אימות, חיוב, מגבלת קצב, גודל בקשה ותעבורה, וסירוב של בדיקת המדיניות של הארגון, לעולם לא מפעילים מעבר. אלה ממשיכים לפי הטיפול הרגיל שלהם בניסיונות חוזרים ובשגיאות. כן מתבצע מעבר כש-Amazon Bedrock או Google Cloud's Agent Platform מסרבים למודל שהחשבון שלך לא יכול להפעיל, ו-Claude Code מתייחס לכך כאל מודל שאינו זמין ולא כאל שגיאת אימות.

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

הגדר שרשרת להפעלה אחת עם הדגל --fallback-model, שמקבל רשימה מופרדת בפסיקים:

claude --fallback-model sonnet,haiku

כדי לשמור שרשרת בין הפעלות, הגדר את fallbackModel ב-הגדרות כמערך:

{
  "fallbackModel": ["claude-sonnet-5", "claude-haiku-4-5"]
}

הדגל --fallback-model גובר על הגדרת fallbackModel. כל רשומה מקבלת שם מודל או כינוי, ו-"default" מתרחב למודל ברירת המחדל.

Claude Code לא מאשר את השרשרת בהפעלה, ו-/status לא מציג אותה. ההודעה שמוצגת כשמתרחש מעבר היא הסימן הגלוי הראשון שגיבוי מוגדר.

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

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

Claude Code מחיל את השרשרת גם על תתי סוכנים. כשבבקשה של תת סוכן מתבצע מעבר לגיבוי, Claude Code מנסה את מודלי הגיבוי שהגדרת לפי הסדר, ותת הסוכן ממשיך על המודל שמקבל את הבקשה. המודל של ההפעלה שלך לא משתנה. לפני v2.1.247, כשל שהשרשרת מכסה סיים את תת הסוכן.

#מעבר אוטומטי למודל גיבוי

הסעיף הזה עוסק בגיבוי מבוסס תוכן ממודלי Fable, מ-Opus 5.5, מ-Sonnet 5.5 ומ-Opus 5. לגיבוי מבוסס זמינות כשמודל עמוס או לא זמין, ראה שרשראות מודל גיבוי.

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

• Fable 5.1, Fable 5 ו-Opus 5.5: בקשות שסומנו בביולוגיה רצות מחדש על Opus 5, ובקשות שסומנו באבטחת סייבר רצות מחדש על Opus 4.8.
• Sonnet 5.5: בקשות שסומנו באבטחת סייבר רצות מחדש על Sonnet 5. בקשות שסומנו בביולוגיה מסתיימות בסירוב, כי ל-Sonnet 5.5 אין מודל גיבוי לביולוגיה.
• Opus 5: בקשות שסומנו באבטחת סייבר רצות מחדש על Opus 4.8. בקשות שסומנו בביולוגיה מסתיימות בסירוב, כי Opus 5 מריץ מסווגי ביולוגיה משלו בלי מודל גיבוי.

ב-Amazon Bedrock, ב-Google Cloud's Agent Platform וב-Microsoft Foundry, Claude Code מכריע את היעדים האלה דרך מזהי המודל של הפריסה שלך. ראה הפעלת גיבוי ב-Bedrock, ב-Agent Platform וב-Foundry.

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

אחרי גיבוי, ההפעלה ממשיכה על מודל הגיבוי. כדי לחזור למודל המקורי שלך, הרץ /model.

גיבוי לפי קטגוריה דורש Claude Code v2.1.219 או חדש יותר. לפני v2.1.219, כל בקשת Fable 5 מסומנת רצה מחדש על מודל Opus ברירת המחדל של הספק שלך, ו-Opus 5 לא היה מקור גיבוי.

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

#רמת מאמץ אחרי גיבוי

כש-Claude Code מעביר את ההפעלה שלך למודל הגיבוי, הוא שומר את רמת המאמץ שבה רצה הבקשה המסומנת. לדוגמה, הפעלה על Opus 5.5 בברירת המחדל medium שלה שעוברת לגיבוי ל-Opus 4.8 נשארת ב-medium, אף על פי ש-Opus 4.8 ברירת המחדל שלו היא high.

רמה אחרת חלה במקרים כמו אלה:

• שינוי משלך: אחרי שאתה בוחר רמת מאמץ, בוחר מודל ב-/model, או ממשיך את ההפעלה מאוחר יותר, הרמה של הבקשה המסומנת כבר לא עוברת הלאה.
• מאמץ שהוגדר לתור אחד: אם העלית את התור המסומן עם ultrathink, או ש-frontmatter של effort במיומנות קבע את הרמה שלו, הרמה הזו חלה על התור הזה. תורים מאוחרים יותר רצים ברמה שסדר הכרעת המאמץ נותן למודל הגיבוי.

כדי לראות את הרמה שהוגדרה להפעלה שלך אחרי גיבוי, הרץ /effort status. כדי לשנות אותה, הרץ /effort.

#בדיקה מה הפעיל את הגיבוי

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

כדי לבדוק אם התאמות אישיות הן הגורם, התחל הפעלה עם claude --safe-mode, שמבטל התאמות אישיות כמו CLAUDE.md, מיומנויות, שרתי MCP ו-hooks. מצב git ושמות תיקיות אינם התאמות אישיות ועדיין נכללים.

#שאלה לפני מעבר

כדי להחליט מה קורה בכל פעם שבקשה מסומנת, הרץ /config, בחר ב-Switch models when a message is flagged, ובחר ב-Ask each time. אפשר גם להגדיר את switchModelsOnFlag ל-false בקובץ ההגדרות שלך. Claude Code אז עוצר בבקשה מסומנת שהייתה מחליפה מודלים, ונותן לך שתי אפשרויות: לעבור למודל הגיבוי, או לערוך את ההנחיה ולנסות שוב.

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

אם תבחר להישאר על המודל הנוכחי, הערך שנשמר הוא false, כמו Ask each time. אם תסגור את השאלה, Claude Code לא שומר כלום ושואל שוב בפעם הבאה שבקשה מסומנת הייתה מחליפה מודלים.

כשבחרת Ask each time, חלק מהמקרים מתנהגים אחרת:

• כשלקטגוריה המסומנת אין מודל גיבוי, כמו סימון ביולוגיה על Opus 5 או על Sonnet 5.5, Claude Code לא מציג את השאלה והבקשה מסתיימת בסירוב.
• אם שני המודלים מסמנים את אותה בקשה, אפשר לערוך את ההנחיה ולנסות שוב, או להתחיל הפעלה חדשה.
• בהפעלות ענן באפליקציה לנייד, עריכה וניסיון חוזר אינם נתמכים. עבור מודלים, או המשך את ההפעלה מדפדפן במחשב או מהאפליקציה למחשב.
• במצב לא אינטראקטיבי ובשילובי SDK שלא יכולים להציג את השאלה, בקשה מסומנת מסיימת את התור בסירוב.
• בתת סוכן, Claude Code לא מציג את השאלה, ובקשה מסומנת שהייתה מחליפה מודלים רצה מחדש על מודל הגיבוי.
• כשיעד הגיבוי חסום על ידי availableModels, Claude Code לא מציג את השאלה. הבקשה המסומנת מסתיימת בסירוב, כמו בגיבוי אוטומטי כשהיעד חסום.

#הפעלת גיבוי ב-Bedrock, ב-Agent Platform וב-Foundry

ב-Amazon Bedrock, ב-Google Cloud's Agent Platform וב-Microsoft Foundry, מזהי המודל ייחודיים לספק, ולכן גיבוי אוטומטי פועל רק כש-Claude Code יכול לזהות כל מודל שמעורב:

• Claude Code חייב לזהות את המודל הנוכחי כמקור גיבוי. Fable 5.1 ו-Fable 5 מזוהים כשמזהה המודל מכיל claude-fable-5, תואם לערך של ANTHROPIC_DEFAULT_FABLE_MODEL, או ממופה עם modelOverrides. Opus 5.5, Sonnet 5.5 ו-Opus 5 מזוהים לפי מזהה המודל של הספק או לפי מיפוי modelOverrides.
• יעד Opus חייב להיות מוכרע בפריסה שלך, בלי קשר לאיזה מודל סירב: הגדר את ANTHROPIC_DEFAULT_OPUS_MODEL, או שמור רשומת Opus 4.8 ברשימת המודלים של הספק. בלי אחד מאלה, הגיבוי נשאר כבוי לכל מודל מקור, כולל Sonnet 5.5, ובקשות מסומנות מסתיימות בסירוב.
• מודל הגיבוי של הקטגוריה המסומנת חייב להיות מוכרע בפריסה שלך. ממודל Fable, מ-Opus 5.5 או מ-Opus 5, אם הגדרת את ANTHROPIC_DEFAULT_OPUS_MODEL, בקשות מסומנות רצות מחדש על המודל הזה לכל קטגוריה שיש לה גיבוי. סימון ביולוגיה על Opus 5 עדיין מסתיים בסירוב. אם לא הגדרת אותו, בקשות שסומנו באבטחת סייבר רצות מחדש על רשומת Opus 4.8, ובקשות שסומנו בביולוגיה ממודל Fable או מ-Opus 5.5 רצות על רשומת Opus 5. מ-Sonnet 5.5, בקשות שסומנו באבטחת סייבר רצות מחדש על המודל שהגדרת ב-ANTHROPIC_DEFAULT_SONNET_MODEL, או על רשומת Sonnet 5 ברשימת המודלים של הספק אם לא הגדרת אותו.

אם אי אפשר לזהות אחד משני המודלים, Claude Code לא עובר. הבקשה המסומנת מסתיימת בהודעת סירוב, ואפשר להחליף מודלים עם /model ולנסות שוב. כדי ששני המודלים יהיו ניתנים לזיהוי, הגדר את ההצמדות למודל המקור שלך:

• מודלי Fable: הגדר את ANTHROPIC_DEFAULT_FABLE_MODEL למזהה מודל ה-Fable שלך כדי ש-Claude Code יזהה אותו כמקור גיבוי.
• כל מודל מקור: הגדר את ANTHROPIC_DEFAULT_OPUS_MODEL למזהה מודל Opus כדי להפעיל גיבוי ולתת לקטגוריות המסומנות יעד. הצמדה שנותנת שם למודל מחוץ למשפחת Opus, או למודל שסירב, משאירה את הסירוב בעינו.
• Sonnet 5.5: בנוסף להצמדת Opus, הגדר את ANTHROPIC_DEFAULT_SONNET_MODEL או שמור רשומת Sonnet 5 ברשימת המודלים של הספק כדי לספק את המודל שעליו הבקשה רצה מחדש. הצמדת Sonnet שנותנת שם למודל מחוץ למשפחת Sonnet, או ל-Sonnet 5.5 עצמו, משאירה את הסירוב בעינו.

למודל הגיבוי חייב להיות גם חלון הקשר גדול לפחות כמו זה של ההפעלה, אחרת Claude Code לא עובר והבקשה המסומנת מסתיימת באותו סירוב. אצל הספקים האלה מודלי המקור רצים עם חלון ההקשר של 1M כברירת מחדל. הצמד מודל שגם הוא רץ כך, כמו Opus 4.8 ב-ANTHROPIC_DEFAULT_OPUS_MODEL או Sonnet 5 ב-ANTHROPIC_DEFAULT_SONNET_MODEL, באמצעות מזהה ש-Claude Code יכול להתאים למודל הזה.

#עומסי עבודה של מחקר אבטחה וביולוגיה

עומסי עבודה באבטחה התקפית או בביולוגיה, כולל בדיקות חדירה, תרגילי Capture the Flag (CTF), ובסיסי קוד סמוכים לביולוגיה, מפעילים גיבוי לעיתים קרובות, לעיתים קרובות בבקשה הראשונה. לעבודה ביולוגית מהותית על Fable 5.1, Fable 5 או Opus 5.5, הבקשה המסומנת הראשונה שמחליפה מודלים מעבירה את ההפעלה ל-Opus 5, ובקשות מאוחרות יותר שסומנו בביולוגיה מסתיימות שם בסירובים, כי ל-Opus 5 אין גיבוי לביולוגיה. ב-Opus 5 וב-Sonnet 5.5, הסירובים האלה מתקבלים כבר מהבקשה המסומנת הראשונה.

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

#כוונון רמת המאמץ

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

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

אם מגדירים רמה שהמודל הפעיל לא תומך בה, Claude Code עובר לרמה הנתמכת הגבוהה ביותר ששווה לרמה שהוגדרה או נמוכה ממנה. לדוגמה, xhigh רץ כ-high ב-Opus 4.6. הארגון או ההגדרות שלך יכולים גם להגביל את הרמות שמודל מציע. ראו מגבלות מאמץ של הארגון.

Claude Code קובע את רמת המאמץ של הסשן לפי הסדר הזה, ולוקח את הראשון שחל:

1. משתנה הסביבה CLAUDE_CODE_EFFORT_LEVEL
2. רמה שבוחרים בסשן, למשל עם /effort, בורר /model, או applyFlagSettings()
3. הפעלה עם --effort
4. ההגדרות שלך: הרמה שנשמרה למודל או מפתח effortLevel, עם הקדימות ביניהם ובין קובצי ההגדרות כפי שמפורט ב-modelSettings
5. מאמץ ברירת המחדל של המודל: high בכל מודל שתומך במאמץ, מלבד ש-Opus 5.5, Sonnet 5.5 ו-Haiku 5.5 ברירת המחדל שלהם היא medium ו-Opus 4.7 ברירת המחדל שלו היא xhigh. אם הארגון מגדיר רמת מאמץ כברירת מחדל ל-מודל ברירת המחדל של הארגון, הרמה הזו היא ברירת המחדל כשמריצים את המודל הזה.

אחרי נפילה אוטומטית למודל, ראו רמת מאמץ אחרי נפילה לרמה שחלה. לסוכני משנה ולחברי צוות, ראו רמת המאמץ של סוכני משנה וחברי צוות.

Opus 5.5 מתחיל ב-medium אלא אם אחד המקורות שלמעלה מגדיר לו רמה, ומפתח effortLevel ברמה העליונה בקובץ הגדרות המשתמש לא נספר עבור Opus 5.5. המפתח הזה הוא הצורה הישנה ש-/effort כתב לפני ש-Claude Code שמר רמות לפי מודל: הוא ממשיך לחול במקום שבו חל קודם, על Opus 5, Fable 5.1 ומודלים מוקדמים יותר, ו-Opus 5.5 ומודלים שיצאו אחריו מתחילים בברירת המחדל שלהם עד שבוחרים להם רמה עם /effort או בורר /model. מפתח effortLevel ברמה העליונה בהגדרות פרויקט, מקומיות או מנוהלות, או מפתח שמועבר עם --settings, חל על כל מודל.

כשמגדירים low, medium, high או xhigh בסשן אינטראקטיבי במחשב, משך הזמן נקבע לפי אופן האישור:

• Enter במחוון /effort או בבורר /model, או רמה שמוקלדת אחרי /effort: שמירת הרמה כברירת המחדל והחלה שלה בסשנים מאוחרים יותר
• s במחוון /effort או בבורר /model: החלת הרמה על הסשן הזה בלבד. נדרש Claude Code בגרסה v2.1.257 או חדשה יותר

Claude Code שומר את הרמה לפי מודל, תחת המפתח modelSettings בהגדרות המשתמש, כך שכל מודל שומר את הרמה שלו.

max היא רמת ההסקה העמוקה ביותר. אלא אם מגדירים אותה דרך משתנה הסביבה CLAUDE_CODE_EFFORT_LEVEL, Claude Code מחיל את max על הסשן הנוכחי בלבד.

[!NOTE]

רמה שבוחרים מבקרת המאמץ בטלפון או בדפדפן שמחוברים דרך Remote Control חלה על הסשן הזה בלבד.

כשמגדירים רמה עם /effort בהרצה עם -p, Claude Code מחיל אותה על הסשן הזה בלבד ולא שומר אותה כברירת המחדל.

למחוון /effort יש גם מתג Ultracode. Ultracode הוא הגדרה של Claude Code ולא רמת מאמץ של מודל: כשהוא פועל, Claude מתזמר זרימות עבודה דינמיות למשימות מהותיות, בכל רמת מאמץ שבה הסשן רץ. למקומות שבהם אפשר להגדיר אותו באופן קבוע, ראו את ההגדרה ultracode.

הפעלה או כיבוי של ultracode עם /effort או עם ההגדרה ultracode משאירים את רמת המאמץ ללא שינוי. הדגל --effort ultracode והערך effortLevel: "ultracode" ב-Agent SDK מפעילים אותו וגם מגדירים את הרמה ל-xhigh. בחירת רמה במחוון /effort או בבורר /model משאירה את ultracode כפי שהיה.

אפשר להפעיל את ultracode בכל אחת מהדרכים הבאות:

• /effort: מריצים /effort ultracode כדי להפעיל אותו לסשן הנוכחי או /effort ultracode off כדי לכבות אותו. במחוון /effort, לוחצים Tab כדי להפוך את מתג Ultracode, ואז Enter כדי להחיל אותו
• דגל --effort: מפעילים עם claude --effort ultracode, שמתחיל את הסשן במאמץ xhigh עם ultracode פועל
• הגדרת ultracode: מגדירים "ultracode": true בקובץ הגדרות, עם --settings, או בבקשת בקרה של Agent SDK. בקשת applyFlagSettings() מקבלת גם effortLevel: "ultracode", שמפעיל אותו ומגדיר את רמת המאמץ ל-xhigh

הצורה /effort ultracode off, מתג המחוון, והשארת ultracode פועל ברמות מאמץ שאינן xhigh דורשים Claude Code בגרסה v2.1.284 או חדשה יותר. לפני v2.1.284, הפעלת ultracode הגדירה את הסשן למאמץ xhigh, בחירת רמה אחרת כיבתה אותו, ומגבלת מאמץ מתחת ל-xhigh הפכה אותו ללא זמין.

העברת ultracode לדגל --effort או לערך effortLevel ב-Agent SDK דורשת Claude Code בגרסה v2.1.203 או חדשה יותר. לפני v2.1.203, --effort ultracode הדפיס Unknown --effort value 'ultracode' והסשן התחיל במאמץ ברירת המחדל.

ההגדרה השמורה effortLevel ומשתנה הסביבה CLAUDE_CODE_EFFORT_LEVEL לא מקבלים ultracode. אם CLAUDE_CODE_EFFORT_LEVEL או מגבלת מאמץ קובעים את רמת הסשן, ultracode נשאר פועל ברמה הזו.

Ultracode לא זמין כאשר:

• זרימות העבודה כבויות
• המודל לא תומך במאמץ xhigh

במקרים האלה --effort ultracode מתחיל את הסשן עם ultracode כבוי, ברמת המאמץ הגבוהה ביותר שהמודל וכל מגבלה מתירים, עד xhigh.

#בחירת רמת מאמץ

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

בבדיקות על Opus 5.5 ו-Fable 5.1, Claude ברמה גבוהה יותר בדק יותר מקרי קצה ואימת יותר מהעבודה שלו לפני המענה. הוא גם קיבל יותר החלטות בעצמו. ברמה נמוכה יותר, Claude החזיר נקודת התחלה מוקדם יותר, מה שמתאים לעבודה שבה בודקים כל תוצאה ומכוונים את הצעד הבא. כדי לראות את אותן משימות רצות בכל רמה, קראו Using Claude Code: Spending your effort בבלוג.

סולם המאמץ מכויל לפי מודל, ולכן אותו שם רמה לא מייצג את אותו ערך בסיסי בין מודלים.

Opus 5.5 ברירת המחדל שלו היא medium, רמה אחת מתחת לברירת המחדל high של Opus 5. בבדיקות של Anthropic, Opus 5.5 ב-medium משתווה ל-Opus 5 ב-high או עולה עליו בהערכות תכנות ועבודת ידע. ברמה נתונה, Opus 5.5 נוטה לחשוב יותר בכל תור מ-Opus 5. במעבר מ-Opus 5 ל-Opus 5.5, מתחילים ב-medium במקום להעביר את הרמה ששימשה ב-Opus 5. כדי לבדוק רמות מול העבודה שלך, ראו Calibrate effort במדריך הפרומפטים של Opus 5.5.

#שימוש ב-ultrathink להסקה עמוקה חד פעמית

כוללים את ultrathink בכל מקום בפרומפט כדי לבקש הסקה עמוקה יותר בתור הזה בלי לשנות את הגדרת המאמץ של הסשן. Claude Code מזהה את מילת המפתח ומוסיף הוראה בתוך ההקשר. Claude Code מעביר ביטויים אחרים כמו "think", "think hard" ו-"think more" כטקסט פרומפט רגיל ולא מזהה אותם כמילות מפתח.

כשמוקלדת בפרומפט של הטרמינל, המילה יכולה גם להעלות את התור הזה למאמץ xhigh. כשהיא יכולה, המילה מוצגת בצבעי קשת. נדרש Claude Code בגרסה v2.1.311 או חדשה יותר. אם המילה אינה בצבעי קשת כשמתחילים תור חדש, נסו אחד מאלה:

• הקלידו אותה מחדש מחוץ לכל דבר כמו מרכאות, סוגריים, נתיב או פקודה, בפרומפט שלא מתחיל ב-/
• בטלו את CLAUDE_CODE_EFFORT_LEVEL אם הוא מוגדר מתחת ל-xhigh, העלו את maxEffortLevel שלכם ל-xhigh או מעל, או בקשו ממנהל הארגון להעלות את מגבלת הארגון
• הריצו /model בסשן כדי לעבור למודל Opus 5.5, Sonnet 5.5, Haiku 5.5 או Fable 5.1. במקום שבו המילה לא יכולה להעלות תור, כמו ב-Amazon Bedrock, הגדירו את רמת המאמץ

#הגדרת רמת המאמץ

אפשר לשנות מאמץ בכל אחת מהדרכים הבאות:

• /effort: מריצים /effort בלי ארגומנטים כדי לפתוח מחוון אינטראקטיבי, /effort ואחריו שם רמה כדי להגדיר ישירות, או /effort auto כדי לנקות את הרמה השמורה של המודל הפעיל
• ב-/model: משתמשים במקשי החצים שמאלה וימינה כדי לכוונן את מחוון המאמץ בבחירת מודל. הרמה החדשה מתחילה עם ההודעה הבאה לכל המאוחר. עד אז, Claude יכול להמשיך לעבוד ברמה הישנה, גם במודל חדש. כל עוד מקור שמדרג מעל הבחירה חל, כמו CLAUDE_CODE_EFFORT_LEVEL, Claude עובד ברמה של המקור הזה.
• דגל --effort: מעבירים שם רמה כדי להגדיר אותה לסשן יחיד בהפעלת Claude Code
• משתנה סביבה: מגדירים את CLAUDE_CODE_EFFORT_LEVEL לשם רמה. כדי ש-Claude Code לא ישלח רמת מאמץ, מגדירים אותו ל-auto או ל-unset
• הגדרות: מגדירים רמה לפי מודל ב-modelSettings, או מגדירים את effortLevel ל-low, medium, high או xhigh כברירת מחדל למודלים שאין להם רמה. max לא מתקבל כרמה באף אחד מהמפתחות, ול-ultracode יש מפתח ultracode משלו
• ממכשיר מחובר: בסשן Remote Control, בוחרים רמה מבקרת המאמץ בטלפון או בדפדפן. הרמה חלה על הסשן הנוכחי בלבד. נדרש Claude Code בגרסה v2.1.234 או חדשה יותר
• frontmatter של מיומנות ושל סוכן משנה: מגדירים effort בקובץ Markdown של מיומנות או של סוכן משנה כדי לדרוס את רמת המאמץ כשהמיומנות או סוכן המשנה רצים

ה-effort של מיומנות חל עד סוף התור שבו היא רצה, או לכל ריצת סוכן המשנה המפוצל עם context: fork. ה-effort של סוכן משנה חל בזמן שסוכן המשנה רץ, אלא אם ההפעלה שלו דורסת אותו. כל עוד אחד מהם חל, המיומנות או סוכן המשנה רצים ברמה שלהם, בכל רמה שמפעילים איתה, שומרים או בוחרים. אם CLAUDE_CODE_EFFORT_LEVEL מוגדר, הרמה הזו חלה במקומה.

maxEffortLevel או מגבלת מאמץ של הארגון עדיין מגבילים את הרמה שבה המיומנות או סוכן המשנה רצים. אם מגדירים effortLevel ב-הגדרות מנוהלות, Claude Code מחיל אותו בשלב ההגדרות של סדר קביעת המאמץ, ומשתמשים עדיין יכולים לשנות את הרמה עם /effort או --effort. כדי להשאיר משתמשים ברמה או מתחתיה, מגדירים maxEffortLevel.

#רמת המאמץ של סוכני משנה וחברי צוות

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

#בדיקת רמת המאמץ שהוגדרה

מחוון המאמץ מופיע ב-/model כשנבחר מודל נתמך. רמה בכותרת הסשן, לדוגמה "with low effort", מגיעה מהגדרת המאמץ, גם אם Claude עדיין עובד ברמה הישנה. בהפעלה וכשמשנים אותה, גם הכותרת התחתונה מציגה לזמן קצר את הרמה שהוגדרה לסשן.

#מתי רמת מאמץ חדשה מתחילה

בסשן טרמינל, אחרי ש-/effort מאשר את הרמה החדשה, ההודעה הבאה שנשלחת רצה ברמה הזו. אפשר לשלוח אותה אחרי שהתור שבעיצומו מסתיים או בזמן ש-Claude עדיין עובד:

• אחרי שהתור מסתיים: אין צורך לעשות דבר עד אז, וצפוי שהתור יסתיים ברמה הישנה
• בזמן ש-Claude עדיין עובד: מקלידים הודעה, כמו keep going, ולוחצים Enter כדי להכניס אותה לתור בלי להפריע לתור. Claude מקבל אותה כשקריאות הכלים הנוכחיות מסתיימות, או כשהתור מסתיים לכל המאוחר, ועובד ברמה החדשה מהנקודה הזו ואילך.

לפני v2.1.242, Claude Code יכול היה להכניס את /effort עצמו לתור עד שהתור הסתיים, ותמיד עשה זאת בסשן שלא מושך דגלי תכונות, כמו אצל ספק צד שלישי.

#שליחה בלי רמת מאמץ

כש-Claude Code לא שולח רמת מאמץ למודל נתמך, ברירת המחדל של ה-API חלה במקום זו של Claude Code. כדי ש-Claude Code לא ישלח רמה, מפעילים את claude ממעטפת שמייצאת את CLAUDE_CODE_EFFORT_LEVEL עם הערך auto או הערך unset, שעושים את אותו הדבר:

export CLAUDE_CODE_EFFORT_LEVEL=auto

כותרת הסשן והכותרת התחתונה לא מציגות רמת מאמץ כל עוד לא נשלחת רמה. כדי לאשר שלא נשלחת רמה, מריצים /effort status בפרומפט של Claude Code:

• Effort level: auto: לא נשלחת רמת מאמץ.
• Effort level: auto (currently <level>): עדיין נשלחת רמה. אם הגדרת maxEffortLevel מתחת ל-max חלה על המודל הפעיל, Claude Code שולח את ברירת המחדל שלו למודל, מונמכת למגבלה הזו. הסירו את ההגדרה או הגדירו אותה ל-max.

[!NOTE]

לפני v2.1.304, /effort status הדפיס Effort level: auto (currently high) גם כשלא נשלחה רמה.

#הסקה מסתגלת ותקציבי חשיבה קבועים

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

מודלי Fable, Sonnet 5 ומאוחר יותר, Haiku 5.5, ו-Opus 4.7 ומאוחר יותר תמיד משתמשים בהסקה מסתגלת. מצב תקציב החשיבה הקבוע ו-CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING לא חלים עליהם.

ב-Opus 4.6 וב-Sonnet 4.6 אפשר להגדיר CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING=1 כדי לחזור לתקציב החשיבה הקבוע הקודם שנשלט על ידי MAX_THINKING_TOKENS. ראו משתני סביבה.

#חשיבה מורחבת

חשיבה מורחבת היא הנימוק ש-Claude פולט לפני שהוא מגיב. במודלים שתומכים בנימוק מסתגל, רמת המאמץ היא הבקרה העיקרית לכמות החשיבה שמתרחשת. ההגדרות למטה מפעילות או מכבות את החשיבה ושולטות באופן שבו היא מוצגת. כשחשיבה כבויה ב-Anthropic API, Claude Code שולח מאמץ high במקום רמה גבוהה יותר למודלים שהוא יודע שלא מקבלים את השילוב הזה, כמו Opus 5.

אי אפשר לכבות חשיבה ב-Opus 5.5, ב-Sonnet 5.5, ב-Haiku 5.5 או במודלי Fable. מתג הסשן והשורה של /config מציגים Thinking can't be turned off עבור המודלים האלה במקום להציע את המתג, והגדרה שמורה alwaysThinkingEnabled: false או MAX_THINKING_TOKENS=0 לא משפיעה שם. במודלים האלה, המודל מחליט בכל צעד כמה לחשוב לפי רמת המאמץ. ההגדרה השמורה חלה שוב כשעוברים למודל שמקבל אותה.

Claude Code מקפל את פלט החשיבה כברירת מחדל. לחצו Ctrl+O כדי להחליף למצב מפורט ולראות את הנימוק כטקסט אפור נטוי. סשנים אינטראקטיביים ב-Anthropic API מקבלים כברירת מחדל בלוקי חשיבה מושחרים, לכן הגדירו showThinkingSummaries: true בהגדרות אם אתם רוצים שהסיכומים המלאים יהיו זמינים כשאתם מרחיבים. אתם מחויבים על כל אסימוני החשיבה שנוצרים, גם כשהם מקופלים או מושחרים.

#הקשר מורחב

Fable 5.1, Fable 5, Sonnet 5 ואילך, Haiku 5.5, Opus 4.6 ואילך, ו-Sonnet 4.6 תומכים בחלון הקשר של מיליון אסימונים לסשנים ארוכים עם בסיסי קוד גדולים.

Fable 5.1, Fable 5, Sonnet 5 ואילך, Haiku 5.5, ו-Opus 4.7 ואילך רצים עם חלון 1M כברירת מחדל, בלי צורך בסיומת [1m]. זה כולל סשנים ב-Amazon Bedrock, ב-Agent Platform של Google Cloud וב-Microsoft Foundry, וסשנים של שער אפליקציות Claude. כדי להריץ אותם עם חלון של 200K, ראו כיבוי הקשר 1M.

Opus 4.6 ו-Sonnet 4.6 מגיעים ל-1M רק דרך וריאנט ה-[1m] שלהם, והגישה לוריאנט הזה תלויה בתוכנית שלכם. בתוכניות Max, Ultra, Team ו-Enterprise, כולל מושבי Team Standard ומושבי Team Premium, Opus 4.6 עם הקשר 1M כלול במנוי. Sonnet 4.6 עם הקשר 1M דורש זיכויי שימוש בכל תוכנית מנוי, כולל Max ו-Ultra.

Claude Code בודק את דרישות התוכנית האלה רק כשהוא מתחבר ל-Anthropic API ישירות. אם מפנים את ANTHROPIC_BASE_URL אל שער LLM וההתחברות השמורה ל-claude.ai נשארת האישור הפעיל, Claude Code לא בודק את זיכויי השימוש של התוכנית. אפשרויות [1m] נשארות זמינות ב-/model, והשער מחליט אם הבקשה מצליחה. לפני v2.1.229, Claude Code דחה את /model sonnet[1m] בתצורה הזו כשלא היה אפשר לאשר זיכויי שימוש בחשבון.

ב-Anthropic API, חלון הקשר של 1M משתמש בתמחור המודל הרגיל בלי תוספת על אסימונים מעבר ל-200K, חוץ מאשר ב-Haiku 5.5, שעולה יותר בהנחיות ארוכות מ-100K אסימונים. בתוכניות שבהן הקשר מורחב כלול במנוי, השימוש נשאר מכוסה על ידי המנוי. בתוכניות שניגשות להקשר מורחב דרך זיכויי שימוש, האסימונים מחויבים לזיכויי השימוש.

#בחירת הקשר 1M עבור Opus 4.6 או Sonnet 4.6

כדי לבחור וריאנט 1M לפי שם, הוסיפו את הסיומת [1m] לכינוי מודל או לשם מודל מלא:

# Append [1m] to a full model name
/model claude-opus-4-6[1m]
/model claude-sonnet-4-6[1m]

# Or to an alias: the suffix applies to the model the alias resolves to
/model opus[1m]

#חלון הקשר מאחורי שער LLM

אם מגדירים את ANTHROPIC_BASE_URL לשער LLM או לפרוקסי אחר, Claude Code נותן לכל מודל שהוא מזהה את אותו חלון הקשר שיש למודל ב-Anthropic API. Fable 5.1, Fable 5, Sonnet 5 ואילך, Haiku 5.5, ו-Opus 4.7 ואילך מקבלים את חלון ה-1M בלי וריאנט [1m] לבחירה, ומודל שמגיע ל-1M רק דרך וריאנט ה-[1m] שלו, כמו Opus 4.6, רץ ב-200K בלעדיו. Claude Code לא יכול לזהות מגבלה נמוכה יותר שהשער או השרת שמאחוריו אוכפים. אם השער דוחה בקשות מעל 200K אסימונים, הגדירו CLAUDE_CODE_AUTO_COMPACT_WINDOW=200000 בסביבה שמפעילה את Claude Code, כדי שסשנים בכל מודל יידחסו בגבול הזה.

#כיבוי הקשר 1M

כדי להשאיר סשנים בחלון של 200K, הגדירו CLAUDE_CODE_DISABLE_1M_CONTEXT=1 במעטפת או בקובץ הגדרות. Claude Code מסיר את וריאנטי המודל [1m] מבורר המודלים. במודלים שרצים עם חלון ה-1M כברירת מחדל, כמו מודלי Fable, Sonnet 5 ואילך, ו-Opus 4.7 ואילך, הוא גם מתייחס למודל כאל מודל עם חלון הקשר של 200K:

• כשדחיסה אוטומטית פועלת, הסשנים נדחסים בגבול 200K דרך דחיסה אוטומטית. הגדרת חלון הדחיסה האוטומטית מעל 200K לא מסירה את ההגבלה, כי Claude Code מגביל את החלון הזה לחלון הקשר של המודל.
• כשדחיסה אוטומטית כבויה, הסשנים נעצרים בגבול 200K עם שגיאת מגבלת ההקשר במקום להידחס.

#חלון הקשר והתמחור של Haiku 5.5

ב-Anthropic API, Haiku 5.5 רץ עם חלון הקשר של 1M בכל תוכנית, בלי סיומת [1m] לבחירה. מזהה המודל שלו הוא claude-haiku-5-5. כדי להשתמש בו, הריצו /model claude-haiku-5-5 בסשן, או הפעילו את Claude Code מהמעטפת עם claude --model claude-haiku-5-5.

בקשה של Haiku 5.5 עולה יותר לכל אסימון כשההנחיה שלה ארוכה מ-100K אסימונים. ראו תמחור Anthropic לשני התעריפים.

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

#חלון הקשר ודחיסה אוטומטית

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

#הגדרת חלון הדחיסה האוטומטית

[!NOTE]

אם Claude Code הזהיר לגבי הערך של CLAUDE_CODE_AUTO_COMPACT_WINDOW, ראו הערכים והאזהרות של המשתנה.

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

• למודל הנוכחי, בהפעלה הזאת ובהפעלות שאחריה: הריצו /autocompact עם ערך, כמו /autocompact 500k. Claude Code שומר את זה בהגדרות המשתמש תחת המודל הנוכחי ב-modelSettings ומחיל את זה על ההפעלה הנוכחית. אם היקף הגדרות בעדיפות גבוהה יותר, כמו הגדרות מנוהלות, מגדיר חלון משלו למודל הזה או לכל מודל, הפקודה שומרת את הערך שלכם אבל ההפעלה שומרת על החלון של ההיקף הזה, והפקודה אומרת זאת. הריצו /autocompact auto כדי לחזור לחלון המכוונן למודל שלכם. לפני v2.1.288, הפקודה שמרה חלון אחד לכל מודל, בתור autoCompactWindow ברמה העליונה.
• לכל מודל: הגדירו autoCompactWindow בקובץ הגדרות, כמו "autoCompactWindow": 200000 ב-~/.claude/settings.json. חלון ששמרתם למודל עם /autocompact גובר על המפתח הזה באותו קובץ עבור המודל הזה.
• להפעלה אחת: העבירו --autocompact כשמתחילים את Claude Code. הדגל דורס את ההגדרה השמורה להפעלה הזאת בלי לשנות אותה, ו-claude --autocompact auto מריץ את ההפעלה בחלון המכוונן גם אם להגדרה השמורה יש ערך. בניגוד ל-/autocompact, הדגל לא נדחה על ידי היקף הגדרות בעדיפות גבוהה יותר כמו הגדרות מנוהלות.
• בסקריפטים ובסביבות ענן: הגדירו CLAUDE_CODE_AUTO_COMPACT_WINDOW לספירת אסימונים כמו 200000. אלא אם Claude Code מתעלם מהערך, המשתנה גובר על הפקודה, על הדגל ועל הגדרת autoCompactWindow. אז /autocompact מדווח על הדריסה בלי לשמור. ה-used_percentage בשורת המצב נמדד מול חלון ההקשר המלא של המודל, כך שכל עוד המשתנה מוגדר, האחוז הזה לא מציין מתי הדחיסה תרוץ.
• עבור סוכן משנה אחד: ראו הגדרת חלון הדחיסה האוטומטית לסוכן משנה אחד.

הפקודה והדגל מקבלים גודל חלון מ-100K עד 1M אסימונים, בכל אחת מהצורות האלה:

• ספירת אסימונים פשוטה, כמו 200000
• סיומת k או M, כמו 500k או 1M
• מספר חשוף מ-100 עד 1000, שמשמעותו אלפים, כך ש-200 מגדיר 200,000

בכל דרך שתגדירו את החלון, Claude Code מגביל אותו לחלון ההקשר של המודל.

#ערכים ואזהרות עבור CLAUDE_CODE_AUTO_COMPACT_WINDOW

אזהרה שמצטטת את הערך של CLAUDE_CODE_AUTO_COMPACT_WINDOW שלכם אומרת שהערך נמצא מחוץ ל-100,000 עד 1,000,000 או שאינו ספירת אסימונים. כדי להפסיק את האזהרה, הגדירו מספר בטווח הזה, כמו CLAUDE_CODE_AUTO_COMPACT_WINDOW=200000. ב-Claude Code v2.1.304 ואילך, אפשר גם לכתוב את המספר עם k לאלפים או M למיליונים, כמו ב-200k או 1M.

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

מספר בלי סיומת נקרא כמספר האסימונים הזה, כך ש-CLAUDE_CODE_AUTO_COMPACT_WINDOW=200 אומר 200 אסימונים אף על פי ש-/autocompact 200 אומר 200,000.

#ספי ברירת מחדל לדחיסה אוטומטית

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

• הפעלות ענן נדחסות כשהשיחה מתקרבת למגבלת המודל
• Sonnet 4.6 ו-Opus 4.6 בלי הקשר מורחב נדחסים בגבול 200K
• כשמגדירים CLAUDE_CODE_DISABLE_1M_CONTEXT=1, מודלים עם חלון מקורי של 1M, כמו Sonnet 5 ומודלי Fable, נדחסים בגבול 200K
• מודלים שרצים עם חלון מקורי של 1M נדחסים לפני שהחלון מתמלא, בערך ב-967K אסימונים כברירת מחדל. אלה כוללים את מודלי Fable, את Sonnet 5 ואילך, את Haiku 5.5, ואת Opus 4.7 ואילך. מאחורי ANTHROPIC_BASE_URL מותאם, ראו חלון ההקשר מאחורי שער
• הפעלות על מזהה מודל ש-Claude Code לא מזהה, כמו כינוי של שער LLM, נדחסות בחלון ההקשר ש-Claude Code מניח עבור המזהה. ראו תיקון החלון עבור שער או מזהה מודל מותאם

ראו את ההגדרה idleCompaction למתי Claude Code גם דוחס שיחה שמשאירים בלי פעילות.

#תיקון החלון עבור שער או מזהה מודל מותאם

כל אחת משתי אזהרות ההפעלה האלה אומרת ש-Claude Code לא מזהה את מזהה המודל של ההפעלה, ולכן הוא לא יכול לדעת את חלון ההקשר של המודל ומניח 200K אסימונים:

⚠ Model "my-gateway-opus" isn't recognized · context assumed to be 200k tokens · ...
Claude Code doesn't recognize the model "my-gateway-opus", so it assumes a context window of 200k tokens. Update Claude Code, or see https://code.claude.com/docs/en/model-config#correct-the-window-for-a-gateway-or-custom-model-id to set the window.

Claude Code דוחס אוטומטית את השיחה ב-200K המשוערים, כך שאם חלון ההקשר האמיתי של המודל הוא 200K, אין מה לתקן. במקרה האחר, תנו ל-Claude Code את החלון האמיתי בכל אחת מהדרכים האלה שמתאימה למזהה שלכם:

• מודל חדש יותר מגרסת Claude Code שלכם: הריצו claude update במעטפת. אם Claude Code מזהה את המזהה אחרי העדכון, אין צורך להגדיר שום דבר נוסף.
• השם של השער או של הספק שלכם למודל ש-Claude Code מכיר: הוסיפו רשומת modelOverrides שממפה את מזהה המודל של Anthropic למזהה שלכם, כמו "claude-opus-4-8": "my-gateway-opus". אפשר במקום זאת לרשום את המזהה שלכם בשורה של modelPicker עם behavesAs שמוגדר למודל הזה. בכל אחת מהדרכים, Claude Code מתייחס אחר כך למזהה כאל המודל הזה.
• מודל עם חלון של 1M: הוסיפו [1m] למזהה במקום שבו מגדירים את המודל, כמו claude --model 'my-gateway-opus[1m]' במעטפת. אם כיביתם הקשר של 1M, מתקבל אותו חלון עם הסיומת או בלי הסיומת.
• כל חלון אחר: הגדירו CLAUDE_CODE_MAX_CONTEXT_TOKENS לגודל החלון באסימונים בסביבה שמפעילה את Claude Code, כמו CLAUDE_CODE_MAX_CONTEXT_TOKENS=400000. עבור מזהה לא מזוהה שלא מתחיל ב-claude- ואין לו סיומת [1m], המשתנה נכנס לתוקף בפני עצמו. עבור כל מזהה אחר, בדקו קודם לאילו מזהים הוא חל.

ברגע ש-Claude Code מזהה את המזהה או משתמש בחלון שנתתם לו, האזהרה לא מופיעה יותר כשמתחילים הפעלה על המזהה הזה.

#לאילו מזהים CLAUDE_CODE_MAX_CONTEXT_TOKENS חל

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

האופן שבו המשתנה חל תלוי במזהה. Claude Code מתייחס למזהה כאיות של ספק או כאיות מותאם כשהוא לא מתחיל ב-claude-, בכל רישיות, או כשהוא נושא סיומת ש-Claude Code מסיר בקריאת המזהה, כמו תאריך @YYYYMMDD שמשמש ב-Agent Platform של Google Cloud. לפני v2.1.259, Claude Code לא הביא בחשבון סיומת שהוסרה, כך שמזהה claude- לא מזוהה עם סיומת תאריך טופל כשם claude- חשוף.

איות לא מזוהה של ספק או איות מותאם, אותו איות עם [1m], וכל מזהה אחר הם שלושה מקרים נפרדים:

• אם Claude Code לא יכול לפתור איות של ספק או איות מותאם למודל שהוא מזהה והמזהה לא מכיל [1m], המשתנה חל ישירות ודחיסה יזומה ממשיכה בחלון המוצהר.

• אם Claude Code לא יכול לפתור איות של ספק או איות מותאם למודל שהוא מזהה והמזהה מכיל [1m], בכל רישיות, Claude Code מניח עבורו חלון של 1M והמשתנה לא חל בפני עצמו. כדי לתקן את החלון ועדיין לשמור על דחיסה יזומה, הגדירו גם CLAUDE_CODE_DISABLE_1M_CONTEXT=1. כשהמשתנה הזה מוגדר, Claude Code מגדיר את גודל המזהה כמו אותו איות בלי [1m], כך ש-CLAUDE_CODE_MAX_CONTEXT_TOKENS חל כשהוא היה חל על האיות בלי התג.

  עם חלון מוצהר מעל 200K, האזהרה שמגבלת 200K לא נאכפת צפויה בתצורה הזאת.

• אם המזהה נפתר למודל ש-Claude Code מזהה, או שהמזהה הוא שם claude- חשוף בלי סיומת ש-Claude Code יכול להסיר, בכל רישיות, המשתנה נכנס לתוקף רק כשמגדירים גם DISABLE_COMPACT, שמבטל את כל הדחיסה.

  לדוגמה, מזהה שמכיל שם מודל Claude ש-Claude Code מכיר, כמו anthropic/claude-opus-4-8, us.anthropic.claude-…-v1:0, או claude-sonnet-4-5@20250929 עם תאריך, נפתר למודל הזה. זה כולל מזהים שמכילים גם [1m]: Claude Code פותר את claude-opus-4-8[1m] ל-Opus 4.8 גם כש-CLAUDE_CODE_DISABLE_1M_CONTEXT מוגדר.

עבור מזהה מודל ש-Claude Code לא מזהה, הגדירו CLAUDE_CODE_DISABLE_UNKNOWN_MODEL_WINDOW_ENFORCEMENT=1 כדי ש-Claude Code ידחוס רק אחרי שה-API דוחה את השיחה עם שגיאת אורך יתר ש-Claude Code מזהה. Claude Code לא מריץ את השחזור הזה כששער משכתב את השגיאה לניסוח ש-Claude Code לא מזהה.

#בדיקת המודל הנוכחי

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

• בשורת המצב, אם הוגדרה אחת
• ב-/status, שמציג גם את פרטי החשבון

#הוספת אפשרות מודל מותאמת

השתמשו ב-ANTHROPIC_CUSTOM_MODEL_OPTION כדי להוסיף רשומה מותאמת אחת לבורר /model בלי להחליף את הכינויים המובנים. זה שימושי לבדיקת מזהי מודל ש-Claude Code לא מציג כברירת מחדל. בפריסות של שער LLM, Claude Code יכול למלא את הבורר מנקודת הקצה /v1/models של השער כש-CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY=1 מוגדר, כך שהמשתנה הזה נדרש רק כשהגילוי כבוי או לא מחזיר את המודל הרצוי. ראו גילוי מודלים בשער.

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

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

export ANTHROPIC_CUSTOM_MODEL_OPTION="my-gateway/claude-opus-5-5"
export ANTHROPIC_CUSTOM_MODEL_OPTION_NAME="Opus via Gateway"
export ANTHROPIC_CUSTOM_MODEL_OPTION_DESCRIPTION="Custom deployment routed through the internal LLM gateway"

ANTHROPIC_CUSTOM_MODEL_OPTION_NAME ו-ANTHROPIC_CUSTOM_MODEL_OPTION_DESCRIPTION הם אופציונליים:

• אם משמיטים את השם, הרשומה מציגה את שם המודל כש-Claude Code מזהה את המזהה, ואת מזהה המודל כשהוא לא מזהה אותו.
• אם משמיטים את התיאור, Claude Code משתמש ב-Custom model (<model-id>).

Claude Code מציג את הרשומה המותאמת אחרי הרשומות המובנות, וכל שורות modelPicker שמוסיפים מגיעות אחריה.

Claude Code מדלג על אימות למזהה המודל שמוגדר ב-ANTHROPIC_CUSTOM_MODEL_OPTION, כך שאפשר להשתמש בכל מחרוזת שנקודת הקצה של ה-API מקבלת.

כש-availableModels מוגדר, כללו גם את מזהה המודל המותאם ברשימת המותרים. אם לא, Claude Code מסנן את הרשומה המותאמת מהבורר ודוחה בחירת --model שלה כמו כל מודל מוחרג אחר.

מזהה מותאם שמשבץ שם משפחה, כמו my-gateway/claude-opus-5-5, נספר כרשומה ספציפית למשפחה הזאת ומבטל את תו הכללי שלה, לכן רשמו גם את הגרסאות שאתם מתכוונים להשאיר ניתנות לבחירה. ראו התנהגות מיזוג.

#משתני סביבה

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

אצל ספקי צד שלישי, התאמה אישית של תצוגת מודל מוצמד והיכולות שלו מתאר מה השורה של מודל מוצמד מציגה בבורר /model.

הערה: ANTHROPIC_SMALL_FAST_MODEL הוצא משימוש לטובת ANTHROPIC_DEFAULT_HAIKU_MODEL.

#הצמדת מודלים לפריסות אצל צד שלישי

כשפורסים את Claude Code דרך Amazon Bedrock, Google Cloud's Agent Platform, Microsoft Foundry, או Claude Platform on AWS, הצמד גרסאות מודל לפני ההשקה למשתמשים.

בלי הצמדה, Claude Code משתמש בכינויי מודל כמו fable, opus, sonnet ו-haiku שנפתרים למזהה מודל ברירת מחדל מובנה לכל ספק. ברירת המחדל הזו יכולה לפגר אחרי המהדורה החדשה ביותר של Anthropic, והמודל שהיא מצביעה אליו עשוי עדיין לא להיות מופעל בחשבון של משתמש. כשברירת המחדל לא זמינה, משתמשי Amazon Bedrock ו-Google Cloud's Agent Platform רואים הודעה והסשן נופל חזרה לגרסה מוקדמת יותר של מודל ברירת המחדל, או למודל Sonnet ברירת המחדל כשברירת המחדל היא מודל Opus ואין גרסת Opus זמינה. משתמשי Microsoft Foundry רואים שגיאות במקום זאת, כי ל-Microsoft Foundry אין בדיקת הפעלה מקבילה.

ב-Amazon Bedrock וב-Google Cloud's Agent Platform, משתמש שמתחיל את הסשן בגרסת Sonnet או Opus מסוימת, למשל עם --model, ANTHROPIC_MODEL, או הגדרת model, מצמיד את הגרסה הזו כברירת המחדל של הסשן לכינוי התואם: בדיקת ההפעלה מדלגת על ברירת המחדל המובנית שהיא מחליפה ולא מציגה הודעת נפילה חזרה. לפני v2.1.211, הבדיקה רצה ויכלה להציג הודעה גם כשמודל סשן הוגדר במפורש.

[!WARNING]

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

השתמש במשתני הסביבה הבאים עם מזהי מודל ספציפיים לגרסה עבור הספק שלך:

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

מודל מוצמד עם חלון 1M מקורי, כמו Opus 4.8 או Sonnet 5, רץ עם חלון ההקשר של 1M בלי שום סיומת כש-Claude Code יכול להתאים את המזהה המוצמד למודל הזה. המזהה תואם כשהוא מכיל את מזהה ה-API של Anthropic של המודל, כמו ש-us.anthropic.claude-opus-4-8 מכיל את claude-opus-4-8, או כשרשומת modelOverrides ממפה את המודל אליו. במזהה מוצמד ש-Claude Code לא יכול להתאים למודל, סשנים רצים עם חלון 200K כברירת מחדל אלא אם המזהה נושא את הסיומת [1m].

למודל שמגיע ל-1M דרך וריאנט [1m] שלו, כמו Opus 4.6 או Sonnet 4.6, אפשר הקשר מורחב על ידי צירוף [1m] למזהה המודל ב-ANTHROPIC_DEFAULT_OPUS_MODEL או ב-ANTHROPIC_DEFAULT_SONNET_MODEL:

export ANTHROPIC_DEFAULT_OPUS_MODEL='claude-opus-4-6[1m]'

עם הסיומת [1m], חלון ההקשר של 1M חל על כל השימוש בכינוי המוצמד, כולל שלב ה-Opus של Plan Mode ב-opusplan וסוכני משנה ששדה ה-frontmatter model שלהם מציין את הכינוי.

• Claude Code מסיר את הסיומת לפני שליחת מזהה המודל לספק שלך.
• צרף [1m] רק כשהמודל הבסיסי תומך בהקשר של 1M.
• הסיומת נקראת לפי משתנה, לא לפי מודל. ב-Amazon Bedrock, ב-Google Cloud's Agent Platform וב-Microsoft Foundry, מזהה Opus 4.6 או Sonnet 4.6 בלי [1m] במשתנה אחד משתמש בהקשר של 200K גם אם משתנה אחר מגדיר את אותו מודל עם הסיומת.

כשאתה מגדיר משתנה ANTHROPIC_DEFAULT_*_MODEL, בורר /model מציג שורה אחת למודל הזה במקום השורות המובנות של המשפחה, כולל שורות הקשר של 1M. כדי להגיע לחלון 1M בלי להוסיף את הסיומת למשתנה הזה, המשתמשים שלך מריצים /model opus[1m], ו-Claude Code מחיל את הסיומת על המודל שהמשתנה מציין. /model sonnet[1m] עובד באותו אופן.

[!NOTE]

רשימת היתר availableModels שנמסרת דרך MDM או קובץ הגדרות מנוהל עדיין חלה בשימוש בספקי צד שלישי. הגדרות שמנוהלות בשרת לא נמסרות שם.

הסינון מתאים לפי כינוי מודל כמו opus, קידומת גרסה כמו claude-opus-4-8, או מזהה המודל המלא בצורת הספק. קידומות ספציפיות לספק כמו us.anthropic. לא מוסרות, ולכן כדי לאפשר מודל מסוים, מפה אותו דרך modelOverrides או ציין את מזהה צורת הספק המלא שלו:

• Google Cloud's Agent Platform: כשהמזהה ש-Claude Code מבקש נושא תאריך @, כמו claude-sonnet-4-5@20250929, כלול את התאריך ברשומת רשימת ההיתר שלך. לבדו, claude-sonnet-4-5 לא תואם את המזהה הזה תחת אף אחת מהגדרות availableModelsMatch.
• מודלים מוצמדים: ציין את הערך שהגדרת במשתנה ANTHROPIC_DEFAULT_*_MODEL של המודל

כל סיומת [1m] מוסרת גם מרשומת רשימת ההיתר וגם מהמודל המבוקש לפני ההתאמה.

#התאמה אישית של תצוגת מודל מוצמד והיכולות שלו

כשאתה מצמיד מודל אצל ספק צד שלישי, השורה שלו בבורר /model מציגה כברירת מחדל את שם המודל אם Claude Code מזהה את המזהה המוצמד, ואת המזהה הגולמי אחרת:

• מזוהה: המזהה המדויק של מודל ש-Claude Code מכיר, כמו מזהה ה-API של Anthropic שלו או הצורה שלו אצל הספק או ה-gateway שלך, עם או בלי הסיומת [1m]. הצמד את us.anthropic.claude-sonnet-4-5-20250929-v1:0 והשורה נקראת Sonnet 4.5.
• לא מזוהה: כל מזהה אחר, כמו ARN של פרופיל הסקה של אפליקציה או גרסת מודל ש-Claude Code לא מכיר, אלא אם רשומת modelOverrides ממפה מודל למזהה הזה. ב-Microsoft Foundry, שמות פריסה מוגדרים על ידי המשתמש, ולכן Claude Code אף פעם לא מזהה מזהה מוצמד שם, ממופה או לא, והשורה מציגה את שם הפריסה כברירת מחדל.

כששורה מציגה את שם המודל, תיאור ברירת המחדל שלה כולל את המזהה המוצמד כדי שעדיין תוכל לראות איזה מזהה מוצמד.

Claude Code עשוי גם לא לזהות אילו תכונות מודל מוצמד תומך בהן. אתה יכול להגדיר את שם התצוגה והתיאור בעצמך ולהצהיר על יכולות עם משתני סביבה נלווים לכל מודל מוצמד.

המשתנים האלה נכנסים לתוקף אצל ספקי צד שלישי כמו Amazon Bedrock, Google Cloud's Agent Platform ו-Microsoft Foundry. משתני _NAME ו-_DESCRIPTION נכנסים לתוקף גם כש-ANTHROPIC_BASE_URL מצביע ל-LLM gateway. אין להם השפעה בחיבור ישיר ל-api.anthropic.com.

אותן סיומות _NAME, _DESCRIPTION ו-_SUPPORTED_CAPABILITIES זמינות ל-ANTHROPIC_DEFAULT_SONNET_MODEL, ANTHROPIC_DEFAULT_HAIKU_MODEL, ANTHROPIC_DEFAULT_FABLE_MODEL ו-ANTHROPIC_CUSTOM_MODEL_OPTION.

Claude Code מפעיל תכונות כמו רמות מאמץ וחשיבה מורחבת על ידי התאמת מזהה המודל לדפוסים ידועים. מזהים ספציפיים לספק כמו ARN של Amazon Bedrock או שמות פריסה מותאמים אישית לעתים קרובות לא תואמים לדפוסים האלה, ומשאירים תכונות נתמכות כבויות. הגדר את _SUPPORTED_CAPABILITIES כדי לומר ל-Claude Code אילו תכונות המודל באמת תומך בהן:

כש-_SUPPORTED_CAPABILITIES מוגדר, Claude Code מפעיל את היכולות שברשימה ומכבה את אלה שלא ברשימה עבור המודל המוצמד התואם. כשהמשתנה לא מוגדר, Claude Code נופל חזרה לזיהוי מובנה לפי מזהה המודל.

הדוגמה הזו מצמידה את Opus ל-ARN של מודל מותאם אישית ב-Amazon Bedrock, מגדירה שם ידידותי, ומצהירה על היכולות שלו:

export ANTHROPIC_DEFAULT_OPUS_MODEL='arn:aws:bedrock:us-east-1:123456789012:custom-model/abc'
export ANTHROPIC_DEFAULT_OPUS_MODEL_NAME='Opus via Bedrock'
export ANTHROPIC_DEFAULT_OPUS_MODEL_DESCRIPTION='Opus 4.7 routed through a Bedrock custom endpoint'
export ANTHROPIC_DEFAULT_OPUS_MODEL_SUPPORTED_CAPABILITIES='effort,xhigh_effort,max_effort,thinking,adaptive_thinking,interleaved_thinking'

#דריסת מזהי מודל לפי גרסה

בפלטפורמות שמשבצות את Claude Code ומגדירות את CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST, תצורת המודל של המארח גוברת על הגדרות מודל מנוהלות, בעוד שרשימת היתר מנוהלת availableModels נשארת בתוקף אלא אם המארח מספק רשימה משלו. חריגים לקדימות של הגדרות מנוהלות מציין אילו מפתחות ומשתנים המארח דורס.

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

modelOverrides ממפה מזהי מודל Anthropic בודדים למחרוזות הספציפיות לספק ש-Claude Code שולח ל-API של הספק שלך. כשמשתמש בוחר מודל ממופה בבורר /model, Claude Code משתמש בערך שהגדרת במקום ברירת המחדל המובנית.

זה מאפשר למנהלי ארגון לנתב כל גרסת מודל ל-ARN מסוים של פרופיל הסקה ב-Amazon Bedrock, לשם גרסה ב-Google Cloud's Agent Platform, או לשם פריסה ב-Microsoft Foundry, לצורך ממשל, הקצאת עלויות, או ניתוב אזורי.

הגדר את modelOverrides בקובץ ההגדרות שלך:

{
  "modelOverrides": {
    "claude-opus-4-7": "arn:aws:bedrock:us-east-2:123456789012:application-inference-profile/opus-prod",
    "claude-opus-4-6": "arn:aws:bedrock:us-east-2:123456789012:application-inference-profile/opus-46-prod",
    "claude-sonnet-4-6": "arn:aws:bedrock:us-east-2:123456789012:application-inference-profile/sonnet-prod"
  }
}

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

כדי לעצור את שורת האבחון [claude-code:unrecognized_model] למזהה כמו כינוי gateway, הוסף רשומה עם המזהה הזה כערך שלה.

דריסות מחליפות את מזהי המודל המובנים שעומדים מאחורי כל רשומה בבורר /model. ב-Amazon Bedrock, רשומות modelOverrides גוברות על כל פרופילי הסקה ש-Claude Code מגלה אוטומטית בהפעלה. Claude Code מעביר ערכים שכבר מקוריים לספק, כמו ARN של פרופיל הסקה ב-Amazon Bedrock או שמות פריסה ב-Microsoft Foundry, לספק כפי שהם.

דריסות חלות גם כשאתה מעביר מזהה מודל של Anthropic ישירות דרך --model, משתנה הסביבה ANTHROPIC_MODEL, או משתנה סביבה ANTHROPIC_DEFAULT_*_MODEL. ב-Amazon Bedrock, ב-Google Cloud's Agent Platform וב-Mantle, מזהה מודל של Anthropic בלי רשומת modelOverrides נפתר לאותו מזהה ספציפי לספק כמו שורת בורר /model לגרסה הזו, כשהספק תומך בגרסה הזו. Mantle תומך בתת קבוצה של גרסאות. למזהה מודל של Anthropic מחוץ לתת הקבוצה הזו, Claude Code שולח את המזהה הגולמי ל-Mantle בלי למפות אותו, אלא אם רשומת modelOverrides מכסה אותו. לפני v2.1.200, --model וערכי משתני הסביבה הגיעו לספק כפי שהם בלי לעבור דרך מפת הדריסות.

modelOverrides עובד לצד availableModels. רשימת ההיתר מוערכת מול מזהה המודל של Anthropic, לא מול ערך הדריסה, כך שרשומה כמו "opus" ב-availableModels ממשיכה להתאים גם כשגרסאות Opus ממופות ל-ARN. כש-enforceAvailableModels מוגדר בהגדרות מנוהלות, ה-Default הנאכף נפתר דרך modelOverrides מהגדרות מנוהלות בלבד. מיפוי של מנהל, כמו גרסה שמוצמדת ל-ARN של פרופיל הסקה, מכובד ב-Default הנאכף. דריסות מהגדרות משתמש או פרויקט לא משפיעות עליו.

כש-availableModels מוגדר בהגדרות מנוהלות, רק modelOverrides מהגדרות מנוהלות חל על מזהה מודל של Anthropic שמועבר ישירות דרך --model או משתני הסביבה שלמעלה. Claude Code מתעלם מדריסות בהגדרות משתמש או פרויקט עבור המזהים האלה, ואף פעם לא פותר מזהה שהרשימה המנוהלת מחריגה דרך modelOverrides מכל מקור הגדרות. הגבלת מקור מנוהל זו דורשת Claude Code v2.1.200 או מאוחר יותר. ראה הגבלת בחירת מודל לגבי הטיפול במזהים חסומים.

#תצורת שמירת פרומפט במטמון

Claude Code משתמש אוטומטית בשמירת פרומפט במטמון כדי לייעל ביצועים ולהפחית עלויות. אתה יכול לבטל שמירת פרומפט במטמון באופן גלובלי או עבור רמות מודל מסוימות:

כדי לבחור את ה-TTL של המטמון לשיחה הראשית ולסוכני משנה בנפרד, ראה בחר את ה-TTL בעצמך. לגבי מה שמפעיל החטאת מטמון, ראה איך Claude Code משתמש בשמירת פרומפט במטמון.

#היסטוריית גרסאות

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