📘 תיעוד 108

תצורת מודל

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

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

עבור הגדרת model ב-Claude Code, ניתן להגדיר:

• כינוי מודל
• שם מודל
  • Anthropic API: שם מודל מלא
  • Amazon Bedrock: מזהה inference profile ARN
  • Microsoft Foundry: שם פריסה (deployment name)
  • Google Cloud's Agent Platform: שם גרסה (version name)

להנחיות לגבי איזה מודל ורמת מאמץ מתאימים לסוגי עבודה שונים, ראה Choosing a Claude model and effort level in Claude Code בבלוג.

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

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

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

הגרסה שאליה נפתרים הכינויים opus ו-sonnet תלויה בספק:

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

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

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

לפני גרסה v2.1.219, הכינוי opus נפתר אל Opus 4.8 ב-Anthropic API החל מגרסה v2.1.154, וב-Claude Platform on AWS, Amazon Bedrock ו-Google Cloud's Agent Platform החל מגרסה v2.1.207. לפני גרסה v2.1.207, הכינוי opus נפתר אל Opus 4.7 ב-Claude Platform on AWS ואל Opus 4.6 ב-Amazon Bedrock וב-Google Cloud's Agent Platform.

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

הערה: המודל Opus 5 דורש את Claude Code בגרסה v2.1.219 ומעלה. המודל Sonnet 5 דורש גרסה v2.1.197 ומעלה. המודל Opus 4.8 דורש גרסה v2.1.154 ומעלה. הרץ 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 apps gateway, שבהן הכינוי נפתר אל 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:

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

הערה: המודל Fable 5.1 דורש את Claude Code בגרסה v2.1.257 ומעלה. אם בקשה עבורו מגרסה ישנה יותר נכשלת, ראה Claude Code does not support this model. הרץ claude update כדי לשדרג. לזמינות תחת מדיניות של אפס שמירת נתונים, ראה Model availability under ZDR.

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

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

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

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

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

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

בהפעלה שבה Remote Control מחובר, בהפעלה ברקע (background session), או בהפעלה של חבר צוות ב-agent team, ייתכן שאיש אינו נמצא ליד הטרמינל, ולכן Claude Code ממתין עם בקשת ההסכמה באמצע ההפעלה עד למועד האחרון של dialogExpiry, חמש דקות כברירת מחדל. אם איש לא ענה עד המועד האחרון, Claude Code מסיים את התור מבלי לשלוח את הבקשה ומוסיף הודעה לתמליל, שאותה מציג גם לקוח Remote Control. בחירת המודל שלך נותרת ללא שינוי, ו-Claude Code מבקש הסכמה שוב בהודעה הבאה שלך.

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

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

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

#הגדרת המודל שלך

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

1. במהלך הפעלה: השתמש ב-/model <alias|name> כדי לעבור מיד, או הרץ /model ללא ארגומנט כדי לפתוח את הבורר. ראה when Claude Code asks you to confirm the switch
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 בשורת המודל.

אם אתה מגדיר מודל באמצעות /model במצב לא אינטראקטיבי (non-interactive mode), עם הדגל -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 apps gateway, הספק או השער שלך קובעים את מה שתשלם, ולכן שורות הבורר אינן מציגות מחיר. המחיר הוא תווית תצוגה בלבד, הוא אינו משפיע על איזה מודל שורה מסוימת בוחרת או על מה שהספק שלך מחייב. לפני גרסה v2.1.206, הפעלות ב-Claude Platform on AWS ובשער הציגו את מחירי המחירון של Anthropic, ושורה יכלה להציג מחיר של מודל שונה מזה שהיא בחרה.

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

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

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

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

כאשר Claude Code אינו יכול לדעת אילו ווי PreModelSwitch מועברים על ידי התוספים המנוהלים של הארגון שלך, לדוגמה מכיוון שטעינת תוסף מנוהל נכשלה, הוא מסרב לבצע את המעבר במקום להחיל אותו ללא בדיקה, והוא בודק שוב בכל ניסיון חדש. ראה Model switch was blocked by a PreModelSwitch hook עבור ההודעה ואופן השחזור.

