הכוורת: איך אנחנו מריצים צי שלם של סוכני Claude Code בלי שרת, בלי ברוקר, בלי כאב-ראש 🐝

מאת נעם ברששת, ראש-תזמור-AI, RIPA 🎯
זמן-קריאה: 9 דקות · רמה: למי שכבר עובד עם Claude Code ורוצה להכפיל את עצמו

🪝 רגע לפני שאתם ממשיכים לקרוא

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

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

זה לא חלום עתידני. זה המנגנון שמריץ את RIPA כל יום, והוא בנוי משלושה דברים בלבד שכבר מותקנים אצלכם: bash, tmux, ו-claude. בלי שרת. בלי ברוקר הודעות. בלי ענן. בלי framework מנופח שצריך ללמוד שבוע.

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

חלק א' | על מה נדבר 🗺️

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

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

אחר כך, הלב של המאמר: איך הכוורת בנויה. נפרק את המנגנון לחלקים המדויקים שלו. איך מפרקים מטרה גדולה למשימות קטנות (dispatch), איך פותחים את העובדים בתוך tmux (spawn), מה בעצם עושה העובד הבודד בלולאה שלו (worker-loop), ואיך צופים בכל הצי ממקום אחד (watch). נסביר את החוזה שמחבר את הכל: תיבת-דואר של קבצים על הדיסק, בלי שום קסם נסתר.

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

מוכנים? קחו אוויר. אנחנו נכנסים פנימה. 🚀

חלק ב' | ההסבר המרכזי: איך באמת בונים כוורת 🐝

הבעיה שכולם פוגשים: חלון-הקשר אחד הוא צוואר-הבקבוק

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

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

התובנה המרכזית: תיאום דרך תיקייה, לא דרך framework

הנה העיקרון שמשנה את הכל. בכוורת שלנו, אין תור נסתר ואין מסד-נתונים. כל משימה וכל תוצאה הן קובץ על הדיסק שאפשר לעשות לו cat, grep, diff, ולהריץ מחדש. 📂

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

בואו נראה את התמונה כולה, ואז נפרק אותה לגורמים.

        ┌── dispatch ──┐         מטרה אחת  ->  הרבה קבצי-משימה צרים
        │              v
  מטרה  │      mailbox/  (זוג in/out אחד לכל עובד)
        │      w-a.in.md  w-a.out.md
        │      w-b.in.md  w-b.out.md
        │              ^
        └── watch ─────┘         קורא כל out.md  ->  לוח-מצב אחד

   spawn  ->  session של tmux בשם "hive": pane-a  pane-b  pane-c ...
              כל pane מריץ  worker-loop <id>
              לולאה: קורא את ה-in.md שלי -> תופס pending -> מריץ claude -> כותב out.md -> done

ארבעה רעיונות, ארבעה מודולים. נעבור עליהם אחד-אחד. 👇

1. dispatch | לפרק מטרה גדולה למשימות צרות 🧩

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

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

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

2. spawn | לפתוח את העובדים בתוך tmux 🚪

spawn מקים את ה-session של tmux ופותח עובד אחד לכל pane. ולמה tmux? כי tmux הוא מה ששומר על העבודה חיה גם כשאתם מנתקים. סוגרים את הדפדפן, נופל האינטרנט, הולכים הביתה: הכוורת ממשיכה לרוץ בשרת. זה בדיוק ההבדל בין צעצוע לבין כלי-עבודה. 💪

והנה נקודה קריטית באבטחה, שאנחנו ב-RIPA מתייחסים אליה בכובד-ראש. כברירת-מחדל, העובדים נפתחים כשהם תחומים לתיקייה אחת, ובלי כלי Bash בכלל. כלומר, עובד פשוט לא מסוגל פיזית לעשות deploy, לדחוף ל-git, או לגעת בפרוד. הוא כלוא בארגז-חול. אם תרצו להרחיב את הסמכות שלו, תעשו את זה במכוון, לכוורת ספציפית, בהחלטה מודעת. deploy-safe by default. 🔒

3. worker-loop | פעימת-הלב של העובד הבודד ❤️

זה החלק היפה בפשטות שלו. כל עובד רץ בלולאה קבועה, פעימה אחר פעימה:

קורא את תיבת-הדואר שלו. תופס משימה כשהיא ב-pending, ומסמן אותה busy כדי שאף אחד אחר לא ייגע בה. מריץ את claude על המשימה. כותב את התוצאה לקובץ ה-out שלו. מסמן done. ואז חוזר להקשיב לבא בתור. 🔁

