Jev : l’IA qui ne veut pas discuter avec vous

ChatGPT, Claude ou Gemini sont conçus pour parler, écrire et raisonner. Jev prend une direction assez différente : il ne génère pratiquement rien. On lui présente une situation, il prend une décision. Et pour automatiser des applications, cette nuance peut changer beaucoup de choses.

Quand on parle d’intelligence artificielle aujourd’hui, on pense presque immédiatement aux grands modèles de langage : ChatGPT, Claude, Gemini…

Vous leur donnez une consigne et ils produisent du texte.

Jev, lancé en septembre 2026 par TypeSafe AI, part d’un principe presque opposé : pour automatiser un logiciel, avons-nous réellement besoin de générer des phrases ?

Souvent, non.

Une application veut surtout savoir :

• ce mail concerne-t-il le support, la facturation ou le commercial ?

• cette demande est-elle urgente ?

• ce prospect paraît-il intéressant ?

• quel outil mon agent doit-il utiliser ?

• cette opération semble-t-elle suffisamment sûre pour continuer automatiquement ?

Jev est conçu précisément pour ce genre de décisions.

ChatGPT rédige, Jev choisit

Prenons un exemple très simple.

Vous recevez ce message :

« Bonjour, je viens d'être prélevé deux fois ce mois-ci. Pouvez-vous vérifier rapidement ? »

Un LLM classique peut répondre :

« Ce message semble concerner un problème de facturation. Le client indique avoir été prélevé deux fois et souhaite une vérification rapide. »

C'est parfaitement compréhensible pour un humain.

Mais pour un logiciel, nous aurions préféré quelque chose comme :

Service : facturation
Urgent : oui
Probabilité : 94 %

C'est précisément la philosophie de Jev.

On lui fournit un état — un email, un ticket, un document, un objet JSON, etc. — puis des questions dont les réponses possibles sont définies à l'avance.

Le modèle renvoie alors des décisions structurées accompagnées de probabilités, directement exploitables par du code.

Trois types de décisions

Jev propose notamment trois primitives.

Choice permet de choisir parmi plusieurs possibilités.

Par exemple :

support / commercial / facturation / autre

Score permet d'attribuer une valeur.

Par exemple :

intérêt commercial : 0,82

Enfin, Noul correspond à une décision probabiliste de type oui/non.

Par exemple :

demande urgente : 0,91

Et plusieurs questions peuvent être évaluées lors du même appel.

Voilà une différence importante avec un LLM.

Jev n'a pas besoin de générer :

« Après analyse du message, je considère qu'il s'agit probablement… »

Il répond directement avec quelque chose que l'application peut exploiter.

Alors Jev remplace ChatGPT ?

Pas vraiment.

Ils ne font tout simplement pas le même travail.

Vous voulez rédiger la réponse au client ?

LLM.

Vous voulez déterminer automatiquement vers quel service envoyer son message ?

Jev.

Et c'est probablement en combinant les deux que les choses deviennent intéressantes.

TypeSafe présente d'ailleurs Jev comme une brique destinée à compléter les modèles génératifs plutôt qu'à les remplacer.

Un exemple d'automatisation très concret

Imaginons le formulaire de contact d'un site.

Aujourd'hui, on pourrait envoyer chaque message à ChatGPT avec une instruction du genre :

« Analyse cette demande, indique le service concerné, évalue son urgence et détermine s'il s'agit probablement d'un prospect. Retourne uniquement du JSON. »

Ça fonctionne.

Mais on utilise alors un modèle conçu pour générer du langage afin de produire finalement trois petites valeurs.

Avec Jev, on peut directement poser les trois questions :

Département ?
commercial / technique / facturation / autre

Urgence ?
oui / non

Potentiel commercial ?
score de 0 à 1

Puis le code classique reprend la main :

commercial + score > 0,8 → création du prospect dans le CRM.

technique + urgent → ticket prioritaire.

facturation → envoi au service comptabilité.

confiance trop faible → vérification humaine.

Ce dernier point est particulièrement intéressant : la probabilité fournie par Jev peut devenir elle-même une règle d'automatisation.

