איך צמצמתי את צריכת הטוקנים ב-OpenClaw ב-90% (כולל המודלים הכי זולים)

לוח הבקרה שלי ב-OpenRouter הראה שכבר לפני ארוחת הצהריים ביום שלישי הוצאתי 47 דולר. רצתי אולי על תריסר משימות קוד — שום דבר דרמטי, רק קצת ריפקטורינג וכמה תיקוני באגים. ואז הבנתי שברירות המחדל של OpenClaw מנתבות בשקט כל אינטראקציה, כולל פינגים של פעימת רקע, דרך Claude Opus במחיר של 15+ דולר למיליון טוקנים.

אם גם לכם קרו הפתעות כאלה — ולפי הפורומים, להרבה אנשים זה כבר קרה ("אני כבר מוציא 40 דולר וזה אפילו לא בשימוש רב," כתב משתמש אחד) — המדריך הזה מציג את שיטת הבדיקה והאופטימיזציה המלאה שבה השתמשתי כדי להוריד את ההוצאה החודשית בכ-90%. לא רק "להחליף למודל זול יותר", אלא פירוק שיטתי של איפה הטוקנים באמת נשרפים, איך לעקוב אחריהם, אילו מודלים חסכוניים באמת מחזיקים בעבודה סוכנותית, ושלושה קונפיגים שאפשר להעתיק ולהדביק כבר היום. כל התהליך לקח לי אחר צהריים אחד.

מהי צריכת הטוקנים ב-OpenClaw (ולמה היא כל כך גבוהה כברירת מחדל)?

טוקנים הם יחידת החיוב של כל אינטראקציה עם AI ב-OpenClaw. אפשר לחשוב עליהם כעל חתיכות קטנות של טקסט — בערך 4 תווים באנגלית לטוקן אחד. כל הודעה שאתם שולחים, כל תשובה שאתם מקבלים, וכל תהליך רקע שרץ: הכול מחויב בטוקנים.

הבעיה היא שברירות המחדל של OpenClaw מכוונות ליכולת מקסימלית, לא לעלות מינימלית. מיד עם ההתקנה, המודל הראשי מוגדר ל-anthropic/claude-opus-4-5 — האופציה היקרה ביותר שקיימת. פינגים של פעימת רקע? גם הם רצים על Opus. תת-סוכנים שנפתחים כדי לטפל במשימות צדדיות? גם Opus. להשתמש ב-Opus בשביל פינג רקע זה כמו לשכור מנתח מוח כדי להדביק פלסטר. טכנית זה יעבוד, אבל המחיר מופרך.

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

למה צמצום צריכת הטוקנים ב-OpenClaw חוסך יותר מכסף בלבד

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

מודלים זולים יותר הם לעיתים קרובות גם מהירים יותר. Gemini 2.5 Flash-Lite רץ בערך לעומת כ-51 ב-Opus — שיפור מהירות של פי 4 בכל אינטראקציה. GPT-OSS-120B על Cerebras מגיע ל-, בערך פי 35 מהר יותר מ-Opus. בלולאה סוכנותית עם 50+ סבבי קריאות לכלים, ההבדל הזה אומר סיום תוך דקות במקום להמתין ל-13.6 שניות של Opus עד לטוקן הראשון בכל סבב.

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

תחזית חיסכון לפי פרופילי שימוש שונים:

אלה לא מספרים תיאורטיים. מפתח אחד תיעד מעבר מ- — חיתוך אמיתי של 90% — באמצעות שילוב של ניתוב מודלים עם תיקוני הנזילות הנסתרים שנפרטים בהמשך המדריך.

האנטומיה של צריכת הטוקנים ב-OpenClaw: לאן כל טוקן באמת הולך

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

בדקתי כמה סשנים והשוויתי מול ועם דמפיי /context מהקהילה, כדי לבנות חשבון טוקנים למשימת קוד טיפוסית אחת. הנה לאן בערך 20,000 טוקנים באמת הלכו:

This paragraph contains content that cannot be parsed and has been skipped.

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

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

איך לעקוב אחר צריכת הטוקנים ב-OpenClaw (אי אפשר לחסוך ממה שלא רואים)

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

בדקו את לוח הבקרה שלכם ב-OpenRouter

