failproofai 1.0.1-beta.1 → 1.0.2-beta.0

package/.next/standalone/docs-old/he/agenteye/evaluation-suite.mdx

@@ -0,0 +1,299 @@
+---
+title: "חבילת הערכה"
+description: "Failproof AI Observability יכול לדרג באופן אוטומטי כל הרצה של סוכן שהסתיימה מבחינת איכות: אתה מספק שירות דירוג קטן, ו-Observability מטפל בשאר."
+---
+
+Failproof AI Observability יכול לדרג באופן אוטומטי כל הרצה של סוכן שהסתיימה מבחינת איכות: אתה מספק שירות דירוג קטן, ו-Observability מטפל בשאר. השתמש בו כדי לעקוב אחר הממדים שחשובים לך (עזרתיות, יעילות כלים, עובדתיות, בטיחות; אתה בוחר), לתפוס רגרסיות מוקדם, ולהשוות סוכנים או סביבות בהצצה. הדירוג הוא אופציונלי: הצינור לא עושה כלום עד שתגדיר את `EVALUATOR_ENDPOINT` בשרת.
+
+> **הערה:** אתה מגדיר את ממדי הציון. ההערכה שלך יכולה להחזיר כל מפתחות מספריים שהיא רוצה; Observability אחסן, טרנד ומציג כל מה שאתה שולח חזרה.
+
+## במבט חטוף
+
+1. **כתוב מדרג.** הקם שירות HTTP קטן שקורא תמליל של סשן ומחזיר ציונים. Observability משלח התייחסות עובדת שאתה יכול להעתיק. ראה [כתיבת מעריך עם ה-SDK](#writing-an-evaluator-with-the-sdk).
+2. **הצביע ל-Observability על זה.** קבע את `EVALUATOR_ENDPOINT` (ו-`EVALUATOR_TOKEN` משותף) בתהליך השרת.
+3. **צפה בציונים שנחתו.** כל סשן שהסתיים מדורג באופן אוטומטי; התוצאות מופיעות בעמוד פרטי הסשן, בגריד הסשנים ובלוחות שנשמרו.
+
+![תצוגת פרטי סשן עם סיכום ההערכה, סרגלי ציון לממד, וטקסט נמקות בפס ימני](/agenteye/images/session-detail.png)
+
+*לאחר הגדרת מעריך, כל הרצה שהושלמה מדורגת והתוצאות מופיעות בפס הימני של הסשן: הסיכום בחלק העליון, ואחריו סרגלי ציון לממד עם נמקות.*
+
+---
+
+## איך זה עובד
+
+```mermaid
+flowchart LR
+    ING["ingest /events<br/>agent_end"] --> SRV["Observability server"]
+    SRV -->|"POST /evaluate"| EV["Evaluator service"]
+    EV -->|"done or pending"| SRV
+    SRV -->|"poll GET /evaluate/{job_id}"| EV
+    EV -->|"done"| SRV
+    SRV --> RES["evaluations<br/>terminal results"]
+```
+
+כאשר Failproof AI Observability SDK פולט אירוע `agent_end` לסשן, השרת מתכנן הערכה. לאחר מכן הוא עושה POST של תמליל האירוע המלא לשירות ההערכה שלך, שיכול:
+
+- **להחזיר את התוצאה בשורה** עם `{"status":"done", "scores":{...}, "reasoning":{...}, "summary":"..."}`. התוצאה מנוספת לציר הזמן של ההערכה של הסשן. `reasoning` ו-`summary` הם אופציונליים.
+- **לדחות** עם `{"status":"pending", "job_id":"abc-123"}`. Observability ואז קורא `GET {EVALUATOR_ENDPOINT}/evaluate/abc-123` עד שההערכה שלך מחזירה `{"status":"done", ...}` או `{"status":"error", "error":"..."}`.
+
+  קצב הסקר הוא לכל עבודה: תגובת `pending` עשויה לכלול `next_poll_secs` כדי לדרוג; אחרת Observability משתמש בערך `default_poll_interval_secs` מ-`GET /config`; אחרת השרת חוזר אל `EVALUATOR_POLLING_INTERVAL_SECS` (ברירת מחדל 10 שניות). כל הערכים מוגבלים ל-[1 שניה, 1 שעה].
+
+סשנים שלא פלטו `agent_end` (לדוגמה, תהליך סוכן שהתרסק) יכולים גם להיאסף: `GET /config` של ההערכה עשוי להחזיר `{"inactivity_timeout_secs": 1800}`, וה-Observability יעריך כל סשן שנשמר בחוסר פעילות לפי זמן זה. קבע את השדה ל-`null` או השמיט אותו כדי להשבית את הנופל החלופי.
+
+הצינור הוא כל ל-no-op כאשר `EVALUATOR_ENDPOINT` לא מוגדר.
+
+סשן יכול להצטבר **הערכות מסוף מרובות לאורך זמן**: כל אירוע `agent_end` (וכל הערכה חוזרת ידנית מלוח המחוונים) מוסיף שורת הערכה חדשה. זוהי הדרך הנתמכת להערכת שיחה שנעתקה: משתמש מסיים סוכן, חוזר מאוחר יותר, שולח עוד אירועים, מסיים את הסוכן שוב, והערכה שנייה רצה כנגד התמליל המעודכן המלא. לוח המחוונים משרטט את ההערכה העדכנית ביותר כהכותרת והערכות הקודמות כציר זמן ניתן לצמצום. בזמן שהערכה אחת פועלת לסשן, אירועי `agent_end` נוספים עבור אותו סשן מתעלמים; האחד הבא לאחר השלמת ההערכה הפועלת יתור הערכה טרייה כרגיל.
+
+הנופל החלופי של חוסר פעילות מחדש בסשנים שנעתקו: אם אירועים חדשים מגיעים לאחר הערכה סוף קודמת וסשן ואז הולך ללא פעילות בעבר `inactivity_timeout_secs`, הערכה טרייה מתורה.
+
+כשלים חולפים (5xx, 429, timeouts, שגיאות רשת) מנסים שוב עם backoff אקספוננציאלי עד `EVALUATOR_MAX_ATTEMPTS`; תגובות 4xx הן סופיות. Observability בטוח להריץ עם מספר מקבלות שרת במרובה; העבודה מחולקת כך שאותו סשן לעולם לא יישלח פעמיים במקביל.
+
+---
+
+## חוזה HTTP
+
+כל מסלול מאומת משתמש **ב-Bearer Token Auth**. אותו ערך חייב להיות מוגדר משני הצדדים:
+
+- שרת Observability: משתנה env `EVALUATOR_TOKEN`
+- שירות Evaluator: מוגדר באותו אופן (ה-SDK `agenteye-evaluator` קורא `EVALUATOR_TOKEN` לפי מוסכמה)
+
+אם `EVALUATOR_TOKEN` לא מוגדר, השרת לא שולח כותרת `Authorization`; ההערכה עשויה לקבל בקשות אנונימיות, שזה בסדר לרשת פנימית בלבד אך מודחה באינטרנט הציבורי.
+
+### נתיבים שההערכה חייבת להגיש
+
+| נתיב | גוף / פרמטרים | תגובה |
+|---|---|---|
+| `GET /health` | ללא | `{"status":"ok"}` (פתוח, ללא auth) |
+| `GET /config` | ללא | `{"inactivity_timeout_secs": <int> \| null, "default_poll_interval_secs": <int> \| omitted}` |
+| `POST /evaluate` | `EvalRequest` JSON | `{"status":"done", ...}` או `{"status":"pending", "job_id":"..."}` |
+| `GET /evaluate/{id}` | ללא | אותה צורת תגובה כמו `/evaluate` |
+
+### גוף `EvalRequest` שנשלח על ידי השרת
+
+```json
+{
+  "schema_version": "1",
+  "session_id":     "session-abc123",
+  "agent_id":       "planner",
+  "environment":    "production",
+  "started_at":     "2026-05-10T12:00:00Z",
+  "ended_at":       "2026-05-10T12:05:00Z",
+  "events": [
+    { "id": 1234, "ts": "...", "event_type": "agent_start", "payload": { ... } },
+    ...
+  ]
+}
+```
+
+### צורות תגובה
+
+**סינכרוני (בוצע):**
+
+```json
+{
+  "status": "done",
+  "scores": { "helpfulness": 0.85, "tool_efficiency": 0.6 },
+  "reasoning": {
+    "helpfulness": "answered the question directly with citations",
+    "tool_efficiency": "called list_files three times when one would have done"
+  },
+  "summary": "strong answer quality, weak tool selection"
+}
+```
+
+`reasoning` (מפת הנמקה לכל ציון) ו-`summary` (נרטיב אחד-פסקה כולל) שניהם אופציונליים. מפתחות ב-`reasoning` צריכים לשקף מפתחות ב-`scores`; לוח המחוונים משרטט כל ערך בשורה מתחת לסרגל הציון שלו. הערכות ישנות יותר שמחזירות רק `scores` ממשיכות לעבוד ללא שינוי; `reasoning` ו-`summary` פשוט קוראים כ-null ויכולות ה-UI המתאימות מושמטות.
+
+**אסינכרוני (דחוי):**
+
+```json
+{ "status": "pending", "job_id": "abc-123", "next_poll_secs": 30 }
+```
+
+`next_poll_secs` הוא אופציונלי; אם מושמט השרת חוזר ל-`default_poll_interval_secs` של ההערכה מ-`/config`, ואז ל-משתנה ה-env `EVALUATOR_POLLING_INTERVAL_SECS` שלו.
+
+**שגיאה סופית בצד המעריך:**
+
+```json
+{ "status": "error", "error": "model service unavailable" }
+```
+
+השרת מתייחס לכל גוף 2xx אחר כשגיאת פרוטוקול ורושם `error` סופי לסשן.
+
+---
+
+## כתיבת מעריך עם ה-SDK
+
+אתה לא חייב ליישם את חוזה HTTP ביד. החבילה Python `agenteye-evaluator` נותנת לך ליפוף FastAPI מוקלד שמטפל בהתאמה, ניתוב וצורות בקשה/תגובה בשבילך.
+
+Failproof AI Observability גם משלח **מעריך התייחסות עובד** שמדרג `helpfulness`, `tool_efficiency` ו-`factuality` מצורת התמליל. העתק אותו כנקודת התחלה וחליף בלוגיקה שלך: שופט LLM, מנוע כללים, כל מה שמתאים לסטנדרט האיכות שלך.
+
+מעריך ברור ברירת מחדל:
+
+```python
+import os
+from agenteye_evaluator import Evaluator, EvalRequest, EvalResponse
+
+app = Evaluator(token=os.environ["EVALUATOR_TOKEN"])
+
+@app.evaluator
+def run(req: EvalRequest) -> EvalResponse:
+    # Inspect req.events (the full session transcript) and return scores.
+    tool_calls = sum(1 for e in req.events if e.event_type == "tool_use")
+    return EvalResponse(
+        scores={"tool_calls": float(tool_calls)},
+        reasoning={"tool_calls": f"{tool_calls} tool invocations in the transcript"},
+        summary="tight tool loop" if tool_calls < 5 else "agent looped on tools",
+    )
+```
+
+מופע ה-`app` פועל תחת כל שרת ASGI, כך שתחילת `uvicorn module:app`.
+
+עבור הערכות שצריכות לדחות עבודה יקרה, החזור ב-`JobPending` בעוד רושם `@app.job_lookup` handler; שרת Observability סוקר `GET /evaluate/{job_id}` עד שתחזיר סטטוס סופי או עד שהמכסה `EVALUATOR_MAX_POLL_DURATION_SECS` (ברירת מחדל 1 שעה) חולפת.
+
+ה-API reference המלא, דפוס אסינכרוני וסכמת אירועים תועדו ב-README של SDK ה-`agenteye-evaluator`.
+
+---
+
+## הרצת המעריך שלך
+
+ההערכה היא **השירות שלך** — Failproof AI Observability לא משלח מעריך ברירת מחדל, כך שאתה בונה והרץ אותו במקום שבו אתה מריץ את השירותים שלך. הוא פועל תחת כל שרת ASGI (לדוגמה `uvicorn my_evaluator:app`); הגיש את נתיבי `/health`, `/config` ו-`/evaluate` מ-[חוזה HTTP](#http-contract), ואז הצביע את השרת אליו (ראה [הגדרת השרת](#configuring-the-server)).
+
+ברגע שההערכה ניתנת להשגה, `GET /health` מחזיר `{"status":"ok"}`. לאחר הרצה של סוכן מקצה לקצה, `GET /evaluations` בשרת מחזיר שורה עם `status: "done"` וציונים שההערכה שלך ייצרה.
+
+---
+
+## הגדרת השרת
+
+קבע בתהליך השרת:
+
+| Env var | משמעות |
+|---|---|
+| `EVALUATOR_ENDPOINT` | URL בסיסי של ההערכה שלך (`http://evaluator:9000`). לא מוגדר = צינור מנוטרל. |
+| `EVALUATOR_TOKEN` | Bearer token. חייב להיות שווה לערך שהשירות ההערכה מוגדר איתו. |
+| `EVALUATOR_WORKERS` | משימות עובדים לכל מופע שרת (ברירת מחדל 2). |
+| `EVALUATOR_CLAIM_BATCH` | שורות שטענו לכל תיקיית עובדים (ברירת מחדל 4). אצוות מעובדות **במקביל**; תחולה אפקטיבית בנקודת ההערכה שלך היא `EVALUATOR_WORKERS × EVALUATOR_CLAIM_BATCH`. |
+| `EVALUATOR_POLL_IDLE_SECS` | כמה זמן עובד ישן בין ניסיונות dispatч כאשר לא מוערך (ברירת מחדל 2 שניות). |
+| `EVALUATOR_POLLING_INTERVAL_SECS` | נופל סופי ל-`GET /evaluate/{id}` קצב כאשר לא `next_poll_secs` ולא `default_poll_interval_secs` של ההערכה מוגדר (ברירת מחדל 10 שניות). |
+| `EVALUATOR_REQUEST_TIMEOUT_MS` | קצבאו לכל בקשה (ברירת מחדל 30000). |
+| `EVALUATOR_MAX_ATTEMPTS` | לאחר נסיונות חולפים רבים זה, התוצאה מוקלטת כ-`error` סופי (ברירת מחדל 5). |
+| `EVALUATOR_CONFIG_REFRESH_SECS` | קצבאו של `GET /config` (ברירת מחדל 300). |
+| `EVALUATOR_MAX_POLL_DURATION_SECS` | זמן קיר מקסימלי שסשן עשוי להישאר בתור הסקר לפני שהוא מסתיים כ-`timeout` (ברירת מחדל 3600 שניות). משמר כנגד מעריך שמחזיר `pending` לנצח. |
+
+כדי להפעיל דירוג אוטומטי, קבע הן את `EVALUATOR_ENDPOINT` והן את `EVALUATOR_TOKEN` בשרת, ואז הפעל מחדש כדי להרים את השינוי. עם `EVALUATOR_ENDPOINT` לא מוגדר הצינור נשאר no-op.
+
+כפתורי הכיול לעיל הם אופציונליים; קבע משתנים סביבה מתאימים בשרת רק אם אתה צריך לדרוג את ברירות המחדל.
+
+---
+
+## API reference
+
+| שיטה | נתיב | הרשאה נדרשת | מטרה |
+|---|---|---|---|
+| `GET` | `/evaluations` | `evaluations:read` | תוצאות סופיות של שאילתה. תומך בـ `session_id`, `agent_id`, `environment`, `status` (`done`/`error`/`timeout`), `ts_from`, `ts_to`, `cursor`, `limit`, `score_filters`, `latest_per_session`. `limit` מכתת ל-50 וקצוב ב-200 (שימו לב זה שונה מ-`/events`, שקצוב ב-1000). `environment` מקבל רשימה המופרדת בפסיקים (למשל `environment=prod,staging`); ערכים יחידים עדיין פועלים. עם `latest_per_session=true` התגובה מכילה לכל היותר שורה אחת לכל `session_id` (ההאחרונה לפי `completed_at`) בשימוש בעמוד רשימת הסשנים כדי לצמצם ציר זמן הערכה של סשן לכותרת הנוכחית שלו. ברירת מחדל לשקר (מחזיר את ההיסטוריה המלאה). |
+| `GET` | `/evaluations/aggregate` | `evaluations:read` | בריאות eval מצטברת עבור פרוסה מסוננת: ספירה כוללת, פירוט done/error/timeout, סטטיסטיקה לכל מפתח ציון (ספירה/ממוצע/דקות/מקס/p50 על פני מפתחות `scores` שרירותיים) וציר זמן מגודל זמן. מקבל **אותם פרמטרים סינון כמו `/evaluations`** בתוספת `featured_keys` (CSV של מפתחות ציון לטרנד) ו-`latest_per_session`. הנוסחאות לתכונת Dashboards; מדדים מדויקים על כל הסט התואם, לא דגום. |
+| `GET` | `/evaluations/environments` | `evaluations:read` | ערכי סביבה מובחנים מטבלת ה-`evaluations`. משמש למילוי תפריטי סינון המתוגבלים לנתונים הניתנים לקריאה הערכה. |
+| `GET` | `/evaluation-jobs` | `evaluations:read` | ראות להערכות בטיסה. סנן לפי `status` (`pending`/`polling`). |
+| `GET` | `/events` | `events:read` | זרימת אירועים גולמיים של סשן. תומך ב-`session_id`, `agent_id`, `event_type` (CSV), `environment` (CSV), `ts_from`, `ts_to`, `cursor`, `limit` וכן `order`. `order` הוא `desc` (newest-first, ברירת מחדל) או `asc` (oldest-first); ערך לא מוכר חוזר אל `desc`. סמן עמוד דרך ה-`next_cursor` של התגובה (מזהה אירוע): העבור אותו חזרה כמו `cursor` כדי לקבל את העמוד הבא; עם `asc` העמוד הבא הוא האירועים לאחר מזהה זה, עם `desc` האירועים לפניו. `limit` מכתת ל-50 וקצוב ב-1000. |
+| `GET` | `/sessions/:session_id/export` | `events:read` | מחזיר את גוף JSON המדוייק שההערכה תקבל לסשן זה, המוגש כקובץ הורדה בשם `session-<id>.json`. שימושי לניגון סשנים ייצור דרך `agenteye-evaluator` לבדיקה offline. הבתים זהים בדיוק לבתים שצינור ההערכה שולח. |
+| `POST` | `/sessions/:session_id/re-evaluate` | `evaluations:trigger` | תור הערכה טרייה לסשן; רץ בין אם הערכה קודמת קיימת או לא. התוצאה החדשה היא **מוספת** לציר זמן ההערכה של הסשן ולא דורסת את הקודמת, כך ציונים קודמים נשארים גלויים כהיסטוריה. מחזיר `202` על תור, `404` לסשן לא ידוע, `409` אם הערכה כבר בטיסה. השתמש בזה לאחר פריסת מעריך חדש, או לסשנים שמעולם לא פלטו `agent_end`. |
+
+### סינון לפי טווח ציון: `score_filters`
+
+`GET /evaluations` מקבל פרמטר אופציונלי `score_filters` שמצמצם תוצאות לפי ערכים מספריים בתוך `scores` object. הפרמטר הוא רשימה המופרדת בפסיקים של ערכי `key:min..max`; כל קשר עשוי להיות מושמט. כניסות מרובות משלבות עם AND לוגי. שורות כאשר המפתח הנקוב חסר או לא מספרי מודדות. בקשה עשויה להכיל לכל היותר 20 ערכי סינון; חריגה מזה מחזיר HTTP 400.
+
+דוגמאות:
+```text
+# helpfulness in [0.5, 0.8]
+GET /evaluations?score_filters=helpfulness:0.5..0.8
+
+# tool_efficiency at most 0.3 (no lower bound)
+GET /evaluations?score_filters=tool_efficiency:..0.3
+
+# helpfulness >= 0.5 AND factuality >= 0.9
+GET /evaluations?score_filters=helpfulness:0.5..,factuality:0.9..
+```
+
+לכל אובייקט תגובה `/evaluations` יש שדות אלה:
+
+| שדה | סוג | הערות |
+|---|---|---|
+| `evaluation_id` | string (UUID) | המזהה הקנוני להערכה סופית זו. כל הערכה סופית מקבלת UUID חדש; סשן אחד יכול להחזיק מרובות. |
+| `id` | string (UUID) | כינוי backward-compatibility הנושא את אותו ערך כמו `evaluation_id`. |
+| `session_id` | string | הסשן שהערכה זו רצה כנגדו. סשן יכול להיות הערכות מרובות בציר הזמן. |
+| `agent_id` | string | מזהה את הסוכן שייצר את הסשן. |
+| `environment` | string | תווית סביבה מעתקת מהסשן. |
+| `status` | enum | אחד מ-`"done"`, `"error"`, `"timeout"`. |
+| `scores` | object \| null | ציונים שהוחזרו על ידי ההערכה שלך. |
+| `reasoning` | object \| null | מפת הנמקה אופציונלית לכל ציון שהוחזרה על ידי ההערכה שלך. מפתחות בדרך כלל משקפים אלה ב-`scores`. לוח המחוונים משרטט כל ערך מתחת לסרגל הציון שלו. |
+| `summary` | string \| null | נרטיב אחד-פסקה כולל אופציונלי שהוחזר על ידי ההערכה שלך. לוח המחוונים משרטט זאת למעלה פירוק הציון לכל ציון כהערכה של ההערכה. |
+| `error` | string \| null | למלא ב-`"error"` / `"timeout"` בלבד. |
+| `attempt_count` | integer | מספר ניסיונות dispatch (≥ 1). |
+| `duration_ms` | integer \| null | משך הניסיון הסופי. |
+| `completed_at` | string (ISO 8601 UTC) | מתי התוצאה הסופית נוקדה. תוצאות מסודרות לפי `completed_at` (newest first). |
+| `created_at` | string (ISO 8601 UTC) | נושא את אותו חותם זמן כמו `completed_at` (semantics write-once). |
+
+---
+
+## הרשאות
+
+| הרשאה | מיוחסות |
+|---|---|
+| `evaluations:read` | רשימת תוצאות הערכה, צפייה בציונים בלוח המחוונים וטעינת מדדי בריאות לוח המחוונים. |
+| `evaluations:trigger` | תור ידנית של הערכה לסשן דרך `POST /sessions/:session_id/re-evaluate` או כפתור re-evaluate של לוח המחוונים. |
+| `dashboards:read` | צפייה בלוחות שמורים (גם צריך `evaluations:read` כדי לטעון את המדדים שלהם). |
+| `dashboards:write` | יצירה ועריכת לוחות. |
+| `dashboards:delete` | מחיקת לוחות. |
+
+ה-bootstrap admin (`ADMIN_KEY`, `ADMIN_EMAIL`) מקבל אלה באופן אוטומטי.
+
+---
+
+## צפייה בתוצאות
+
+- **`/sessions/<id>`**: אירועים ציר זמן + פס ימני המציג את ציוני הסשן וכל שגיאה מניסיון ה-dispatch. אם המפתח שלך כולל `evaluations:trigger`, כפתור **re-evaluate** מופיע ליד כפתור ה-export, שימושי לסשנים שמעולם לא פלטו `agent_end`, או להרעיש ציונים לאחר פריסת מעריך חדש. לוח המחוונים סוקר את התוצאה החדשה ומעדכן את פס הימני כאשר הוא נוחת.
+- **`/sessions`**: גריד סשנים ניתן לסינון; עמודת הציון מציגה את סטטוס ההערכה וציונים של כל סשן בהצצה.
+- **`/dashboards`**: צפיות בריאות eval שמורה (ראה [לוחות](#dashboards) להלן).
+
+![גריד הסשנים עם כלולי סטטוס הערכה לכל סשן ובתגים מדורגים בצבע (עזרתיות, עובדתיות, tool_efficiency, בטיחות, קוהרנטיות)](/agenteye/images/sessions-list.png)
+
+*גריד הסשנים מציג את סטטוס ההערכה וציונים של כל הרצה בהצצה; תגים אדומים/כהים/ירוקים גורמים לציונים נמוכים לקפוץ החוצה.*
+
+---
+
+## לוחות
+
+דף **Dashboards** (`/dashboards`) מאפשר לך שמירה של שילוב של סינני הערכה כתצוגה בשם וניתנת לשימוש חוזר וצפייה כיצד האות פרוסה של הערכות עושה בהצצה. לוחות הם **משותפים בכל הארגון שלך**; כולם עם `dashboards:read` רואים את אותה סט.
+
+כל לוח משמירה:
+
+- **סינונים**: אותם בקרים כמו עמוד הסשנים: סביבה, סטטוס, סוכן, חלון זמן מתגלגל וסינני טווח ציון (`key:min..max`).
+- **תצורת תצוגה**: איזה מפתחות ציון לתכונה, סף בריאות ירוק/כהה/אדום, איזה פנלים להציג והאם לצמצם לאחרון הערכה לכל סשן.
+
+כל כרטיס מציג את מספר הסשנים התואמים, פירוט done/error/timeout, ממוצע של כל ציון בתכונה וטרנדלין ספארק קטן. פתיחת לוח מציגה את הפנלים במלוא הגודל; **"פתח בסשנים"** מושיב אותך לעמוד הסשנים מקדים מסונן לאותה פרוסה בדיוק. מדדים מחושבים בצד שרת על פני כל הסט התואם (דרך `GET /evaluations/aggregate`), כך המספרים מדויקים ולא דגומים.
+
+![לוח בריאות eval עם סרגלי ציון ממוצע לממד evaluator, breakdown tool ok-vs-error, כלים למעלה וטרנד events-per-hour](/agenteye/images/dashboard-quality.png)
+
+**הרשאות:** צפייה צריכה הן `dashboards:read` והן `evaluations:read`; יצירה ועריכה צריכה `dashboards:write`; מחיקה צריכה `dashboards:delete`. ה-bootstrap admin מקבל את כל אלה באופן אוטומטי.
+
+---
+
+## פתרון בעיות
+
+**סשנים קיימים אך לא נוצרות הערכות.** אשר כי `EVALUATOR_ENDPOINT` מוגדר בתהליך השרת, שהשרת וההערכה משתפים אותו ערך `EVALUATOR_TOKEN` וכי נקודת הסוף `/health` של ההערכה ניתנת להשגה מהשרת. עם `EVALUATOR_ENDPOINT` לא מוגדר הצינור הוא no-op.
+
+**הערכות בטיסה צוברות.** שאילתה `GET /evaluation-jobs` כדי לראות את התור בטיסה. בדוק את `attempt_count`, `next_attempt_at` ו-`last_error` על כל שורה. סיבות נפוצות: שירות ההערכה לא ניתן להשגה או מחזיר 5xx (מנסה שוב עם backoff), `EVALUATOR_TOKEN` שגוי (401 סופי) או מעריך אסינכרוני שמחזיר `pending` לנצח (ראה להלן).
+
+**סשנים הושלמו אך לא הערכה סופית.** שאילתה `GET /evaluation-jobs?status=polling`; התוצאה עדיין עשויה להיות בטיסה. אם עבודה תקועה ב-`pending`, לשרת יש בעיה להשגת ההערכה; בדוק שהערכה מעלה וכי `EVALUATOR_TOKEN` משחק.
+
+**`HTTP 401 from evaluator: invalid bearer token`.** ה-`EVALUATOR_TOKEN` בשרת לא משחק עם הערך שהשירות ההערכה מוגדר איתו. הם חייבים להיות זהים.
+
+**מעריך אסינכרוני מחזיר `pending` לנצח.** השרת סוקר `GET /evaluate/{job_id}` עד שההערכה מחזירה `done` או `error`, או עד ש-`EVALUATOR_MAX_POLL_DURATION_SECS` (ברירת מחדל 1 שעה) חולפת. לאחר הכובע ההערכה מוקלטת כ-`timeout` והוסרת מתור הבטיסה. הרם את `EVALUATOR_MAX_POLL_DURATION_SECS` אם ההערכה שלך בחוקיות צריכה יותר מברירת המחדל.
+
+---
+
+## שלבים הבאים
+
+- [מיומנות סוכן Evaluator](/he/agenteye/evaluator-skill): יש לסוכן קידוד עיצוב הממדים שלך כנגד סשנים אמיתיים וביצוע שירות זה בשבילך.
+- [Python SDK](/he/agenteye/python-sdk): פלטו את אירועי `agent_end` שמפעילים דירוג.
+- [API keys](/he/agenteye/api-keys): הרשאות `evaluations:read` ו-`evaluations:trigger`.
+- [Audits](/he/agenteye/audits): תכונת בריאות אוטומטית נוספת של Observability, לבדיקה מבוססת מדיניות.

package/.next/standalone/docs-old/he/agenteye/evaluations.mdx

@@ -0,0 +1,51 @@
+---
+title: "הערכות"
+description: "בעיות איכות מוצאות אותך כעת, במקום שתשמע עליהן בתלונת משתמש."
+---
+
+
+בעיות איכות מוצאות אותך כעת, במקום שתשמע עליהן בתלונת משתמש. חבר את שירות ההדירוג שלך פעם אחת ו-Failproof AI Observability מדרג כל הרצה שהושלמה באופן אוטומטי, כך שירידה בעזרתיות או עלייה בהלוצינציות מופיעה מעצמה, לפני שלקוח חש בכך.
+
+![רשת ההפעלות עם עמודת ניקוד: כל הרצה נושאת תג סטטוס הערכה ותגי עזרתיות, עובדתיות וַיעילות כלים בקודים צבעים](/agenteye/images/sessions-list.png)
+
+*כל הרצה ברשת ההפעלות נושאת את הניקודים שלה; תגים אדומים, כתומים וירוקים הופכים את ההרצות החלשות לבולטות מבלי שתפתח אפילו תמלול אחד.*
+
+## הפסק דגימה ידנית של הרצות
+
+נהגת לבדוק כמה הרצות וקיווית שהשאר בסדר. כעת כל סשן שהושלם מקבל ניקוד ברגע שהוא מסתיים, בממדים שחשובים לך: עזרתיות, יעילות כלים, עובדתיות, בטיחות, כל מה שקובע את רמת האיכות שלך. אתה מגדיר את מפתחות הניקוד; Failproof AI Observability שומר, עוקב אחר מגמות ומציג כל מה שמעריך שלך חוזר חזור. אף הרצה לא מחליקה ללא ניקוד, והתה מפסיק ללמוד על נסיגה מכרטיס תמיכה.
+
+הניקודים נוסעים עם רשת ההפעלות ב-**`/<org-slug>/sessions`** (סרגל צד → *observe* → *sessions*), אשכול תגים אחד לכל שורה. רוצה רק את ההרצות שירדו? סנן את הרשת לפי טווח ניקוד, נניח עזרתיות מתחת ל-0.5, וציין בדיוק את ההרצות שכדאי לקרוא. צפייה בניקודים דורשת את ההרשאה `evaluations:read`.
+
+## ראה למה הרצה קיבלה ניקוד נמוך
+
+מספר אומר לך שהרצה הייתה חלשה; דף ההפעלה אומר לך למה. פתח כל הרצה והרגל הימני מתחיל עם סיכום הכותרת, ואז מציג עמודה לכל ממד עם הנימוק של המעריך שלך מתחתה, כך שתעבור מ"זה קיבל 0.4 בעובדתיות" לטעות המדויקת בשניות.
+
+![הרגל הימני של הפעלה: סיכום ההערכה בחלקו העליון, ואז עמודות ניקוד לכל ממד כל אחת עם שורת נימוק, לצד ציר הזמן המלא של האירוע](/agenteye/images/session-detail.png)
+
+*תצוגת פרטי ההפעלה: סיכום, עמודות ניקוד לכל ממד, והנימוק מאחורי כל ניקוד, ממש לצד ציר הזמן של האירוע של ההרצה.*
+
+שלחת מעריך חדשותי, או מסתכל על הרצה שהתרסקה לפני שיכול היה להתדרג? כפתור **re-evaluate** (מעוגן ב-`evaluations:trigger`) משדרג את ההפעלה במקום ומוסיף את התוצאה הטרייה לציר הזמן שלה, כך שניקודים קודמים נשארים גלויים כהיסטוריה. תמצא אותו ב-**`/<org-slug>/sessions/<session-id>`**.
+
+## צפה במגמת איכות על כל הצי
+
+הרצה אחת עם ניקוד נמוך היא רעש; קוהורטה שלמה שמחליקה היא סימן. לוחות בקרה שמורים הופכים את הניקודים שלך למגמה שאתה יכול לצפות בה במבט אחד: עזרתיות ממוצעת השבוע מול השבוע שעבר, לכל סוכן, לכל סביבה.
+
+![לוח בקרה איכות: עמודות ניקוד ממוצע לכל ממד מעריך לצד מגמה לאורך זמן](/agenteye/images/dashboard-quality.png)
+
+*לוח בקרה איכות שמור מעקב אחר מפתחות הניקוד שאתה מציג, כך שסחיפה איטית היא ברורה הרבה לפני שהוא הופך לתקרית.*
+
+לוחות בקרה ממוקמים ב-**`/<org-slug>/dashboards`** (סרגל צד → *analyze* → *dashboards*), משותפים לכל הארגון שלך, וכל כרטיס מצבור את ההפעלות התואמות: כמה, הממוצע של כל ניקוד מוצג, וקו מגמה דקיק. "Open in sessions" מוריד אותך ישירות להרצות שסוננו מראש מאחורי כל מספר. צפייה דורשת `dashboards:read` בתוספת `evaluations:read`.
+
+## חבר מעריך פעם אחת
+
+ניקוד הוא בחירה וnמשמר כיבוי לחלוטין עד שאתה מצביע את Failproof AI Observability על מתדרג. אתה מקים שירות HTTP קטן אחד (Observability משלח התייחסות עובדת שתוכל להעתיק), קובע שני ערכים בשרת שלך, וכל הרצה מעתה מתדרגת בשבילך. ההדרכה המלאה, חוזה הניקוד, וה-SDK חיים בהנחיה העמוקה.
+
+לא בטוח איזה ממדים כדאי לדרג בהתחלה? [כישורון סוכן המעריך](/he/agenteye/evaluator-skill) מאפשר לסוכן קידוד שלך לעבוד זאת כנגד ההפעלות שלך, ואז לבנות ולפרוס את השירות.
+
+## קשור
+
+- [חבילת הערכה](/he/agenteye/evaluation-suite): חבר את המעריך שלך, חוזה הניקוד, וה-SDK.
+- [כישורון סוכן מעריך](/he/agenteye/evaluator-skill): תן לסוכן קידוד לבחור את ממדי הניקוד שלך ובנה את המעריך.
+- [הפעלות](/he/agenteye/sessions): רשת ההרצה-אחר-הרצה שבה ניקודים מופיעים.
+- [לוחות בקרה](/he/agenteye/dashboards): שמור וחלוק מגמות איכות על פני הארגון שלך.
+- [ביקורות](/he/agenteye/audits): תכונת האיכות האוטומטית האחרת של Observability, לחקירות חוצות-הפעלה.

package/.next/standalone/docs-old/he/agenteye/evaluator-skill.mdx

@@ -0,0 +1,168 @@
+---
+---
+title: "כישרון סוכן הערכה של Failproof AI Observability"
+description: "עבור מ\"אני חושב שהסוכן שלנו לפעמים רע\" לשירות ניקוד פרוס, כשהסוכן הקוד שלך עושה גם את ההחלטה וגם את הבנייה."
+---
+
+
+עבור מ*\"אני חושב שהסוכן שלנו לפעמים רע\"* לשירות ניקוד פרוס, כשהסוכן הקוד שלך עושה גם את ההחלטה וגם את הבנייה. **כישרון Failproof AI Observability evaluator** (`agenteye-evaluator`) הוא *Agent Skill*: תיקייה קטנה של הוראות שסוכן קוד כמו Claude Code או Codex טוען לפי דרישה. זה מלמד את הסוכן לעבוד ולברר אילו מימדי איכות כדאי לעקוב עבור *הסוכן שלך*, ואז לכתוב, לבדוק ולפרוס את [שירות ה-evaluator](/he/agenteye/evaluation-suite) שמדרג אותם.
+
+זה **לא** מדרג מתארח, רישום שאתה מעלה אליו, או מערכת תוספים. ה-evaluator שלך נשאר שירות HTTP שלך בתשתית שלך, בדיוק כما מתואר בהדרכה [Evaluation suite](/he/agenteye/evaluation-suite). הכישרון רק מלמד את הסוכן שלך לבנות זאת טוב, כך שכל מה שהוא עושה, אתה יכול לעשות בעצמך על ידי כתיבת אותו קוד.
+
+---
+
+## החלק הקשה הוא להחליט מה לדרג
+
+משטח ה-SDK קטן — דקורטור ושני מודלים — וסוכן יכול לכתוב את זה מ[החוזה](/he/agenteye/evaluation-suite#http-contract) לבד. זה לא המקום שבו evaluators נכשלים. הם נכשלים כי הם דורגים את הדבר הלא נכון, וה-evaluator שדורג את הדבר הלא נכון הוא גרוע מכלום: הוא מייצר לוח מחוונים שכולם למדו להתעלם ממנו.
+
+אז רוב הכישרון הוא החלק לפני שקוד כלשהו קיים. יש לסוכן לראיין אותך (*\"תאר הפעלה שהלכה טוב; עכשיו אחת שהלכה בצורה רעה\"*), ואז לשוך את הסשנים האמיתיים שלך דרך [`agenteye` CLI](/he/agenteye/cli) וקרא אותם מקצה לקצה. שתי החצאים האלה בדרך כלל לא מסכימים, והפער הוא הנקודה: מה אתה מתכוון למדוד בעבור מה שהתמלילים שלך יכולים להתמוך בו. מימד שורד רק אם הוא **ניתן לחישוב** מהאירועים ו**מבדיל** — אם הוא מדרג 0.9 גם בהפעלה הטובה שלך וגם בהרעה, הוא לא מלמד כלום ומתחלק.
+
+מה שחוזר הוא הצעה של 2-4 מימדים כשהנימוק מצורף, בשבילך לאשר לפני שכתוב שורה אחת.
+
+```mermaid
+flowchart TD
+    YOU["you: 'I want evals for my support bot'"] --> AGENT["coding agent (Claude Code / Codex)<br/>loads the agenteye-evaluator skill"]
+    AGENT -->|"interview: what does good vs bad look like?"| YOU
+    AGENT -->|"agenteye --json sessions / events"| DATA["your real sessions<br/>what actually happens"]
+    DATA --> DIMS["2-4 dimensions, you sign off"]
+    DIMS --> SVC["your evaluator service<br/>agenteye-evaluator SDK"]
+    SVC --> SCORES["scores land in the dashboard<br/>and agenteye evals"]
+```
+
+---
+
+## איך זה קשור לחלקי ההערכה האחרים
+
+ארבע מסמכים מכסים ניקוד, והם מוסרים זה לזה בסדר:
+
+| עמוד | מה זה | הגע אליו כאשר |
+|---|---|---|
+| **[Evaluations](/he/agenteye/evaluations)** | התכונה: ניקודים בגריד הסשנים, לוחות מחוונים, הערכה מחדש | אתה רוצה לדעת מה ניקוד אוטומטי מקבל לך |
+| **[Evaluation suite](/he/agenteye/evaluation-suite)** | החוזה HTTP, ה-SDK, משתני סביבת השרת | אתה מיישם או ניפוי באגים ב-evaluator בעצמך |
+| **Evaluator skill** (מסמך זה) | דלת קדמית בשפה טבעית לעיצוב *וגם* בנייה של המדרג | אתה רוצה להעבור מ"אני רוצה evals" לשירות שרץ |
+| **[CLI skill](/he/agenteye/cli-skill)** | דלת קדמית בשפה טבעית על ה-`agenteye` CLI | אתה רוצה *לקרוא* את הניקודים שכבר יש לך |
+| **[Python SDK skill](/he/agenteye/python-sdk-skill)** | דלת קדמית בשפה טבעית על כלי הסוכן שלך | הסוכן שלך עדיין לא משדר סשנים — אין שום דבר לדרג |
+
+### לעומת CLI skill: בנייה לעומת קריאה
+
+שני הכישרונות מכוונים במכוון שאינם חופפים, והתקנת שניהם היא ההגדרה הרגילה — הסוכן בוחר ביניהם על סמך מה שאתה שואל:
+
+- **`agenteye-evaluator`** (מסמך זה) בונה את הדבר שמייצר ניקודים. עבודתו מסתיימת כאשר ניקודים נוחתים בפעם הראשונה.
+- **[`agenteye-cli`](/he/agenteye/cli-skill)** קורא ניקודים שכבר קיימים (`agenteye evals`). *"האם איכות ירדה השבוע?"* היא השאלה שלה, לא של הכישרון הזה.
+
+---
+
+## דרישות מוקדמות
+
+1. **`agenteye` CLI מותקן ומחובר** (`pipx install agenteye`, ואז `agenteye login`). הכישרון מסתמך עליו פעמיים: לשוך את הסשנים האמיתיים שהוא מעצב בהם, ולאשר שהניקודים שלך נוחתו בסוף. הכניסה שלך צריכה `events:read`, בתוספת `evaluations:read` לאישור סופי זה. כמו CLI skill, היא **לא יכולה** להשלים את כניסת קוד חד-פעמית שנשלחה בדוא\"ל עבורך.
+2. **מקום ל-evaluator לחיות בו.** הוא מובנה לתמונה ורץ כשירות ממושך, אז הוא צריך ריפו אמיתי, לא קובץ סקראץ'. Evaluators לעתים קרובות חיים בריפו שלהם, נפרדים מהסוכן שנדרג — הכישרון חפש אחד קיים ושואל לפני סיבוך חדש.
+3. **גלגל `agenteye-evaluator` SDK** — קרא את הסעיף הבא לפני שהסוכן שלך מתחיל להקליד `pip` פקודות.
+
+---
+
+## איפה להשיג זאת
+
+הכישרון פורסם בקולקציית הכישרונות הציבורית של Failproof AI:
+
+**[github.com/FailproofAI/skills](https://github.com/FailproofAI/skills)** → [`skills/agenteye-evaluator/`](https://github.com/FailproofAI/skills/tree/main/skills/agenteye-evaluator)
+
+המחסן ציבורי והכישרון לא זקוק לכל אישור משלו — הוא רק מנהל את `agenteye` CLI עם הסשן *שלך* התחברת אליו, וכותב קוד בריפו *שלך*. שים לב שהוא מסופק כתיקייה משלו ו**לא** בתוך חבילת `pipx install agenteye`, אז אל תחפש אותו שם.
+
+## התקנת הכישרון
+
+הנתיב המהיר ביותר הוא [`skills`](https://skills.sh) CLI, המביא את התיקייה וזורקת אותה למקום שהסוכן שלך מחפש:
+
+```bash
+# Claude Code, this project only
+npx skills add FailproofAI/skills --skill agenteye-evaluator -a claude-code
+
+# every project (installs to ~/.claude/skills/)
+npx skills add FailproofAI/skills --skill agenteye-evaluator -a claude-code -g --copy
+
+# Codex instead
+npx skills add FailproofAI/skills --skill agenteye-evaluator -a codex
+```
+
+אז נהל זאת כמו כל כישרון אחר:
+
+```bash
+npx skills list -a claude-code           # what's installed
+npx skills update agenteye-evaluator     # pull the latest version
+npx skills remove agenteye-evaluator     # remove it
+```
+
+מעדיף להתקין ביד? Agent Skill הוא רק תיקייה המכילה `SKILL.md` (בתוספת הפניות אופציונליות), אז הועתקה עובדת גם:
+
+- **Claude Code**: הצב את תיקייה `agenteye-evaluator/` ב-`~/.claude/skills/` (כל פרויקט) או `<your-repo>/.claude/skills/` (הריפו הזה בלבד). Claude Code גילוי אוטומטי שלה — אימות עם רשימה `/skills`, או פשוט שאל אותו evals.
+- **Codex (OpenAI)**: Codex קורא אותו `SKILL.md`. ה-`agents/openai.yaml` המצורף מגדיר `allow_implicit_invocation: true`, אז Codex בחירה אוטומטית בכישרון כאשר משימה תואמת; אחרת הזמן זאת בפירוש כ-`$agenteye-evaluator`.
+
+---
+
+## ה-SDK לא ב-PyPI הציבורי
+
+> **Warning:** קרא את זה לפני שאתה מעביר סוכן להתקין את ה-SDK.
+
+הכישרון ציבורי; ה-SDK שהוא מנהל אינו. `agenteye-evaluator` משודר רק כיצירה ריליז פרטית, ובשונה מ-`agenteye`, השם הוא **לא תבועה על PyPI ציבורי** — אז `pip install agenteye-evaluator` חשוף יכול לשוך חבילה של זר לתוך השירות שקורא את התמלילים של הייצור שלך. זה בעיה של שרשרת אספקה, לא טעות הקלדה.
+
+הכישרון יודע זאת ועוסק בסולם התקנה במקום, עוצר בשלב הראשון החל: ה-monorepo מקור אם אתה בתוך ריפו AgentEye, אחרת גלגל ריליז פרטי מ-GitHub Releases (צריך גישה), ואם כלום לא נגיע זה **עוצר ואומר לך לשאול את איש הקשר Failproof AI שלך לגלגל** במקום improvising.
+
+אז אם הסוכן שלך מציע `pip install agenteye-evaluator` חשוף מ-PyPI ציבורי, זה הדבר שהכישרון לא היה נטען. עצור שם בדוק שהוא מותקן.
+
+---
+
+## מה אתה יכול לשאול אותו
+
+סיבוב טיול אמיתי מתחיל בשאלה עמומה ומסתיים בעיצוב שחתום, לא עם קוד:
+
+```text
+you   ▸ I want evals for our support bot. I think it's sometimes bad.
+
+agent ▸ Before I write anything: describe a run that went well,
+        and one that went badly.
+
+you   ▸ Good: it answers from the docs. Bad: it makes stuff up,
+        or gives up and says "contact support".
+
+agent ▸ Running: agenteye --json sessions --status error --since 7d
+        Reading 5 sessions, including two you'd call bad.
+
+        Your words say factuality and deflection. The transcripts
+        agree on deflection (2 of 5 end with a support hand-off,
+        and it's plain in model_response.content), but factuality
+        needs a ground truth your events don't carry.
+
+        So I'd score three things:
+          - deflection      rules, cheap, separates your two runs
+          - tool_efficiency rules, catches the retry loop in run-004
+          - groundedness    LLM judge: is every claim in the docs it retrieved?
+
+        "factuality" would need ground truth we don't have; groundedness
+        is the closest thing your transcripts can actually support.
+        OK with those three names? Renaming later splits the history.
+
+you   ▸ yes
+
+agent ▸ No evaluator in this repo. Should I scaffold one here, or do
+        you have one elsewhere?
+```
+
+משם זה כותב את המימדים המבוססים על כללים קודם (חינם, מיידי, דטרמיניסטי), בודק אותם כנגד סשן שלכד אמיתי כולל הריקים והעולם לא בסוף שמתרסקים naive evaluators, ורק מגיע לשופט LLM בממד הסובייקטיבי. זה יודע את [מגבלות ה-dispatcher](/he/agenteye/evaluation-suite#configuring-the-server) — timeout בקשה 30 שניות ו-8 שיחות בו-זמנית פריסה-רחבה — אז אם השופט לא יתאים בהצלחה, זה הולך async עם `JobPending` במקום להפוך את השופט שלך לחצוי וחזור חמש פעמים בחמש פעמים העלות.
+
+אז זה פורס, מגדיר את שני משתני סביבת השרת, ומאשר עם `agenteye --json evals --session-id <id>` ש-scores בעצם נוחתו. ניקודים נחתו הוא ההוכחה היחידה.
+
+---
+
+## מה להשגיח על
+
+- **שמות מימדים קרובים לקבוע.** מפתחות ניקוד הם מחרוזות שרירותיות והפלטפורמה עולה כל דבר שאתה שולח, מה שאומר שום דבר במורד הזרם מתקן בחירה רעה. שנה קורא ובמימדים נפרדים: סשנים ישנים שמור המפתח הישן והטרנד שבר. זו הסיבה שהכישרון מקבל חתימה מוגדרת לפני קוד כתיבה — קח את ההנחיה ברצינות.
+- **Fixtures הם תמלילי ייצור אמיתיים.** עיצוב כנגד סשנים אמיתיים אומר שוך אותם לדיסק, והם יכולים להכיל נתוני לקוח. הכישרון שואל לפני התחייב שלהם לגיט; אם בספק, שמור `fixtures/` מחוץ לריפו ויש כל מפתח לשוך שלהם שלהם.
+- **הסוכן כותב ופורס שירות שקורא כל תמליל.** זה עובד כמוך, מחובר לפי ההרשאות של כניסת ה-CLI שלך, אבל סקור את ה-evaluator כמו כל קוד אחר שנוגע לנתוני ייצור.
+
+---
+
+## הצעדים הבאים
+
+- **[Evaluation suite](/he/agenteye/evaluation-suite)**: החוזה HTTP, ה-SDK, ומשתני סביבת השרת שהכישרון מגדיר.
+- **[Evaluations](/he/agenteye/evaluations)**: איפה הניקודים מופיעים ברגע שהם נוחתו.
+- **[CLI skill](/he/agenteye/cli-skill)**: הכישרון האחות, לקריאת תוצאות במקום בנייה של המדרג.
+- **[CLI](/he/agenteye/cli)**: הנושא הפקודה מאחורי נתוני הסשן שהכישרון עיצוב כנגדו.

package/.next/standalone/docs-old/he/agenteye/event-stream.mdx

@@ -0,0 +1,50 @@
+---
+title: "Event Stream"
+description: "ברגע שהエージェנט שלך עושה משהו, אתה רואה את זה."
+---
+
+
+ברגע שהエージェนט שלך עושה משהו, אתה רואה את זה. ה-Event Stream הוא הדופק החי שלך על כל agent בייצור: ללא המתנה, ללא חיפוש בלוגים, ללא ניחוש מה זה עתה קרה.
+
+![ה-Event Stream החי: שורות אירוע בצבעים שונים המתעדכנות בזמן אמת, ניתנות לסינון לפי סביבה, agent, session, סוג אירוע וחיפוש חופשי](/agenteye/images/events-stream.png)
+
+*כל אירוע מכל agent בארגון שלך, החדש ביותר קודם, מתעדכן כשזה קורה.*
+
+## הדופק החי שלך על כל agent
+
+כאשר agent מתחיל run, קורא ל-model, משתמש בכלי, מריץ hook או נתקל בשגיאה, השורה מופיעה בראש הזרם ברגע שזה קורה. זה עוקב אחרי כל אירוע בכל agent בארגון שלך, החדש ביותר קודם, כך שתמיד יש לך תמונה עדכנית במקום ישנה.
+
+זה אומר ללא ניטור קבצי לוג בשרת כלשהו, ללא חיפוש על מכונות שונות, ללא חיבור timestamps ביד. אתה פותח עמוד אחד והוא כבר שומר על הייצור.
+
+השורות בצבעיות לפי סוג, כך שתוכל לקרוא את הזרם במבט חטוף במקום לנתח כל שורה. במבט חטוף, כל שורה מראה לך:
+
+- **את הסוג שלו**, בצבעיות: `agent_start`, `model_response`, `tool_use`, `hook_completed`, `error`, ועוד.
+- **סיכום בשורה אחת** של מה שקרה, כך שנדיר שצריך לפתוח משהו רק כדי להבין את הרעיון הכללי.
+- **ספירות tokens** עבור הצעד.
+- **תג מילוי context-window** שם זה רלוונטי, כך שגדילת prompt וsquash הקרוב נראים לעין לפני שהם גורמים לבעיות.
+
+ניטור בזמן אמת פירושו שתופס deploy גרוע, לולאה שהופכת להוראשית, או פרץ של שגיאות כשזה קורה, לא בביקורת הלוג של מחר.
+
+## מצא את ה-run היחיד שחשוב
+
+כאשר משהו נראה לא בסדר, לא תרצה את כל הנתונים. אתה רוצה את ה-run היחיד שהשתבר. הזרם מסנן במהירות: לפי סביבה, לפי agent, לפי session, לפי סוג אירוע, או לפי חיפוש חופשי.
+
+סנן לפי session id או agent id כדי לעקוב אחרי run אחד מהאירוע הראשון שלו לאחרון. סנן לפי סוג אירוע כדי לבודד סוג אחד של פעילות, לדוגמה כל `error` בכל הארגון בתצוגה אחת. ערם מסננים כדי להצטמצם מ"הכל, בכל מקום" ל"agent זה, בייצור, עם שגיאות" בזוג קליקים, ואז פעול לפי מה שתמצא.
+
+חיפוש חופשי חוצה ישירות להודעה, שם כלי, או id שכבר יש לך ביד, כך שדוח של לקוח הופך ל-run המדויק תוך שניות.
+
+## איפה למצוא את זה
+
+ה-Event Stream הוא בית הארגון שלך. התחברות והוא הראשון בו אתה נוחת, ב-`/<org-slug>/`, כך שהטריאז מתחיל ברגע שאתה מגיע.
+
+מאחוריו, ה-agents שלך פולטים אירועים דרך ה-SDK, ה-collector משלח אותם לשרת Failproof AI Observability שלך, והזרם עוקב אחריהם כשהם מגיעים לתשתית שאתה שולט בה. כאשר אתה רוצה את התצוגה המצטברת במקום את השביל הגולמי, האירועים של כל run קורסים לשורה אחת ב-Sessions, קליק אחד משם.
+
+זה האמת הגולמית שעליה כל משטח observe אחר בנוי, כך שכאשר מספר נראה לא נכון במקום אחר, הזרם הוא המקום בו אתה מאשר מה שבאמת קרה.
+
+## קשור
+
+- [Sessions](/he/agenteye/sessions): אותם אירועים מצטברים לשורה אחת לכל run, עם גרף ביצוע בסגנון git.
+- [Telemetry](/he/agenteye/telemetry): מה שה-agents שלך שולחים וכיצד אירועים מגיעים לזרם.
+- [Error tracking](/he/agenteye/error-tracking): משטח טריאז אחד לכל מה שנפל.
+- [Alerts](/he/agenteye/alerts): הפוך כל סף לכלל paging.
+- [CLI and agents](/he/agenteye/cli-and-agents): אותו שביל חי מהטרמינל שלך.