כאשר אתה מחליף מודלים דרך המתודה setModel() ב-Agent SDK או ממכשיר המחובר דרך Remote Control, או מאפליקציה כמו Desktop app שמריצה את ה-CLI של Claude Code ומחליפה עבורך, Claude Code בודק שהמחרוזת היא כזו שהוא מזהה לפני שמירתה. בדיקה זו דורשת את Claude Code בגרסה v2.1.200 ומעלה. בדיקת בחירה של Remote Control דורשת גרסה v2.1.260 ומעלה במחשב שלך. ב-Anthropic API, התוכנה Claude Code מזהה:

• כינוי מודל
• רשומה מתוך הבורר של /model
• כל שם שמתחיל ב-claude-
• ערך שהגדרת בעצמך כאפשרות מודל מותאמת אישית או ב-modelOverrides

התוכנה Claude Code דוחה מחרוזת לא מזוהה עם ההודעה Model "<name>" is not a recognized model id. וההפעלה שומרת על המודל הנוכחי שלה, במקום לשמור את המחרוזת ולהיכשל בבקשה הבאה. ראה the error reference עבור שלבי שחזור.

הבדיקה רצה ב-Anthropic API בלבד. ב-Amazon Bedrock, Google Cloud's Agent Platform, Microsoft Foundry, Claude Platform on AWS, ומאחורי שער LLM או ANTHROPIC_BASE_URL מותאם אישית, הספק או השער שלך מגדירים את שמות המודלים, ולכן Claude Code מעביר כל מחרוזת מבלי לבדוק אותה. הבדיקה אינה מכסה גם את הדגל --model, את משתנה הסביבה ANTHROPIC_MODEL או את הגדרת model. ערך שגוי שהוקלד שם מייצר שגיאת There's an issue with the selected model בבקשה הראשונה במקום זאת. התוכנה Claude Code עדיין יכולה לכתוב את שורת האבחון של מודל לא מזוהה בזמן הבקשה, בכל ספק.

כאשר למודל המבוקש יש תאריך הוצאה משימוש מתוזמן או שהוא ממופה אוטומטית לגרסה חדשה יותר, Claude Code מציג אזהרה שמציינת את שם המודל המבוקש. הפעלות אינטראקטיביות מציגות אותה כהודעת הפעלה. החל מגרסה v2.1.182, אותה אזהרה נכתבת ל-stderr במצב לא אינטראקטיבי (non-interactive mode) בעת שימוש בפורמט פלט טקסט ברירת מחדל. הבדיקה מכסה גם model שהוגדר ב-subagent frontmatter. אזהרת ה-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 מופעלת
• ההגדרה availableModels או הגבלות מודלים ארגוניות מחריגות את המודל
• המודל אינו זמין לחשבון שלך

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

#הפעלה חדשה מתחילה במודל שונה מזה שבחרת

כאשר אתה בוחר מודל באמצעות /model וההפעלה הבאה שלך מתחילה במודל אחר, אלה הסיבות הנפוצות:

• בחרת בו עבור הפעלה אחת. לחיצה על s בבורר, הפעלה באמצעות --model, והרצת /model במצב לא אינטראקטיבי חלות כולן על ההפעלה הנוכחית ומשאירות את ברירת המחדל השמורה שלך כפי שהיא.
• גורם בעל עדיפות גבוהה יותר קובע את המודל. ערך model בהגדרות פרויקט או הגדרות מנוהלות, ANTHROPIC_MODEL במעטפת שלך, או ברירת מחדל ארגונית שמנהל המערכת שלך הגדיר כדי לדרוס בחירות משתמשים, מוחלים שוב בכל הפעלה. בחירת ה-/model שלך עדיין שמורה, אך היא נדחית מפני עדיפות גבוהה יותר. כאשר הגדרות פרויקט או הגדרות מנוהלות קובעות את המודל, כותרת ההפעלה מציינת את שם הקובץ.
• Claude Code לא הצליח לשמור את בחירתך. הפקודה /model כותבת את model אל ~/.claude/settings.json. אם אינך יכול לכתוב לקובץ זה, לדוגמה מכיוון שכלי אחר מייצר אותו או מקשר אותו לעותק לקריאה בלבד, המודל שבחרת נמשך עבור ההפעלה וההפעלה הבאה קוראת את הערך הישן. הגדר את model בכלי שמייצר את הקובץ, או הפוך את הקובץ לניתן לכתיבה. ראה A change you made in Claude Code is lost in new sessions.
• חידשת הפעלה. הפעלה שאתה מחדש באמצעות 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 נשארת בתוקף אלא אם המארח מספק רשימה משלו. הסעיף Exceptions to managed settings precedence מציין אילו מפתחות ומשתנים נדרסים על ידי המארח.