אם אתם מנתבים דרך OpenRouter, דף ה- הוא לוח הבקרה הכי פשוט בלי שום התקנה. אפשר לסנן לפי מודל, ספק, מפתח API ותקופת זמן. תצוגת Usage Accounting מפרקת לכל בקשה את הטוקנים של prompt, completion, reasoning ו-tokens במטמון. יש גם כפתור Export (CSV או PDF) לניתוח לטווח ארוך.

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

בדקו את לוגי ה-API המקומיים שלכם

OpenClaw שומר נתוני סשן ב-~/.openclaw/agents.main/sessions/sessions.json, כולל totalTokens לכל סשן. אפשר גם להריץ openclaw logs --follow --json כדי לקבל לוגים בזמן אמת לכל בקשה.

נקודה חשובה שכדאי להכיר: , ולכן הדשבורד עלול להציג ערכים ישנים מלפני הקומפקט. סמכו יותר על /status ועל /context detail מאשר על הסכומים השמורים.

השתמשו במעקב צד שלישי (למשתמשים בינוניים עד כבדים)

LiteLLM proxy נותן לכם endpoint תואם OpenAI מול יותר מ-100 ספקים, ומבצע . היתרון הבולט: תקציבים קשיחים לכל מפתח שנשמרים גם אחרי /clear — תת-סוכן שיצא משליטה לא יוכל לעקוף תקרה שקבעתם.

Helicone אפילו פשוט יותר — שמספקת תצוגת Sessions שמקבצת בקשות קשורות. פרומפט אחד של "תקן את הבאג הזה" שמתפצל ל-8+ קריאות תת-סוכן מוצג כשורה אחת בסשן עם העלות הכוללת האמיתית. .

בדיקות מהירות בתוך OpenClaw

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

• /status — מציג שימוש בקונטקסט, טוקני קלט/פלט אחרונים, ועלות משוערת
• /usage full — פוטר שימוש לכל תשובה
• /context detail — פירוט טוקנים לפי קובץ, יכולת וכלי
• /compact [guidance] — כופה קומפקט עם מחרוזת מיקוד אופציונלית

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

קרב המודלים הזולים ביותר ב-OpenClaw: אילו מודלי תקציב באמת יודעים לעבוד סוכנותית

כאן רוב המדריכים טועים. הם מציגים טבלת מחירים, מצביעים על השורה הזולה ביותר, וזהו. אבל בנצ'מרקים לא מנבאים ביצועים סוכנותיים בעולם האמיתי — נקודה שהקהילה העלתה בקול רם ובחוזקה. כמו שמשתמש אחד ניסח: "benchmarks aren't doing any justice to understand which one works best for agentic AI."

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

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

אזהרה לגבי DeepSeek ו-Gemini Flash בקריאות לכלים

DeepSeek V3.2 נראה מצוין על הנייר — 72–74% ב-, וזול פי 11–36 מ-Sonnet. בפועל, ב-Cline, Roo Code, Continue ו-NVIDIA NIM מתעדות התנהגות שבורה בקריאות לכלים. פסק הדין של Composio ראש בראש: "." הניסוח הקצר של Zvi Mowshowitz: "."

ל-Gemini 2.5 Flash יש פער דומה. שרשור בפורום Google AI Developers בשם "Very frustrating experience with Gemini 2.5 function calling performance" נפתח כך: "."

OpenRouter הדגיש ניואנס קריטי: "." אם אתם מנתבים מודלים זולים דרך OpenRouter, חפשו את התג :exacto — החלפת ספק שקטה יכולה להפוך מודל זול ואמין ללולאת retries יקרה בן לילה.

מתי להשתמש בכל מודל

• Gemini Flash-Lite: פעימות רקע, פינגים של keep-alive, שאלות ותשובות פשוטות. לא למשימות רב-שלביות עם קריאות לכלים.
• MiniMax M2.5/M2.7: המודל היומיומי שלכם למשימות קוד כלליות. במחיר נמוך משמעותית מ-Sonnet.
• Claude Haiku 4.5: גיבוי אמין כשהמודלים הזולים נתקעים בקריאות לכלים. אמינות מצוינת לקריאות כלים, בכ-3x פחות מ-Sonnet.
• Claude Sonnet 4.6: משימות סוכנותיות מורכבות ורב-שלביות. כאן מתחילים לקבל תמורה אמיתית לכסף.
• Claude Opus: שמרו אותו לבעיות הכי קשות. אל תיתנו לו להיות ברירת המחדל לשום דבר אחר.