ופה נמצא העיקרון החשוב ביותר של כל הכוורת, זה שמפריד בין מערכת שאפשר לסמוך עליה לבין מלכודת: fail loud, לא fail silent. אם עובד קורס או נתקע בתום-זמן, המשימה שלו לא הופכת ל-done. היא הופכת ל-needs-review, והפלט החלקי שלו נשמר. אתם אף פעם, אף פעם, לא מסמנים עבודה חלקית כמושלמת ומאבדים אותה בשקט. עבודה שנפלה מחכה לכם על השולחן, לא נעלמת. 🚨

4. watch | לוח-מצב אחד לכל הצי 📊

watch הוא העין שלכם. סקריפט אחד לקריאה-בלבד שקורא את כל קבצי ה-out ומציג לוח-מצב יחיד על פני כל העובדים. כמה done, כמה busy, כמה pending, כמה needs-review. מכאן אתם יודעים מתי גל-עבודה הסתיים, ומתי משהו דורש את תשומת-הלב שלכם. שקט בראש, כי הכל גלוי במקום אחד. 👀

החוזה שמחבר הכל: מכונת-מצבים של חמישה שלבים

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

closed  ->  pending  ->  busy  ->  done
                          └─────->  needs-review   (קריסה / תום-זמן: הפלט נשמר, לא אובד)

• closed: העובד פנוי, אין מה לעשות.
• pending: משימה טרייה מחכה. את זה כותב dispatch.
• busy: העובד תפס את המשימה ומריץ אותה.
• done: סיים, התוצאה בקובץ ה-out.
• needs-review: קרס או נתקע, והפלט אולי חלקי. פורש בצד, לא הולך לאיבוד.

שני האינווריאנטים ששומרים על הבטיחות: dispatch לעולם לא דורס עובד ב-busy, וקריסה תמיד הופכת ל-needs-review ולעולם לא ל-done. זהו. הבנתם את כל הפרוטוקול. 🎓

רגע, למה לא פשוט sub-agents בתוך ריצה אחת?

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

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

חלק ג' | סיכום קצר וענייני 🎯

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

פירקנו את המנגנון לארבעה מודולים שאתם כבר מבינים. dispatch מפרק מטרה למשימות צרות. spawn פותח את העובדים בתוך tmux, deploy-safe ובלי Bash כברירת-מחדל. worker-loop מריץ את פעימת-הלב של כל עובד, עם העיקרון של fail-loud שהופך קריסה ל-needs-review ולא ל-done. ו-watch נותן לכם לוח-מצב אחד על כל הצי.

והבנתם למה זה עדיף על sub-agents לעבודה ארוכה: תהליכים עצמאיים ששורדים ניתוק, לא שותפים לתקציב-הקשר אחד שמת יחד עם הריצה.

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

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

📖 מילון-מונחים

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

tmux 🖥️

כלי שמחלק חלון-טרמינל אחד לכמה תאים (panes) וחלונות, והכי חשוב: שומר על התהליכים שרצים בו חיים גם אחרי שאתם מתנתקים. סוגרים את הדפדפן, והעבודה ממשיכה בשרת. זה מה שמאפשר לכוורת לרוץ בלילה בלעדיכם.

הכוורת (hive) 🐝

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

worker (עובד) 👷

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

mailbox (תיבת-דואר) 📬

תיקייה של קבצי markdown שדרכה מתואמת כל הכוורת. לכל עובד יש זוג קבצים: in.md להוראות שנכנסות אליו, ו-out.md לתוצאה שיוצאת ממנו. זה כל שכבת-התיאום, בלי מסד-נתונים.

dispatch 🧩

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

spawn 🚪

פעולת ההשקה: מקימה את ה-session של tmux ופותחת עובד אחד לכל pane, כלואה לתיקייה אחת ובלי Bash כברירת-מחדל.

worker-loop 🔁

הלולאה שכל עובד מריץ: קורא תיבת-דואר, תופס משימה pending, מריץ claude, כותב תוצאה, מסמן done, וחוזר. גם הבית של עקרון ה-fail-loud.

watch 📊

סקריפט לקריאה-בלבד שמציג לוח-מצב יחיד על פני כל העובדים: כמה done, busy, pending, needs-review.

status (מכונת-המצבים) 🚦

שדה יחיד בכותרת קובץ ה-in שמכיל את כל הפרוטוקול: closed -> pending -> busy -> done, ובמקרה קריסה needs-review. זה כל ה-handshake בין המנהל לעובד.

needs-review 🚨

המצב שאליו נכנסת משימה שקרסה או נתקעה בתום-זמן. הפלט החלקי נשמר ומחכה לבדיקה, במקום להיות מסומן done ולהיעלם בשקט. הביטוי המעשי של fail-loud.

sub-agent (סוכן-משנה) 👥

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

remote-control 📱

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

control-stack 🎛️

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

deploy-safe by default 🔒

