Jev de TypeSafe : des décisions typées plus rapides et moins chères que les appels LLM classiques

Voir la vidéo complète sur Jev

Le problème caché derrière les appels LLM

On utilise souvent un grand modèle de langage pour prendre une décision simple : sélectionner une option, attribuer un score, classer un contenu ou vérifier une condition.

Le workflow ressemble généralement à ça :

1. Construire un prompt.
2. Envoyer le contexte au modèle.
3. Demander une réponse JSON.
4. Parser le résultat.
5. Vérifier le schéma.
6. Relancer l’appel si la réponse est invalide.

Ça fonctionne, mais c’est parfois une machine énorme pour résoudre un petit problème.

Si tu veux seulement choisir une villa parmi cinq résultats déjà filtrés, tu n’as pas forcément besoin de demander au modèle de rédiger trois paragraphes avant de récupérer un identifiant. Si tu veux évaluer quatorze critères éditoriaux, tu ne veux pas non plus gérer quatorze appels indépendants et quatorze formats de réponse potentiellement différents.

C’est précisément le terrain sur lequel Jev se positionne.

Jev, c’est quoi exactement ?

Jev est créé par TypeSafe. Parmi les personnes associées au projet, on retrouve Diogo Almeida, ancien chercheur chez OpenAI et co-auteur du papier InstructGPT.

Le principe est simple :

• tu fournis un state, sous forme de texte ou de JSON ;
• tu poses une ou plusieurs questions typées ;
• Jev retourne des valeurs conformes au schéma demandé ;
• les réponses sont accompagnées de probabilités.

Les types de questions présentés incluent notamment Choice, Noul et Score.

Jev n’est donc pas présenté comme un chatbot supplémentaire. Il cible les moments où une application doit transformer un contexte en jugements bornés et exploitables directement par le code.

Une représentation simplifiée

Voici la forme conceptuelle d’une requête. Ce JSON illustre le modèle mental, pas la signature exacte d’un SDK :

{
  "state": {
    "request": "Villa calme pour six personnes, proche de la plage",
    "availableVillas": [
      { "id": "villa-12", "capacity": 6, "distanceToBeachKm": 0.4 },
      { "id": "villa-27", "capacity": 8, "distanceToBeachKm": 1.1 }
    ]
  },
  "questions": [
    {
      "id": "bestVilla",
      "type": "Choice",
      "options": ["villa-12", "villa-27"]
    },
    {
      "id": "requestFit",
      "type": "Score",
      "min": 0,
      "max": 10
    }
  ]
}

La réponse attendue peut ensuite être consommée comme une donnée applicative :

{
  "bestVilla": {
    "value": "villa-12",
    "probabilities": {
      "villa-12": 0.84,
      "villa-27": 0.16
    }
  },
  "requestFit": {
    "value": 9,
    "probabilities": {
      "8": 0.18,
      "9": 0.67,
      "10": 0.15
    }
  }
}

L’intérêt ne réside pas seulement dans la valeur finale. Les probabilités permettent aussi de définir des règles de contrôle. Si les deux premières options sont presque à égalité, l’application peut demander une validation humaine au lieu de présenter le résultat comme certain.

Ce que Jev change dans une architecture IA

La bonne question n’est pas : « Est-ce que Jev remplace les LLM ? »

La bonne question est : « Quelle partie du workflow a vraiment besoin de génération libre ? »

Cette séparation est importante.

Le code doit conserver les faits exacts : prix, disponibilité, capacité, permissions ou limites contractuelles. Jev intervient sur les jugements bornés : meilleure option, adéquation, catégorie ou score. Le LLM reste utile lorsqu’il faut produire du langage. L’humain reprend la main quand l’erreur peut avoir des conséquences importantes.

Trois cas d’usage concrets chez Mike

VillaSlot : choisir parmi des villas déjà filtrées

Dans VillaSlot, le code commence par appliquer les contraintes objectives. Il peut retirer les villas indisponibles, trop petites ou hors budget.

Jev ne remplace pas cette logique. Il reçoit la liste déjà filtrée et choisit parmi les options restantes selon la demande du voyageur.

C’est une distinction essentielle :

• le code établit les candidats valides ;
• Jev évalue leur adéquation ;
• l’application utilise le résultat ou demande une confirmation.

On évite ainsi de confier à un système probabiliste une vérification que le code peut effectuer exactement.