(מחירי המודלים משתנים לעיתים קרובות — בדקו את המחירים העדכניים ב- או בעמודי הספקים לפני שאתם מתחייבים לקונפיגורציה.)

הדליפות הנסתרות של הטוקנים שרוב המדריכים מדלגים עליהן

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

הדליפה של ה-heartbeat ראויה לציון משלה. כברירת מחדל, פעימות heartbeat רצות על המודל הראשי (Opus) כל 30 דקות. הגדרה של isolatedSession: true מורידה את זה מכ-100,000 טוקנים להרצה — ירידה של 95–98% באותו דלי בודד.

שלושה ניצחונות מהירים שחוסכים הכי הרבה טוקנים בפחות משתי דקות

שלושתם ללא סיכון ולוקחים פחות משתי דקות:

1. /clear בין משימות לא קשורות (5 שניות). זהו החיסכון הגדול ביותר בטוקנים. הקונצנזוס בפורומים מציב את זה על רק מניקוי היסטוריית הסשן לפני התחלת עבודה חדשה. זוכרים את דלי ה-185k טוקנים מהדמפ של /context? /clear מוחק אותו.

2. /model haiku-4.5 לעבודה שחורה (10 שניות). החלפת מודל טקטית נותנת במשימות שגרתיות. Haiku מסתדר מצוין עם רוב משימות הקוד הישירות, חיפושי קבצים והודעות commit.

3. צמצום .clawrules לפחות מ-200 שורות + הוספת .clawignore (90 שניות). קובץ החוקים שלכם נטען בכל הודעה. ב-200 שורות זה בערך 1,500–2,000 טוקנים בכל סיבוב; ב-1,000 שורות זה 8,000–10,000 טוקנים שממשיכים להכביד על כל בקשה. בשילוב עם .clawignore שמוציא את node_modules/, dist/, קבצי lock וקוד שנוצר אוטומטית, מפתח אחד טוען ל- רק מהמשמעת הזו.

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

שלוש תצורות מלאות ומוערות של openclaw.json מופיעות כאן — מ"רק להתחיל לחסוך" ועד "סטאק אופטימיזציה מלא". כל אחת כוללת הערות בתוך השורה והערכות עלות חודשית.

לפני שמתחילים:

• רמת קושי: מתחילים (Config A) → ביניים (Config B) → מתקדם (Config C)
• זמן נדרש: כ-5 דקות ל-Config A, כ-15 דקות ל-Config C
• מה צריך: OpenClaw מותקן, עורך טקסט, וגישה ל-~/.openclaw/openclaw.json

Config A: מתחילים — פשוט לחסוך כסף

חמש שורות. אפס מורכבות. מחליף את מודל ברירת המחדל מ-Opus ל-Sonnet, מכבה תקורת זיכרון, ומבודד את פעימות ה-heartbeat ל-Haiku.

1// ~/.openclaw/openclaw.json
2{
3  "agents": {
4    "defaults": {
5      "model": { "primary": "anthropic/claude-sonnet-4-6" },  // היה Opus — חיסכון מיידי של פי 3-5
6      "heartbeat": {
7        "every": "55m",                // התאמה ל-TTL cache של שעה למקסימום פגיעות cache
8        "model": "anthropic/claude-haiku-4-5",  // Haiku לפינגים, לא Opus
9        "isolatedSession": true        // ~100k → 2-5k טוקנים להרצה
10      }
11    }
12  },
13  "memory": { "enabled": false }       // חוסך ~500-2k טוקנים לסשן
14}

מה אמורים לראות אחרי ההחלה: הריצו /status לפני ואחרי. העלות לכל בקשה אמורה לרדת בצורה ניכרת, ובקשות heartbeat בעמוד ה-Activity של OpenRouter אמורות להופיע כ-Haiku במקום Opus.

Config B: ביניים — ניתוב חכם בשלוש שכבות