כאשר 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 ב-subagent frontmatter, הפרמטר model של הכלי Agent, מודלים של חברי צוות ב-agent team, המשתנה CLAUDE_CODE_SUBAGENT_MODEL, ובגרסה v2.1.197 ומטה, בורר המודלים באשף /agents
• מודלים של מיומנויות ופקודות: השדה model ב-frontmatter של מיומנויות ופקודות
• מודל יועץ: ההגדרה 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 מריצה את תת הסוכן או חבר הצוות על מודל נסיגה במקום להכשיל את הבקשה. ראה Choose a model עבור נסיגת תת סוכן ו-Specify teammates and models עבור נסיגת חבר צוות.

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

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

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

• הגדרת advisorModel: היועץ מנוטרל עבור ההפעלה

• הדגל --advisor: התוכנה Claude Code יוצאת עם שגיאה בעת ההפעלה. בהפעלה ברקע (background session), היא מתחילה את ההפעלה ללא היועץ במקום לצאת

התוכנה Claude Code מסתירה מודלים מוחרגים מהבורר של /model. מזהה מודל מלא ברשימה שאין לו שורת בורר מובנית, כגון גרסה ישנה יותר שהרשימה מקבעת, מופיע בבורר של /model כשורה נפרדת עם תווית, אלא אם Claude Code מחליף את האפשרויות המובנות במערך של modelPicker. לפני גרסה v2.1.199, מזהה כזה ניתן היה לבחירה רק על ידי הקלדת /model <id>.

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

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

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

#כיסוי פני שטח

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

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

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

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

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

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

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

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

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

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

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

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

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

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

• availableModels: מגביל לאילו מודלים בעלי שם משתמשים יכולים לעבור
• enforceAvailableModels: מרחיב את רשימת ההיתרים availableModels אל אפשרות ה-Default, כך ש-Default אינו יכול להיפתר למודל שמחוץ לרשימה
• 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 על פני מקורות מנוהלים. הסעיף how Claude Code combines managed sources מציין את הרשימה של איזה מקור חלה. אחרת, רשימות מהגדרות משתמש, פרויקט ומקומיות משורשרות ומוסרות כפילויות כמו הגדרות מערך אחרות. לפני גרסה v2.1.175 של Claude Code, רשומות מטווחים בעלי עדיפות נמוכה יותר מוזגו לתוך הרשימה המנוהלת במקום להיות מוחלפות על ידה.

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

#מזהי מודל Mantle

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

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

מנהלי ארגון בתוכניות 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 בלבד. בכל ספק אחר, השתמש ב-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 עדיין מקבלים עדיפות גם כאשר הדריסה מופעלת. הדריסה זמינה למערך מוגבל של ארגונים. שאל את צוות החשבון שלך ב-Anthropic לגבי זמינות.

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

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

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

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

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

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

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

#מגבלות מאמץ ארגוניות

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

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

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

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

#הגדרת מודל default

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

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

לפני גרסה v2.1.219, הכינוי default נפתר אל Opus 4.8 ב-Anthropic API, ב-Max, ב-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, תחת התנאים המפורטים בסעיף שלו.

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

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

#הגדרת מודל opusplan

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

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

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

