איך להעביר הודעות בין סשנים של Claude Code
גלו כיצד סשנים של Claude Code מתקשרים ביניהם על אותו שרת באמצעות ListAgents ו-SendMessage. המדריך מפרט את דרישות הגרסה ל-macOS, Linux ו-Windows ואת אופן פעולת התכונה.
מה המשמעות של העברת הודעות בין סשנים של Claude Code
שני סשנים של Claude Code יכולים להעביר הודעות זה לזה כאשר הם פועלים באותו מחשב, תחת אותו משתמש במערכת ההפעלה. הודעה היא פיסת טקסט רגיל שסשן אחד של Claude כותב עבור סשן אחר. היא אינה כוללת היסטוריית שיחה או קבצים. Claude מאתר את הסשן האחר באמצעות הכלי ListAgents ומעביר את הטקסט באמצעות SendMessage, ולכן אינכם קוראים לאף אחד מהכלים האלה ידנית. אתם מציינים מה הסשן האחר צריך לדעת, ו-Claude כותב את ההודעה בעצמו.
התכונה נקראת העברת הודעות בין סשנים. נכון ל-November 2026, היא דורשת את Claude Code v2.1.224 או גרסה מאוחרת יותר ב-macOS וב-Linux, כולל Linux בתוך WSL 2, ואת v2.1.234 או גרסה מאוחרת יותר ב-Windows מקורי. העברת הודעות בין סשנים באותו מחשב פועלת אצל כל הספקים, כולל Amazon Bedrock, Claude Platform on AWS, Google Cloud's Agent Platform ו-Microsoft Foundry, שבהם נדרשת גרסה v2.1.248 או מאוחרת יותר. גישה לסשנים שלכם במחשבים אחרים או בענן מוגבלת יותר: היא מתבצעת דרך Remote Control, שדורש התחברות ל-claude.ai, ולכן אינה פועלת עם API key או אצל ארבעת הספקים האלה. כאשר סשן עומד בדרישות האלה, העברת ההודעות כבר מופעלת ואין צורך להפעיל דבר. ההתנהגות המתוארת להלן מבוססת על התיעוד של Anthropic להעברת הודעות בין סשנים.
VPS הוא המקום שבו התכונה הזו חשובה, משום שב-VPS סשנים נשארים פעילים מספיק זמן כדי שיהיה טעם לפנות אליהם. במחשב נייד סוגרים את המכסה. בשרת עם tmux, סשן שהתחלתם ביום שני עדיין פועל ביום חמישי ועדיין מחזיק את ההקשר של מאגר קוד אחד. לאחר שיש לכם שני סשנים כאלה, האופן שבו הם מתקשרים כבר אינו עניין תאורטי. אם עדיין לא הגדרתם זאת, התחילו במדריך הפעלת Claude Code ב-VPS עם tmux, שמכסה את תשתית הסשנים שעליה מדריך זה מסתמך.
מתי כדאי להשתמש בסשן שני
התחילו בבחינת העלות. כל סשן הוא מופע (instance) נפרד של Claude עם חלון הקשר (context window) משלו, לכן שני סשנים עולים בערך פי שניים מסשן אחד לאורך אותה תקופת זמן. הודעה שנשלחה נספרת בשימוש בדיוק כמו prompt שהקלדתם. סנכרון אינו בחינם, ועבודה שהיא למעשה רצף פעולות אחד הופכת לאיטית ויקרה יותר כאשר מפצלים אותה בין סשנים.
המקרים שבהם סשן שני מחזיר את ההשקעה דומים זה לזה. שני חלקי עבודה רצים בו-זמנית מבלי להמתין זה לזה, ואחד מהם לומד משהו שהשני זקוק לו במהלך המשימה.
- סשן אחד מוצא שינוי שובר (breaking change) בזמן שהשני בונה על הקוד שהוא שבר. Claude מסכם את השינוי ושולח אותו, במקום שתצטרכו להקליד אותו מחדש בטרמינל השני.
- שני סשנים עובדים על אותו מאגר (repository) בתוך git worktrees נפרדים, ואחד מהם צריך לדעת מה התעדכן.
- תהליך הגירה (migration) ארוך או הרצת בדיקות מדווחים על התוצאות שלהם לסשן שבו אתם צופים.
- סשן בונה (builder) וסשן מבקר (reviewer), שבו המבקר קורא את מה שהבונה יצר ושולח בחזרה את הממצאים שלו.
כאשר העבודה היא סדרתית, או כאשר שני הסשנים עורכים את אותם הקבצים, השתמשו בסשן אחד. כאשר אתם רוצים קבוצה מסונכרנת ש-Claude יוצר ומנהל בתוך משימה אחת, מדובר בצוותי סוכנים (agent teams), תכונה נפרדת שעדיין נמצאת בשלבי ניסוי. כאשר אתם רק רוצים את אותה שיחה בטרמינל אחר, המשיכו את הסשן הקיים במקום זאת. העברת הודעות בין סשנים נועדה לסשנים עצמאיים שאתם מתחילים ומנהלים בעצמכם.
וודאו שהתכונה קיימת לפני שתתכננו סביבה
תחילה, בדקו את הגרסה:
claude --versionהשוו את המספר ל-2.1.224. לאחר מכן, בתוך session, הקלידו /list-agents, שמגיב גם ל-/peers. הפקודה מדפיסה את כל ה-agents שניתן להגיע אליהם מה-session הנוכחי, יחד עם השם שבו כל אחד מהם מזוהה. אם הפקודה אינה מזוהה כלל, ל-session הזה אין יכולת העברת הודעות בין-session, ושום ערך של crossSessionInbound לא ישנה זאת. הקלידו /status וחפשו שורה של Peer address: היא מכילה את כתובת ה-inbox של ה-session הנוכחי, עם הקידומת uds:.
מלכודת אחת משפיעה על משתמשי VPS בגרסאות ישנות. לפני v2.1.248, העברת הודעות על אותו שרת הייתה תלויה ב-feature-flag fetching, ומספר משתני פרטיות מכבים את ה-fetching הזה, מה שמשאיר את התכונה במצב כבוי כברירת מחדל. DO_NOT_TRACK, DISABLE_TELEMETRY, CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC ו-DISABLE_GROWTHBOOK כולם עושים זאת. אנשים מאבטחים שרת חדש על ידי הדבקת משתנים אלו לתוך ~/.bashrc, ואז תוהים מדוע /list-agents אינו קיים. החל מ-v2.1.248, העברת הודעות בין sessions על אותו שרת עובדת גם כשה-fetching כבוי, לכן עדכון גרסה הוא הפתרון הנקי ביותר. המשתנים עדיין משפיעים על sessions מחוץ לשרת זה: כשה-fetching כבוי, Claude מגיע אליהם רק כאשר Remote Control זמין, ו-CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC ו-DISABLE_GROWTHBOOK הופכים את ה-Remote Control ללא זמין. אותם ערכים יכולים להגיע מתוך ה-map של env בקובץ הגדרות או מהגדרות מנוהלות, לכן בדקו תחילה את ה-shell.
env | grep -E 'DO_NOT_TRACK|DISABLE_TELEMETRY|DISABLE_GROWTHBOOK|NONESSENTIAL'בגרסה ישנה, בטלו (unset) את המשתנה שמציג ערך. עבור DISABLE_TELEMETRY ו-CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC, כל ערך שאינו ריק מפעיל את ההתנהגות, כולל המחרוזת 0, לכן DISABLE_TELEMETRY=0 לא מבצע את מה שהוא נראה כעושה. אתם מכבים זאת על ידי ביטול המשתנה או הגדרתו כמחרוזת ריקה.
תנו לסשנים שמות כדי להבדיל ביניהם
Claude מפנה הודעה לסשן לפי שמו, אך אין חובה להגדיר שם. אם אינכם מגדירים שם, Claude Code נותן לסשן שם בעצמו, ו-Claude עדיין יכול למצוא את הסשן באמצעות ListAgents ולשלוח אליו הודעה באמצעות SendMessage. בסשן אינטראקטיבי, השם האוטומטי משלב את שם תיקיית העבודה עם סיומת בת שני תווים, כגון myapp-3f. זה מתאים לסשן אחד, אך מבלבל כשיש ארבעה סשנים, ושני סשנים עלולים לקבל את אותו שם. כדי לבחור את השם בעצמכם, הגדירו אותו בעת הפעלת הסשן:
claude --name builder-apiאפשר להגדיר את השם גם באמצעות /rename בתוך סשן פעיל. כל עוד הסשן אינו מחובר אל Remote Control, הפלט של /list-agents מציג את תיקיית העבודה של כל סשן מקומי. כך אפשר להבדיל בין סשנים בעלי אותו שם, והרשימה של Claude מוסיפה מזהה קצר לכתובת כאשר שמות מתנגשים. בזמן שהסשן מחובר אל Remote Control, /list-agents משמיט את תיקיות העבודה ואת שמו של כל סשן שאי אפשר לשייך לאדם, ולכן שורה כזו תוצג בתור (unnamed session). המידע ש-Claude עצמו רואה בעת חיפוש יעד אינו משתנה. בחירת שמות בעצמכם זולה יותר מקריאת מזהים. שם שבחרתם גם הופך את ההשלמה המוקדמת של @ לשימושית: החל מ־v2.1.232, הקלדת @builder בשורת בקשה ובחירת הסשן מבהירות ל-Claude בדיוק לאיזה סשן אתם מתכוונים.
פריסת tmux בעלת שני סשנים שניתן לשחזר
זהו סשן בונה (builder) וסשן סוקר (reviewer) על אותו מאגר (repository). הסוקר עובד ב-git worktree נפרד, כך ששני הסשנים לעולם לא כותבים לאותו קובץ. הפקודה git worktree add עם HEAD יוצרת checkout מנותק (detached), וזה מה שדרוש עבור סשן שנועד לקריאה ולא לביצוע commits. מכיוון ששני הסשנים מבצעים תפקידים שונים, כדאי להעניק לסוקר סגנון פלט משלו, המשנה את ה-system prompt של אותו סשן ונשמר לאורך כל התהליך, במקום להיעלם כמו הנחיה שהוקלדה פעם אחת.
cd ~/src/api
git worktree add ../api-review HEAD
tmux new-session -d -s agents -n builder -c ~/src/api
tmux new-window -t agents -n reviewer -c ~/src/api-review
tmux send-keys -t agents:builder 'claude --name builder-api' C-m
tmux send-keys -t agents:reviewer 'claude --name reviewer-api' C-m
tmux attach -t agentsהפקודה Ctrl+b ולאחריה w מציגה את החלונות לפי שם כדי שתוכל לבחור אחד. בחלון הבונה, הרץ את /list-agents. אתה אמור לראות את reviewer-api עם ספריית העבודה שלו ~/src/api-review. אם הוא חסר, סשן הסוקר טרם סיים לעלות, או שאחת משתי הבעיות בסעיף הבא רלוונטית. לאחר מכן, העבר משהו בשפה פשוטה:
Tell reviewer-api which files I changed for the rate limiter and what to look at first.Claude כותב את הסיכום ושולח אותו. אתה לא כותב את טקסט ההודעה, ומה ש-Claude שולח משתנה. בחלון הסוקר, ההודעה מופיעה כתצוגה מקדימה עמומה בשורה אחת, הנושאת את שם השולח ואת השורה הראשונה של הטקסט, כגון › Message from @builder-api: …. אם הסשן אינו פעיל, Claude מתחיל תור חדש בו מיד. אם הוא באמצע תור, ההודעה ממתינה עד לנקודה שבין קריאות לכלים (tool calls), כך שפקודה רצה לעולם לא נקטעת. הפקודה Ctrl+O פותחת את מציג התעתיק (transcript viewer) עם הטקסט המלא, ו-Claude קורא את ההודעה כולה בין אם תרחיב אותה ובין אם לא. הצמד עובד טוב יותר כאשר הבונה שומר על שינויים קטנים, מכיוון ש-diff צר יוצר העברה קצרה יותר וסקירה שהסשן השני יכול לסיים בתור אחד, וזהו ההרגל שמיומנות המפתח הבכיר העצלן נועדה לאכוף.
מי יכול לראות את מי על אותו VPS
העברת הודעות על אותה מכונה לעולם אינה עוברת דרך השרתים של Anthropic. כל סשן מקשר את ה-inbox socket שלו, שהוא Unix domain socket עם נתיב במערכת הקבצים של אותה מכונה, וסשן מופיע ברשימות של סשנים אחרים שלך רק כאשר הוא מקשר אחד כזה. מכאן נובעות שתי השלכות, ושתי אלו רלוונטיות לשרת.
ה-socket מוגבל למשתמש מערכת ההפעלה שלך. סשן שהתחלת כ-root וסשן שהתחלת כ-deploy לא יכולים לראות זה את זה, גם אם הם זה לצד זה באותו שרת tmux, כיוון שסשן של משתמש אחד אינו יכול להגיע ל-socket של משתמש אחר. הרץ את שני הסשנים תחת אותו משתמש.
למכולה (container) יש מערכת קבצים משלה. סשן בתוך Docker וסשן על ה-host אינם יכולים להגיע זה לזה. שני סשנים בתוך אותה מכולה יכולים להעביר הודעות זה לזה כרגיל. אם אתה שומר סוכנים במכולות לצורך בידוד, כפי שמתואר ב-הרצת סוכני תכנות ב-VM זמני, צפה לכך שהעברת הודעות תעבוד בתוך המכולה ולא מעבר לגבולות המכולה.
הסשנים שלך במכונות אחרות, והסשנים בענן, מופיעים ברשימה רק כל עוד הסשן הנוכחי מחובר ל-Remote Control, וסשנים במכונות אחרות מסומנים כ-Remote Control. החל מגרסה v2.1.225, Claude יכול להתחיל שיחה עם סשן במכונה אחרת שלך, ולא רק להשיב לאחד. הודעות אלו עוברות דרך השרתים של Anthropic, וכך גם הודעות לסשן בענן. סשן בענן אינו יכול להשיב עם SendMessage, גם כאשר ההודעה נושאת כתובת למענה: ההודעה עדיין מגיעה, ואתה קורא את תגובת הסשן בענן בתמליל השיחה ב-claude.ai/code. אם סשן זה אינו מחובר ל-Remote Control כאשר Claude שולח הודעה אל מחוץ למכונה, ההודעה עדיין נשלחת, אך ללא כתובת למענה, ולכן הצד השני אינו יכול להשיב לה.
מדוע ההודעה שלך מעולם לא הגיעה
הסיבה הרגילה לכך אינה קשורה לרשת. סשן הקבלה החליט מה לעשות עם ההודעה, וההחלטה הייתה לא למסור אותה. כל הודעה שמגיעה מסתיימת באחת משלוש תוצאות: נמסרה, הוחזקה (הושמה בצד ללא מסירה עד לאישורך), או סורבה (נמחקה ללא מסירה).
כאשר לא חל ערך crossSessionInbound, Claude Code מחליט עבור כל הודעה על ידי השוואת מצבי ההרשאות של שני הסשנים. הוא מקבץ סשנים שעוקפים בקשות הרשאה למחלקה אחת, וכל סשן אחר למחלקה השנייה. auto, acceptEdits ו-dontAsk נחשבים כבקשת אישור. מצב Plan נחשב כעקיפה בסשן טרמינל אינטראקטיבי שיש לו הרשאות עקיפה זמינות. אם אינך בטוח לאיזו מחלקה שייך סשן מסוים, כדאי לקרוא תחילה את מה כל מצב הרשאה עושה בפועל, מכיוון ש-auto הוא המצב שבו רוב הסשנים מתחילים כיום, והוא נמצא בצד של בקשות האישור בחלוקה זו. הכלל הוא סימטרי:
- סשן קבלה שמבקש הרשאות מקבל כל הודעה שנשלחת אליו. הוא מחזיק הודעה רק כאשר סשן השליחה מזדהה ככזה שעוקף בקשות אישור.
- סשן קבלה שעוקף בקשות אישור מחזיק כל הודעה עד לאישורך. הוא מוסר הודעה רק כאשר השולח גם הוא עוקף בקשות אישור.
לכן, תהליך העבודה הראשון שרוב האנשים בונים הוא בדיוק זה שלא עובד. אתה מפעיל builder עם --permission-mode bypassPermissions כי אתה רוצה שהוא ירוץ ללא השגחה, אתה משאיר את ה-reviewer על הגדרות ברירת המחדל, וכל הודעה שה-builder שולח ממתינה בתיבת דו-שיח לאישור שאף אחד לא צופה בה. תיבת הדו-שיח הזו נסגרת לאחר המועד האחרון של dialogExpiry, שברירת המחדל שלו היא 5m, וההודעה נמחקת. בדוק במסך של סשן הקבלה אם קיימת תיבת דו-שיח לאישור ממתין לפני שאתה מאשים את ה-socket.
כדי לגרום לסשן לקבל הודעות ללא השגחה, הגדר את crossSessionInbound ל-accept. המקום שבו אתה מגדיר זאת קובע אם ההגדרה תחול. Claude Code קורא תחילה הגדרות מנוהלות, לאחר מכן את הדגל --settings, ולבסוף הגדרות משתמש, ומחיל את הערך הראשון שהוא מוצא. ערך בהגדרות פרויקט או בהגדרות מקומיות חל רק כאשר הוא מחמיר יותר, לפי סולם העדיפויות accept < hold < refuse. ערך accept ב-.claude/settings.json הוא רופף יותר מכל דבר אחר, ולכן הוא מתעלם ממנו בכל פעם שמקור מהימן הגדיר ערך. שים אותו ב-~/.claude/settings.json, או העבר אותו עבור סשן אחד. החל מגרסה v2.1.232, השורה /config Messages from your other sessions כותבת עבורך את אותה הגדרת משתמש.
claude --name runner --settings '{"crossSessionInbound":"accept"}'עובד claude -p ללא ממשק (headless) קושר socket של תיבת דואר נכנס כמו סשן אינטראקטיבי ומופיע ברשימה, אך הוא אינו יכול להציג תיבת דו-שיח לאישור. Claude Code מחזיק שם הודעה למשך אותו מועד אחרון של dialogExpiry, חמש דקות כברירת מחדל, מוסר אותה אם שינוי במצב או בהגדרות מאפשר זאת בפרק זמן זה, ובמקרים אחרים מוחק אותה ומדווח עליה כפגה לשולח שהוא יכול להגיע אליו. השורה --settings לעיל היא הדרך שבה אתה מאפשר לעובד כזה לקבל הודעות. סשן שהופעל במצב bare אינו קושר socket כלל, ולכן הוא אינו יכול לקבל הודעות ואינו יכול להופיע ברשימה.
כאשר העברת המשימה נתקעת
לולאות הודעות מטופלות עבורכם. Claude Code מגביל את קצב ההודעות החוזרות מכל שולח, משליך הודעות זהות שמגיעות בתוך חלון זמן קצר, ומגביל ל־50 את מספר ההודעות שהתקבלו וממתינות לקריאה בכל session, כך שלולאה בין שני sessions נעצרת מעצמה. מספר ההודעות המוחזקות מוגבל ל־100, והודעות ישנות יותר נזרקות מעבר למגבלה זו. החל מ־v2.1.238, כאשר תיבת הדואר הנכנס של session משליכה את ההודעות שלכם בגלל הגבלת הקצב או בגלל תור מלא, הוא מודיע על כך ל־session שלכם.
הכשל שכן מתרחש שקט יותר, והוא נובע מהעברת משימה ולא מלולאה. Session A שואל את session B שאלה שעליו לקבל עליה תשובה לפני שיוכל להמשיך, ואז עובר למצב המתנה. B מחזיק את ההודעה, או ש־B נמצא באמצע תור ארוך, או ש־B עונה על שאלה ש־A לא באמת שאל. A ממתין. אתם חוזרים כעבור שעה ומוצאים שני sessions במצב המתנה, בלי שהתבצעה עבודה.
נסחו העברות משימה שאינן דורשות תשובה. הודעה טובה מוסרת עובדה או החלטה: מה השתנה ומה הייתה התוצאה. הודעה גרועה מבקשת מה־session האחר אישור, או תשובה שהשולח חסום בלעדיה. Claude כבר הונחה לעולם לא לבקש מ־session אחר פעולה שהגדרות ההרשאות שלו עצמו חוסמות, ולהחזיר את העבודה אליכם. הרחיבו את הכלל הזה בעצמכם. אם session אינו יכול להתקדם בלי תשובה, אתם אלה שצריכים לענות לו. אם session אחד רק צריך לדעת מתי אחר מסיים משימה ארוכה, בקשו הודעה במקום תשובה: החל מ־v2.1.236 בשני ה־sessions, Claude יכול לבקש מאחד ה־sessions שלכם במחשב הזה לשלוח הודעה יחידה כאשר הוא עובר בפעם הבאה למצב המתנה או יוצא, ו־Claude Code מבטל את הבקשה לאחר 12 שעות אם לא מתקבלת הודעה. גם משמעת בהקשר מסייעת כאן, משום ש־session שאיבד את חוט המחשבה כותב הודעות מעורפלות; ניהול ההקשר ב־Claude Code עוסק בצד הזה.
התייחסו להודעה נכנסת כאל קלט שאינו מהימן
Claude Code מודיע ל־Claude המקבל שההודעה הגיעה מסשן אחר ולא מכם, ומגביל את הפעולות שההודעה יכולה לבצע. האכיפה הזו מתבצעת בתוכנית העוטפת את המודל, ולא בנכונות של המודל לציית. זהו ההבדל המעשי שיוצר מעטפת סוכן. הודעה אינה יכולה להשיב בשמכם לבקשת הרשאה ממתינה, משום שהסכמה מסשן אחר אינה ההסכמה שלכם. היא אינה יכולה לשנות הגדרות הרשאה, CLAUDE.md או תצורה אחרת רק משום שסשן אחר ביקש זאת. פקודת slash בתוך הטקסט, כגון /compact, מתקבלת כטקסט רגיל ולעולם אינה מופעלת. אם פעולה על ההודעה דורשת הרשאה שאין לסשן המקבל, תוצג אותה בקשה שהייתם רואים עבור כל פעולה אחרת. כאשר הסשן השולח פועל במצב אוטומטי, המסווג שלו בודק גם הוא כל הודעה לפני ש־Claude Code מוסר אותה, והודעה שהוא חוסם אינה מגיעה לנמען. מגבלות אלה נשמרות גם במצבים המתירניים, ולכן סשן שמאפשר עקיפות מחזיק הודעות נכנסות כברירת מחדל במקום לתת בהן אמון.
הדבר מכסה הרשאות. הוא אינו מכסה תוכן. ייתכן שהסשן השולח קרא תיאור של pull request, דף אינטרנט, קובץ README של תלות או תגובה ל־issue שנכתבה על ידי אדם זר, וכל דבר שקרא עשוי להשפיע על הטקסט שהוא כותב לסשן האחר שלכם. ההודעה היא נתונים. יש להתייחס אליה באותה חשדנות כמו לכל טקסט אחר שנכנס לסשן ממקור חיצוני. זהו העיקרון המתואר ב־שמירת סודות מחוץ לסוכני ה־AI שלכם: הניחו שכל דבר שחצה גבול אמון עלול להיות שגוי, ולעולם אל תאפשרו לו לאשר את עצמו.
קיימים שני אמצעי בקרה אם ברצונכם לצמצם זאת. הגדרת crossSessionInbound ל־refuse משליכה הודעות עמיתים נכנסות בלי למסור אותן, ומהגדרות הפרויקט או ההגדרות המקומיות ערך זה גובר על כל מקור אחר, משום שהוא המחמיר ביותר בהיררכיה. כדי למנוע מהסשן לשלוח או להציג רשימות, הוסיפו כללי deny להרשאות עם השמות SendMessage ו־ListAgents, שניהם נכתבים כשמות כלים בלבד, ללא specifier. הגדרת isolatePeerMachines ל־true מחייבת את אישורכם המפורש לפני שהודעה כלשהי מגיעה לסשן שמחוץ למכונה הזו, ואישור זה נדרש גם במצב bypassPermissions.
{
"crossSessionInbound": "refuse",
"isolatePeerMachines": true
}חסימת SendMessage מונעת גם העברת הודעות ל־subagents, משום שאותו כלי משמש לשתי הפעולות. סשן שחוסם זאת אינו מציג שינוי גלוי ב־/status שלו או ברשימות של סשנים אחרים באותה מכונה. לכן יש לאמת את ההגדרה מתוך תצורת הסשן ולא לפי התצוגה.
גשרים ושרתי MCP עם זיכרון משותף
בתקופה האחרונה הופיעו כמה פרויקטים של צד-שלישי המבצעים פעולות דומות: גשרים מקומיים בין סוכנים (agents) המעבירים טקסט ביניהם, ושרתי MCP (פרוטוקול הקשר מודל) המעניקים למספר סוכנים מאגר משותף לקריאה וכתיבה. יש להתייחס אליהם כאל תצורה שונה ולא כאל מתחרים, ויש לוודא כל פקודת התקנה מול קובץ ה-README של הפרויקט לפני הרצתה. העברת הודעות מבוססת על דחיפה (push), כיוון שהשולח מזין טקסט ישירות לתור של המקבל. מאגר משותף מבוסס על משיכה (pull), כיוון שאף צד אינו מופרע והסשן רואה את ההערה רק כאשר הוא ניגש לבדוק אותה. משיכה היא שיטה רגועה יותר עבור מצב שמשתנה לאט, והיא פועלת רק כאשר סשן מבצע בדיקה בפועל.
אם תבחרו בדרך זו, השאלות שכדאי לשאול נוגעות לתהליך ולא לרשימת התכונות. תחת איזה משתמש השרת רץ, ומה הוא מורשה לקרוא בשרת. המדריך הרצת שרתי MCP על גבי VPS מכסה את ההגדרה הזו. המדריך שיתוף יכולות סוכנים בין מאגרים מכסה את המקרה הפשוט יותר, שבו מה שברצונכם לשתף בין סשנים הוא הנחיות ולא מצב חי (live state), דבר המפחית משמעותית את כמות ההודעות שהייתם שולחים אחרת. לתמונה הרחבה יותר, הרצת סוכן תכנות על גבי VPS הוא המקום להתחיל בו.
FAQ
מדוע הפקודה /list-agents אינה מזוהה בסשן שלי?
הסשן אינו תומך בהעברת הודעות בין סשנים. בדקו תחילה את claude --version: התכונה דורשת גרסה 2.1.224 ומעלה ב-macOS וב-Linux, גרסה 2.1.234 ומעלה ב-Windows מקורי, וגרסה 2.1.248 ומעלה ב-Amazon Bedrock, ב-Claude Platform ב-AWS, ב-Google Cloud's Agent Platform וב-Microsoft Foundry. בגרסאות ישנות מ-2.1.248, בדקו גם אם ה-shell שלכם כולל את DO_NOT_TRACK, DISABLE_TELEMETRY, CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC או DISABLE_GROWTHBOOK, שכן כל אחד מהם מכבה את משיכת ה-feature-flag שהייתה נחוצה לגרסאות ישנות עבור העברת הודעות. עדכון לגרסה 2.1.248 ומעלה מסיר תלות זו עבור סשנים באותו מחשב.
מדוע ההודעה ששלחתי לסשן האחר מעולם לא הגיעה?
אם /list-agents עובד, העברת הודעות פעילה ומשהו ספציפי יותר חסם את ההודעה. הסיבה הנפוצה היא הרשאות. סשן שעוקף בקשות הרשאה מחזיק כל הודעה נכנסת לאישורכם, אלא אם השולח גם הוא עוקף הרשאות, ודיאלוג האישור נמחק לאחר זמן הקצוב של dialogExpiry, שברירת המחדל שלו היא חמש דקות. בדקו בסשן המקבל אם קיים דיאלוג אישור ממתין. כדי לתקן זאת, הגדירו את crossSessionInbound ל-accept בתוך ~/.claude/settings.json או העבירו אותו עם --settings, כיוון ש-accept בהגדרות הפרויקט או בהגדרות המקומיות מתעלמים ממנו כערך פחות מחמיר.
האם סשן של Claude Code בתוך Docker יכול לשלוח הודעה לסשן על ה-host?
לא. תיבת הדואר הנכנס של כל סשן היא socket במערכת הקבצים של אותו מחשב, ול-container יש מערכת קבצים משלו, לכן סשן בתוך ה-container וסשן על ה-host אינם יכולים להגיע זה לזה. שני סשנים בתוך אותו container יכולים להעביר הודעות זה לזה כרגיל. כלל דומה מסביר מדוע סשן שרץ כ-root וסשן שרץ כמשתמש הרגיל שלכם אינם יכולים להגיע זה לזה: ה-socket מוגבל למשתמש מערכת ההפעלה שבבעלותו הוא נמצא.
האם בטוח לפעול על פי הודעה מסשן אחר של Claude Code?
התייחסו לטקסט כאל קלט לא מהימן, כיוון שהסשן השולח עשוי היה לקרוא דף אינטרנט, קובץ README או תגובה ב-issue שנכתבו על ידי מישהו אחר. Claude Code כבר מונע מההודעה לפעול באופן עצמאי: הוא אינו יכול לאשר בקשת הרשאה ממתינה, הוא אינו יכול לשנות הגדרות הרשאה או CLAUDE.md לפי בקשה, ופקודת slash בטקסט מגיעה כטקסט רגיל ולעולם אינה מורצת. הגנות אלו מכסות הרשאות ולא שיקול דעת, לכן קראו את מה שהגיע לפני שתורו לסשן המקבל לפעול לפיו.
האם העברת הודעות בין סשנים שולחת את הקוד שלי ל-Anthropic?
בין שני סשנים על אותו מחשב, לא. ההודעה עוברת דרך socket ייעודי לכל סשן על אותו מחשב ולעולם לא דרך השרתים של Anthropic, ורק הטקסט ש-Claude כתב נשלח, לעולם לא היסטוריית שיחות או קבצים. הודעות לסשן במחשב אחר שלכם, או לסשן בענן, אכן עוברות דרך השרתים של Anthropic. החל מגרסה 2.1.225, Claude יכול להתחיל שיחה עם סשן במחשב אחר שלכם, ולא רק להשיב לאחד. סשן בענן מקבל את ההודעה אך אינו יכול להשיב לה עם SendMessage, לכן תקראו את התגובה שלו ב-transcript שלו ב-claude.ai/code. הגדירו את isolatePeerMachines ל-true כדי לדרוש את אישורכם לפני שמידע כלשהו עוזב את המחשב.