Sonnet ראשי לעבודה אמיתית. Haiku לתת-סוכנים ולקומפקט. Gemini Flash-Lite כגיבוי זול כש-Claude מוגבל בקצב. שרשראות fallback מטפלות אוטומטית בתקלות ספק.

1{
2  "agents": {
3    "defaults": {
4      "model": {
5        "primary": "anthropic/claude-sonnet-4-6",
6        "fallbacks": [
7          "anthropic/claude-haiku-4-5",       // אם Sonnet נחסם בקצב
8          "google/gemini-2.5-flash-lite"      // אופציית חירום זולה במיוחד
9        ]
10      },
11      "models": {
12        "anthropic/claude-sonnet-4-6": {
13          "params": { "cacheControlTtl": "1h", "maxTokens": 8192 }
14        }
15      },
16      "heartbeat": {
17        "every": "55m",                       // 55 דקות < TTL cache של שעה = פגיעות cache
18        "model": "google/gemini-2.5-flash-lite",  // סנטים בודדים לפינג
19        "isolatedSession": true,
20        "lightContext": true                   // קונטקסט מינימלי בקריאות heartbeat
21      },
22      "subagents": {
23        "maxConcurrent": 4,                   // ירד מברירת מחדל 8
24        "model": "anthropic/claude-haiku-4-5" // תת-סוכנים לא צריכים Sonnet
25      },
26      "compaction": {
27        "mode": "safeguard",
28        "model": "anthropic/claude-haiku-4-5", // סיכומי קומפקט דרך Haiku
29        "memoryFlush": { "enabled": true }
30      }
31    }
32  }
33}

תוצאה צפויה: לוגים של תת-סוכנים אמורים להציג עכשיו תמחור של Haiku. פעימות heartbeat יהיו כמעט ללא עלות. שרשרת fallback מבטיחה שגם אם Claude נופל, הסשן לא נתקע — הוא פשוט מתגלגל ל-Gemini.

Config C: משתמשי כוח — סטאק אופטימיזציה מלא

הקצאת מודל לכל תת-סוכן בנפרד, קיבוע קומפקט הקונטקסט ל-Haiku, ניתוב vision ל-Gemini Flash, .clawrules + .clawignore הדוקים, והשבתת skills לא בשימוש. זו התצורה שמביאה אתכם לאזור של 85–90% חיסכון.

1{
2  "agents": {
3    "defaults": {
4      "workspace": "~/clawd",
5      "model": {
6        "primary": "anthropic/claude-sonnet-4-6",
7        "fallbacks": [
8          "openrouter/anthropic/claude-sonnet-4-6",  // ספק אחר כגיבוי
9          "minimax/minimax-m2-7",                     // גיבוי זול לעבודה יומיומית
10          "anthropic/claude-haiku-4-5"                // מוצא אחרון
11        ]
12      },
13      "models": {
14        "anthropic/claude-sonnet-4-6": {
15          "params": { "cacheControlTtl": "1h", "maxTokens": 8192 }
16        },
17        "minimax/minimax-m2-7": {
18          "params": { "maxTokens": 8192 }
19        }
20      },
21      "heartbeat": {
22        "every": "55m",
23        "model": "google/gemini-2.5-flash-lite",
24        "isolatedSession": true,
25        "lightContext": true,
26        "activeHours": "09:00-19:00"           // בלי heartbeats בלילה
27      },
28      "subagents": {
29        "maxConcurrent": 4,
30        "model": "anthropic/claude-haiku-4-5"
31      },
32      "contextPruning": { "mode": "cache-ttl", "ttl": "1h" },
33      "compaction": {
34        "mode": "safeguard",
35        "model": "anthropic/claude-haiku-4-5",
36        "identifierPolicy": "strict",
37        "memoryFlush": { "enabled": true }
38      },
39      "bootstrapMaxChars": 12000,              // ירד מברירת מחדל 20000
40      "imageModel": "google/gemini-3-flash"    // משימות חזותיות דרך מודל זול
41    }
42  },
43  "memory": { "enabled": true, "max_context_tokens": 800 },  // זיכרון מינימלי
44  "skills": {
45    "entries": {
46      "web-search":       { "enabled": false },
47      "image-generation": { "enabled": false },
48      "audio-transcribe": { "enabled": false }
49    }
50  }
51}

