סוכני דפדפן בשבע שניות: איך jev-ultrafast חיפש טיסה מציריך ללונדון בפחות מחצי סנט
הסוכן של Browser Use ממלא את Google Flights תוך 7.1 שניות, כי מודל החלטות בוחר כל פעולה ומודל קטן רק מקליד. מפרקים איך סוכן דפדפן רואה דף, מריצים אותו אצלנו, סופרים כל סנט, ומבינים מתי לא להשתמש בו בכלל.
הסוכן jev-ultrafast מילא את Google Flights מציריך ללונדון ועצר במסך התוצאות. הוא לא מזמין טיסה.
המודל Jev של TypeSafe בוחר פעולה ואלמנט מתוך טבלה ממוספרת, ומודל קטן (Mercury 2.5) כותב טקסט רק כשצריך.
בהקלטה היו 17 החלטות של Jev בכ-0.0002 דולר כל אחת, לפי המחירון הרשמי, פלוס 0.00006 דולר לטקסט. לא כולל דפדפן.
מריצים uv sync, מוסיפים מפתח TypeSafe, מפתח OpenRouter, ומריצים uv run jev. הממשק מראה כל החלטה והסתברות.
כשיש API, משתמשים בו. יש קפצ'ה או תנאי שימוש שאוסרים? עוצרים. פעולה בלתי הפיכה? אישור אנושי.
הכתבה ב־5 שניות · נבנה עם HyperFrames
סוכן דפדפן של Browser Use חיפש טיסות מציריך ללונדון ב-Google Flights תוך 7.1 שניות, מהמשפט הראשון ועד שהתוצאות על המסך. הפרויקט נקרא jev-ultrafast, הוא עלה ל-GitHub ב-16 בספטמבר, ותוך חודש אסף יותר מ-23 אלף כוכבים. בכתבה הזאת אנחנו לוקחים את החיפוש הזה, ציריך-לונדון, ומלווים אותו מקצה לקצה: איך סוכן דפדפן רואה דף, למה עד עכשיו זה היה איטי ויקר, מה בדיוק השתנה, איך מריצים את זה אצלנו, כמה עולה כל צעד, ומתי עדיף בכלל לא להשתמש בסוכן כזה.
רגע של דיוק לפני שמתחילים: הסוכן לא מזמין טיסה. הוא ממלא את טופס החיפוש, מגיע למסך התוצאות ועוצר שם. בדיוק כמו שכתוב ב-README של הפרויקט, הוא "לא בוחר ולא מזמין טיסה". זה חשוב, ונחזור לזה בסוף.
מה זה בכלל סוכן דפדפן
סוכן דפדפן הוא תוכנה שמחברת מודל AI לדפדפן אמיתי, כך שהמודל יכול ללחוץ, להקליד ולגלול באתרים במקומנו, עבור כל מי שרוצה לבצע משימות באתרים שאין להם API. תחשבו על זה כמו על עוזר אישי שיושב מול המחשב שלנו: אנחנו אומרים לו "תחפש לי טיסה מציריך ללונדון ב-20 בספטמבר", והוא פותח את האתר וממלא את השדות.
בואו נפרק את זה. כדי לעבוד, הסוכן צריך שלושה דברים:
עיניים. הדרך שבה הוא "רואה" את הדף. יש לזה שלוש גישות עיקריות. הראשונה היא ה-DOM (מבנה העץ של כל האלמנטים בדף, כמו שלד של בניין). השנייה היא עץ הנגישות (accessibility tree), גרסה מסוננת של ה-DOM שהדפדפן בונה עבור קוראי מסך של אנשים עיוורים, ושמכילה רק את מה שאפשר ללחוץ עליו או לקרוא: כפתורים, שדות, קישורים. השלישית היא צילום מסך שנשלח למודל שמבין תמונות.
ידיים. רשימת פעולות סגורה: ללחוץ, להקליד, לבחור מתפריט, לגלול, לחכות, ולהכריז "סיימתי".
מוח. המודל שמחליט, בכל רגע, איזו פעולה לעשות ועל איזה אלמנט.
כל זה רץ בלולאה: מסתכלים על הדף, מחליטים, פועלים, מסתכלים שוב. בחיפוש ציריך-לונדון שלנו, הסוכן רואה שדה "Where from?", מחליט להקליד בו, מקליד, רואה שהופיעה רשימת הצעות, בוחר את ציריך, וממשיך לשדה הבא.
למה זה היה איטי ויקר
עד לא מזמן, ה"מוח" בלולאה הזאת היה מודל שפה גדול, ומסתבר שזו בדיוק הבעיה. מודל שפה (LLM) הוא מודל שמייצר טקסט, מילה אחרי מילה. כשמבקשים ממנו להחליט על לחיצה, הוא כותב תשובה שלמה, לפעמים עם הסבר, ואז קוד אחר צריך לפענח את הטקסט הזה ולהפוך אותו לפעולה. תחשבו על זה כמו לשאול מישהו "ימינה או שמאלה?" ולקבל חיבור של פסקה.
יש לזה שלושה מחירים. הראשון הוא זמן: כל צעד הוא קריאה למודל גדול שלוקחת שניות, ומשימה של עשרים צעדים הופכת לדקה ויותר. השני הוא כסף: בכל צעד שולחים למודל את כל מצב הדף, ולפעמים גם צילום מסך, ומשלמים על כל טוקן (יחידת הטקסט שעליה המודלים גובים כסף). השלישי הוא אמינות: מודל שמייצר טקסט חופשי יכול גם להחזיר משהו שלא מתאים לשום אלמנט בדף.
וגם הצד של הדפדפן היה כבד. במסמך הביצועים של jev-ultrafast, המפתחים מתעדים שהגרסה המקורית שלהם קראה שוב ושוב את עץ הנגישות, פתרה מאות צמתים בדף, ופסלה החלטות בכל שינוי קטן בדף, כולל אנימציות. הגרסה המשופרת ירדה מ-1,092 קריאות לדפדפן ל-101 בלבד, באותה משימה בדיוק. וחשוב להיות הוגנים: גם הגישה של מודל גדול עם צילומי מסך עובדת, והיא עדיין הגמישה ביותר לאתרים מסובכים. היא פשוט משלמת על הגמישות הזאת בזמן ובכסף.
מה השתנה: מודל שמחליט, ומודל קטן שרק מקליד
הקטע המדליק הוא ש-jev-ultrafast מפצל את המוח לשניים.
החלק הראשון הוא Jev, מודל של חברה בשם TypeSafe. לפי התיעוד שלה, Jev הוא מודל "System One" (השם לקוח מהספר "לחשוב מהר, לחשוב לאט" של דניאל כהנמן, על החשיבה המהירה והאינטואיטיבית). הוא לא כותב טקסט בכלל. הוא מקבל מצב ושאלות סגורות, ומחזיר בחירה מתוך רשימה, עם הסתברות לכל אפשרות. תחשבו על זה כמו על שאלון אמריקאי במקום מבחן פתוח: אי אפשר "לענות משהו אחר".
בכל צעד, הסוכן מצלם את הדף לא כתמונה אלא כטבלה ממוספרת של האלמנטים שאפשר להפעיל, למשל [2] combobox "Where from?" ו-[3] combobox "Where to?". אחר כך הוא שואל את Jev, בבקשה אחת לרשת, כמה שאלות במקביל: איזו פעולה (CLICK, TYPE_TEXT, SELECT, גלילה, WAIT, DONE או BLOCKED), ועל איזה אלמנט ללחוץ אם זו לחיצה, ובאיזה להקליד אם זו הקלדה. השאלות על האלמנט הן "ספקולטיביות": שואלים את כולן מראש, ומשתמשים רק בזו שמתאימה לפעולה שנבחרה. שתי החלטות, נסיעה אחת ברשת.
החלק השני הוא מודל שפה קטן ומהיר, שנכנס לתמונה רק כשהפעולה היא TYPE_TEXT. בהדגמה זה Mercury 2.5 של Inception, דרך OpenRouter, עם חשיבה כבויה. בהקלטה הרשמית הוא ייצר את המילה Zurich ב-581 אלפיות שנייה ואת London ב-346.
ועוד החלטה אחת שחוסכת המון: אין צילומי מסך בלולאה. הסוכן קורא את הדף כמבנה, בקריאה אחת לדפדפן, ושולח למודל רק טקסט גלוי. וגם לגבי אבטחה יש כאן משהו יפה: הפלט של המודל אף פעם לא הופך לסלקטור, לקואורדינטות, לפקודת shell או לקוד JavaScript. הוא רק בוחר מספר מתוך טבלה שהקוד שלנו בנה.
הלולאה של jev-ultrafast: מטבלה להחלטה ללחיצה
צילום מצב
קריאה אחת לדפדפן בונה טבלה ממוספרת של כל הכפתורים והשדות הגלויים, למשל [2] Where from?
Jev מחליט
בקשה אחת: איזו פעולה (CLICK, TYPE_TEXT, SELECT...) ועל איזה אלמנט. מחזיר בחירה והסתברויות, לא טקסט.
צריך טקסט?
רק אם הפעולה היא TYPE_TEXT, מודל קטן (Mercury 2.5) כותב את הערך, למשל Zurich.
בדיקה לפני פעולה
הקוד מוודא שהדף לא השתנה ושהאלמנט לא מוסתר, ורק אז לוחץ או מקליד.
המתנה קצרה
אחרי הקלדה בשדה עם הצעות מחכים עד 200ms, אחרי שאר הפעולות עד 50ms.
DONE + אימות
כשהתוצאות מופיעות הסוכן עוצר, ובודק עצמאי מוודא מסלול, תאריך ותוצאות.
חוזרים לצעד 1, עד שהמשימה מושלמת
בידיים: מריצים את זה אצלנו
ההתקנה לקוחה כמו שהיא מה-README הרשמי. צריך את uv (מנהל החבילות המהיר של Python), Chrome, ושני מפתחות: מפתח של TypeSafe בשביל Jev, ומפתח של OpenRouter בשביל מודל הטקסט.
מריצים את jev-ultrafast (מתוך ה-README הרשמי)
git clone https://github.com/browser-use/jev-ultrafast.git
cd jev-ultrafast
uv synccp .env.example .env# Add TYPESAFE_API_KEY and TEXT_MODEL_API_KEY.
uv run jev
# then open http://127.0.0.1:8766# -> Start demo -> Run automatically# if Chrome does not connect:
uv run browser-harness --doctor
במילים: משכפלים את הריפו, מריצים uv sync, מעתיקים את קובץ ההגדרות, ממלאים את TYPESAFE_API_KEY ואת TEXT_MODEL_API_KEY, ומריצים uv run jev. אחר כך פותחים את http://127.0.0.1:8766 ולוחצים על Start demo ואז Run automatically. בממשק רואים בזמן אמת את טבלת האלמנטים הממוספרת, את ההסתברויות של כל פעולה ושל כל אלמנט, ואת מה שבוצע. יש גם כפתור Choose next שעוצר לפני כל פעולה, וזו הדרך הכי טובה להבין מה קורה בפנים.
החיבור ל-Chrome עובר דרך Browser Harness, פרויקט נוסף של Browser Use שמותקן אוטומטית ומחבר את הסוכן ל-Chrome האמיתי שלנו. שימו לב שזה אומר שהסוכן עובד עם הפרופיל שלנו, כולל החשבונות המחוברים. אם החיבור לא עובד, מריצים uv run browser-harness --doctor ומאשרים remote debugging ב-Chrome.
כמה עולה כל צעד
בואו נפרק את החיפוש ציריך-לונדון לפי מסמך הביצועים הרשמי. בהקלטה היו 17 בקשות ל-Jev, עשר פעולות בדף ועוד WAIT אחד, ושתי קריאות למודל הטקסט. זמן התגובה החציוני של Jev היה 178 אלפיות שנייה. לחיצת החיפוש בוצעה אחרי 5.2 שניות, והסוכן הכריז "סיימתי" אחרי 7.07 שניות, כשהזמן הזה כולל גם את הטעינה של Google.
בצד הכסף, ההקלטה צרכה 90,558 טוקנים של קלט ו-6,325 טוקנים של פלט אצל Jev. בעמוד המודלים של TypeSafe כתוב ש-Jev עולה 0.042 דולר למיליון טוקנים של קלט, והפלט בחינם. החשבון שלנו: בערך 0.0038 דולר לכל ה-Jev, כלומר בערך 0.0002 דולר להחלטה. שתי קריאות הטקסט עלו לפי OpenRouter 0.00006 דולר. ביחד, כל חיפוש הטיסה עלה בערך 0.4 סנט, לא כולל את עלות הדפדפן. חשוב לדייק: הסכום של Jev הוא החישוב שלנו לפי המחירון, כי TypeSafe לא החזירה סכום מחויב, והמפתחים עצמם מציינים את זה.
כדי לקבל תחושה של סדר הגודל, חישבנו מה היה עולה בדיוק אותו מספר טוקנים במודלים אחרים, לפי המחירון הרשמי:
גרף · נתונים מאומתים
אותו חיפוש ציריך-לונדון, אותם טוקנים: כמה זה עולה
Jev + Mercury 2.50.39סנט
Gemini 3.1 Flash Lite3.2סנט
Claude Sonnet 5.524.4סנט
חישוב שלנו: 90,558 טוקני קלט ו-6,325 טוקני פלט מההקלטה הרשמית (docs/performance.md של jev-ultrafast). Jev לפי עמוד המודלים של TypeSafe (0.042$ למיליון קלט, פלט חינם) + 0.00006$ ששולמו ל-Mercury 2.5 לפי OpenRouter. Sonnet 5.5 לפי מחירון Anthropic (2$/10$), Gemini 3.1 Flash Lite לפי OpenRouter (0.25$/1.5$). השוואה אילוסטרטיבית: סוכן מבוסס LLM היה צורך מספר טוקנים אחר. לא כולל עלות דפדפן. נכון ל־2026-10-19.
אותם טוקנים ב-Claude Sonnet 5.5 (2 דולר למיליון קלט, 10 לפלט) היו עולים כ-24 סנט, וב-Gemini 3.1 Flash Lite כ-3.2 סנט. זו השוואה אילוסטרטיבית: סוכן שמבוסס על מודל גדול היה עובד אחרת ומייצר מספר טוקנים אחר. אבל היא ממחישה למה מודל החלטות שלא כותב טקסט משנה את הכלכלה של סוכני דפדפן.
ולגבי המהירות: בהשוואה של שש ריצות מתחלפות עם אותם מודלים, הזמן החציוני ירד מ-9.45 ל-7.09 שניות, ירידה של 25%. המפתחים עצמם כותבים שזה שלוש חזרות על משימה אחת בפרופיל אחד, ולא בנצ'מרק אמינות כללי. אותה מדיניות פתחה ערך בוויקיפדיה ב-2.8 שניות.
מתי לא להשתמש בסוכן דפדפן
כאן מגיע החלק שהכי חשוב לי. סוכן דפדפן הוא פטיש מצוין, אבל לא כל דבר הוא מסמר.
כשיש API. אם לשירות יש ממשק תכנותי רשמי, הוא כמעט תמיד מהיר יותר, זול יותר, יציב יותר ומותר יותר. סוכן דפדפן הוא פתרון לאתרים שאין להם API, לא תחליף ל-API קיים. הדף של Google Flights יכול להשתנות מחר בבוקר, ה-API של ספק טיסות לא.
כשיש קפצ'ה או חסימת בוטים. אתר ששם קפצ'ה (מבחן "אני לא רובוט") אומר לנו משהו ברור: הוא לא רוצה תנועה אוטומטית. יש היום כלים שבנויים בדיוק כדי לעקוף את זה. הפרויקט invisible_playwright_mcp, למשל, צבר כ-2,800 כוכבים בפחות משלושה שבועות, ומתאר את עצמו כשרת MCP ש"לא מזוהה על ידי אנטי-בוטים וקפצ'ות". גם Scout של Outcrawl, סוכן קוד פתוח שעלה ב-13 באוקטובר, מציע בענן שלו פתרון קפצ'ות, וכך גם הענן של Browser Use, שכותב בהגינות שאף הגדרה לא מבטיחה הצלחה מול כל קפצ'ה. בעיניי, עקיפה של מנגנון הגנה באתר שלא שלנו היא לא שאלה טכנית אלא שאלה משפטית ואתית, ושווה לעצור לפניה.
כשתנאי השימוש אוסרים. בתנאי השימוש של Google, למשל, כתוב במפורש שאסור להשתמש באמצעים אוטומטיים כדי לגשת לתוכן בניגוד להוראות שהאתר מפרסם למכונות, כמו קובץ robots.txt. לפני שמכוונים סוכן לאתר, קוראים את התנאים שלו.
כשהטעות יקרה. הסוכן הזה לא מזמין טיסה, וזה לא במקרה. המפתחים כותבים במפורש שגם כשהסוכן מכריז DONE, זו לא הוכחה להצלחה, ולכן בהדגמה יש בודק עצמאי שמוודא בנפרד את המסלול, התאריך והתוצאות. תשלומים, מחיקות ושליחת טפסים צריכים אישור אנושי.
השוואה
סוכן דפדפן, API או לעצור: איך מחליטים
ויש גם מגבלות טכניות שכדאי להכיר: לפי ה-README, הגרסה הנוכחית לא תומכת ב-shadow DOM, ב-iframes, ב-canvas, בהעלאת קבצים, בטאבים חדשים ובגלילה מקוננת. זה MVP (גרסה ראשונה מינימלית), לא מוצר גמור.
בעיניי: הסוכן הוא לא מודל, הוא מערכת
שורה תחתונה, הסיפור כאן הוא לא "מודל מהיר יותר". הסיפור הוא ארכיטקטורה. במקום לתת למודל אחד גדול לעשות הכל, מפרקים את המשימה: קוד דטרמיניסטי בונה טבלה של מה שאפשר לעשות, מודל החלטות בוחר מתוכה, מודל קטן כותב טקסט רק כשצריך, וקוד אחר בודק שהלחיצה עדיין תקפה לפני שהיא קורית. ככה מגיעים לשבע שניות ולפחות מחצי סנט, ולא בגלל שמודל אחד נהיה גאון.
בעיניי זה גם השיעור הרחב יותר לכל מי שבונה סוכנים: כל מקום שבו אנחנו נותנים למודל גדול לבחור מתוך רשימה סגורה הוא מקום שבו אפשר לחסוך זמן וכסף. ובאותה נשימה, צריך לזכור את המגבלות: שלוש ריצות על משימה אחת הן לא הוכחה כללית, Jev עדיין לא רואה תמונות, ואתרים מורכבים עדיין ידרשו את הגישה הכבדה.
בדקו את עצמכם
מה הסיבה המרכזית לכך ש-jev-ultrafast מגיע לשבע שניות?
אז איזו משימה שאנחנו עושים כל שבוע ידנית באתר בלי API, היינו נותנים ראשונה לסוכן של שבע שניות?
רוצים ללכת עם זה רחוק יותר?
את כל הבסיס של סוכנים, MCP וכלים שמחברים את Claude לעולם, אני מפרק לעומק בקורס Practical AI with Claude, בעברית. מי שרוצה לבנות סוכנים כאלה בעצמו מתוך הטרמינל ימצא את זה בקורס Claude Code Mastery, באנגלית.
