Illustration pour l'article Comment implémenter le tool calling avec Jev ?

Implémenter le tool calling avec le modèle de décision Jev par TypeSafe

Par Eric Burel - Formateur chez LBKE

Publié le 12 novembre 2026 - Mis à jour le 16 novembre 2026

Jev, un modèle de décision efficace pour remplacer les LLM

Jev est le premier modèle d’IA de la famille des “System One”, conçu par la société TypeSafe AI.

Si Jev fait la une de l’actualité, c’est parce que son fonctionnement innovant lui permet d’être extrêmement efficace, avec des coûts très inférieurs à ceux d’un LLM.

Mais attention, contrairement à un LLM, Jev ne parle pas : il prend des décisions !

Il s’agit donc d’un modèle d’IA conçu non pas pour créer des chatbots, mais plutôt pour automatiser des tâches complexes qui impliquent de réaliser rapidement de nombreux choix.

Jev est à voir comme un nouvel outil polyvalent, mis à disposition des développeurs et développeuses IA agentiques pour créer des systèmes IA toujours plus efficaces.

Découvrons comment implémenter le tool calling, une fonctionnalité fondamentale des modèles d’IA pour l’agentique, avec Jev.

Comprendre le tool calling : une tâche de classification et une tâche de génération

Le tool calling est la capacité des modèles d’IA à choisir des outils pour accomplir une tâche.

Auparvant, seuls les grands modèles de langage LLM pouvaient choisir des outils dans n’importe quel contexte à partir d’un prompt. Mais avec les modèles System One comme Jev, fini le monopole des LLM !

Formellement, Jev s’applique à toutes les tâches de classification sur des données non structurées. Pour pouvoir l’utiliser pour le tool calling, il faut donc le reformuler ce problème sous forme de choix.

En l’occurrence, le tool calling peut être décomposé en deux tâches distinctes :

Par exemple, si je souhaite planter un arbre, je peux choisir entre prendre une pelle ou un râteau, c’est la tâche de classification. Si je choisis la pelle, je dois ensuite définir la profondeur du trou à creuser, c’est la tâche de génération.

Un LLM réalise ces deux tâches en même temps, sa réponse contiendra à la fois le nom des outils et les paramètres à leur fournir.

Un modèle “System One” comme Jev se concentre uniquement sur le choix de l’outil, mais vise à être plus rapide et moins coûteux sur cette étape.

Il faut donc combiner un appel à Jev pour choisir l’outil, et un appel à un LLM pour le paramétrer.

Tool Calling avec Jev : les grandes étapes

Les étapes du tool calling avec Jev sont finalement :

  1. Choisir l’outil avec Jev en fonction du prompt de l’utilisateur et des outils disponibles ;
  2. Demander à un LLM de générer les paramètres des outils sélectionnés ;
  3. Appeler l’outil (dans votre code ou via le protocole MCP, car un LLM n’exécute jamais un outil lui-même) ;
  4. Demander à un LLM de conclure en fonction des résultats de l’outil.

L’étape 4 peut être rendue facultative pour des tâches d’automatisation pure, comme nous l’expliquons dans notre article précédent sur le “Dynamic Direct Return” avec LangChain.

On peut réaliser ces actions plusieurs fois pour résoudre un problème, et ainsi implémenter une boucle agentique originale fondée sur Jev.

L’intérêt de cette architecture est qu’appeler Jev ne coûte quasiment rien par rapport à un LLM de taille moyenne. L’hypothèse est qu’en allégeant la charge de travail du LLM, on devrait in fine avoir des résultats plus fiables avec un coût réduit. Attention, cette hypothèse reste à confirmer !

Appeler Jev avec son SDK officiel, les API System One ou les Decision API

Jev n’étant pas un LLM, on n’utilise pas le pseudo-standard OpenAI typique des LLM mais une interface dédiée. TypeSafe propose un SDK dans plusieurs langages de programmation.

Autre alternative : l’intégration Jev / OpenRouter via une API spécifique aux modèles System One ou la “Decisions API” experimentale. Cette nouvelle API est destinée à supporter aussi les modèles de décision concurrents de Jev annoncés par OpenAI et Gemini. Enfin, l’API MediaPipe Decision Maker, toujours par Google, peut utiliser le même format que Jev pour la prise de décision en local.

Une requête de choix d’outil ressemble à ceci avec un appel HTTP direct à l’API d’OpenRouter :

def pick_tool(user_prompt):
    response = requests.post(
        "https://openrouter.ai/api/alpha/decisions",
        headers={...},
        json={
            "model": "typesafe/jev-1.13",
            "state": {
                # La question de l'utilisateur (prompt)
                "user_prompt": 
                user_prompt 
                + "\nYou are tasked to pick the next relevant tools for the task " 
                + "(multiple tools can be used in parallel if necessary)"
            },
            # Liste des outils que l'on peut sélectionner
            # sous forme de questions oui/non (utiliser ou pas)
            "questions": {
                shovel.name: {
                    # "Noul" = booléen avec score
                    "type": "noul",
                    "instructions": shovel.description,
                    "criteria": {
                        "true": "Use this tool for next step",
                        "false": "Do not use this tool yet",
                    },
                },
            },
        },
    )
    return response.json()

