{
  "aboutHtml": "<p>Jev הוא מודל הדגל של TypeSafe והמודל הראשון בקטגוריה החדשה <strong>System One</strong>. הוא אינו כותב טקסט, אלא מקבל במהירות החלטות שהתוכנה יכולה להשתמש בהן מיד: מוסרים <strong>מצב</strong> (<code>state</code>) — טקסט או JSON — וקבוצת <strong>שאלות</strong>, ומקבלים ערכים מוגדרי טיפוס עם הסתברויות מכוילות.</p><p>מודלי שפה כותבים מילים לבני אדם, ואילו Jev, לפי TypeSafe, קרוב יותר לקוד: תשובה מיד בצורה שהקוד צריך, מהירות גבוהה, ואין בתשובה שום ערך מחוץ לאפשרויות שהוגדרו. המודל תוכנן לתת תשובות יציבות בבקשות חוזרות.</p><h4>במה System One שונה ממודל שפה</h4><ul><li><strong>אינו מייצר.</strong> Jev אינו כותב תשובות למשתמש, אינו כותב קוד ואינו מסביר את מהלך ההסקה. אתם מגדירים את התשובות האפשריות — באמצעות אחד משלושת סוגי השאלות.</li><li><strong>מאומן להחלטות מכוילות.</strong> TypeSafe מאמנת את המודל בשיטת RLCD (Reinforcement Learning for Calibrated Decisions): ההסתברויות מותאמות לתוצאות בפועל ומשקפות אי־ודאות. מתוך תשובות רבות עם הסתברות של 0,8, בערך 80% אמורות להיות נכונות. כיול הוא תכונה של מדגם גדול, ולא הבטחה לנכונותה של תשובה בודדת.</li><li><strong>מטרת אימון שונה.</strong> מודלי שיחה מאומנים למצוא חן בעיני אנשים (RLHF), ולפי התצפית של TypeSafe זה מעודד ריצוי ושגיאות שנשמעות בטוחות. אחד השותפים ליצירת RLHF, דיוגו אלמיידה, הוא מייסד שותף של TypeSafe.</li></ul><p>השם מתייחס ל«מערכת 1» בספרו של דניאל כהנמן «לחשוב מהר, לחשוב לאט»: שיפוט אינטואיטיבי מהיר לעומת חשיבה שקולה ואיטית של «מערכת 2». Jev נוצר לשיפוטים מהירים וצרים.</p><h4>שלושה סוגי שאלות</h4><p>שאלה היא שיפוט אחד לגבי המצב, והתשובה היא ערך שהקוד משווה לסף, ממיין או מעביר הלאה.</p><ol><li><strong>Choice — בחירת אפשרות.</strong> מחלקה לפנייה, קטגוריית מוצר, שפת קטע קוד. האפשרויות הן מילון «אפשרות → תיאור», עד 255 אפשרויות. התשובה כוללת את ה־<code>choice</code> שנבחר, <code>probabilities</code> לכל האפשרויות (בסכום של 1) ומידת ביטחון <code>confidence</code>. אם הרשימה עשויה לא לכסות את כל המקרים, הוסיפו «אחר» או «אף אחת מהאפשרויות».</li><li><strong>Score — דירוג בסולם.</strong> מקום בסולם מסודר שאתם מתארים: חומרת שגיאה, מידת הרוגז של הלקוח, רמת מיומנות. בין 2 ל־10 רמות, מהנמוכה לגבוהה; המודל מעריך כל רמה בנפרד, בלי לראות את מספרה ואת שכנותיה. התשובה כוללת <code>score</code> (סכום מספרי הרמות כפול הסתברויותיהן, ולכן הערך עשוי להיות בין הרמות), <code>legend</code> עם תיאורי הרמות, <code>probabilities</code> ו־<code>confidence</code>.</li><li><strong>Noul — כן או לא.</strong> האם הטענה נכונה. התשובה <code>noul</code> היא הסתברות ל«כן» בין 0 ל־1: קרוב ל־1 — «כן» בטוח, קרוב ל־0 — «לא» בטוח, קרוב ל־0,5 — המודל מתלבט. אין <code>confidence</code> נפרד: מספר אחד מתאר את התשובה בשלמותה. <code>criteria</code> אופציונלי מבהיר מה נחשב «כן» ומה «לא».</li></ol><p>איך לבחור: אפשרויות ידועות ללא סדר — choice; דרגות בספקטרום — score; «כן/לא» בלבד, כשההסתברות עצמה חשובה — noul. Noul 0,5 פירושו סיכוי שווה ל«כן» ול«לא», ולא «רמה בינונית»: score מודד דרגה. מבין שני סוגים מתאימים בחרו את זה שהקוד פועל לפיו מיד: choice לתנאים מסועפים, score לסף, noul ל־<code>if</code>.</p><p>אפשר לשלב סוגים בבקשה אחת. התשובה תמיד מוגבלת לאפשרויות שלכם ואינה תלויה בשאלות אחרות: אפשר להוסיף או להסיר שאלות בלי לשנות את שאר התשובות.</p><h4>המצב</h4><p>המצב הוא מה שהמודל מעריך: הודעת לקוח, קטע מסמך, רשומה מבסיס נתונים או מצב היישום שלכם.</p><ul><li><strong>מחרוזת</strong> — כשיש טקסט אחד: הודעה, מאמר, קטע.</li><li><strong>אובייקט</strong> — שדות בעלי שם, רשומות קשורות, מצב היישום. TypeSafe ממליצה על אובייקט לרוב הבקשות: לכל חלק יש שם מובן.</li><li><strong>מערך</strong> — רצף של הודעות או רשומות.</li></ul><p>הכינו אותו כחומרים למומחים: שימו יחד התכתבות, הזמנה וכללי החזרה אם ההחלטה דורשת להשוות ביניהם. שמרו תוכן במצב ושיפוטים בשאלות. אם השאלה עוסקת בחלק אחד של המצב, ציינו בה את הנתיב אליו בגרשיים הפוכים, למשל <code>ticket.messages[0].text</code>.</p><h4>איך להגדיר שאלות</h4><ul><li><strong>שיפוט מהיר אחד לכל שאלה.</strong> שאלה טובה היא כזו שאדם שמבין בתחום ועם ההקשר הדרוש יענה עליה בשנייה: «האם יש דחיפות בהודעה?». «נתח את ההודעה והחלט מה לעשות» הוא כבר הסקה איטית, וצריך לחלקו לשאלות פשוטות.</li><li><strong>כל השאלה ב־<code>instructions</code>.</strong> מפתח השאלה, למשל <code>refund_requested</code>, דרוש רק לקוד שלכם ואינו מועבר למודל.</li><li><strong>כל השאלות לגבי מצב אחד בבקשה אחת.</strong> המודל מעריך אותן במקביל: לפי TypeSafe, שאלות נוספות כמעט אינן מאריכות את זמן התשובה ועלותן רק הטוקנים שלהן. שאלה «ליתר ביטחון» עולה כמעט כלום — הקוד יחליט בעצמו אילו תשובות דרושות.</li><li><strong>שיפוט מורכב בחלקים.</strong> במקום «הערך בקשת סטארט־אפ», שאלו בנפרד על גודל השוק, ההיתכנות הטכנית וההבדלים מהמתחרים, וחשבו את התוצאה בקוד עם משקלים. השתנו העדיפויות — שנו את המשקלים, ולא את השאלה.</li><li><strong>שאלות תלויות בבקשה שנייה.</strong> תשובות בבקשה אחת אינן משמשות הקשר זו לזו. בקשה שנייה דרושה רק אם אי אפשר להרכיב אותה ללא התשובה הראשונה: צריך לטעון נתונים נוספים או לבחור אפשרויות לשאלה הבאה.</li><li><strong>שאלה ארוכה כאובייקט.</strong> <code>instructions</code> ו־<code>criteria</code> הם בדרך כלל מחרוזות, אך יכולים להיות אובייקט או מערך: השאלה בשדה אחד, והנתונים באחרים. כך נוח להשוות קורות חיים לרשומות בסיס נתונים בשאלה אחת.</li></ul><h4>מידת ביטחון</h4><p>ב־choice וב־score, <code>confidence</code> בין 0 ל־1 מציג עד כמה ההסתברות מרוכזת בתשובה אחת: 1 — כולה באפשרות אחת, 0 — שווה בכל האפשרויות. ב־score רמה סמוכה מפחיתה את הביטחון פחות מרמה רחוקה. ב־noul מידת הביטחון היא הערך עצמו: ככל שהוא רחוק מ־0,5, כך התשובה נחרצת יותר.</p><p>TypeSafe ממליצה על שלושה טווחים:</p><ol><li><strong>ביטחון גבוה</strong> — פעלו אוטומטית.</li><li><strong>בינוני</strong> — פעלו בזהירות, למשל בקשו מהמשתמש אישור.</li><li><strong>נמוך</strong> — העבירו את המקרה לאדם, הבהירו את הבקשה או חברו מסלול גיבוי, למשל מודל חזק יותר עם הסקה.</li></ol><p>ככל שהטעות יקרה יותר, הסף צריך להיות מחמיר יותר: לפעולות בלתי הפיכות — גבוה יותר מאשר לקריאה. התשובה אומרת מה לבחור, ומידת הביטחון אם כדאי לפעול. התאימו את הספים לפי הנתונים שלכם, בהשוואה בין מידת הביטחון לדיוק.</p><h4>איך לבנות מערכת סביב Jev</h4><p>Jev מיועד לא לסוכנים שבוחרים בעצמם את השלב הבא ועלולים לסטות בכל סבב, אלא לתוכנות שבהן הקוד מנהל את התהליך והמודל עונה על שאלות משמעות צרות. שמונת שלבי התכנון לפי TypeSafe:</p><ol><li>כל מה שאפשר לעשות בקוד, עשו בקוד — באופן מהימן ובעלות נמוכה.</li><li>במצב — רק מה שהשאלות הנוכחיות צריכות; עובדות עדכניות — מבסיס הידע שלכם, ולא מזיכרון המודל.</li><li>מבנה במצב: JSON מקונן, ובשאלה נתיב לשדה הדרוש בגרשיים הפוכים, אם כך יש פחות עמימות.</li><li>שאלות צרות ומוגדרות ככל האפשר — לפי TypeSafe, אולי הכלל החשוב ביותר: שאלה רחבה מסתירה כמה שיפוטים מאחורי תשובה אחת.</li><li>מבנה בשאלות: השאלה עצמה קצרה; הסברים, דוגמאות וערכים מהבסיס שלכם בשדות סמוכים באובייקט <code>instructions</code> או <code>criteria</code>, ולא במחרוזת ארוכה אחת.</li><li>שאלות עצמאיות רבות למצב אחד בבקשה אחת — יותר תועלת לכל דולר.</li><li>הקוד משלב תשובות: באמצעות כללים, סכום משוקלל או כתכונות למודל קלאסי של למידת מכונה.</li><li>הסתעפות לפי מידת ביטחון: מקרים לא בטוחים לאדם או למודל עם הסקה.</li></ol><p>Jev אינו צ&#39;אט או מודל להשלמת קוד אוטומטית, ואי אפשר להחליף בו מודל שפה בסוכן תכנות. אבל סוכן יכול לכתוב עבורכם קוד שקורא ל־Jev במקום שבו צריך תשובה מהירה ומכוילת.</p><h4>תחומי שימוש</h4><ul><li><strong>אוטומציה ברקע</strong> — החלטות שמפעילים מיליון פעמים בלי אדם לידן.</li><li><strong>זמן אמת</strong> — לפי TypeSafe, רוב הבקשות מבוצעות בתוך כ־100 אלפיות השנייה: מספיק לעיבוד בזמן הפעולה ולממשקים.</li><li><strong>נתונים גדולים</strong> — חיפוש במאגרים עצומים, תיוג יומני עבודה של סוכנים, תכונות לחיזוי.</li><li><strong>בדיקת מודלים אחרים</strong> — בקשות, חילוץ מידע, הסקה, קריאות לכלים: עקיפת מגבלות, שגיאות ציטוט ומידע מומצא.</li><li><strong>חיפוש ודירוג</strong> — רלוונטיות של צמד «שאילתה — מועמד», דירוג מחדש, בחירת הקשר.</li><li><strong>הסתעפות לפי כוונה</strong> — מה המשתמש רוצה ואיזה מטפל דרוש: לוגיקה פשוטה, מודל ייעודי או אדם; הנושא, המורכבות והסיכון קובעים לאיזה מודל שפה להעביר את הבקשה.</li><li><strong>בדיקות הגנה</strong> — קלט, פלט וקריאות לכלים של מודל שפה: הוראות מוזרקות, הפרות כללים, דליפת נתונים אישיים.</li><li><strong>תמיכה</strong> — נושא הפנייה וכוונתה, דחיפות, רוגז, סיכון נטישה, בקשת החזר כספי, תור.</li><li><strong>פיקוח על תוכן</strong> — לפי כללי הפלטפורמה שלכם: רעילות, בריונות, ספאם, הונאה, עצות מסוכנות, נתונים אישיים; לפי חומרה ומידת ביטחון — לאפשר, להזהיר, לבדוק או לחסום.</li><li><strong>ענפים</strong> — מקרי ביטוח, חקירות פיננסיות ו־KYC, חוזים ופרסום, כרטיסי מוצרים, גיוס עובדים, לקוחות פוטנציאליים, משחקים, סיכונים, חיזוי ביקוש, גרפי ידע, סקירות מדעיות, בדיקות משמעות של קוד ב־CI.</li></ul><h4>מאפיינים</h4><ul><li><strong><code>jev-latest</code></strong> — כינוי לגרסה היציבה האחרונה, כרגע Jev 1.13; הגרסה שהשיבה מופיעה בשדה <code>model</code>, למשל <code>jev-1.13.0</code>. בגרסה חדשה הכינוי עובר אליה, והתשובות עשויות להשתנות בלי תיקונים מצדכם — עקבו אחר השדה הזה אם הספים הותאמו לגרסה.</li><li><strong>הקשר</strong> — 64K טוקנים בכל בקשה: המצב וכל השאלות יחד; המצב עם השאלה הארוכה ביותר עד 32K. המודל קורא את המצב פעם אחת ובודק מולו את כל השאלות במקביל.</li><li><strong>קלט</strong> — טקסט בלבד: מחרוזת, אובייקט JSON או מערך טקסטים. תמונות, אודיו ווידאו עדיין אינם נתמכים — המירו אותם לטקסט מראש.</li><li><strong>שפה</strong> — שפת האימון העיקרית היא אנגלית, ובה הדיוק כרגע הגבוה ביותר. המודל מקבל שפות אחרות, כולל סינית, יפנית וקוריאנית, אך הדיוק נמוך יותר — בדקו על הנתונים שלכם.</li><li><strong>מחירים וחיוב ב־Ailoot API</strong> — התנאים תלויים במתודה שנבחרה ומצוינים בכרטיס שלה.</li><li><strong>הגדרה</strong> — Jev אינו עובר אימון נוסף על נתוני הלקוח: החומרים שלכם ב־<code>state</code>, וכללי התחום ב־<code>instructions</code> וב־<code>criteria</code>.</li><li><strong>נתונים</strong> — TypeSafe מדווחת ש־Jev אינו מאומן על בקשות ותשובות של לקוחות.</li></ul><h4>נקודות חולשה ידועות של Jev 1.13</h4><p>TypeSafe מפרטת בגלוי את נקודות החולשה של הגרסה הנוכחית ומבטיחה לתקן רבות מהן בגרסאות הבאות. המודל מהיר, מכויל ושופט היטב בעזרת היגיון בריא, אבל:</p><ol><li><strong>קורא מילולית.</strong> עונה על השאלה שנכתבה, ולא על המשתמעת: הסתייגויות, שלילות ותנאים מרומזים מובנים מילולית. כתבו תנאי מדויק ומקרי קצה ב־<code>criteria</code>; פרשנות בלתי נמנעת חלקו לשתי שאלות מילוליות.</li><li><strong>אינו מחשבון.</strong> ספירת תווים, חזרות ופריטי רשימה אינה מהימנה, והטעות גדלה עם הגודל — ספרו בקוד, עם שאלה לכל מועמד. המודל מבין צבעים ב־hex או ב־RGB פחות טוב משמותיהם. <code>score</code> מתאים לסף, אך לא למספר מדויק בין רמות.</li><li><strong>תאריכים וזמן.</strong> איזה תאריך מוקדם יותר, מה המרווח ביניהם, האם תאריך נכלל בתקופה — לא מהימן, במיוחד בפורמטים מעורבים ובתאריכים יחסיים. חלצו חלקי תאריך באמצעות choice (עם אפשרות «לא צוין»), והשוו בקוד.</li><li><strong>ניסוח עקיף.</strong> שלילות כפולות ושאלות על תכונה של תכונה מפחיתות את הדיוק. כתבו ישירות וציינו חלקי מצב בשמם.</li><li><strong>תוכן עודף במצב.</strong> טקסט זר מפחית את הדיוק. סננו בקוד, ואם אי אפשר — הסירו תוכן לא רלוונטי בשאלות noul.</li><li><strong>טקסט עוין.</strong> כברירת מחדל המודל אינו מצפה למלכודות במצב: הוראה מוזרקת או טקסט שמתווכח על סיווגו שלו יכולים להזיז את התשובה. כתבו קריטריונים מדויקים ובדקו מקרי גבול לפני ההפעלה.</li><li><strong>סתירות.</strong> אם <code>instructions</code> ו־<code>criteria</code> מבקשים דברים שונים — למשל ב־noul «כן» מתואר כ«לא» — הדיוק יורד. הקריטריונים הם המשך השאלה.</li><li><strong>סדר האפשרויות.</strong> לפעמים המודל נוטה לאפשרות הראשונה ב־choice. שנו את הסדר ובדקו שהתשובה אינה משתנה.</li><li><strong>יצירה.</strong> Jev לא אומן לכתוב טקסט. לחילוץ נתונים מצאו מועמדים בביטוי רגולרי או במודל יוצר, ותנו ל־Jev לבחור את הנכון באמצעות choice.</li></ol>",
  "aboutText": "Jev הוא מודל הדגל של TypeSafe והמודל הראשון בקטגוריה החדשה **System One**. הוא אינו כותב טקסט, אלא מקבל במהירות החלטות שהתוכנה יכולה להשתמש בהן מיד: מוסרים **מצב** (`state`) — טקסט או JSON — וקבוצת **שאלות**, ומקבלים ערכים מוגדרי טיפוס עם הסתברויות מכוילות.\n\nמודלי שפה כותבים מילים לבני אדם, ואילו Jev, לפי TypeSafe, קרוב יותר לקוד: תשובה מיד בצורה שהקוד צריך, מהירות גבוהה, ואין בתשובה שום ערך מחוץ לאפשרויות שהוגדרו. המודל תוכנן לתת תשובות יציבות בבקשות חוזרות.\n\n### במה System One שונה ממודל שפה\n\n- **אינו מייצר.** Jev אינו כותב תשובות למשתמש, אינו כותב קוד ואינו מסביר את מהלך ההסקה. אתם מגדירים את התשובות האפשריות — באמצעות אחד משלושת סוגי השאלות.\n- **מאומן להחלטות מכוילות.** TypeSafe מאמנת את המודל בשיטת RLCD (Reinforcement Learning for Calibrated Decisions): ההסתברויות מותאמות לתוצאות בפועל ומשקפות אי־ודאות. מתוך תשובות רבות עם הסתברות של 0,8, בערך 80% אמורות להיות נכונות. כיול הוא תכונה של מדגם גדול, ולא הבטחה לנכונותה של תשובה בודדת.\n- **מטרת אימון שונה.** מודלי שיחה מאומנים למצוא חן בעיני אנשים (RLHF), ולפי התצפית של TypeSafe זה מעודד ריצוי ושגיאות שנשמעות בטוחות. אחד השותפים ליצירת RLHF, דיוגו אלמיידה, הוא מייסד שותף של TypeSafe.\n\nהשם מתייחס ל«מערכת 1» בספרו של דניאל כהנמן «לחשוב מהר, לחשוב לאט»: שיפוט אינטואיטיבי מהיר לעומת חשיבה שקולה ואיטית של «מערכת 2». Jev נוצר לשיפוטים מהירים וצרים.\n\n### שלושה סוגי שאלות\n\nשאלה היא שיפוט אחד לגבי המצב, והתשובה היא ערך שהקוד משווה לסף, ממיין או מעביר הלאה.\n\n1. **Choice — בחירת אפשרות.** מחלקה לפנייה, קטגוריית מוצר, שפת קטע קוד. האפשרויות הן מילון «אפשרות → תיאור», עד 255 אפשרויות. התשובה כוללת את ה־`choice` שנבחר, `probabilities` לכל האפשרויות (בסכום של 1) ומידת ביטחון `confidence`. אם הרשימה עשויה לא לכסות את כל המקרים, הוסיפו «אחר» או «אף אחת מהאפשרויות».\n2. **Score — דירוג בסולם.** מקום בסולם מסודר שאתם מתארים: חומרת שגיאה, מידת הרוגז של הלקוח, רמת מיומנות. בין 2 ל־10 רמות, מהנמוכה לגבוהה; המודל מעריך כל רמה בנפרד, בלי לראות את מספרה ואת שכנותיה. התשובה כוללת `score` (סכום מספרי הרמות כפול הסתברויותיהן, ולכן הערך עשוי להיות בין הרמות), `legend` עם תיאורי הרמות, `probabilities` ו־`confidence`.\n3. **Noul — כן או לא.** האם הטענה נכונה. התשובה `noul` היא הסתברות ל«כן» בין 0 ל־1: קרוב ל־1 — «כן» בטוח, קרוב ל־0 — «לא» בטוח, קרוב ל־0,5 — המודל מתלבט. אין `confidence` נפרד: מספר אחד מתאר את התשובה בשלמותה. `criteria` אופציונלי מבהיר מה נחשב «כן» ומה «לא».\n\nאיך לבחור: אפשרויות ידועות ללא סדר — choice; דרגות בספקטרום — score; «כן/לא» בלבד, כשההסתברות עצמה חשובה — noul. Noul 0,5 פירושו סיכוי שווה ל«כן» ול«לא», ולא «רמה בינונית»: score מודד דרגה. מבין שני סוגים מתאימים בחרו את זה שהקוד פועל לפיו מיד: choice לתנאים מסועפים, score לסף, noul ל־`if`.\n\nאפשר לשלב סוגים בבקשה אחת. התשובה תמיד מוגבלת לאפשרויות שלכם ואינה תלויה בשאלות אחרות: אפשר להוסיף או להסיר שאלות בלי לשנות את שאר התשובות.\n\n### המצב\n\nהמצב הוא מה שהמודל מעריך: הודעת לקוח, קטע מסמך, רשומה מבסיס נתונים או מצב היישום שלכם.\n\n- **מחרוזת** — כשיש טקסט אחד: הודעה, מאמר, קטע.\n- **אובייקט** — שדות בעלי שם, רשומות קשורות, מצב היישום. TypeSafe ממליצה על אובייקט לרוב הבקשות: לכל חלק יש שם מובן.\n- **מערך** — רצף של הודעות או רשומות.\n\nהכינו אותו כחומרים למומחים: שימו יחד התכתבות, הזמנה וכללי החזרה אם ההחלטה דורשת להשוות ביניהם. שמרו תוכן במצב ושיפוטים בשאלות. אם השאלה עוסקת בחלק אחד של המצב, ציינו בה את הנתיב אליו בגרשיים הפוכים, למשל `ticket.messages[0].text`.\n\n### איך להגדיר שאלות\n\n- **שיפוט מהיר אחד לכל שאלה.** שאלה טובה היא כזו שאדם שמבין בתחום ועם ההקשר הדרוש יענה עליה בשנייה: «האם יש דחיפות בהודעה?». «נתח את ההודעה והחלט מה לעשות» הוא כבר הסקה איטית, וצריך לחלקו לשאלות פשוטות.\n- **כל השאלה ב־`instructions`.** מפתח השאלה, למשל `refund_requested`, דרוש רק לקוד שלכם ואינו מועבר למודל.\n- **כל השאלות לגבי מצב אחד בבקשה אחת.** המודל מעריך אותן במקביל: לפי TypeSafe, שאלות נוספות כמעט אינן מאריכות את זמן התשובה ועלותן רק הטוקנים שלהן. שאלה «ליתר ביטחון» עולה כמעט כלום — הקוד יחליט בעצמו אילו תשובות דרושות.\n- **שיפוט מורכב בחלקים.** במקום «הערך בקשת סטארט־אפ», שאלו בנפרד על גודל השוק, ההיתכנות הטכנית וההבדלים מהמתחרים, וחשבו את התוצאה בקוד עם משקלים. השתנו העדיפויות — שנו את המשקלים, ולא את השאלה.\n- **שאלות תלויות בבקשה שנייה.** תשובות בבקשה אחת אינן משמשות הקשר זו לזו. בקשה שנייה דרושה רק אם אי אפשר להרכיב אותה ללא התשובה הראשונה: צריך לטעון נתונים נוספים או לבחור אפשרויות לשאלה הבאה.\n- **שאלה ארוכה כאובייקט.** `instructions` ו־`criteria` הם בדרך כלל מחרוזות, אך יכולים להיות אובייקט או מערך: השאלה בשדה אחד, והנתונים באחרים. כך נוח להשוות קורות חיים לרשומות בסיס נתונים בשאלה אחת.\n\n### מידת ביטחון\n\nב־choice וב־score, `confidence` בין 0 ל־1 מציג עד כמה ההסתברות מרוכזת בתשובה אחת: 1 — כולה באפשרות אחת, 0 — שווה בכל האפשרויות. ב־score רמה סמוכה מפחיתה את הביטחון פחות מרמה רחוקה. ב־noul מידת הביטחון היא הערך עצמו: ככל שהוא רחוק מ־0,5, כך התשובה נחרצת יותר.\n\nTypeSafe ממליצה על שלושה טווחים:\n\n1. **ביטחון גבוה** — פעלו אוטומטית.\n2. **בינוני** — פעלו בזהירות, למשל בקשו מהמשתמש אישור.\n3. **נמוך** — העבירו את המקרה לאדם, הבהירו את הבקשה או חברו מסלול גיבוי, למשל מודל חזק יותר עם הסקה.\n\nככל שהטעות יקרה יותר, הסף צריך להיות מחמיר יותר: לפעולות בלתי הפיכות — גבוה יותר מאשר לקריאה. התשובה אומרת מה לבחור, ומידת הביטחון אם כדאי לפעול. התאימו את הספים לפי הנתונים שלכם, בהשוואה בין מידת הביטחון לדיוק.\n\n### איך לבנות מערכת סביב Jev\n\nJev מיועד לא לסוכנים שבוחרים בעצמם את השלב הבא ועלולים לסטות בכל סבב, אלא לתוכנות שבהן הקוד מנהל את התהליך והמודל עונה על שאלות משמעות צרות. שמונת שלבי התכנון לפי TypeSafe:\n\n1. כל מה שאפשר לעשות בקוד, עשו בקוד — באופן מהימן ובעלות נמוכה.\n2. במצב — רק מה שהשאלות הנוכחיות צריכות; עובדות עדכניות — מבסיס הידע שלכם, ולא מזיכרון המודל.\n3. מבנה במצב: JSON מקונן, ובשאלה נתיב לשדה הדרוש בגרשיים הפוכים, אם כך יש פחות עמימות.\n4. שאלות צרות ומוגדרות ככל האפשר — לפי TypeSafe, אולי הכלל החשוב ביותר: שאלה רחבה מסתירה כמה שיפוטים מאחורי תשובה אחת.\n5. מבנה בשאלות: השאלה עצמה קצרה; הסברים, דוגמאות וערכים מהבסיס שלכם בשדות סמוכים באובייקט `instructions` או `criteria`, ולא במחרוזת ארוכה אחת.\n6. שאלות עצמאיות רבות למצב אחד בבקשה אחת — יותר תועלת לכל דולר.\n7. הקוד משלב תשובות: באמצעות כללים, סכום משוקלל או כתכונות למודל קלאסי של למידת מכונה.\n8. הסתעפות לפי מידת ביטחון: מקרים לא בטוחים לאדם או למודל עם הסקה.\n\nJev אינו צ'אט או מודל להשלמת קוד אוטומטית, ואי אפשר להחליף בו מודל שפה בסוכן תכנות. אבל סוכן יכול לכתוב עבורכם קוד שקורא ל־Jev במקום שבו צריך תשובה מהירה ומכוילת.\n\n### תחומי שימוש\n\n- **אוטומציה ברקע** — החלטות שמפעילים מיליון פעמים בלי אדם לידן.\n- **זמן אמת** — לפי TypeSafe, רוב הבקשות מבוצעות בתוך כ־100 אלפיות השנייה: מספיק לעיבוד בזמן הפעולה ולממשקים.\n- **נתונים גדולים** — חיפוש במאגרים עצומים, תיוג יומני עבודה של סוכנים, תכונות לחיזוי.\n- **בדיקת מודלים אחרים** — בקשות, חילוץ מידע, הסקה, קריאות לכלים: עקיפת מגבלות, שגיאות ציטוט ומידע מומצא.\n- **חיפוש ודירוג** — רלוונטיות של צמד «שאילתה — מועמד», דירוג מחדש, בחירת הקשר.\n- **הסתעפות לפי כוונה** — מה המשתמש רוצה ואיזה מטפל דרוש: לוגיקה פשוטה, מודל ייעודי או אדם; הנושא, המורכבות והסיכון קובעים לאיזה מודל שפה להעביר את הבקשה.\n- **בדיקות הגנה** — קלט, פלט וקריאות לכלים של מודל שפה: הוראות מוזרקות, הפרות כללים, דליפת נתונים אישיים.\n- **תמיכה** — נושא הפנייה וכוונתה, דחיפות, רוגז, סיכון נטישה, בקשת החזר כספי, תור.\n- **פיקוח על תוכן** — לפי כללי הפלטפורמה שלכם: רעילות, בריונות, ספאם, הונאה, עצות מסוכנות, נתונים אישיים; לפי חומרה ומידת ביטחון — לאפשר, להזהיר, לבדוק או לחסום.\n- **ענפים** — מקרי ביטוח, חקירות פיננסיות ו־KYC, חוזים ופרסום, כרטיסי מוצרים, גיוס עובדים, לקוחות פוטנציאליים, משחקים, סיכונים, חיזוי ביקוש, גרפי ידע, סקירות מדעיות, בדיקות משמעות של קוד ב־CI.\n\n### מאפיינים\n\n- **`jev-latest`** — כינוי לגרסה היציבה האחרונה, כרגע Jev 1.13; הגרסה שהשיבה מופיעה בשדה `model`, למשל `jev-1.13.0`. בגרסה חדשה הכינוי עובר אליה, והתשובות עשויות להשתנות בלי תיקונים מצדכם — עקבו אחר השדה הזה אם הספים הותאמו לגרסה.\n- **הקשר** — 64K טוקנים בכל בקשה: המצב וכל השאלות יחד; המצב עם השאלה הארוכה ביותר עד 32K. המודל קורא את המצב פעם אחת ובודק מולו את כל השאלות במקביל.\n- **קלט** — טקסט בלבד: מחרוזת, אובייקט JSON או מערך טקסטים. תמונות, אודיו ווידאו עדיין אינם נתמכים — המירו אותם לטקסט מראש.\n- **שפה** — שפת האימון העיקרית היא אנגלית, ובה הדיוק כרגע הגבוה ביותר. המודל מקבל שפות אחרות, כולל סינית, יפנית וקוריאנית, אך הדיוק נמוך יותר — בדקו על הנתונים שלכם.\n- **מחירים וחיוב ב־Ailoot API** — התנאים תלויים במתודה שנבחרה ומצוינים בכרטיס שלה.\n- **הגדרה** — Jev אינו עובר אימון נוסף על נתוני הלקוח: החומרים שלכם ב־`state`, וכללי התחום ב־`instructions` וב־`criteria`.\n- **נתונים** — TypeSafe מדווחת ש־Jev אינו מאומן על בקשות ותשובות של לקוחות.\n\n### נקודות חולשה ידועות של Jev 1.13\n\nTypeSafe מפרטת בגלוי את נקודות החולשה של הגרסה הנוכחית ומבטיחה לתקן רבות מהן בגרסאות הבאות. המודל מהיר, מכויל ושופט היטב בעזרת היגיון בריא, אבל:\n\n1. **קורא מילולית.** עונה על השאלה שנכתבה, ולא על המשתמעת: הסתייגויות, שלילות ותנאים מרומזים מובנים מילולית. כתבו תנאי מדויק ומקרי קצה ב־`criteria`; פרשנות בלתי נמנעת חלקו לשתי שאלות מילוליות.\n2. **אינו מחשבון.** ספירת תווים, חזרות ופריטי רשימה אינה מהימנה, והטעות גדלה עם הגודל — ספרו בקוד, עם שאלה לכל מועמד. המודל מבין צבעים ב־hex או ב־RGB פחות טוב משמותיהם. `score` מתאים לסף, אך לא למספר מדויק בין רמות.\n3. **תאריכים וזמן.** איזה תאריך מוקדם יותר, מה המרווח ביניהם, האם תאריך נכלל בתקופה — לא מהימן, במיוחד בפורמטים מעורבים ובתאריכים יחסיים. חלצו חלקי תאריך באמצעות choice (עם אפשרות «לא צוין»), והשוו בקוד.\n4. **ניסוח עקיף.** שלילות כפולות ושאלות על תכונה של תכונה מפחיתות את הדיוק. כתבו ישירות וציינו חלקי מצב בשמם.\n5. **תוכן עודף במצב.** טקסט זר מפחית את הדיוק. סננו בקוד, ואם אי אפשר — הסירו תוכן לא רלוונטי בשאלות noul.\n6. **טקסט עוין.** כברירת מחדל המודל אינו מצפה למלכודות במצב: הוראה מוזרקת או טקסט שמתווכח על סיווגו שלו יכולים להזיז את התשובה. כתבו קריטריונים מדויקים ובדקו מקרי גבול לפני ההפעלה.\n7. **סתירות.** אם `instructions` ו־`criteria` מבקשים דברים שונים — למשל ב־noul «כן» מתואר כ«לא» — הדיוק יורד. הקריטריונים הם המשך השאלה.\n8. **סדר האפשרויות.** לפעמים המודל נוטה לאפשרות הראשונה ב־choice. שנו את הסדר ובדקו שהתשובה אינה משתנה.\n9. **יצירה.** Jev לא אומן לכתוב טקסט. לחילוץ נתונים מצאו מועמדים בביטוי רגולרי או במודל יוצר, ותנו ל־Jev לבחור את הנכון באמצעות choice.",
  "editorialOverlay": {
    "copy_fields": null,
    "copy_sha256": null,
    "copy_source": null,
    "html_sha256": "25234b93317b52b2245f2e348a1e7091dba89fa144c4752b7d482258b43548c5",
    "module_sha256": "ee9dc1c50b1e6a8fb7fa062030fcb4646b9aaaeb08be513b723a5a92a7290f06",
    "raw_model_unchanged": true,
    "schema": "ailoot-native-model-editorial-v1"
  },
  "locale": "he",
  "methods": [
    {
      "html": "<div class=\"sheet-head\"><span class=\"mav\" aria-hidden=\"true\">TS</span><h2 id=\"sheet-title\">jev-latest</h2><button class=\"icon-btn\" type=\"button\" data-close-sheet aria-label=\"סגירה\">×</button></div><div class=\"idline\"><span>TypeSafe /</span><code>jev-latest</code><button type=\"button\" id=\"copy-id\">העתקת ID</button></div><nav class=\"card-jump-nav\" aria-label=\"חלקי כרטיס המודל\"><button type=\"button\" data-card-jump=\"overview\">התחלה</button><button type=\"button\" data-card-jump=\"methods\">קלט ושיטות</button><button type=\"button\" data-card-jump=\"pricing\">תעריפים</button><button type=\"button\" data-card-jump=\"examples\">דוגמאות</button><button type=\"button\" data-card-jump=\"results\">תוצאות</button><button type=\"button\" data-card-jump=\"aliases\">כינויים</button></nav><div class=\"card-method-tabs\" role=\"tablist\" aria-label=\"שיטות API\"><button type=\"button\" role=\"tab\" tabindex=\"0\" aria-controls=\"card-method-content\" aria-selected=\"true\" id=\"card-method-tab-0\" data-card-method=\"Core|systemone|/v1/systemone|jev-latest\">System One</button></div><div id=\"card-method-content\" role=\"tabpanel\" aria-labelledby=\"card-method-tab-0\"><section class=\"card-section\" data-card-section=\"overview\"><h3 tabindex=\"-1\">התחלה</h3><p class=\"mdesc-full\">מודל החלטות של TypeSafe: אינו כותב טקסט, אלא עונה על שאלות מוגדרות טיפוס לגבי טקסט או JSON — בחירת אפשרות, דירוג בסולם או «כן/לא» עם הסתברויות. מתאים לניתוב, למיון פניות, לפיקוח על תוכן ולניקוד; כל השאלות בבקשה אחת מוערכות במקביל.</p><dl class=\"card-io\" data-card-io><div><dt>סוגי קלט נתמכים</dt><dd>טקסט</dd></div><div><dt>תוצאות</dt><dd>structured</dd></div></dl><details class=\"card-about\"><summary>על המודל</summary><p class=\"note-s\" data-model-method-boundary>התיאור הזה מציג את יכולות המודל. הקלט, הפלט והאפשרויות הזמינים ב-Ailoot מפורטים בהמשך לפי השיטה שנבחרה.</p><div class=\"mabout\" id=\"m-about\"><p>Jev הוא מודל הדגל של TypeSafe והמודל הראשון בקטגוריה החדשה <strong>System One</strong>. הוא אינו כותב טקסט, אלא מקבל במהירות החלטות שהתוכנה יכולה להשתמש בהן מיד: מוסרים <strong>מצב</strong> (<code>state</code>) — טקסט או JSON — וקבוצת <strong>שאלות</strong>, ומקבלים ערכים מוגדרי טיפוס עם הסתברויות מכוילות.</p><p>מודלי שפה כותבים מילים לבני אדם, ואילו Jev, לפי TypeSafe, קרוב יותר לקוד: תשובה מיד בצורה שהקוד צריך, מהירות גבוהה, ואין בתשובה שום ערך מחוץ לאפשרויות שהוגדרו. המודל תוכנן לתת תשובות יציבות בבקשות חוזרות.</p><h4>במה System One שונה ממודל שפה</h4><ul><li><strong>אינו מייצר.</strong> Jev אינו כותב תשובות למשתמש, אינו כותב קוד ואינו מסביר את מהלך ההסקה. אתם מגדירים את התשובות האפשריות — באמצעות אחד משלושת סוגי השאלות.</li><li><strong>מאומן להחלטות מכוילות.</strong> TypeSafe מאמנת את המודל בשיטת RLCD (Reinforcement Learning for Calibrated Decisions): ההסתברויות מותאמות לתוצאות בפועל ומשקפות אי־ודאות. מתוך תשובות רבות עם הסתברות של 0,8, בערך 80% אמורות להיות נכונות. כיול הוא תכונה של מדגם גדול, ולא הבטחה לנכונותה של תשובה בודדת.</li><li><strong>מטרת אימון שונה.</strong> מודלי שיחה מאומנים למצוא חן בעיני אנשים (RLHF), ולפי התצפית של TypeSafe זה מעודד ריצוי ושגיאות שנשמעות בטוחות. אחד השותפים ליצירת RLHF, דיוגו אלמיידה, הוא מייסד שותף של TypeSafe.</li></ul><p>השם מתייחס ל«מערכת 1» בספרו של דניאל כהנמן «לחשוב מהר, לחשוב לאט»: שיפוט אינטואיטיבי מהיר לעומת חשיבה שקולה ואיטית של «מערכת 2». Jev נוצר לשיפוטים מהירים וצרים.</p><h4>שלושה סוגי שאלות</h4><p>שאלה היא שיפוט אחד לגבי המצב, והתשובה היא ערך שהקוד משווה לסף, ממיין או מעביר הלאה.</p><ol><li><strong>Choice — בחירת אפשרות.</strong> מחלקה לפנייה, קטגוריית מוצר, שפת קטע קוד. האפשרויות הן מילון «אפשרות → תיאור», עד 255 אפשרויות. התשובה כוללת את ה־<code>choice</code> שנבחר, <code>probabilities</code> לכל האפשרויות (בסכום של 1) ומידת ביטחון <code>confidence</code>. אם הרשימה עשויה לא לכסות את כל המקרים, הוסיפו «אחר» או «אף אחת מהאפשרויות».</li><li><strong>Score — דירוג בסולם.</strong> מקום בסולם מסודר שאתם מתארים: חומרת שגיאה, מידת הרוגז של הלקוח, רמת מיומנות. בין 2 ל־10 רמות, מהנמוכה לגבוהה; המודל מעריך כל רמה בנפרד, בלי לראות את מספרה ואת שכנותיה. התשובה כוללת <code>score</code> (סכום מספרי הרמות כפול הסתברויותיהן, ולכן הערך עשוי להיות בין הרמות), <code>legend</code> עם תיאורי הרמות, <code>probabilities</code> ו־<code>confidence</code>.</li><li><strong>Noul — כן או לא.</strong> האם הטענה נכונה. התשובה <code>noul</code> היא הסתברות ל«כן» בין 0 ל־1: קרוב ל־1 — «כן» בטוח, קרוב ל־0 — «לא» בטוח, קרוב ל־0,5 — המודל מתלבט. אין <code>confidence</code> נפרד: מספר אחד מתאר את התשובה בשלמותה. <code>criteria</code> אופציונלי מבהיר מה נחשב «כן» ומה «לא».</li></ol><p>איך לבחור: אפשרויות ידועות ללא סדר — choice; דרגות בספקטרום — score; «כן/לא» בלבד, כשההסתברות עצמה חשובה — noul. Noul 0,5 פירושו סיכוי שווה ל«כן» ול«לא», ולא «רמה בינונית»: score מודד דרגה. מבין שני סוגים מתאימים בחרו את זה שהקוד פועל לפיו מיד: choice לתנאים מסועפים, score לסף, noul ל־<code>if</code>.</p><p>אפשר לשלב סוגים בבקשה אחת. התשובה תמיד מוגבלת לאפשרויות שלכם ואינה תלויה בשאלות אחרות: אפשר להוסיף או להסיר שאלות בלי לשנות את שאר התשובות.</p><h4>המצב</h4><p>המצב הוא מה שהמודל מעריך: הודעת לקוח, קטע מסמך, רשומה מבסיס נתונים או מצב היישום שלכם.</p><ul><li><strong>מחרוזת</strong> — כשיש טקסט אחד: הודעה, מאמר, קטע.</li><li><strong>אובייקט</strong> — שדות בעלי שם, רשומות קשורות, מצב היישום. TypeSafe ממליצה על אובייקט לרוב הבקשות: לכל חלק יש שם מובן.</li><li><strong>מערך</strong> — רצף של הודעות או רשומות.</li></ul><p>הכינו אותו כחומרים למומחים: שימו יחד התכתבות, הזמנה וכללי החזרה אם ההחלטה דורשת להשוות ביניהם. שמרו תוכן במצב ושיפוטים בשאלות. אם השאלה עוסקת בחלק אחד של המצב, ציינו בה את הנתיב אליו בגרשיים הפוכים, למשל <code>ticket.messages[0].text</code>.</p><h4>איך להגדיר שאלות</h4><ul><li><strong>שיפוט מהיר אחד לכל שאלה.</strong> שאלה טובה היא כזו שאדם שמבין בתחום ועם ההקשר הדרוש יענה עליה בשנייה: «האם יש דחיפות בהודעה?». «נתח את ההודעה והחלט מה לעשות» הוא כבר הסקה איטית, וצריך לחלקו לשאלות פשוטות.</li><li><strong>כל השאלה ב־<code>instructions</code>.</strong> מפתח השאלה, למשל <code>refund_requested</code>, דרוש רק לקוד שלכם ואינו מועבר למודל.</li><li><strong>כל השאלות לגבי מצב אחד בבקשה אחת.</strong> המודל מעריך אותן במקביל: לפי TypeSafe, שאלות נוספות כמעט אינן מאריכות את זמן התשובה ועלותן רק הטוקנים שלהן. שאלה «ליתר ביטחון» עולה כמעט כלום — הקוד יחליט בעצמו אילו תשובות דרושות.</li><li><strong>שיפוט מורכב בחלקים.</strong> במקום «הערך בקשת סטארט־אפ», שאלו בנפרד על גודל השוק, ההיתכנות הטכנית וההבדלים מהמתחרים, וחשבו את התוצאה בקוד עם משקלים. השתנו העדיפויות — שנו את המשקלים, ולא את השאלה.</li><li><strong>שאלות תלויות בבקשה שנייה.</strong> תשובות בבקשה אחת אינן משמשות הקשר זו לזו. בקשה שנייה דרושה רק אם אי אפשר להרכיב אותה ללא התשובה הראשונה: צריך לטעון נתונים נוספים או לבחור אפשרויות לשאלה הבאה.</li><li><strong>שאלה ארוכה כאובייקט.</strong> <code>instructions</code> ו־<code>criteria</code> הם בדרך כלל מחרוזות, אך יכולים להיות אובייקט או מערך: השאלה בשדה אחד, והנתונים באחרים. כך נוח להשוות קורות חיים לרשומות בסיס נתונים בשאלה אחת.</li></ul><h4>מידת ביטחון</h4><p>ב־choice וב־score, <code>confidence</code> בין 0 ל־1 מציג עד כמה ההסתברות מרוכזת בתשובה אחת: 1 — כולה באפשרות אחת, 0 — שווה בכל האפשרויות. ב־score רמה סמוכה מפחיתה את הביטחון פחות מרמה רחוקה. ב־noul מידת הביטחון היא הערך עצמו: ככל שהוא רחוק מ־0,5, כך התשובה נחרצת יותר.</p><p>TypeSafe ממליצה על שלושה טווחים:</p><ol><li><strong>ביטחון גבוה</strong> — פעלו אוטומטית.</li><li><strong>בינוני</strong> — פעלו בזהירות, למשל בקשו מהמשתמש אישור.</li><li><strong>נמוך</strong> — העבירו את המקרה לאדם, הבהירו את הבקשה או חברו מסלול גיבוי, למשל מודל חזק יותר עם הסקה.</li></ol><p>ככל שהטעות יקרה יותר, הסף צריך להיות מחמיר יותר: לפעולות בלתי הפיכות — גבוה יותר מאשר לקריאה. התשובה אומרת מה לבחור, ומידת הביטחון אם כדאי לפעול. התאימו את הספים לפי הנתונים שלכם, בהשוואה בין מידת הביטחון לדיוק.</p><h4>איך לבנות מערכת סביב Jev</h4><p>Jev מיועד לא לסוכנים שבוחרים בעצמם את השלב הבא ועלולים לסטות בכל סבב, אלא לתוכנות שבהן הקוד מנהל את התהליך והמודל עונה על שאלות משמעות צרות. שמונת שלבי התכנון לפי TypeSafe:</p><ol><li>כל מה שאפשר לעשות בקוד, עשו בקוד — באופן מהימן ובעלות נמוכה.</li><li>במצב — רק מה שהשאלות הנוכחיות צריכות; עובדות עדכניות — מבסיס הידע שלכם, ולא מזיכרון המודל.</li><li>מבנה במצב: JSON מקונן, ובשאלה נתיב לשדה הדרוש בגרשיים הפוכים, אם כך יש פחות עמימות.</li><li>שאלות צרות ומוגדרות ככל האפשר — לפי TypeSafe, אולי הכלל החשוב ביותר: שאלה רחבה מסתירה כמה שיפוטים מאחורי תשובה אחת.</li><li>מבנה בשאלות: השאלה עצמה קצרה; הסברים, דוגמאות וערכים מהבסיס שלכם בשדות סמוכים באובייקט <code>instructions</code> או <code>criteria</code>, ולא במחרוזת ארוכה אחת.</li><li>שאלות עצמאיות רבות למצב אחד בבקשה אחת — יותר תועלת לכל דולר.</li><li>הקוד משלב תשובות: באמצעות כללים, סכום משוקלל או כתכונות למודל קלאסי של למידת מכונה.</li><li>הסתעפות לפי מידת ביטחון: מקרים לא בטוחים לאדם או למודל עם הסקה.</li></ol><p>Jev אינו צ&#39;אט או מודל להשלמת קוד אוטומטית, ואי אפשר להחליף בו מודל שפה בסוכן תכנות. אבל סוכן יכול לכתוב עבורכם קוד שקורא ל־Jev במקום שבו צריך תשובה מהירה ומכוילת.</p><h4>תחומי שימוש</h4><ul><li><strong>אוטומציה ברקע</strong> — החלטות שמפעילים מיליון פעמים בלי אדם לידן.</li><li><strong>זמן אמת</strong> — לפי TypeSafe, רוב הבקשות מבוצעות בתוך כ־100 אלפיות השנייה: מספיק לעיבוד בזמן הפעולה ולממשקים.</li><li><strong>נתונים גדולים</strong> — חיפוש במאגרים עצומים, תיוג יומני עבודה של סוכנים, תכונות לחיזוי.</li><li><strong>בדיקת מודלים אחרים</strong> — בקשות, חילוץ מידע, הסקה, קריאות לכלים: עקיפת מגבלות, שגיאות ציטוט ומידע מומצא.</li><li><strong>חיפוש ודירוג</strong> — רלוונטיות של צמד «שאילתה — מועמד», דירוג מחדש, בחירת הקשר.</li><li><strong>הסתעפות לפי כוונה</strong> — מה המשתמש רוצה ואיזה מטפל דרוש: לוגיקה פשוטה, מודל ייעודי או אדם; הנושא, המורכבות והסיכון קובעים לאיזה מודל שפה להעביר את הבקשה.</li><li><strong>בדיקות הגנה</strong> — קלט, פלט וקריאות לכלים של מודל שפה: הוראות מוזרקות, הפרות כללים, דליפת נתונים אישיים.</li><li><strong>תמיכה</strong> — נושא הפנייה וכוונתה, דחיפות, רוגז, סיכון נטישה, בקשת החזר כספי, תור.</li><li><strong>פיקוח על תוכן</strong> — לפי כללי הפלטפורמה שלכם: רעילות, בריונות, ספאם, הונאה, עצות מסוכנות, נתונים אישיים; לפי חומרה ומידת ביטחון — לאפשר, להזהיר, לבדוק או לחסום.</li><li><strong>ענפים</strong> — מקרי ביטוח, חקירות פיננסיות ו־KYC, חוזים ופרסום, כרטיסי מוצרים, גיוס עובדים, לקוחות פוטנציאליים, משחקים, סיכונים, חיזוי ביקוש, גרפי ידע, סקירות מדעיות, בדיקות משמעות של קוד ב־CI.</li></ul><h4>מאפיינים</h4><ul><li><strong><code>jev-latest</code></strong> — כינוי לגרסה היציבה האחרונה, כרגע Jev 1.13; הגרסה שהשיבה מופיעה בשדה <code>model</code>, למשל <code>jev-1.13.0</code>. בגרסה חדשה הכינוי עובר אליה, והתשובות עשויות להשתנות בלי תיקונים מצדכם — עקבו אחר השדה הזה אם הספים הותאמו לגרסה.</li><li><strong>הקשר</strong> — 64K טוקנים בכל בקשה: המצב וכל השאלות יחד; המצב עם השאלה הארוכה ביותר עד 32K. המודל קורא את המצב פעם אחת ובודק מולו את כל השאלות במקביל.</li><li><strong>קלט</strong> — טקסט בלבד: מחרוזת, אובייקט JSON או מערך טקסטים. תמונות, אודיו ווידאו עדיין אינם נתמכים — המירו אותם לטקסט מראש.</li><li><strong>שפה</strong> — שפת האימון העיקרית היא אנגלית, ובה הדיוק כרגע הגבוה ביותר. המודל מקבל שפות אחרות, כולל סינית, יפנית וקוריאנית, אך הדיוק נמוך יותר — בדקו על הנתונים שלכם.</li><li><strong>מחירים וחיוב ב־Ailoot API</strong> — התנאים תלויים במתודה שנבחרה ומצוינים בכרטיס שלה.</li><li><strong>הגדרה</strong> — Jev אינו עובר אימון נוסף על נתוני הלקוח: החומרים שלכם ב־<code>state</code>, וכללי התחום ב־<code>instructions</code> וב־<code>criteria</code>.</li><li><strong>נתונים</strong> — TypeSafe מדווחת ש־Jev אינו מאומן על בקשות ותשובות של לקוחות.</li></ul><h4>נקודות חולשה ידועות של Jev 1.13</h4><p>TypeSafe מפרטת בגלוי את נקודות החולשה של הגרסה הנוכחית ומבטיחה לתקן רבות מהן בגרסאות הבאות. המודל מהיר, מכויל ושופט היטב בעזרת היגיון בריא, אבל:</p><ol><li><strong>קורא מילולית.</strong> עונה על השאלה שנכתבה, ולא על המשתמעת: הסתייגויות, שלילות ותנאים מרומזים מובנים מילולית. כתבו תנאי מדויק ומקרי קצה ב־<code>criteria</code>; פרשנות בלתי נמנעת חלקו לשתי שאלות מילוליות.</li><li><strong>אינו מחשבון.</strong> ספירת תווים, חזרות ופריטי רשימה אינה מהימנה, והטעות גדלה עם הגודל — ספרו בקוד, עם שאלה לכל מועמד. המודל מבין צבעים ב־hex או ב־RGB פחות טוב משמותיהם. <code>score</code> מתאים לסף, אך לא למספר מדויק בין רמות.</li><li><strong>תאריכים וזמן.</strong> איזה תאריך מוקדם יותר, מה המרווח ביניהם, האם תאריך נכלל בתקופה — לא מהימן, במיוחד בפורמטים מעורבים ובתאריכים יחסיים. חלצו חלקי תאריך באמצעות choice (עם אפשרות «לא צוין»), והשוו בקוד.</li><li><strong>ניסוח עקיף.</strong> שלילות כפולות ושאלות על תכונה של תכונה מפחיתות את הדיוק. כתבו ישירות וציינו חלקי מצב בשמם.</li><li><strong>תוכן עודף במצב.</strong> טקסט זר מפחית את הדיוק. סננו בקוד, ואם אי אפשר — הסירו תוכן לא רלוונטי בשאלות noul.</li><li><strong>טקסט עוין.</strong> כברירת מחדל המודל אינו מצפה למלכודות במצב: הוראה מוזרקת או טקסט שמתווכח על סיווגו שלו יכולים להזיז את התשובה. כתבו קריטריונים מדויקים ובדקו מקרי גבול לפני ההפעלה.</li><li><strong>סתירות.</strong> אם <code>instructions</code> ו־<code>criteria</code> מבקשים דברים שונים — למשל ב־noul «כן» מתואר כ«לא» — הדיוק יורד. הקריטריונים הם המשך השאלה.</li><li><strong>סדר האפשרויות.</strong> לפעמים המודל נוטה לאפשרות הראשונה ב־choice. שנו את הסדר ובדקו שהתשובה אינה משתנה.</li><li><strong>יצירה.</strong> Jev לא אומן לכתוב טקסט. לחילוץ נתונים מצאו מועמדים בביטוי רגולרי או במודל יוצר, ותנו ל־Jev לבחור את הנכון באמצעות choice.</li></ol></div></details></section><section class=\"card-section\" data-card-section=\"methods\"><h3 tabindex=\"-1\">זמין ב-Ailoot · קלט ושיטות</h3><details class=\"card-method\" open><summary><b>Ailoot · System One</b> <code>POST /v1/systemone</code></summary><dl class=\"method-capabilities\"><div><dt>סוגי קלט</dt><dd><code>text</code></dd></div><div><dt>סוגי פלט</dt><dd><code>structured</code></dd></div><div><dt>הקשר</dt><dd>⁦64,000⁩ tokens</dd></div><div><dt>פורמט פלט</dt><dd>json</dd></div></dl><div class=\"tw\" data-card-parameters data-typed-parameters><table><thead><tr><th>שדה</th><th>סוג</th><th>דרישה</th><th>ערכים ומגבלות</th><th>ברירת מחדל</th></tr></thead><tbody><tr data-parameter-availability=\"source_interface\"><th data-cell-label=\"שדה\" scope=\"row\"><span class=\"card-cell-label\">שדה</span><code class=\"card-field-name\">model</code></th><td data-cell-label=\"סוג\" data-field-type><span class=\"card-cell-label\">סוג</span><code>string</code></td><td data-cell-label=\"דרישה\"><span class=\"card-cell-label\">דרישה</span>חובה</td><td data-cell-label=\"ערכים ומגבלות\"><span class=\"card-cell-label\">ערכים ומגבלות</span><div>jev-latest</div></td><td data-cell-label=\"ברירת מחדל\" data-default=\"unspecified\"><span class=\"card-cell-label\">ברירת מחדל</span>—</td></tr><tr data-parameter-availability=\"source_interface\"><th data-cell-label=\"שדה\" scope=\"row\"><span class=\"card-cell-label\">שדה</span><code class=\"card-field-name\">state</code></th><td data-cell-label=\"סוג\" data-field-type><span class=\"card-cell-label\">סוג</span><code>string|object|array</code></td><td data-cell-label=\"דרישה\"><span class=\"card-cell-label\">דרישה</span>חובה</td><td data-cell-label=\"ערכים ומגבלות\"><span class=\"card-cell-label\">ערכים ומגבלות</span></td><td data-cell-label=\"ברירת מחדל\" data-default=\"unspecified\"><span class=\"card-cell-label\">ברירת מחדל</span>—</td></tr><tr data-parameter-availability=\"source_interface\"><th data-cell-label=\"שדה\" scope=\"row\"><span class=\"card-cell-label\">שדה</span><code class=\"card-field-name\">questions</code></th><td data-cell-label=\"סוג\" data-field-type><span class=\"card-cell-label\">סוג</span><code>object</code></td><td data-cell-label=\"דרישה\"><span class=\"card-cell-label\">דרישה</span>חובה</td><td data-cell-label=\"ערכים ומגבלות\"><span class=\"card-cell-label\">ערכים ומגבלות</span><div>מספר שדות מזערי באובייקט: ⁦1⁩</div></td><td data-cell-label=\"ברירת מחדל\" data-default=\"unspecified\"><span class=\"card-cell-label\">ברירת מחדל</span>—</td></tr><tr data-parameter-availability=\"source_interface\"><th data-cell-label=\"שדה\" scope=\"row\"><span class=\"card-cell-label\">שדה</span><code class=\"card-field-name\">questions.&lt;id&gt;.type</code></th><td data-cell-label=\"סוג\" data-field-type><span class=\"card-cell-label\">סוג</span><code>string</code></td><td data-cell-label=\"דרישה\"><span class=\"card-cell-label\">דרישה</span>חובה</td><td data-cell-label=\"ערכים ומגבלות\"><span class=\"card-cell-label\">ערכים ומגבלות</span><div>noul, choice, score</div></td><td data-cell-label=\"ברירת מחדל\" data-default=\"unspecified\"><span class=\"card-cell-label\">ברירת מחדל</span>—</td></tr><tr data-parameter-availability=\"source_interface\"><th data-cell-label=\"שדה\" scope=\"row\"><span class=\"card-cell-label\">שדה</span><code class=\"card-field-name\">questions.&lt;id&gt;.instructions</code></th><td data-cell-label=\"סוג\" data-field-type><span class=\"card-cell-label\">סוג</span><code>string|object|array|null</code></td><td data-cell-label=\"דרישה\"><span class=\"card-cell-label\">דרישה</span>רשות</td><td data-cell-label=\"ערכים ומגבלות\"><span class=\"card-cell-label\">ערכים ומגבלות</span></td><td data-cell-label=\"ברירת מחדל\" data-default=\"unspecified\"><span class=\"card-cell-label\">ברירת מחדל</span>—</td></tr><tr data-parameter-availability=\"source_interface\"><th data-cell-label=\"שדה\" scope=\"row\"><span class=\"card-cell-label\">שדה</span><code class=\"card-field-name\">questions.&lt;id&gt;.criteria</code></th><td data-cell-label=\"סוג\" data-field-type><span class=\"card-cell-label\">סוג</span><code>object|array|null</code></td><td data-cell-label=\"דרישה\"><span class=\"card-cell-label\">דרישה</span>רשות</td><td data-cell-label=\"ערכים ומגבלות\"><span class=\"card-cell-label\">ערכים ומגבלות</span><div>תנאים: noul: תיאורי true/false אופציונליים שיכולים להיות null; choice: אובייקט קריטריונים; score: מערך קריטריונים לא ריק</div></td><td data-cell-label=\"ברירת מחדל\" data-default=\"unspecified\"><span class=\"card-cell-label\">ברירת מחדל</span>—</td></tr><tr data-parameter-availability=\"source_interface\"><th data-cell-label=\"שדה\" scope=\"row\"><span class=\"card-cell-label\">שדה</span><code class=\"card-field-name\">stream</code></th><td data-cell-label=\"סוג\" data-field-type><span class=\"card-cell-label\">סוג</span><code>boolean|null</code></td><td data-cell-label=\"דרישה\"><span class=\"card-cell-label\">דרישה</span>רשות</td><td data-cell-label=\"ערכים ומגבלות\"><span class=\"card-cell-label\">ערכים ומגבלות</span><div>false, null</div></td><td data-cell-label=\"ברירת מחדל\" data-default=\"unspecified\"><span class=\"card-cell-label\">ברירת מחדל</span>—</td></tr></tbody></table></div><details class=\"card-about\" data-material-combinations><summary>שילובים של חומרי קלט</summary><p class=\"note-s\"><b>noul</b> · נדרש: state, questions.&lt;id&gt;.type=noul</p><p class=\"note-s\"><b>choice</b> · נדרש: state, questions.&lt;id&gt;.type=choice, criteria object</p><p class=\"note-s\"><b>score</b> · נדרש: state, questions.&lt;id&gt;.type=score, nonemptycriteriaarray</p></details><details class=\"note-s\" data-method-contract><summary>פרמטרים ומחזור חיים של השיטה</summary><div class=\"tw\" data-card-table=\"contract\"><table><thead><tr><th>פרמטר</th><th>מפרט</th></tr></thead><tbody><tr><th data-cell-label=\"פרמטר\" scope=\"row\"><span class=\"card-cell-label\">פרמטר</span><code>material_types</code></th><td data-cell-label=\"מפרט\"><span class=\"card-cell-label\">מפרט</span>text</td></tr><tr><th data-cell-label=\"פרמטר\" scope=\"row\"><span class=\"card-cell-label\">פרמטר</span><code>required</code></th><td data-cell-label=\"מפרט\"><span class=\"card-cell-label\">מפרט</span>model, state, questions</td></tr><tr><th data-cell-label=\"פרמטר\" scope=\"row\"><span class=\"card-cell-label\">פרמטר</span><code>optional_controls</code></th><td data-cell-label=\"מפרט\"><span class=\"card-cell-label\">מפרט</span>null</td></tr><tr><th data-cell-label=\"פרמטר\" scope=\"row\"><span class=\"card-cell-label\">פרמטר</span><code>content_type</code></th><td data-cell-label=\"מפרט\"><span class=\"card-cell-label\">מפרט</span>application/json</td></tr></tbody></table></div><p>מחזור חיים: <code>exact retained published method</code></p><p class=\"note-s\">מבני המתודות והמזהים מדויקים; יכולת הספק נפרדת מקבלת הבקשה לביצוע.</p></details></details></section><section class=\"card-section\" data-card-section=\"pricing\"><h3 tabindex=\"-1\">תעריפים</h3><h4>תעריפי שיטות Ailoot</h4><section class=\"meth\" data-route=\"Core\"><header><b><span class=\"alias\">Ailoot</span> System One</b><code>POST /v1/systemone</code></header><dl><div><dt>קלט</dt><dd>⁦≈‏0.000084 ‏$⁩ <em>/ 1K</em></dd></div><div><dt>פלט</dt><dd>⁦‏0.00 ‏$⁩ <em>/ 1K</em></dd></div></dl></section><p class=\"note-s\">לפני הבקשה Ailoot משריינת סכום משוער. לאחר קבלת התוצאה היא מסדירה את החיוב הסופי לפי השימוש המדוד. הסדרת חיוב בהזרמה משתמשת ברשומת השימוש הסופית. <a href=\"/docs/he/billing/reserve/\">איך פועלים שריון הסכום והסדרת החיוב →</a></p></section><section class=\"card-section\" data-card-section=\"examples\"><h3 tabindex=\"-1\">דוגמאות לבקשות</h3><h4>Ailoot · System One</h4><div class=\"code-group\"><div class=\"cg-bar\"><div class=\"cg-tabs\" role=\"tablist\" aria-label=\"אפשרויות קוד\"><button class=\"cg-tab\" id=\"model-code-665-tab-0\" role=\"tab\" type=\"button\" aria-controls=\"model-code-665-panel-0\" aria-selected=\"true\" tabindex=\"0\">דוגמת סיווג</button></div><div class=\"cg-tools\"><button class=\"cg-btn cg-copy\" type=\"button\" aria-label=\"העתקת הקוד\"><svg class=\"cp\" viewBox=\"0 0 16 16\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.4\"><rect x=\"5.25\" y=\"5.25\" width=\"8.5\" height=\"8.5\" rx=\"1.75\"/><path d=\"M10.75 5.25V3.5a1.25 1.25 0 0 0-1.25-1.25H3.5A1.25 1.25 0 0 0 2.25 3.5v6a1.25 1.25 0 0 0 1.25 1.25h1.75\"/></svg><svg class=\"ok\" viewBox=\"0 0 16 16\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.4\"><path d=\"m3 8.5 3.25 3.25L13 5\"/></svg></button></div></div><div class=\"cg-body\"><div class=\"cg-pane\" id=\"model-code-665-panel-0\" role=\"tabpanel\" aria-labelledby=\"model-code-665-tab-0\"><pre data-lang=\"bash\"><code>set -eu\n: &quot;${AILOOT_API_KEY:?Set your Ailoot API key}&quot;\n: &quot;${AILOOT_TEXT_FILE:?Set your actual UTF-8 customer message}&quot;\nexport AILOOT_TEXT_FILE\npython3 - &lt;&lt;&#39;PY_REQUEST&#39;\nimport json,os\nfrom pathlib import Path\np=json.loads(&#39;{&quot;model&quot;: &quot;jev-latest&quot;, &quot;state&quot;: &quot;&quot;, &quot;questions&quot;: {&quot;is_urgent&quot;: {&quot;type&quot;: &quot;noul&quot;, &quot;instructions&quot;: &quot;Does the supplied customer message express urgency?&quot;}}}&#39;)\nf=Path(os.environ[&quot;AILOOT_TEXT_FILE&quot;])\nif not f.is_file():raise SystemExit(&quot;Choose your actual UTF-8 source material&quot;)\ntext=f.read_text(encoding=&quot;utf-8&quot;)\nif not text.strip():raise SystemExit(&quot;Source material must contain text&quot;)\np[&quot;state&quot;]=text\nPath(&quot;request.json&quot;).write_text(json.dumps(p,ensure_ascii=False))\nPY_REQUEST\ncurl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/systemone \\\n  -H &quot;Authorization: Bearer $AILOOT_API_KEY&quot; -H &#39;Content-Type: application/json&#39; \\\n  --data-binary @request.json -D response-headers.txt -o result.json\npython3 - &lt;&lt;&#39;PY_RESULT&#39;\nimport json\nfrom pathlib import Path\nprint(json.dumps(json.loads(Path(&quot;result.json&quot;).read_text()),ensure_ascii=False,indent=2))\nPY_RESULT\n</code></pre></div></div></div></section><section class=\"card-section\" data-card-section=\"results\"><h3 tabindex=\"-1\">קבלה ושמירה של תוצאות</h3><h4>Ailoot · System One</h4><p class=\"note-s\">json</p><div class=\"card-result-process\" data-all-results><h5>שמירת כל התוצאות שהושלמו</h5><p class=\"note-s\">שמרו כל תגובה מלאה, קובץ ומקטע תוכן שהוחזרו.</p><p class=\"note-s\">יש לשמור כל תשובה לפי מזהה השאלה שסופק לה, ההסתברות והמקרא; נוסחת הביטחון המשתמשת ב־n דורשת n&gt;1, בלי לקבוע כלל API למספר מזערי של אפשרויות.</p></div><details class=\"card-about\" data-output-fields><summary>שדות התגובה</summary><div class=\"tw\" data-card-table=\"output\"><table><thead><tr><th>שדה</th><th>סוג</th></tr></thead><tbody><tr><th data-cell-label=\"שדה\" scope=\"row\"><span class=\"card-cell-label\">שדה</span><code class=\"card-field-name\">answers.&lt;id&gt;.type</code></th><td data-cell-label=\"סוג\" data-field-type><span class=\"card-cell-label\">סוג</span>string</td></tr><tr><th data-cell-label=\"שדה\" scope=\"row\"><span class=\"card-cell-label\">שדה</span><code class=\"card-field-name\">answers.&lt;id&gt;.noul</code></th><td data-cell-label=\"סוג\" data-field-type><span class=\"card-cell-label\">סוג</span>number</td></tr><tr><th data-cell-label=\"שדה\" scope=\"row\"><span class=\"card-cell-label\">שדה</span><code class=\"card-field-name\">answers.&lt;id&gt;.choice</code></th><td data-cell-label=\"סוג\" data-field-type><span class=\"card-cell-label\">סוג</span>string</td></tr><tr><th data-cell-label=\"שדה\" scope=\"row\"><span class=\"card-cell-label\">שדה</span><code class=\"card-field-name\">answers.&lt;id&gt;.score</code></th><td data-cell-label=\"סוג\" data-field-type><span class=\"card-cell-label\">סוג</span>number</td></tr><tr><th data-cell-label=\"שדה\" scope=\"row\"><span class=\"card-cell-label\">שדה</span><code class=\"card-field-name\">answers.&lt;id&gt;.confidence</code></th><td data-cell-label=\"סוג\" data-field-type><span class=\"card-cell-label\">סוג</span>number</td></tr><tr><th data-cell-label=\"שדה\" scope=\"row\"><span class=\"card-cell-label\">שדה</span><code class=\"card-field-name\">answers.&lt;id&gt;.probabilities</code></th><td data-cell-label=\"סוג\" data-field-type><span class=\"card-cell-label\">סוג</span>object</td></tr><tr><th data-cell-label=\"שדה\" scope=\"row\"><span class=\"card-cell-label\">שדה</span><code class=\"card-field-name\">answers.&lt;id&gt;.legend</code></th><td data-cell-label=\"סוג\" data-field-type><span class=\"card-cell-label\">סוג</span>object</td></tr><tr><th data-cell-label=\"שדה\" scope=\"row\"><span class=\"card-cell-label\">שדה</span><code class=\"card-field-name\">usage</code></th><td data-cell-label=\"סוג\" data-field-type><span class=\"card-cell-label\">סוג</span>object</td></tr></tbody></table></div></details><details class=\"card-about\" data-method-errors><summary>שגיאות והשלבים הבאים</summary><div class=\"tw\" data-card-table=\"errors\"><table><thead><tr><th>תגובה</th><th>תנאי</th><th>השלב הבא</th></tr></thead><tbody><tr><th data-cell-label=\"תגובה\" scope=\"row\"><span class=\"card-cell-label\">תגובה</span>⁦400⁩ · <code>invalid_request_error</code></th><td data-cell-label=\"תנאי\"><span class=\"card-cell-label\">תנאי</span>שדות נדרשים, ייצוג חומר או ערך פרמטר שאינם תקינים</td><td data-cell-label=\"השלב הבא\"><span class=\"card-cell-label\">השלב הבא</span>תקנו את השדות שצוינו לפני בקשת יצירה חדשה.</td></tr></tbody></table></div></details></section><section class=\"card-section\" data-card-section=\"aliases\"><h3 tabindex=\"-1\">כינויים</h3><h4>כינויים למודל</h4><p class=\"note-s\"><span data-model-alias-route=\"Core\"><b>Ailoot</b> <a href=\"#m=jev-latest&amp;route=Core&amp;caller=jev-latest&amp;fmt=systemone\"><code>jev-latest</code></a></span></p><h4>כינויים לנתיבי שיטות</h4><p class=\"note-s\">השתמשו בנתיבי השיטות המוצגים למעלה.</p><h4>מזהי מודלים קשורים IDs</h4><p class=\"note-s\"><a href=\"#m=jev-latest&amp;route=Core&amp;caller=jev-latest&amp;fmt=systemone\"><code>jev-latest</code></a></p></section></div>",
      "method_identity": {
        "effective_request_model_id": "jev-latest",
        "fmt": "systemone",
        "http": "POST",
        "path": "/v1/systemone",
        "request_model_id": "jev-latest",
        "route_label": "Core"
      },
      "method_key": "Core|systemone|/v1/systemone|jev-latest",
      "ordinal": 0,
      "rawMethod": {
        "cache_read": null,
        "cache_write": null,
        "cache_write_1h": null,
        "cache_write_5m": null,
        "conditional_meter": null,
        "contract": {
          "data": {
            "all_results": "Retain every answer by its supplied question ID, probability and legend; confidenceformulausingnrequiresn>1withoutassertinganAPIminchoicesrule.",
            "errors": [
              {
                "code": null,
                "condition": "שדות נדרשים, ייצוג חומר או ערך פרמטר שאינם תקינים",
                "http_status": 400,
                "recovery": "תקנו את השדות שצוינו לפני בקשת יצירה חדשה.",
                "type": "invalid_request_error"
              }
            ],
            "hints": [],
            "ignored_fields": [],
            "lifecycle": {
              "mode": "exact retained published method"
            },
            "material_combinations": [
              {
                "mode": "noul",
                "required": [
                  "state",
                  "questions.<id>.type=noul"
                ]
              },
              {
                "mode": "choice",
                "required": [
                  "state",
                  "questions.<id>.type=choice",
                  "criteria object"
                ]
              },
              {
                "mode": "score",
                "required": [
                  "state",
                  "questions.<id>.type=score",
                  "nonemptycriteriaarray"
                ]
              }
            ],
            "operation_modes": [
              "noul",
              "choice",
              "score"
            ],
            "outputs": {
              "all_results": "יש לשמור כל תשובה לפי מזהה השאלה שסופק לה, ההסתברות והמקרא; נוסחת הביטחון המשתמשת ב־n דורשת n>1, בלי לקבוע כלל API למספר מזערי של אפשרויות.",
              "family": "structured",
              "fields": [
                {
                  "description": null,
                  "name": "answers.<id>.type",
                  "type": "string"
                },
                {
                  "description": null,
                  "name": "answers.<id>.noul",
                  "type": "number"
                },
                {
                  "description": null,
                  "name": "answers.<id>.choice",
                  "type": "string"
                },
                {
                  "description": null,
                  "name": "answers.<id>.score",
                  "type": "number"
                },
                {
                  "description": null,
                  "name": "answers.<id>.confidence",
                  "type": "number"
                },
                {
                  "description": null,
                  "name": "answers.<id>.probabilities",
                  "type": "object"
                },
                {
                  "description": null,
                  "name": "answers.<id>.legend",
                  "type": "object"
                },
                {
                  "description": null,
                  "name": "usage",
                  "type": "object"
                }
              ],
              "format": "json"
            },
            "parameters": [
              {
                "availability": "source_interface",
                "default": null,
                "default_known": false,
                "enum": [
                  "jev-latest"
                ],
                "enum_known": true,
                "name": "model",
                "required": true,
                "type": "string"
              },
              {
                "availability": "source_interface",
                "default": null,
                "default_known": false,
                "enum": null,
                "enum_known": false,
                "name": "state",
                "required": true,
                "type": "string|object|array"
              },
              {
                "availability": "source_interface",
                "default": null,
                "default_known": false,
                "enum": null,
                "enum_known": false,
                "min_properties": 1,
                "name": "questions",
                "required": true,
                "type": "object"
              },
              {
                "availability": "source_interface",
                "default": null,
                "default_known": false,
                "enum": [
                  "noul",
                  "choice",
                  "score"
                ],
                "enum_known": true,
                "name": "questions.<id>.type",
                "required": true,
                "type": "string"
              },
              {
                "availability": "source_interface",
                "default": null,
                "default_known": false,
                "enum": null,
                "enum_known": false,
                "name": "questions.<id>.instructions",
                "required": false,
                "type": "string|object|array|null"
              },
              {
                "availability": "source_interface",
                "conditions": "noul: תיאורי true/false אופציונליים שיכולים להיות null; choice: אובייקט קריטריונים; score: מערך קריטריונים לא ריק",
                "default": null,
                "default_known": false,
                "enum": null,
                "enum_known": false,
                "name": "questions.<id>.criteria",
                "required": false,
                "type": "object|array|null"
              },
              {
                "availability": "source_interface",
                "default": null,
                "default_known": false,
                "enum": [
                  false,
                  null
                ],
                "enum_known": true,
                "name": "stream",
                "required": false,
                "type": "boolean|null"
              }
            ],
            "profile_binding": "Exact existing Ailoot model and method; interface constraints below do not assert provider qualification.",
            "unsupported": [
              "stream=true",
              "duplicateandcase-variedcanonicalkeys"
            ]
          },
          "hints": [
            "מבני המתודות והמזהים מדויקים; יכולת הספק נפרדת מקבלת הבקשה לביצוע."
          ],
          "input": {
            "content_type": "application/json",
            "material_types": [
              "text"
            ],
            "optional_controls": null,
            "required": [
              "model",
              "state",
              "questions"
            ]
          },
          "lifecycle": {
            "mode": "exact retained published method"
          },
          "method": {
            "http": "POST",
            "path": "/v1/systemone"
          },
          "operation_modes": [
            "systemone"
          ],
          "output": {
            "family": [
              "structured"
            ],
            "format": "structured decisions JSON",
            "multioutputs": "retain every actual response output"
          }
        },
        "ctx": 64000,
        "examples": [
          {
            "code": "set -eu\n: \"${AILOOT_API_KEY:?Set your Ailoot API key}\"\n: \"${AILOOT_TEXT_FILE:?Set your actual UTF-8 customer message}\"\nexport AILOOT_TEXT_FILE\npython3 - <<'PY_REQUEST'\nimport json,os\nfrom pathlib import Path\np=json.loads('{\"model\": \"jev-latest\", \"state\": \"\", \"questions\": {\"is_urgent\": {\"type\": \"noul\", \"instructions\": \"Does the supplied customer message express urgency?\"}}}')\nf=Path(os.environ[\"AILOOT_TEXT_FILE\"])\nif not f.is_file():raise SystemExit(\"Choose your actual UTF-8 source material\")\ntext=f.read_text(encoding=\"utf-8\")\nif not text.strip():raise SystemExit(\"Source material must contain text\")\np[\"state\"]=text\nPath(\"request.json\").write_text(json.dumps(p,ensure_ascii=False))\nPY_REQUEST\ncurl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/systemone \\\n  -H \"Authorization: Bearer $AILOOT_API_KEY\" -H 'Content-Type: application/json' \\\n  --data-binary @request.json -D response-headers.txt -o result.json\npython3 - <<'PY_RESULT'\nimport json\nfrom pathlib import Path\nprint(json.dumps(json.loads(Path(\"result.json\").read_text()),ensure_ascii=False,indent=2))\nPY_RESULT\n",
            "label": "Classify your actual customer message",
            "language": "bash"
          }
        ],
        "family": "systemone",
        "fast_multiplier": null,
        "flex_multiplier": null,
        "fmt": "systemone",
        "http": "POST",
        "img_in": null,
        "img_out": null,
        "in": 0.084,
        "input": [
          "text"
        ],
        "label": "System One",
        "max_out": 0,
        "max_tool_calls": null,
        "out": 0,
        "output": [
          "structured"
        ],
        "path": "/v1/systemone",
        "pricing_profiles": [
          {
            "dimensions": {},
            "label": "Core",
            "units": [
              {
                "amount": 0.084,
                "amount_unit": "usd_per_million_tokens",
                "key": "in",
                "label": "Input",
                "side": "in"
              },
              {
                "amount": 0,
                "amount_unit": "usd_per_million_tokens",
                "key": "out",
                "label": "Output",
                "side": "out"
              }
            ]
          }
        ],
        "request_model_id": "jev-latest",
        "route_label": "Core",
        "status_reads": [],
        "tiers": [],
        "tool_prices": null,
        "unit": "token",
        "units": []
      }
    }
  ],
  "model_id": "jev-latest",
  "nativeProvenance": {
    "input_facts_canonical_sha256": "e8092b31b6e79461ccfcfa6b61507b69dbd1e995be8745d9eddc1a34abf826cb",
    "input_html_sha256": "0cb482f0219cbfcf01819bce8cfc6b60cdedcdfbbd628d2fe457ebe568d77e9c",
    "private_audit_sha256": "a53275b17284ab0c6d184d04af7bc6f7c0bb6850fd93a2b7cd40125b8e53de1e",
    "role": "historical-normalized-input-audit-hashes",
    "schema": "ailoot-native-model-provenance-v2"
  },
  "page": {
    "canonical": "https://ailoot.ai/models/he/jev-latest/",
    "description": "מודל החלטות של TypeSafe: אינו כותב טקסט, אלא עונה על שאלות מוגדרות טיפוס לגבי טקסט או JSON — בחירת אפשרות, דירוג בסולם או «כן/לא» עם הסתברויות. מתאים לניתוב, למיון פניות, לפיקוח על תוכן ולניקוד; כל השאלות בבקשה אחת מוערכות במקביל.",
    "locale": "he",
    "md_url": "https://ailoot.ai/models/he/jev-latest/index.md",
    "title": "jev-latest — Ailoot",
    "url": "https://ailoot.ai/models/he/jev-latest/"
  },
  "rawModel": {
    "about": "Jev הוא מודל הדגל של TypeSafe והמודל הראשון בקטגוריה החדשה **System One**. הוא אינו כותב טקסט, אלא מקבל במהירות החלטות שהתוכנה יכולה להשתמש בהן מיד: מוסרים **מצב** (`state`) — טקסט או JSON — וקבוצת **שאלות**, ומקבלים ערכים מוגדרי טיפוס עם הסתברויות מכוילות.\n\nמודלי שפה כותבים מילים לבני אדם, ואילו Jev, לפי TypeSafe, קרוב יותר לקוד: תשובה מיד בצורה שהקוד צריך, מהירות גבוהה, ואין בתשובה שום ערך מחוץ לאפשרויות שהוגדרו. המודל תוכנן לתת תשובות יציבות בבקשות חוזרות.\n\n### במה System One שונה ממודל שפה\n\n- **אינו מייצר.** Jev אינו כותב תשובות למשתמש, אינו כותב קוד ואינו מסביר את מהלך ההסקה. אתם מגדירים את התשובות האפשריות — באמצעות אחד משלושת סוגי השאלות.\n- **מאומן להחלטות מכוילות.** TypeSafe מאמנת את המודל בשיטת RLCD (Reinforcement Learning for Calibrated Decisions): ההסתברויות מותאמות לתוצאות בפועל ומשקפות אי־ודאות. מתוך תשובות רבות עם הסתברות של 0,8, בערך 80% אמורות להיות נכונות. כיול הוא תכונה של מדגם גדול, ולא הבטחה לנכונותה של תשובה בודדת.\n- **מטרת אימון שונה.** מודלי שיחה מאומנים למצוא חן בעיני אנשים (RLHF), ולפי התצפית של TypeSafe זה מעודד ריצוי ושגיאות שנשמעות בטוחות. אחד השותפים ליצירת RLHF, דיוגו אלמיידה, הוא מייסד שותף של TypeSafe.\n\nהשם מתייחס ל«מערכת 1» בספרו של דניאל כהנמן «לחשוב מהר, לחשוב לאט»: שיפוט אינטואיטיבי מהיר לעומת חשיבה שקולה ואיטית של «מערכת 2». Jev נוצר לשיפוטים מהירים וצרים.\n\n### שלושה סוגי שאלות\n\nשאלה היא שיפוט אחד לגבי המצב, והתשובה היא ערך שהקוד משווה לסף, ממיין או מעביר הלאה.\n\n1. **Choice — בחירת אפשרות.** מחלקה לפנייה, קטגוריית מוצר, שפת קטע קוד. האפשרויות הן מילון «אפשרות → תיאור», עד 255 אפשרויות. התשובה כוללת את ה־`choice` שנבחר, `probabilities` לכל האפשרויות (בסכום של 1) ומידת ביטחון `confidence`. אם הרשימה עשויה לא לכסות את כל המקרים, הוסיפו «אחר» או «אף אחת מהאפשרויות».\n2. **Score — דירוג בסולם.** מקום בסולם מסודר שאתם מתארים: חומרת שגיאה, מידת הרוגז של הלקוח, רמת מיומנות. בין 2 ל־10 רמות, מהנמוכה לגבוהה; המודל מעריך כל רמה בנפרד, בלי לראות את מספרה ואת שכנותיה. התשובה כוללת `score` (סכום מספרי הרמות כפול הסתברויותיהן, ולכן הערך עשוי להיות בין הרמות), `legend` עם תיאורי הרמות, `probabilities` ו־`confidence`.\n3. **Noul — כן או לא.** האם הטענה נכונה. התשובה `noul` היא הסתברות ל«כן» בין 0 ל־1: קרוב ל־1 — «כן» בטוח, קרוב ל־0 — «לא» בטוח, קרוב ל־0,5 — המודל מתלבט. אין `confidence` נפרד: מספר אחד מתאר את התשובה בשלמותה. `criteria` אופציונלי מבהיר מה נחשב «כן» ומה «לא».\n\nאיך לבחור: אפשרויות ידועות ללא סדר — choice; דרגות בספקטרום — score; «כן/לא» בלבד, כשההסתברות עצמה חשובה — noul. Noul 0,5 פירושו סיכוי שווה ל«כן» ול«לא», ולא «רמה בינונית»: score מודד דרגה. מבין שני סוגים מתאימים בחרו את זה שהקוד פועל לפיו מיד: choice לתנאים מסועפים, score לסף, noul ל־`if`.\n\nאפשר לשלב סוגים בבקשה אחת. התשובה תמיד מוגבלת לאפשרויות שלכם ואינה תלויה בשאלות אחרות: אפשר להוסיף או להסיר שאלות בלי לשנות את שאר התשובות.\n\n### המצב\n\nהמצב הוא מה שהמודל מעריך: הודעת לקוח, קטע מסמך, רשומה מבסיס נתונים או מצב היישום שלכם.\n\n- **מחרוזת** — כשיש טקסט אחד: הודעה, מאמר, קטע.\n- **אובייקט** — שדות בעלי שם, רשומות קשורות, מצב היישום. TypeSafe ממליצה על אובייקט לרוב הבקשות: לכל חלק יש שם מובן.\n- **מערך** — רצף של הודעות או רשומות.\n\nהכינו אותו כחומרים למומחים: שימו יחד התכתבות, הזמנה וכללי החזרה אם ההחלטה דורשת להשוות ביניהם. שמרו תוכן במצב ושיפוטים בשאלות. אם השאלה עוסקת בחלק אחד של המצב, ציינו בה את הנתיב אליו בגרשיים הפוכים, למשל `ticket.messages[0].text`.\n\n### איך להגדיר שאלות\n\n- **שיפוט מהיר אחד לכל שאלה.** שאלה טובה היא כזו שאדם שמבין בתחום ועם ההקשר הדרוש יענה עליה בשנייה: «האם יש דחיפות בהודעה?». «נתח את ההודעה והחלט מה לעשות» הוא כבר הסקה איטית, וצריך לחלקו לשאלות פשוטות.\n- **כל השאלה ב־`instructions`.** מפתח השאלה, למשל `refund_requested`, דרוש רק לקוד שלכם ואינו מועבר למודל.\n- **כל השאלות לגבי מצב אחד בבקשה אחת.** המודל מעריך אותן במקביל: לפי TypeSafe, שאלות נוספות כמעט אינן מאריכות את זמן התשובה ועלותן רק הטוקנים שלהן. שאלה «ליתר ביטחון» עולה כמעט כלום — הקוד יחליט בעצמו אילו תשובות דרושות.\n- **שיפוט מורכב בחלקים.** במקום «הערך בקשת סטארט־אפ», שאלו בנפרד על גודל השוק, ההיתכנות הטכנית וההבדלים מהמתחרים, וחשבו את התוצאה בקוד עם משקלים. השתנו העדיפויות — שנו את המשקלים, ולא את השאלה.\n- **שאלות תלויות בבקשה שנייה.** תשובות בבקשה אחת אינן משמשות הקשר זו לזו. בקשה שנייה דרושה רק אם אי אפשר להרכיב אותה ללא התשובה הראשונה: צריך לטעון נתונים נוספים או לבחור אפשרויות לשאלה הבאה.\n- **שאלה ארוכה כאובייקט.** `instructions` ו־`criteria` הם בדרך כלל מחרוזות, אך יכולים להיות אובייקט או מערך: השאלה בשדה אחד, והנתונים באחרים. כך נוח להשוות קורות חיים לרשומות בסיס נתונים בשאלה אחת.\n\n### מידת ביטחון\n\nב־choice וב־score, `confidence` בין 0 ל־1 מציג עד כמה ההסתברות מרוכזת בתשובה אחת: 1 — כולה באפשרות אחת, 0 — שווה בכל האפשרויות. ב־score רמה סמוכה מפחיתה את הביטחון פחות מרמה רחוקה. ב־noul מידת הביטחון היא הערך עצמו: ככל שהוא רחוק מ־0,5, כך התשובה נחרצת יותר.\n\nTypeSafe ממליצה על שלושה טווחים:\n\n1. **ביטחון גבוה** — פעלו אוטומטית.\n2. **בינוני** — פעלו בזהירות, למשל בקשו מהמשתמש אישור.\n3. **נמוך** — העבירו את המקרה לאדם, הבהירו את הבקשה או חברו מסלול גיבוי, למשל מודל חזק יותר עם הסקה.\n\nככל שהטעות יקרה יותר, הסף צריך להיות מחמיר יותר: לפעולות בלתי הפיכות — גבוה יותר מאשר לקריאה. התשובה אומרת מה לבחור, ומידת הביטחון אם כדאי לפעול. התאימו את הספים לפי הנתונים שלכם, בהשוואה בין מידת הביטחון לדיוק.\n\n### איך לבנות מערכת סביב Jev\n\nJev מיועד לא לסוכנים שבוחרים בעצמם את השלב הבא ועלולים לסטות בכל סבב, אלא לתוכנות שבהן הקוד מנהל את התהליך והמודל עונה על שאלות משמעות צרות. שמונת שלבי התכנון לפי TypeSafe:\n\n1. כל מה שאפשר לעשות בקוד, עשו בקוד — באופן מהימן ובעלות נמוכה.\n2. במצב — רק מה שהשאלות הנוכחיות צריכות; עובדות עדכניות — מבסיס הידע שלכם, ולא מזיכרון המודל.\n3. מבנה במצב: JSON מקונן, ובשאלה נתיב לשדה הדרוש בגרשיים הפוכים, אם כך יש פחות עמימות.\n4. שאלות צרות ומוגדרות ככל האפשר — לפי TypeSafe, אולי הכלל החשוב ביותר: שאלה רחבה מסתירה כמה שיפוטים מאחורי תשובה אחת.\n5. מבנה בשאלות: השאלה עצמה קצרה; הסברים, דוגמאות וערכים מהבסיס שלכם בשדות סמוכים באובייקט `instructions` או `criteria`, ולא במחרוזת ארוכה אחת.\n6. שאלות עצמאיות רבות למצב אחד בבקשה אחת — יותר תועלת לכל דולר.\n7. הקוד משלב תשובות: באמצעות כללים, סכום משוקלל או כתכונות למודל קלאסי של למידת מכונה.\n8. הסתעפות לפי מידת ביטחון: מקרים לא בטוחים לאדם או למודל עם הסקה.\n\nJev אינו צ'אט או מודל להשלמת קוד אוטומטית, ואי אפשר להחליף בו מודל שפה בסוכן תכנות. אבל סוכן יכול לכתוב עבורכם קוד שקורא ל־Jev במקום שבו צריך תשובה מהירה ומכוילת.\n\n### תחומי שימוש\n\n- **אוטומציה ברקע** — החלטות שמפעילים מיליון פעמים בלי אדם לידן.\n- **זמן אמת** — לפי TypeSafe, רוב הבקשות מבוצעות בתוך כ־100 אלפיות השנייה: מספיק לעיבוד בזמן הפעולה ולממשקים.\n- **נתונים גדולים** — חיפוש במאגרים עצומים, תיוג יומני עבודה של סוכנים, תכונות לחיזוי.\n- **בדיקת מודלים אחרים** — בקשות, חילוץ מידע, הסקה, קריאות לכלים: עקיפת מגבלות, שגיאות ציטוט ומידע מומצא.\n- **חיפוש ודירוג** — רלוונטיות של צמד «שאילתה — מועמד», דירוג מחדש, בחירת הקשר.\n- **הסתעפות לפי כוונה** — מה המשתמש רוצה ואיזה מטפל דרוש: לוגיקה פשוטה, מודל ייעודי או אדם; הנושא, המורכבות והסיכון קובעים לאיזה מודל שפה להעביר את הבקשה.\n- **בדיקות הגנה** — קלט, פלט וקריאות לכלים של מודל שפה: הוראות מוזרקות, הפרות כללים, דליפת נתונים אישיים.\n- **תמיכה** — נושא הפנייה וכוונתה, דחיפות, רוגז, סיכון נטישה, בקשת החזר כספי, תור.\n- **פיקוח על תוכן** — לפי כללי הפלטפורמה שלכם: רעילות, בריונות, ספאם, הונאה, עצות מסוכנות, נתונים אישיים; לפי חומרה ומידת ביטחון — לאפשר, להזהיר, לבדוק או לחסום.\n- **ענפים** — מקרי ביטוח, חקירות פיננסיות ו־KYC, חוזים ופרסום, כרטיסי מוצרים, גיוס עובדים, לקוחות פוטנציאליים, משחקים, סיכונים, חיזוי ביקוש, גרפי ידע, סקירות מדעיות, בדיקות משמעות של קוד ב־CI.\n\n### מאפיינים\n\n- **`jev-latest`** — כינוי לגרסה היציבה האחרונה, כרגע Jev 1.13; הגרסה שהשיבה מופיעה בשדה `model`, למשל `jev-1.13.0`. בגרסה חדשה הכינוי עובר אליה, והתשובות עשויות להשתנות בלי תיקונים מצדכם — עקבו אחר השדה הזה אם הספים הותאמו לגרסה.\n- **הקשר** — 64K טוקנים בכל בקשה: המצב וכל השאלות יחד; המצב עם השאלה הארוכה ביותר עד 32K. המודל קורא את המצב פעם אחת ובודק מולו את כל השאלות במקביל.\n- **קלט** — טקסט בלבד: מחרוזת, אובייקט JSON או מערך טקסטים. תמונות, אודיו ווידאו עדיין אינם נתמכים — המירו אותם לטקסט מראש.\n- **שפה** — שפת האימון העיקרית היא אנגלית, ובה הדיוק כרגע הגבוה ביותר. המודל מקבל שפות אחרות, כולל סינית, יפנית וקוריאנית, אך הדיוק נמוך יותר — בדקו על הנתונים שלכם.\n- **מחירים וחיוב ב־Ailoot API** — התנאים תלויים במתודה שנבחרה ומצוינים בכרטיס שלה.\n- **הגדרה** — Jev אינו עובר אימון נוסף על נתוני הלקוח: החומרים שלכם ב־`state`, וכללי התחום ב־`instructions` וב־`criteria`.\n- **נתונים** — TypeSafe מדווחת ש־Jev אינו מאומן על בקשות ותשובות של לקוחות.\n\n### נקודות חולשה ידועות של Jev 1.13\n\nTypeSafe מפרטת בגלוי את נקודות החולשה של הגרסה הנוכחית ומבטיחה לתקן רבות מהן בגרסאות הבאות. המודל מהיר, מכויל ושופט היטב בעזרת היגיון בריא, אבל:\n\n1. **קורא מילולית.** עונה על השאלה שנכתבה, ולא על המשתמעת: הסתייגויות, שלילות ותנאים מרומזים מובנים מילולית. כתבו תנאי מדויק ומקרי קצה ב־`criteria`; פרשנות בלתי נמנעת חלקו לשתי שאלות מילוליות.\n2. **אינו מחשבון.** ספירת תווים, חזרות ופריטי רשימה אינה מהימנה, והטעות גדלה עם הגודל — ספרו בקוד, עם שאלה לכל מועמד. המודל מבין צבעים ב־hex או ב־RGB פחות טוב משמותיהם. `score` מתאים לסף, אך לא למספר מדויק בין רמות.\n3. **תאריכים וזמן.** איזה תאריך מוקדם יותר, מה המרווח ביניהם, האם תאריך נכלל בתקופה — לא מהימן, במיוחד בפורמטים מעורבים ובתאריכים יחסיים. חלצו חלקי תאריך באמצעות choice (עם אפשרות «לא צוין»), והשוו בקוד.\n4. **ניסוח עקיף.** שלילות כפולות ושאלות על תכונה של תכונה מפחיתות את הדיוק. כתבו ישירות וציינו חלקי מצב בשמם.\n5. **תוכן עודף במצב.** טקסט זר מפחית את הדיוק. סננו בקוד, ואם אי אפשר — הסירו תוכן לא רלוונטי בשאלות noul.\n6. **טקסט עוין.** כברירת מחדל המודל אינו מצפה למלכודות במצב: הוראה מוזרקת או טקסט שמתווכח על סיווגו שלו יכולים להזיז את התשובה. כתבו קריטריונים מדויקים ובדקו מקרי גבול לפני ההפעלה.\n7. **סתירות.** אם `instructions` ו־`criteria` מבקשים דברים שונים — למשל ב־noul «כן» מתואר כ«לא» — הדיוק יורד. הקריטריונים הם המשך השאלה.\n8. **סדר האפשרויות.** לפעמים המודל נוטה לאפשרות הראשונה ב־choice. שנו את הסדר ובדקו שהתשובה אינה משתנה.\n9. **יצירה.** Jev לא אומן לכתוב טקסט. לחילוץ נתונים מצאו מועמדים בביטוי רגולרי או במודל יוצר, ותנו ל־Jev לבחור את הנכון באמצעות choice.",
    "alias_of": null,
    "aliases": [],
    "author": "TypeSafe",
    "ctx": 64000,
    "formats": [
      "systemone"
    ],
    "guide": "/docs/api/systemone/",
    "id": "jev-latest",
    "input": [
      "text"
    ],
    "kind": "decision",
    "max_out": null,
    "methods": [
      {
        "cache_read": null,
        "cache_write": null,
        "cache_write_1h": null,
        "cache_write_5m": null,
        "conditional_meter": null,
        "contract": {
          "data": {
            "all_results": "Retain every answer by its supplied question ID, probability and legend; confidenceformulausingnrequiresn>1withoutassertinganAPIminchoicesrule.",
            "errors": [
              {
                "code": null,
                "condition": "שדות נדרשים, ייצוג חומר או ערך פרמטר שאינם תקינים",
                "http_status": 400,
                "recovery": "תקנו את השדות שצוינו לפני בקשת יצירה חדשה.",
                "type": "invalid_request_error"
              }
            ],
            "hints": [],
            "ignored_fields": [],
            "lifecycle": {
              "mode": "exact retained published method"
            },
            "material_combinations": [
              {
                "mode": "noul",
                "required": [
                  "state",
                  "questions.<id>.type=noul"
                ]
              },
              {
                "mode": "choice",
                "required": [
                  "state",
                  "questions.<id>.type=choice",
                  "criteria object"
                ]
              },
              {
                "mode": "score",
                "required": [
                  "state",
                  "questions.<id>.type=score",
                  "nonemptycriteriaarray"
                ]
              }
            ],
            "operation_modes": [
              "noul",
              "choice",
              "score"
            ],
            "outputs": {
              "all_results": "יש לשמור כל תשובה לפי מזהה השאלה שסופק לה, ההסתברות והמקרא; נוסחת הביטחון המשתמשת ב־n דורשת n>1, בלי לקבוע כלל API למספר מזערי של אפשרויות.",
              "family": "structured",
              "fields": [
                {
                  "description": null,
                  "name": "answers.<id>.type",
                  "type": "string"
                },
                {
                  "description": null,
                  "name": "answers.<id>.noul",
                  "type": "number"
                },
                {
                  "description": null,
                  "name": "answers.<id>.choice",
                  "type": "string"
                },
                {
                  "description": null,
                  "name": "answers.<id>.score",
                  "type": "number"
                },
                {
                  "description": null,
                  "name": "answers.<id>.confidence",
                  "type": "number"
                },
                {
                  "description": null,
                  "name": "answers.<id>.probabilities",
                  "type": "object"
                },
                {
                  "description": null,
                  "name": "answers.<id>.legend",
                  "type": "object"
                },
                {
                  "description": null,
                  "name": "usage",
                  "type": "object"
                }
              ],
              "format": "json"
            },
            "parameters": [
              {
                "availability": "source_interface",
                "default": null,
                "default_known": false,
                "enum": [
                  "jev-latest"
                ],
                "enum_known": true,
                "name": "model",
                "required": true,
                "type": "string"
              },
              {
                "availability": "source_interface",
                "default": null,
                "default_known": false,
                "enum": null,
                "enum_known": false,
                "name": "state",
                "required": true,
                "type": "string|object|array"
              },
              {
                "availability": "source_interface",
                "default": null,
                "default_known": false,
                "enum": null,
                "enum_known": false,
                "min_properties": 1,
                "name": "questions",
                "required": true,
                "type": "object"
              },
              {
                "availability": "source_interface",
                "default": null,
                "default_known": false,
                "enum": [
                  "noul",
                  "choice",
                  "score"
                ],
                "enum_known": true,
                "name": "questions.<id>.type",
                "required": true,
                "type": "string"
              },
              {
                "availability": "source_interface",
                "default": null,
                "default_known": false,
                "enum": null,
                "enum_known": false,
                "name": "questions.<id>.instructions",
                "required": false,
                "type": "string|object|array|null"
              },
              {
                "availability": "source_interface",
                "conditions": "noul: תיאורי true/false אופציונליים שיכולים להיות null; choice: אובייקט קריטריונים; score: מערך קריטריונים לא ריק",
                "default": null,
                "default_known": false,
                "enum": null,
                "enum_known": false,
                "name": "questions.<id>.criteria",
                "required": false,
                "type": "object|array|null"
              },
              {
                "availability": "source_interface",
                "default": null,
                "default_known": false,
                "enum": [
                  false,
                  null
                ],
                "enum_known": true,
                "name": "stream",
                "required": false,
                "type": "boolean|null"
              }
            ],
            "profile_binding": "Exact existing Ailoot model and method; interface constraints below do not assert provider qualification.",
            "unsupported": [
              "stream=true",
              "duplicateandcase-variedcanonicalkeys"
            ]
          },
          "hints": [
            "מבני המתודות והמזהים מדויקים; יכולת הספק נפרדת מקבלת הבקשה לביצוע."
          ],
          "input": {
            "content_type": "application/json",
            "material_types": [
              "text"
            ],
            "optional_controls": null,
            "required": [
              "model",
              "state",
              "questions"
            ]
          },
          "lifecycle": {
            "mode": "exact retained published method"
          },
          "method": {
            "http": "POST",
            "path": "/v1/systemone"
          },
          "operation_modes": [
            "systemone"
          ],
          "output": {
            "family": [
              "structured"
            ],
            "format": "structured decisions JSON",
            "multioutputs": "retain every actual response output"
          }
        },
        "ctx": 64000,
        "examples": [
          {
            "code": "set -eu\n: \"${AILOOT_API_KEY:?Set your Ailoot API key}\"\n: \"${AILOOT_TEXT_FILE:?Set your actual UTF-8 customer message}\"\nexport AILOOT_TEXT_FILE\npython3 - <<'PY_REQUEST'\nimport json,os\nfrom pathlib import Path\np=json.loads('{\"model\": \"jev-latest\", \"state\": \"\", \"questions\": {\"is_urgent\": {\"type\": \"noul\", \"instructions\": \"Does the supplied customer message express urgency?\"}}}')\nf=Path(os.environ[\"AILOOT_TEXT_FILE\"])\nif not f.is_file():raise SystemExit(\"Choose your actual UTF-8 source material\")\ntext=f.read_text(encoding=\"utf-8\")\nif not text.strip():raise SystemExit(\"Source material must contain text\")\np[\"state\"]=text\nPath(\"request.json\").write_text(json.dumps(p,ensure_ascii=False))\nPY_REQUEST\ncurl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/systemone \\\n  -H \"Authorization: Bearer $AILOOT_API_KEY\" -H 'Content-Type: application/json' \\\n  --data-binary @request.json -D response-headers.txt -o result.json\npython3 - <<'PY_RESULT'\nimport json\nfrom pathlib import Path\nprint(json.dumps(json.loads(Path(\"result.json\").read_text()),ensure_ascii=False,indent=2))\nPY_RESULT\n",
            "label": "Classify your actual customer message",
            "language": "bash"
          }
        ],
        "family": "systemone",
        "fast_multiplier": null,
        "flex_multiplier": null,
        "fmt": "systemone",
        "http": "POST",
        "img_in": null,
        "img_out": null,
        "in": 0.084,
        "input": [
          "text"
        ],
        "label": "System One",
        "max_out": 0,
        "max_tool_calls": null,
        "out": 0,
        "output": [
          "structured"
        ],
        "path": "/v1/systemone",
        "pricing_profiles": [
          {
            "dimensions": {},
            "label": "Core",
            "units": [
              {
                "amount": 0.084,
                "amount_unit": "usd_per_million_tokens",
                "key": "in",
                "label": "Input",
                "side": "in"
              },
              {
                "amount": 0,
                "amount_unit": "usd_per_million_tokens",
                "key": "out",
                "label": "Output",
                "side": "out"
              }
            ]
          }
        ],
        "request_model_id": "jev-latest",
        "route_label": "Core",
        "status_reads": [],
        "tiers": [],
        "tool_prices": null,
        "unit": "token",
        "units": []
      }
    ],
    "model_aliases": [
      {
        "canonical_model_id": "jev-latest",
        "request_model_id": "jev-latest",
        "route_label": "Core"
      }
    ],
    "name": "jev-latest",
    "price": {
      "in": 0.084,
      "in_label": null,
      "out": 0,
      "out_label": null,
      "sort_in": 0.084,
      "sort_out": 0,
      "varies": false
    },
    "short": "מודל החלטות של TypeSafe: אינו כותב טקסט, אלא עונה על שאלות מוגדרות טיפוס לגבי טקסט או JSON — בחירת אפשרות, דירוג בסולם או «כן/לא» עם הסתברויות. מתאים לניתוב, למיון פניות, לפיקוח על תוכן ולניקוד; כל השאלות בבקשה אחת מוערכות במקביל."
  },
  "renderer_schema": {
    "method_order": "Original DTO methods order; every exact route/format/path/caller survives.",
    "prices": "Original public DTO fields and original native display HTML; no flattened or normalized offers."
  },
  "representation": "exact-public-dto-and-native-renderer-html",
  "representationNotes": {
    "current_reference": {
      "about_json_pointer": "/aboutHtml",
      "methods": [
        {
          "contract_json_pointer": "/methods/0/rawMethod/contract",
          "html_json_pointer": "/methods/0/html",
          "method_ordinal": 0
        }
      ],
      "role": "current-semantic-reference"
    },
    "raw_input": {
      "examples_role": "historical-input-not-current-ready-examples",
      "json_pointers": [
        "/rawModel",
        "/methods/0/rawMethod"
      ],
      "role": "historical-owner-input"
    },
    "schema": "ailoot-native-model-representations-v1"
  },
  "schema": "ailoot-static-model-facts-v1",
  "schema_version": 1,
  "shortText": "מודל החלטות של TypeSafe: אינו כותב טקסט, אלא עונה על שאלות מוגדרות טיפוס לגבי טקסט או JSON — בחירת אפשרות, דירוג בסולם או «כן/לא» עם הסתברויות. מתאים לניתוב, למיון פניות, לפיקוח על תוכן ולניקוד; כל השאלות בבקשה אחת מוערכות במקביל.",
  "source": {
    "audit_sha256": "2e00086bcbfc28e64d0cebe97aa47c17d8d5618963027f8ffb9dc6123d7d25b1",
    "bridge_map_sha256": "1125275768b9636fc8461bc7da5061239a81ddfe508e2557843ca42c58ab0036",
    "raw_model_json_sha256": "f8039fde9cbe08951c1788d0d34acd885feaf25c31ebbad4710c3f0f1c8a4c86",
    "renderer_sha256": "c36bd89b8b0dac234af52bf68530df83530b908ec7a9f2e1de2483fe236ae910"
  },
  "sourceRevision": "54ad9a138388d20d5d833ea23b2ce124d8eba7e331f2f27337394ec769dd026d"
}