דוגמה לעקיפה ברמת תת-סוכן — הדביקו אל ~/.openclaw/agents/lint-runner/SOUL.md:

1---
2name: lint-runner
3description: Runs lint/format checks and applies trivial fixes
4tools: [Bash, Read, Edit]
5model: anthropic/claude-haiku-4-5
6---

.clawignore מינימלי אבל יעיל — זה לבדו מקטין בוטסטרפים טיפוסיים מ-150k תווים לכיוון 30–50k:

1node_modules/
2dist/
3build/
4.next/
5coverage/
6.venv/
7vendor/
8*.lock
9package-lock.json
10yarn.lock
11pnpm-lock.yaml
12*.min.js
13*.min.css
14**/__snapshots__/
15**/*.snap

המספרים האלה מתיישבים עם שני דיווחים עצמאיים של משתמשים אמיתיים: התיעוד של Praney Behl על מעבר מ- (קיצוץ של 90%), ו-case studies של LaoZhang שמראים עם אופטימיזציה חלקית.

שימוש בפקודה /model כדי לשלוט בצריכת הטוקנים של OpenClaw תוך כדי עבודה

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

תהליך עבודה מעשי:

• עובדים על ריפקטור מורכב בכמה קבצים? נשארים על Sonnet.
• שאלה מהירה כמו "מה הביטוי הרגולרי הזה עושה?" /model haiku, שואלים, ואז /model sonnet כדי לחזור.
• הודעת commit או ליטוש מסמך? /model flash-lite, וסיימתם.

אפשר להגדיר כינויים ב-openclaw.json תחת commands.aliases כדי למפות שמות קצרים (haiku, sonnet, opus, flash) למחרוזות ספק מלאות. חוסך כמה הקשות בכל מעבר.

המתמטיקה פשוטה: 50 שאילתות ביום על Sonnet הן בערך 3 דולר ליום. אותן 50 שאילתות מחולקות 70/20/10 בין Haiku/Sonnet/Opus הן בערך 1.10 דולר ליום. בחודש זה 90 דולר לעומת 33 דולר — 63% זול יותר בלי לשנות כלים, רק הרגלים.

בונוס: מעקב אחרי מחירי מודלים ב-OpenClaw בין ספקים עם Thunderbit

עם כל כך הרבה מודלים וספקים — OpenRouter, ה-API הישיר של Anthropic, Google AI Studio, DeepSeek, MiniMax — המחירים משתנים כל הזמן. Anthropic הורידו את מחיר הפלט של Opus בכ-67% בן לילה. Google צמצמה את מגבלות ה-free tier של Gemini ב- בדצמבר 2025. לשמור גיליון מחירים סטטי מעודכן ידנית זו מלחמה אבודה.

פותר את זה בלי לכתוב קוד scraping. זו של AI web scraper, שנבנתה בדיוק לחילוץ נתונים מובנים מסוג כזה.

תהליך העבודה שאני משתמש בו:

1. פותחים את דף המודלים של OpenRouter ב-Chrome ולוחצים על "AI Suggest Fields" של Thunderbit. הוא קורא את הדף ומציע עמודות — שם מודל, מחיר קלט, מחיר פלט, חלון קונטקסט, ספק.
2. לוחצים Scrape, ואז מייצאים ישירות ל-Google Sheets.
3. מגדירים scrape מתוזמן באנגלית פשוטה — "every Monday at 9am, re-scrape the OpenRouter model list" — והוא רץ אוטומטית בענן.

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

משווים מחירים בין דפי ספקים ישירים (Anthropic, Google, DeepSeek)? הסקרייפינג של תתי-עמודים ב-Thunderbit עוקב אחרי כל קישור למודל אל דף הפרטים שלו ומושך תעריפים לפי ספק — שימושי כשאתם רוצים לדעת אם ניתוב של Kimi K2.5 דרך OpenRouter זול יותר מאשר חיבור ישיר דרך . בדקו את לפרטי החבילה החינמית והתוכניות.

מסקנות מרכזיות לצמצום צריכת הטוקנים ב-OpenClaw

המסגרת: להבין → לנטר → לנתב → לאופטם.

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

1. אל תשתמשו ב-Opus כברירת מחדל. החליפו את המודל הראשי ל-Sonnet או MiniMax M2.7. זה לבדו חוסך פי 3–5 בעלות.
2. בידוד ל-heartbeats. הגדירו isolatedSession: true ונתבו heartbeat ל-Gemini Flash-Lite. כך דליפה של ~100k טוקנים הופכת ל-~2–5k.
3. נתבו תת-סוכנים ל-Haiku. כל פתיחה צורכת כ-20k טוקנים של קונטקסט עוד לפני שעשו משהו. אל תתנו לזה לקרות על Opus.
4. השתמשו ב-/clear באופן קבוע. חינמי, לוקח 5 שניות, והקונצנזוס בקהילה הוא שזה חוסך יותר מכל פעולה בודדת אחרת.
5. הוסיפו .clawignore. הוצאה של node_modules, קובצי lock ו-artifacts של build מקטינה משמעותית את קונטקסט הבוטסטרפ.
6. נטרו עם /context detail לפני ואחרי שינויים. אם אי אפשר למדוד, אי אפשר לשפר.

המודל הזול ביותר תלוי במשימה. Gemini Flash-Lite לפעימות רקע. MiniMax M2.7 לקוד יומיומי. Haiku לקריאות כלים אמינות. Sonnet לעבודה מורכבת ורב-שלבית. Opus רק לבעיות הכי קשות באמת — ולא לשום דבר אחר.

רוב הקוראים יכולים לראות חיסכון של 50–70% כבר אחר צהריים אחד עם Config A או B. ה-85–90% המלאים דורשים שילוב של כל מה שצוין — ניתוב מודלים, תיקון דליפות נסתרות, .clawignore, ומשמעת סשנים — אבל זה בהחלט אפשרי, וזה מחזיק לאורך זמן.

שאלות נפוצות

1. כמה עולה OpenClaw בחודש?

זה תלוי לגמרי בקונפיגורציה, בהיקף השימוש ובבחירת המודלים. משתמשים קלים (~10 שאילתות ביום) מוציאים בדרך כלל 5–30 דולר לחודש עם אופטימיזציה, או 100+ דולר בברירות המחדל. משתמשים בינוניים (~50 שאילתות ביום) נעים סביב 90–400 דולר בחודש. משתמשים כבדים יכולים להגיע ל- בברירות מחדל — קיצון מתועד אחד היה 5,623 דולר בחודש אחד בלבד. הטלמטריה הפנימית של Anthropic עצמה מצביעה על חציון של .

2. מהו המודל הזול ביותר של OpenClaw שעדיין עובד טוב לקוד?

הוא מודל היומיום הכללי הכי טוב — אמינות טובה בקריאות לכלים, SWE-Pro 56.22, במחיר של בערך $0.28/$1.10 למיליון טוקנים. לפעימות רקע וחיפושים פשוטים, קשה לנצח את Gemini 2.5 Flash-Lite במחיר $0.10/$0.40. Claude Haiku 4.5 במחיר $1/$5 הוא הגיבוי האמין בטווח הביניים כשצריך קריאות כלים מצוינות בלי לשלם את מחיר Sonnet.

3. אפשר להשתמש במודלים חינמיים עם OpenClaw?

טכנית כן. GPT-OSS-120B חינמי ב-/free של OpenRouter וב-NVIDIA Build. ל-Gemini Flash-Lite יש free tier (15 RPM, 1,000 בקשות ביום). DeepSeek נותן . אבל ל-free tiers יש מגבלות קצב אגרסיביות, מהירות נמוכה יותר וזמינות לא יציבה. מודלים בתשלום זול — סנטים בודדים למיליון טוקנים — אמינים הרבה יותר לשימוש קבוע.

4. האם החלפת מודל באמצע שיחה עם /model מאבדת את הקונטקסט שלי?

לא. /model שומר על כל קונטקסט הסשן שלכם — הסיבוב הבא פשוט ינותב למודל החדש עם כל ההיסטוריה intact. זה מאומת בתיעוד המושגים של OpenClaw ועובד באותה צורה גם ב-Claude Code. אפשר לעבור חופשי בין Haiku לשאלות קצרות לבין Sonnet לעבודה מורכבת בלי לאבד דבר.

5. מה הדרך המהירה ביותר להוריד את חשבון OpenClaw שלי כבר היום?

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