Jev: подробное объяснение

Мы использовали LLM как молоток для решения любой задачи в области ИИ, даже для простых решений. Jev справляется с этими задачами за миллисекунды и при этом стоит значительно дешевле. Давайте разберемся, как это работает и где его место.

Компания TypeSafe AI выпустила Jev 15 сентября 2026 года, и реакция была необычно сильной для модели, которая не может вести беседу, писать код или генерировать хотя бы один полезный абзац текста.

Ну, именно в этом ограничении и заключается суть.

Большинству программ не нужен еще один чат-бот. Им нужно принимать тысячи мелких решений, например: Этот тикет срочный? Какая модель должна обработать этот запрос? Опасна ли эта команда shell? Отвечает ли найденный фрагмент на вопрос?

Часто команды отправляют каждое такое решение общей LLM. Модель генерирует ответ по одному токену, приложение парсит его, валидирует и повторяет попытку, если формат неверен. Это работает, но медленно и дорого для решения с пятью возможными вариантами ответа.

Jev создан специально для таких задач. В TypeSafe называют его «Моделью Системы 1» (System One model): на вход подается неструктурированное состояние, а на выходе — типизированные ответы и вероятности.

Давайте разберем, что это значит, где это применимо и где маркетингу стоит проявить сдержанность.

Сначала о проблеме, которую решает Jev

LLM стало гораздо проще интегрировать в ПО после появления вызова инструментов (tool calling) и структурированного вывода.

Вызов инструментов позволяет модели запрашивать функцию в предсказуемом формате. Структурированный вывод позволяет ей возвращать JSON, соответствующий схеме. Оба этих механизма устранили необходимость в большом количестве хрупкого кода для парсинга.

Но базовая модель все еще является генеративной. Даже когда ответом является всего одно слово «billing», она производит токены последовательно. Вы платите за ввод, ждете генерации и часто платите больше за вывод.

Теперь представьте это внутри цикла агента.

1while not done:
2    action = llm(context)
3    result = run_tool(action)
4    context += result

Модель может вызываться снова и снова для выбора инструмента, оценки результата, обнаружения рисков, определения завершения задачи и выбора следующей модели. Один цикл работы агента может содержать множество вызовов, требующих принятия решений, но не генерации прозы.

Jev ориентирован именно на такие вызовы.

Его ставка проста: языковая генерация — неправильный интерфейс, когда код уже знает возможные ответы.

Что такое Jev на самом деле

Краткое и точное описание: это движок семантических решений.

Вы отправляете Jev две вещи:

• Состояние: текст или JSON, описывающий текущую ситуацию.
• Вопросы: решения, которые вы хотите от него получить относительно этого состояния.

Каждый вопрос заранее объявляет форму своего ответа. Jev поддерживает три примитива:

• Choice выбирает один вариант из списка, который вы определяете, и возвращает вероятность для каждого варианта.
• Score помещает входные данные на упорядоченную шкалу, которую вы определяете, например: низкий, средний, высокий.
• Noul отвечает на вопрос «да/нет», возвращая вероятность того, что утверждение верно.

Noul — это название TypeSafe для булева примитива. Необычное имя менее важно, чем результат (число от 0 до 1, с которым ваш код может работать).

1{
2  "model": "jev-latest",
3  "state": "The deploy failed twice and customers are seeing 500s.",
4  "questions": {
5    "urgent": {
6      "type": "noul",
7      "instructions": "Does this need attention right now?"
8    },
9    "owner": {
10      "type": "choice",
11      "instructions": "Which team should handle this?",
12      "criteria": {
13        "engineering": "Product failures and outages",
14        "billing": "Charges, invoices, and refunds",
15        "sales": "Pricing and new accounts"
16      }
17    }
18  }
19}

Ответ содержит вероятность срочности и распределение вероятностей между тремя командами. Нет никакого абзаца для интерпретации и нет четвертой команды, которую модель могла бы придумать.

Ваша программа сохраняет контроль:

1if urgent > 0.9 and owner == "engineering":
2    page_on_call()
3elif confidence < 0.6:
4    send_to_human_review()
5else:
6    add_to_queue(owner)

Именно поэтому люди продолжают называть Jev «умным оператором switch». Эта фраза звучит пренебрежительно, но она улавливает полезную часть дизайна. Обычный код владеет ветвлениями. Модель предоставляет нечеткое суждение, которое обычный код не может рассчитать надежно.

Важное отличие от LLM

Традиционная LLM и Jev могут классифицировать тикет поддержки. Они приходят к ответу по-разному и полезны в разных частях системы.

TypeSafe утверждает, что Jev оценивает каждый вопрос в запросе параллельно. Это меняет подход к проектированию рабочего процесса. Вместо того чтобы задавать один вопрос, ждать и решать, какой вопрос задать следующим, вы можете задать все независимые вопросы об одном и том же состоянии в одном запросе и позволить коду использовать нужные ему ответы.

Компания сообщает о сквозной задержке от 70 до 500 миллисекунд и цене $0.042 за миллион входных токенов, при этом вывод бесплатен. Их рекламные заявления достигают примерно 200-кратного ускорения и 400-кратного удешевления по сравнению с аналогичными рабочими процессами на базе LLM.

Эти большие множители получены из собственных оценок рабочих процессов TypeSafe и находятся на благоприятном конце сравнения. Воспринимайте их как потолок, а не как гарантию для каждого приложения. Базовое преимущество остается убедительным: Jev избегает длинных цепочек рассуждений и генерации вывода, потому что он разработан для ограниченных решений.

Почему важны вероятности

Типизированный ответ решает только половину проблемы.

Предположим, Jev направляет тикет в отдел биллинга. Выбранная метка говорит вам, кто победил. Распределение вероятностей говорит вам, насколько близкой была гонка.

1{
2  "choice": "billing",
3  "probabilities": {
4    "billing": 0.52,
5    "technical": 0.46,
6    "sales": 0.02
7  },
8  "confidence": 0.18
9}

Автоматическая маршрутизация такого тикета была бы безрассудной. Биллинг победил, но едва-едва. Ответ с низкой уверенностью должен запустить другую ветку.

Это дает разработчикам практический паттерн:

• Высокая уверенность: действуйте автоматически, если последствия незначительны.
• Средняя уверенность: запросите подтверждение или вызовите более мощную модель.
• Низкая уверенность: передайте случай человеку или соберите больше информации.

Пороговые значения должны находиться в коде, где их можно просматривать и изменять. Метка на дашборде может терпеть слабый прогноз. Команда, удаляющая данные, должна требовать гораздо более высокого порога.

TypeSafe обучает Jev с помощью Reinforcement Learning for Calibrated Decisions (RLCD). Цель состоит в том, чтобы уверенность отражала точность во многих предсказаниях. Если модель присваивает набору ответов вероятность 90 процентов, примерно 90 процентов этих ответов должны быть правильными.

Заявление об отсутствии галлюцинаций требует точности

TypeSafe утверждает, что Jev не может галлюцинировать. Это утверждение верно только при узком определении.

Jev не может вернуть опцию вне схемы. Если вы определили billing, technical и sales, ответ не может изобрести legal. Он также не может производить некорректную прозу там, где ваш код ожидал метку.

Но он может уверенно выбрать неправильную, но валидную опцию.

Строгая типизация предотвращает невалидные форматы. Она не гарантирует правильное суждение. Это различие важно, потому что ошибка, прошедшая проверку схемы, все равно может привести к возврату средств не тому клиенту, неверной маршрутизации инцидента или одобрению опасной команды.

Более безопасная формулировка: «Jev не может нарушить объявленную схему вывода, но он все еще может ошибаться».

Где Jev вписывается в архитектуру агента

Jev лучше всего работает, когда используется вместе с LLM, а не вместо нее.