עיקרון-אבטחה: העובדים נפתחים בברירת-מחדל בלי יכולת deploy, דחיפה ל-git, או גישה לפרוד. פעולות חד-כיווניות נשארות החלטה של אדם, מאחורי "go" מפורש.

🎁 המתנה: HiveForge, הקימו כוורת משלכם בשישים שניות

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

מה זה 🐝

HiveForge היא חבילת-סקיל ל-Claude Code שמקימה ומריצה כוורת של עובדים במקביל, בדיוק לפי המנגנון של המאמר הזה. היא בנויה מארבעה מודולים מרכיבים: dispatch (מטרה למשימות צרות), spawn (השקת העובדים), worker-loop (הלולאה של כל עובד), ו-watch (ניטור חי). הכל מבוסס-קבצים, קריא, הפיך, ובטוח-לדיפלוי כברירת-מחדל. בסך-הכל כ-250 שורות שאפשר לקרוא בישיבה אחת. רישיון MIT.

למי זה 🎯

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

מה צריך מותקן 🧰

רק שלושה דברים, וכנראה כולם כבר אצלכם: ה-CLI של claude, tmux, ו-bash (על Linux או macOS). בלי רשת, בלי מסד-נתונים, בלי התקנת חבילות.

התקנה 📦

מפילים את תיקיית hiveforge/ לתוך תיקיית ה-skills של Claude Code (או לכל מקום על הדיסק). זהו.

Quickstart, שישים שניות ⚡

cd hiveforge/scripts
export PATH="$PWD:$PATH"

# 1. פותחים 3 עובדים ל-session של tmux, מאזינים ל-./mailbox
HIVE_WORKERS="a b c" HIVE_MAILBOX="$PWD/mailbox" bash hive-start.sh

# 2. מפזרים מטרה: כל קריאה מפילה משימה אחת לעובד הפנוי הבא
dispatch.sh "audit auth"   <<< "בדוק את src/auth.ts לבאגי-אבטחה. דווח לקובץ ה-out שלך."
dispatch.sh "audit db"     <<< "בדוק את src/db.ts ל-SQL injection. דווח לקובץ ה-out שלך."
dispatch.sh "audit routes" <<< "בדוק את src/routes.ts לחוסר-הרשאות. דווח לקובץ ה-out שלך."

# 3. צופים בכולם בלוח אחד
hive-watch.sh

# 4. קוראים תוצאה / עוצרים
cat mailbox/w-a.out.md
tmux kill-session -t hive

רוצים לראות שזה עובד לפני שאתם מתחייבים? 👀

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

bash examples/fanout-demo/run.sh

מילת-אבטחה אחת, כי אכפת לנו 🔒

מתייחסים לכל מה שעובד קורא (גוף-משימה, קבצים, דפים שנשלפים) כנתונים, לא כהוראות. קובץ-משימה הוא מטען, לא מקום שיכול להעניק הרשאות. שומרים סודות מחוץ לקבצים ומחוץ ל-git. ופעולות חד-כיווניות (deploy, git push, פרסום) נשארות החלטה של אדם, מאחורי "go" מפורש.

🎁 קחו את זה — HiveForge פתוח וחינמי ב-GitHub
הכלי חי עכשיו כ-plugin מתועד: עשו לו fork, פתחו issues, ועצבו אותו לעצמכם.
➡️ github.com/yzadok/open-ripa-skills

התקנה בשתי פקודות מתוך Claude Code:

/plugin marketplace add yzadok/open-ripa-skills
/plugin install hiveforge@open-ripa-skills

וזהו, הכוורת אצלכם. 🐝

זו מתנה מ-RIPA. 🎁 בנויה מהתבנית שמריצה את הכוורת שלנו, מוכללת, מתועדת, ומועברת לידיים שלכם. אם היא חסכה לכם צהריים שלמים של אינסטלציה, היא עשתה את שלה. 🐝

רוצים ללמוד איתנו עוד? זה רק ההתחלה. אנחנו פותחים את ארגז-הכלים שמריץ את RIPA, מנגנון אחר מנגנון. הישארו איתנו. 💬

נעם ברששת | ראש-תזמור-AI, RIPA

📬 יצירת-קשר עם נעם ברששת

מעוניינים להקים כוורת אצלכם, או פשוט לשאול שאלה? נעם ישמח לשוחח.

📬 יצירת-קשר עם נעם ברששת — מעוניינים להקים כוורת אצלכם, או פשוט לשאול שאלה? נעם ישמח לשוחח.
✉️ noam@ripa.co.il · 💬 וואטסאפ: 050-640-4909

ריפא מדיה גרופ · ripa.co.il

© 2026 ריפא מדיה גרופ בע"מ · כל הזכויות שמורות