Comprendre le type “Noul”

On connaît tous la tendance des LLM à affirmer n’importe quoi avec un ton péremptoire et une grande confiance ! Jev s’efforce d’éviter ce problème, et le type “Noul” implémente concrètement la volonté de Jev d’évaluer correctement son propre niveau de confiance avant de prendre une décision.

Un Noul est un score qui permet d’obtenir une sorte de booléen amélioré :

Ainsi, pour le tool calling, on déclenche l’appel d’outil si le score est proche de 1. Le seuil idéal dépend de l’outil et du problème à résoudre. En pratique, on fixe typiquement une valeur par défaut, par exemple 0.8, que l’on va ensuite optimiser en observant le comportement de l’agent sur un jeu de test ou face à des bếta-testeurs.

Attention, si le score est inférieur au seuil, cela ne signifie pas forcément que l’outil ne doit pas être appelé. Un score faible proche de 0.0 signifie que Jev est sûr qu’il ne faut pas appeler l’outil, mais un score de 0.5 signifie plutôt que Jev n’arrive pas à trancher. La solution idéale dans ce cas est “d’escalader” le problème en demandant à l’humain ou à un modèle LLM de frontière de prendre une décision.

Résultats d’une première expérimentation : planter un arbre avec Jev

Nous avons testé Jev dans un contexte champêtre : un prompt simple avec un outil unique, une pelle pour creuser un trou et y planter un arbre.

On utilise le coût comme métrique principale, même si la latence serait bien sûr aussi intéressante à étudier dans une seconde étape, ainsi que le taux de succès sur des tâches plus complexes et multi-étapes.

Ordres de grandeur des dépenses avec Jev:

Cost was 0.000103236$
For 1 dollar, you could run this workflow 9686 times
Running this generation 1000 (1K) times would cost 0.103236$
Running this generation 1000000 (1M) times would cost 103.236$

Avec le LLM direct, sans Jev :

Cost was 6.475e-05$
For 1 dollar, you could run this worflow 15444 times 
Running this generation 1000 (1K) times would cost 0.06475$
Running this generation 1000000 (1M) times would cost 64.75$

En utilisant google/gemini-3.1-flash-lite… le tool calling avec Jev n’est pas encore gagnant ! Le choix d’outil est peu cher grâce à Jev, mais les deux appels LLM qu’il faut y ajouter pour exécuter le tool calling (générer les arguments, puis la réponse finale) atténuent le gain.

Pour trancher, il faudrait mettre en place un banc d’essai complet (un sujet au coeur de notre nouvelle formation « Évaluer un système d’IA agentique »), par exemple en s’inspirant des evals de LangChain Deep Agents.

Jev, le couteau-suisse pour les tâches de classification

La société Evalagent a publié une démonstration de l’utilisation de Jev pour le tool calling au sein d’un agent vocal. LangChain illustre d’autres cas d’usage pour Jev comme le routage de modèle ou l’implémentation d’un guardrail de sécurité. Une intégration permet déjà d’utiliser Jev dans LangChain avec une syntaxe intuitive. On retrouve ce même usage de Jev comme guardrails dans cet article.

L’article de recherche “REFLEX with Jev for Efficient Selective Control in LLM Agents” propose une architecture agentique fondée sur Jev pour toutes les décisions, avec un LLM comme solution de repli. Les chercheurs constatent que Jev n’est pas la solution à tout, mais plutôt un outil efficace dans certaines situations : quand l’agent doit prendre des décisions simples mais répétées, ou quand le niveau de confiance fourni par Jev permet de choisir efficacement entre exécution autonome et intervention d’un LLM voire de l’humain.

Utiliser Jev pour le tool calling est une approche originale de la boucle agentique, et les modèles System One ouvrent de nouvelles perspectives pour aborder tous les problèmes de décision pour lesquels des LLM sont utilisés aujourd’hui.

Le code complet pour cette expérimentation est disponible dans le dépôt GitHub lbke/langchain-jev-tool-calling.

Commentez cet article sur les réseaux sociaux :

Partager sur Bluesky

À propos de l'auteur

Photo d'Eric Burel

Eric Burel est ingénieur diplômé de l'ENSIMAG. Il est co-fondateur de LBKE, formateur web et IA, et ambassadeur pour le plan national Osez l'IA.

Il partage régulièrement ses connaissances à travers des articles publiés sur Smashing Magazine et sur son blog. Vous le croiserez sûrement au détour d'un meetup sur Montpellier !

En savoir plus sur Eric Burel

Vous avez apprécié cette ressource ? Découvrez les formations professionnelles courtes de LBKE.

Formation recommandée :

Abonnez-vous pour recevoir les nouvelles ressources

Flux RSS