LLM выполняет работу, требующую языка или более глубоких рассуждений. Она планирует, пишет, объясняет и использует инструменты. Jev обрабатывает частые решения вокруг этой работы.

Три места применения особенно привлекательны.

Маршрутизация моделей

Простой поиск не требует той же модели, что и архитектурный обзор. Jev может оценить запрос и выбрать наименее дорогую модель, способную его выполнить.

1route = jev.choice(
2    state=user_request,
3    options={
4        "fast": "Lookups, extraction, and small local edits",
5        "powerful": "Architecture, ambiguity, and high-stakes work",
6    },
7)
8
9model = fast_model if route == "fast" else powerful_model

Роутер не отвечает на запрос. Он решает, какая модель должна это сделать.

Контроль рисков инструментов

Перед тем как агент выполнит команду shell, Jev может классифицировать ее как read-only, обратимую или разрушительную. Отдельные вопросы могут проверить, удаляет ли она файлы, изменяет историю Git, затрагивает ли production или покидает репозиторий.

Действия read-only с высокой уверенностью могут продолжаться. Разрушительные или неопределенные действия могут приостанавливаться для человеческого одобрения. Интеграция Jev с LangChain применяет этот паттерн через middleware, который проверяет вызов инструмента перед исполнением.

Верификация и надзор

Агент может заявить, что задача выполнена, пока тесты все еще падают. Jev может изучить состояние и ответить на ограниченные вопросы: Прошли ли тесты? Повторяет ли агент одно и то же действие? Соответствует ли вывод политике? Нужно ли пересмотреть этот результат?

Он не заменит жесткий тест, если таковой существует. Он добавляет семантическую проверку там, где правило зависит от смысла.

Задачи, которые Jev может решить сегодня

Лучшие варианты использования обладают тремя свойствами. Вы можете назвать возможные ответы, внимательный человек может быстро оценить входные данные, и решение принимается достаточно часто, чтобы задержка или стоимость имели значение.

Поддержка и операции

• Классификация намерений, срочности, отдела, спама и разочарования клиента.
• Маршрутизация возвратов средств и исключений политики через несколько небольших проверок.
• Ранжирование логов и инцидентов по семантической серьезности до того, как их прочитает человек.

Один запрос может задать все эти вопросы об одном и том же тикете. Затем код комбинирует ответы в фактическую политику маршрутизации компании.

Поиск и retrieval

• Переранжирование найденных фрагментов по степени их соответствия запросу.
• Проверка, поддерживает ли цитата утверждение.
• Фильтрация нерелевантных чанков перед отправкой контекста дорогой LLM.

Embeddings отлично находят семантически связанные тексты. Jev может принять более узкое решение о том, полезен ли конкретный фрагмент для данного вопроса.

Качество и безопасность

• Экранирование промптов на предмет jailbreaks или prompt injection.
• Проверка сгенерированного контента на соответствие политике или критериям.
• Флаг рискованных изменений кода или вызовов инструментов перед их исполнением.

Эти проверки должны располагаться рядом с детерминированными контролями. Семантический классификатор полезен для нечетких рисков, тогда как разрешения, песочницы и тесты обеспечивают правила, которые ПО может проверить точно.

Классификация больших объемов данных

• Маркировка документов, научных статей, списков товаров или сообщений клиентов.
• Преобразование свободного текста в признаки для традиционной модели машинного обучения.
• Оценка каждого элемента большого корпуса против одних и тех же критериев.

Здесь низкая стоимость одного вызова становится чем-то большим, чем просто цифрой бенчмарка. Решение, которое было слишком дорогим для запуска по каждой строке, может перейти в обычный конвейер данных.

Интерфейсы реального времени

• Выбор следующего действия браузера из известных элементов страницы.
• Оценка тональности или ясности во время написания человеком.
• Выбор действия из структурированного состояния игры или симулятора.

На данный момент Jev работает только с текстом, поэтому эти системы должны сначала преобразовать окружение в текст или JSON. Он не смотрит на экран и не играет по пикселям.