שלב ה-Opus במצב תוכנית משתמש באותו חלון הקשר כמו הגדרת המודל opus. בשכבות מנוי שבהן Opus משודרג אוטומטית להקשר של 1M, הכינוי opusplan מקבל את השדרוג גם במצב תוכנית. כדי לאלץ הקשר של 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 יכול לעבור למודל נסיגה במקום להכשיל את הבקשה. שגיאות אימות, חיוב, מגבלת קצב, גודל בקשה ותעבורה, וכן דחייה על ידי בדיקת מדיניות הארגון שלך, לעולם אינן מפעילות מעבר מודל. מקרים אלה פועלים לפי מנגנון הניסיון החוזר והטיפול בשגיאות הרגיל שלהם.

הגדר מודל נסיגה אחד או יותר ו-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. לנסיגה מבוססת זמינות כאשר מודל עמוס או אינו זמין, ראה שרשראות מודל נסיגה.

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

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

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

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

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

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

#בדיקת הגורם שהפעיל נסיגה

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

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

#בקשת אישור לפני החלפה

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

מספר מקרים מתנהגים אחרת:

• כאשר לקטגוריה המסומנת אין מודל נסיגה, כגון סימון ביולוגיה ב-Opus 5, התוכנה Claude Code אינה מציגה את הבקשה והבקשה מסתיימת בסירוב.
• אם שני המודלים מסמנים את אותה הבקשה, באפשרותך לערוך את ההנחיה ולנסות שוב, או להתחיל הפעלה חדשה.
• בהפעלות ענן (cloud sessions) באפליקציית המובייל, עריכה וניסיון חוזר אינם נתמכים. החלף מודלים, או המשך את ההפעלה מדפדפן שולחני או מאפליקציית ה-Desktop.
• במצב לא אינטראקטיבי (non-interactive mode) ובשילובי SDK שאינם יכולים להציג את הבקשה, בקשה מסומנת מסיימת את התור בסירוב במקום זאת.
• כאשר יעד הנסיגה חסום על ידי 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 מזוהה לפי מזהה מודל הספק שלו או מיפוי ב-modelOverrides.
• מודל הנסיגה חייב להיפתר בפריסה שלך. אם תגדיר את ANTHROPIC_DEFAULT_OPUS_MODEL, בקשות מסומנות ירוצו מחדש באותו מודל עבור כל קטגוריה שיש לה נסיגה. סימון ביולוגיה ב-Opus 5 עדיין מסתיים בסירוב. אם לא תגדיר אותו, בקשות שסומנו בתחום אבטחת סייבר ירוצו מחדש על רשומת Opus 4.8 ברשימת המודלים של הספק, ובקשות שסומנו בתחום הביולוגיה ממודל Fable ירוצו על רשומת Opus 5.

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

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

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

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

#התאמת רמת מאמץ

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

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

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

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

1. בחירה מפורשת: משתנה הסביבה CLAUDE_CODE_EFFORT_LEVEL, הפעלה באמצעות --effort, או /effort בהפעלה (ל-/effort לא אינטראקטיבי יש השפעה צרה יותר)
2. מאמץ ברירת המחדל של המודל, ב-Fable 5, Opus 4.8 או Opus 4.7: מהפעם הראשונה שאתה מריץ אחד ממודלים אלה, Claude Code שומר על מאמץ ברירת המחדל של אותו מודל לאורך הפעלות שונות, גם כאשר ההגדרות שלך קובעות רמה אחרת. למודלים Opus 5 ו-Fable 5.1 אין שמירה כזו. השאלה האם רמה שאתה מגדיר מסיימת את השמירה תלויה באופן שבו הגדרת אותה, לדוגמה:
   • מסיים את השמירה: אישור רמה באופן אינטראקטיבי, באמצעות Enter במחוון /effort או בבורר /model, או עם רמה שהוקלדה אחרי /effort, או בחירת רמה מבקרת המאמץ של Remote Control במכשיר מחובר
   • משאיר את השמירה במקומה להפעלות עתידיות: הדגל --effort בעת ההפעלה, או s במחוון /effort או בבורר /model