Autre exemple : choisir le bon modèle IA

Prenons maintenant un système utilisant plusieurs IA.

Une requête arrive :

« Traduis ce texte en anglais. »

Inutile de lancer un modèle coûteux capable de raisonner longuement.

Une autre demande arrive :

« Analyse ces 25 fichiers et cherche pourquoi cette application génère parfois une double facturation. »

Cette fois, un modèle beaucoup plus puissant peut être nécessaire.

Jev peut servir de routeur :

simple → petit modèle

code → modèle spécialisé

raisonnement complexe → modèle puissant

incertain → modèle supérieur ou validation humaine

On commence alors à construire des systèmes dans lesquels une IA ne réalise pas forcément la tâche : elle décide quelle machine doit la réaliser.

C'est particulièrement intéressant pour les agents et les chaînes d'automatisation.

Pourquoi ne pas simplement utiliser des « if » dans les automati?

Parce qu'un if fonctionne parfaitement lorsque la règle est évidente.

si montant > 1000 €
    demander une validation

Mais beaucoup de décisions humaines sont beaucoup moins faciles à traduire en règles.

Comment écrire proprement :

si ce message ressemble à un client vraiment mécontent

Ou :

si ce prospect semble réellement intéressé

Ou encore :

si cette demande paraît suffisamment complexe pour nécessiter un meilleur modèle

C'est précisément l'espace que Jev cherche à occuper : entre la règle informatique totalement déterministe et le gros modèle génératif.

TypeSafe résume cette idée comme l'ajout de jugement aux endroits où des règles rigides commencent à devenir difficiles à écrire.

Rapide et surtout très peu coûteux

Cette spécialisation permet aussi à Jev d'être léger.

TypeSafe annonce actuellement un tarif de 0,042 dollar par million de tokens en entrée, les sorties n'étant pas facturées, ainsi qu'une latence typique annoncée de l'ordre de quelques dizaines à quelques centaines de millisecondes.

Les comparaisons spectaculaires publiées au lancement — parfois plusieurs centaines de fois moins cher ou plus rapide qu'un grand LLM selon les scénarios — proviennent cependant principalement des benchmarks de TypeSafe.

Il vaut donc mieux retenir l'idée générale plutôt qu'un chiffre marketing précis : Jev est conçu pour effectuer énormément de petites décisions rapidement et à très faible coût.

Pas d'hallucination… mais des erreurs restent possibles

Il faut également éviter un raccourci.

Comme Jev ne génère pas librement du texte et doit choisir parmi des valeurs définies à l'avance, il ne peut pas inventer une URL, une date ou une citation comme peut parfois le faire un LLM.

Mais cela ne signifie évidemment pas qu'il a toujours raison.

Il peut très bien classer un message dans la mauvaise catégorie.

La différence est que l'application reçoit également une estimation de confiance et peut décider :

confiance élevée → automatisation

confiance moyenne → modèle plus puissant

confiance faible → humain

C'est probablement l'une des idées les plus intéressantes de Jev.

Une petite brique qui pourrait devenir importante

Jev est encore très récent et il serait prématuré d'en faire le futur remplaçant des LLM.

Ce n'est d'ailleurs pas son objectif.

Mais son approche remet en question une habitude qui s'est installée très vite : utiliser un grand modèle génératif pour absolument tout.

Pour rédiger un article, expliquer un problème ou produire du code, un LLM reste parfaitement adapté.

Pour décider si un ticket est urgent ?

Peut-être avons-nous effectivement sorti le bazooka pour écraser une mouche.

Et dans des systèmes comportant des milliers d'automatisations ou des agents IA travaillant en permanence, une IA spécialisée capable simplement de répondre « oui », « non », « celui-ci », avec 93 % de confiance pourrait finalement s'avérer extrêmement utile.

Jev ne cherche donc pas vraiment à devenir une nouvelle IA avec laquelle discuter.

Il veut plutôt devenir celle qui, discrètement derrière nos applications, décide de ce qui doit se passer ensuite.