Где Jev — неправильный выбор

Полезность Jev снижается, как только пространство ответов перестает быть известным.

• Он не может написать ответ, резюмировать документ, сгенерировать код или объяснить свои рассуждения.
• Он ненадежен для арифметики, подсчета, сравнения дат или точной манипуляции со строками. Оставьте эти операции в коде.
• Он испытывает трудности, когда решение требует нескольких скрытых шагов рассуждения. Разбейте суждение на меньшие вопросы или используйте reasoning model.
• Он не может напрямую извлечь неизвестное значение. Сначала найдите кандидаты, затем позвольте Jev выбрать среди них.
• Нерелевантный контекст может снизить точность. Отправляйте только то состояние, которое необходимо для решения.
• Закрытые веса, ранний доступ, только текстовый ввод и ограниченные независимые данные калибровки делают слепое доверие преждевременным.

Есть также более простое правило: если детерминированный код уже правильно решает проблему, оставьте код. Обычный оператор if быстрее, дешевле и легче тестируется, чем любая модель.

Как использовать Jev, не создавая новый режим отказа

Дешевая модель может остаться дорогой, если ее ошибки создают повторные попытки, ручной просмотр или инциденты в production. Измеряйте весь рабочий процесс, а не цену за токен.

Разумное развертывание выглядит так:

1. Выберите одно ограниченное, низкорисковое решение с четкими возможными ответами.
2. Напишите критерии оценки до вызова модели. Определите, что относится к каждому варианту.
3. Соберите репрезентативные примеры с ожидаемыми ответами, включая неоднозначные и враждебные случаи.
4. Запустите Jev в теневом режиме рядом с текущим рабочим процессом, не позволяя ему менять поведение.
5. Постройте график зависимости точности от уверенности и установите пороговые значения на основе ваших данных.
6. Автоматизируйте самую безопасную ветку первой и оставьте человека или более мощную модель для неопределенных случаев.
7. Закрепите или логируйте версию модели, вопросы, критерии и пороги, чтобы изменения можно было воспроизвести на том же наборе для оценки.

Вопросы являются частью программы. Относитесь к ним как к коду: версионируйте их, проводите ревью и тестируйте всякий раз, когда меняется модель или критерии.

Фактический сдвиг

Jev интересен не потому, что побеждает LLM в написании текстов. Он отказывается писать.

Его вклад — это интерфейс модели, оформленный как ПО: фиксированные типы ответов, явная неопределенность, параллельные вопросы и ветвление, контролируемое кодом.

Это делает его полезным компаньоном для генеративных моделей. LLM создает план, объяснение или код. Jev маршрутизирует запрос, блокирует рискованное действие, проверяет результат и решает, когда неопределенность достаточно высока для эскалации.

Более широкая идея важна, даже если другая модель в конечном итоге заменит Jev. Мы потратили годы, заставляя генеративные модели выполнять все виды интеллекта через текст. Многим производственным системам не нужно больше слов. Им нужно небольшое, быстрое суждение, которое обычное ПО может безопасно использовать.

Это категория, которую Jev пытается создать.

С чего начать

Не начинайте с перестройки вашего агента вокруг Jev. Найдите одно решение, которое сейчас требует медленного вызова LLM или регулярного выражения, которое постоянно ломается.

Дайте Jev минимальное состояние, определите возможные ответы и логируйте его вероятности рядом с текущим результатом. Позвольте ему доказать, что он заслуживает одной ветки, прежде чем вы отдадите ему весь рабочий процесс.

Наиболее полезная ментальная модель остается самой простой → Jev добавляет суждение там, где обычный оператор if понимает значения, но не их смысл.

Источники и дополнительная литература

• TypeSafe AI: Представление моделей System One и Jev
• LangChain: Создание харнеса с Jev
• Flavio Copes: Глубокое погружение в Jev

Надеюсь, вам понравилось читать.

Увидимся в следующем выпуске.

До встречи! :)