3. ההגדרות שלך: הרמה ששמרת עבור המודל או מפתח effortLevel, כאשר סדר העדיפויות ביניהם ובין קבצי הגדרות שונים מפורט ב-modelSettings
4. מאמץ ברירת המחדל של המודל: high בכל מודל שתומך במאמץ, למעט Opus 4.7 שברירת המחדל שלו היא xhigh, וכאשר הארגון שלך מגדיר רמת מאמץ ברירת מחדל עבור מודל ברירת המחדל הארגוני שלו, רמה זו היא ברירת המחדל בעת הפעלת אותו מודל

כאשר אתה מגדיר 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 על ההפעלה הנוכחית בלבד.

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

כאשר אתה מגדיר רמה באמצעות /effort בהרצת -p, התוכנה Claude Code מחילה אותה על אותה הפעלה בלבד ואינה שומרת אותה כברירת המחדל שלך. ב-Fable 5, Opus 4.8 ו-Opus 4.7, רמה זו גם אינה מסיימת את השמירה על מאמץ ברירת המחדל של המודל ואינה דורסת אותה עבור ההפעלה. בזמן ששמירה זו בתוקף, פקודת /effort לא אינטראקטיבית מדווחת Not applied, לכן העבר --effort בעת ההפעלה במקום זאת.

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

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

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

העברת 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 מוגדר לרמה שאינה xhigh, בקשות רצות באותה רמה ותזמור תהליכי העבודה של ultracode נשאר מושבת. בחירה ב-ultracode במצב זה מציגה אזהרה שלפיה משתנה הסביבה דורס את המאמץ עבור ההפעלה.

האפשרות Ultracode אינה זמינה כאשר:

• תהליכי עבודה כבויים
• המודל אינו תומך במאמץ xhigh
• מגבלת מאמץ מתחת ל-xhigh חלה על המודל

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

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

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

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

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

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

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

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

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

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

ב-Fable 5, Opus 4.8 ו-Opus 4.7, מאמץ מ-frontmatter חל גם בזמן שהשמירה על מאמץ ברירת המחדל של המודל בתוקף. לפני גרסה v2.1.267, השמירה קיבלה עדיפות ו-Claude Code התעלם מרמת ה-frontmatter בזמן שהשמירה הייתה פעילה.

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

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

#חשיבה אדפטיבית ותקציבי חשיבה קבועים

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

מודלי Fable, Sonnet 5 ו-Opus 4.7 ואילך משתמשים תמיד בחשיבה אדפטיבית. מצב תקציב חשיבה קבוע ו-CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING אינם חלים עליהם.

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

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

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

לא ניתן לכבות את החשיבה במודלי Fable. למתג ההפעלה, ל-alwaysThinkingEnabled ול-MAX_THINKING_TOKENS=0 אין השפעה שם, ומודל Fable מחליט לכל שלב כמה לחשוב בהתבסס על רמת המאמץ.

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

#הקשר מורחב

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

הזמינות משתנה לפי מודל ותוכנית. ב-Anthropic API, המודלים Fable 5.1, Fable 5, Sonnet 5, ו-Opus 4.7 ואילך רצים עם חלון 1M כברירת מחדל.

בתוכניות Max, Team ו-Enterprise, כולל מושבי Team Standard ו-Team Premium, המודל Opus משודרג אוטומטית להקשר של 1M ללא הגדרה נוספת. המודל Sonnet 4.6 עם הקשר של 1M אינו חלק מהשדרוג האוטומטי ודורש קרדיטים לשימוש בכל תוכנית מנוי, כולל Max.

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

כדי לכבות הקשר של 1M, הגדר את CLAUDE_CODE_DISABLE_1M_CONTEXT=1. התוכנה Claude Code מסירה גרסאות מודל 1M מבורר המודלים. במודלים בעלי חלון 1M מובנה, כגון Sonnet 5 ומודלי Fable, היא מתייחסת למודל כאילו יש לו חלון הקשר של 200K:

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

לפני גרסה v2.1.223, התוכנה Claude Code הגבילה ל-200K הפעלות של Sonnet 5, Opus 4.8 ו-Opus 5 בלבד. ראה משתני סביבה.

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

אם חשבונך תומך בהקשר של 1M, האפשרות מופיעה בבורר של /model בגרסאות האחרונות של Claude Code. אם אינך רואה אותה, נסה להפעיל מחדש את ההפעלה שלך.

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