YouThumb : décider après une analyse visuelle

Pour YouThumb, une première étape analyse l’image. Le résultat de cette analyse devient ensuite le state transmis au moteur de décision.

Jev peut alors répondre à des questions bornées : quelle variante correspond le mieux à l’objectif, quel niveau de lisibilité est observé ou quelle option mérite d’être retenue.

La vision extrait le contexte. Jev structure le jugement. Le code orchestre le workflow.

AgentsMail : quatorze questions en un appel

Dans AgentsMail, Jev sert à effectuer une analyse éditoriale avec quatorze questions réunies dans un seul appel.

L’objectif n’est pas de prédire le comportement de Gmail. Il s’agit d’évaluer le contenu selon une grille définie : clarté, force de l’objet, cohérence, qualité du CTA ou autres critères éditoriaux.

Regrouper les questions permet d’obtenir une sortie structurée pour toute la grille sans construire une chaîne de quatorze appels indépendants.

Les promesses de performance

TypeSafe annonce, sur ses propres workflows, des performances allant jusqu’à :

• 193,6 fois plus rapides ;
• 444,6 fois moins chères.

Ces chiffres sont impressionnants, mais il faut les présenter correctement. Ce sont des chiffres fournisseur mesurés sur les workflows de TypeSafe, pas des benchmarks indépendants couvrant tous les modèles, toutes les charges et tous les cas d’usage.

Le gain réel dépendra notamment :

• du modèle que tu utilises aujourd’hui ;
• de la taille du state ;
• du nombre de questions ;
• de la fréquence des appels ;
• du niveau de génération que tu retires réellement du workflow.

La bonne méthode consiste à tester Jev sur une tâche précise, avec ton propre volume, puis à comparer latence, coût et qualité opérationnelle.

La garantie à ne pas mal comprendre

Jev garantit le respect du schéma. Il ne garantit pas la justesse sémantique de chaque réponse.

Cette différence change tout.

Une valeur peut être parfaitement valide techniquement tout en étant discutable sur le fond. Un choix peut appartenir à la liste autorisée et rester mauvais. Un score peut être compris dans l’intervalle demandé sans refléter correctement la situation.

Les probabilités ne sont pas non plus une preuve de vérité. Elles servent à mesurer et exploiter l’incertitude du système.

Il faut donc prévoir :

1. des états propres et suffisamment explicites ;
2. des options bien définies ;
3. des seuils de confiance ;
4. des jeux de tests proches de la production ;
5. une validation humaine pour les décisions sensibles.

Quand utiliser Jev

Jev devient particulièrement intéressant quand la sortie possible est connue à l’avance :

• choisir une option dans une liste ;
• noter un élément sur une échelle bornée ;
• appliquer une grille d’évaluation ;
• router une demande vers une catégorie ;
• comparer plusieurs candidats déjà validés par le code ;
• regrouper plusieurs jugements structurés dans un même appel.

En revanche, si tu veux écrire un article, expliquer un concept ou mener une conversation ouverte, un LLM génératif reste plus adapté.

Une méthode simple pour l’intégrer

Commence petit :

1. Identifie un appel LLM dont la sortie est déjà très contrainte.
2. Retire du state toutes les données inutiles.
3. Déplace les règles exactes vers du code déterministe.
4. Définis les questions et leurs types.
5. Enregistre valeurs, probabilités, latence et coût.
6. Compare les résultats sur des cas réels.
7. Ajoute une validation humaine lorsque le niveau de confiance est insuffisant.

Ne migre pas toute ton architecture sur la base d’une promesse marketing. Choisis un workflow, mesure, puis élargis si le résultat tient en production.

Conclusion

Jev apporte une réponse intéressante à un problème fréquent : nous utilisons parfois des LLM généralistes pour produire des décisions minuscules, très contraintes et coûteuses à parser.

Son positionnement est clair. Le code garde les faits. Jev produit des jugements bornés. Le LLM génère le contenu. L’humain conserve les décisions sensibles.

La promesse de vitesse et de coût mérite un test sérieux, sans confondre les chiffres de TypeSafe avec des benchmarks indépendants. Et la conformité au schéma ne doit jamais être confondue avec la vérité.

Regarder la démonstration complète de Jev

Pour recevoir chaque semaine des analyses concrètes sur l’IA, les agents et le développement logiciel, rejoins The Agentic Developer.