# Use the opus[1m] or sonnet[1m] alias
/model opus[1m]
/model sonnet[1m]

# Or append [1m] to a full model name
/model claude-opus-4-8[1m]

#חלון ההקשר של Sonnet 5

ב-Anthropic API, המודל Sonnet 5 רץ תמיד עם חלון הקשר של 1M. אין גרסת 200K, אין סיומת [1m] לבחירה, ואין צורך בקרדיטים לשימוש באף תוכנית. הפעלות מבצעות דחיסה אוטומטית לפני שהחלון מתמלא, בכ-967K טוקנים כברירת מחדל. הגדר את CLAUDE_CODE_AUTO_COMPACT_WINDOW כדי לבחור סף אחר.

שתי תצורות מגדירות את תקציב החלון ל-200K במקום זאת:

• שער LLM: כאשר ANTHROPIC_BASE_URL מצביע על שער, התוכנה Claude Code אינה יכולה לאמת תמיכה ב-1M. כדי להשתמש בחלון המלא, בחר Sonnet 5 (1M context) בבורר המודלים, אשר ממופה ל-sonnet[1m]
• CLAUDE_CODE_DISABLE_1M_CONTEXT=1: מגביל הפעלות בכל מודל בעל חלון 1M מובנה לחלון של 200K. ראה הקשר מורחב לאופן שבו ההגבלה נאכפת. שימושי עבור פריסות שצריכות להגביל הקשר

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

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

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

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

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

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

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

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

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

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

• הפעלות ענן דוחסות ככל שהשיחה מתקרבת למגבלת המודל
• המודלים Sonnet 4.6 ו-Opus 4.6 ללא הקשר מורחב דוחסים בגבול של 200K, וכך גם Opus 4.8 ו-Opus 5 כאשר הם רצים עם חלון הקשר של 200K, כגון ב-Amazon Bedrock, Google Cloud's Agent Platform ו-Microsoft Foundry
• כאשר אתה מגדיר CLAUDE_CODE_DISABLE_1M_CONTEXT=1, מודלים בעלי חלון 1M מובנה, כגון Sonnet 5 ומודלי Fable, דוחסים בגבול של 200K
• מודלים הרצים עם חלון 1M מובנה, כגון Sonnet 5, מודלי Fable ו-Opus 4.7 ואילך ב-Anthropic API, דוחסים לפני שהחלון מתמלא, בכ-967K טוקנים כברירת מחדל. ב-Amazon Bedrock, ב-Google Cloud's Agent Platform וב-Microsoft Foundry, הסעיף קיבוע מודלים עבור פריסות צד שלישי מציין אילו מודלים רצים עם חלון זה. עבור התצורות שמתקצבות את Sonnet 5 ב-200K במקום זאת, ראה חלון ההקשר של Sonnet 5
• הפעלות במזהה מודל ש-Claude Code אינו מזהה, כגון כינוי שער LLM, דוחסות בחלון ההקשר ש-Claude Code מניח עבור אותו מזהה. ראה תיקון החלון עבור שער או מזהה מודל מותאם אישית

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

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

האופן שבו המשתנה חל תלוי במזהה. התוכנה Claude Code מתייחסת למזהה כאל איות מותאם אישית או של ספק כאשר הוא אינו מתחיל ב-claude-, בכל אותיות גדולות או קטנות, או כאשר הוא נושא סיומת ש-Claude Code מסיר בעת קריאת המזהה, כגון התאריך @YYYYMMDD המשמש ב-Google Cloud's Agent Platform. לפני גרסה 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, התוכנה Claude Code מציגה אז אזהרת הפעלה שלפיה מגבלת ה-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 מוגדר, כך שמשתנה זה נחוץ רק כאשר הגילוי מושבת או שאינו מחזיר את המודל הרצוי. ראה gateway model discovery.

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

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

export ANTHROPIC_CUSTOM_MODEL_OPTION="my-gateway/claude-opus-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, נחשב כרשומה ספציפית עבור אותה משפחה ומנטרל את התו הכללי שלה, לכן פרט גם את הגרסאות שבכוונתך לשמור כניתנות לבחירה. ראה התנהגות מיזוג.

#משתני סביבה

השתמש במשתני הסביבה הבאים כדי לשלוט בשמות המודלים שהכינויים ממפים אליהם. כל ערך חייב להיות שם מודל מלא, או המזהה המקביל עבור ספק ה-API שלך. כדי לבחור את המודל שבו ההפעלות שלך מתחילות, הגדר את ANTHROPIC_DEFAULT_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, הבדיקה רצה ויכלה להציג הודעה גם כאשר מודל הפעלה הוגדר במפורש.

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

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

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

כדי להפעיל הקשר מורחב עבור מודל מקובע, הוסף [1m] למזהה המודל ב-ANTHROPIC_DEFAULT_OPUS_MODEL, ANTHROPIC_DEFAULT_SONNET_MODEL או ANTHROPIC_DEFAULT_FABLE_MODEL:

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

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

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

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

סינון מתאים לכינוי מודל כגון opus, קידומת גרסה כגון claude-opus-4-8, או מזהה המודל המלא בצורת הספק. קידומות ספציפיות לספק כגון us.anthropic. אינן מוסרות, לכן כדי לאפשר מודל ספציפי, רשום את המזהה המלא שלו בצורת הספק, או מפה אותו דרך modelOverrides. עבור מודל מקובע, מזהה זה הוא הערך שהגדרת במשתנה ANTHROPIC_DEFAULT_*_MODEL שלו. כל סיומת [1m] מוסרת הן מרשומת רשימת ההיתרים והן מהמודל המבוקש לפני ההתאמה.

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

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

• מזוהה: המזהה המדויק של מודל ש-Claude Code מכיר, כגון מזהה ה-Anthropic API שלו או צורת הספק או השער שלך עבורו, עם או בלי הסיומת [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. אין להם השפעה בעת חיבור ישיר ל-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 מפעילה תכונות כמו רמות מאמץ וחשיבה מורחבת על ידי התאמת מזהה המודל לתבניות מוכרות. מזהים ספציפיים לספק כגון Bedrock ARNs או שמות פריסה מותאמים אישית לעיתים קרובות אינם תואמים לתבניות אלה, מה שמשאיר תכונות נתמכות כבויות. הגדר את _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 נשארת בתוקף אלא אם המארח מספק רשימה משלו. הסעיף Exceptions to managed settings precedence מציין אילו מפתחות ומשתנים נדרסים על ידי המארח.

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

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

הדבר מאפשר למנהלי מערכת בארגונים לנתב כל גרסת מודל ל-Amazon Bedrock inference profile ARN ספציפי, לשם גרסה ב-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 כפי שמופיעים בModels overview. עבור מזהי מודל תאריכיים, כלול את סיומת התאריך בדיוק כפי שהיא מופיעה שם. מפתחות לא מוכרים זוכים להתעלמות.

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

דריסות מחליפות את מזהי המודל המובנים העומדים בבסיס כל רשומה בבורר של /model. ב-Amazon Bedrock, רשומות modelOverrides מקבלות עדיפות על פני פרופילי הסקה כלשהם ש-Claude Code מגלה אוטומטית בעת ההפעלה. התוכנה Claude Code מעבירה ערכים שהם כבר טבעיים לספק, כגון Amazon Bedrock inference profile ARNs או שמות פריסה של 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 ממופות ל-ARNs. כאשר enforceAvailableModels מוגדר בהגדרות מנוהלות, ה-Default הנאכף נפתר דרך modelOverrides מהגדרות מנוהלות בלבד. מיפוי של מנהל מערכת, כגון גרסה המקובעת ל-inference profile ARN, מכובד ב-Default הנאכף. דריסות מהגדרות משתמש או פרויקט אינן משפיעות עליו.

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

#תצורת מטמון הנחיות

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

כדי לבחור את זמן החיים של המטמון עבור השיחה הראשית ועבור תתי סוכנים בנפרד, ראה choose the TTL yourself. למה שגורם להחטאת מטמון, ראה How Claude Code uses prompt caching.