Routage d'agents avec Jev : LangChain, Vercel

Dans un agent IA, Jev prend en charge les petites décisions entre deux appels LLM : quel outil ou quel skill utiliser, quel modèle doit traiter l'étape suivante, si l'agent doit continuer ou passer la main, et si un appel d'outil semble trop risqué pour être exécuté. TypeSafe et ses partenaires documentent des schémas pour le routage d'intentions, le choix de modèle, les décisions continuer/arrêter et le filtrage des appels d'outils à risque ; aucun schéma n'est documenté pour décider d'une nouvelle tentative. Avant de confier l'une de ces décisions à Jev plutôt qu'à un LLM, rejouez vos propres décisions journalisées dans les deux et comparez précision, latence et coût.

Ce guide rassemble ce que montrent les documentations officielles de TypeSafe, LangChain, Vercel et Cloudflare en octobre 2026, et signale clairement les endroits où nous décrivons une idée de conception et non une fonction documentée. Nous n'avons pas déployé Jev dans un système client. Pour le contexte sur le modèle lui-même, voir ce qu'est Jev.

Où se situent les décisions de routage dans un agent ?

La plupart des agents tournent en boucle : lire la tâche et le dernier résultat d'outil, décider de la suite, agir, recommencer. L'étape « décider » cache en général plusieurs questions distinctes auxquelles un LLM répond implicitement au sein d'un long prompt. Un modèle de décision les rend explicites. L'esquisse ci-dessous est du pseudocode neutre, pas du code de l'API Jev :

loop:
    state = compact summary of task, last tool result, step count
    answers = decision_model(state, [which_tool, needs_strong_model,
                                     tool_call_risky, should_continue])
    if any answer is below its confidence threshold:
        hand the step to an LLM or a person
    elif tool_call_risky is likely:
        refuse the call, or ask for approval
    else:
        run the chosen tool with the chosen model
    if not should_continue: stop

Deux principes de la documentation de TypeSafe orientent cette conception. Les questions doivent être atomiques : un jugement global se découpe en plusieurs questions, combinées ensuite dans le code. Et l'état doit rester court : Jev « souffre de context rot » quand l'état est rempli de détails inutiles (Jev 1.13 jaggedness). Transmettre la transcription complète est un mauvais réflexe ; transmettez ce dont la décision a besoin.

Routage d'intentions et d'outils

Le schéma de routage d'intentions de TypeSafe est l'exemple officiel le plus clair. Une question Choice classe la demande, une question Score évalue sa complexité, et du code ordinaire décide de sa destination : les demandes de suivi de commande vers du code déterministe, les questions sur les produits et les retours vers des prompts LLM spécialisés, les réclamations vers un LLM ou un humain selon leur complexité. Une confiance faible renvoie vers un humain. La fonction de routage, telle que publiée :

def route_ticket(ticket_id, response):
    intent = response.answers["intent"]
    complexity = response.answers["complexity"]

    if intent.confidence < 0.5:
        # If we don't have enough confidence to classify, route to a human agent
        return route_to_human_agent(ticket_id)

    if intent.choice == "order_status":
        handle_order_status(ticket_id)
    elif intent.choice == "product_question":
        handle_with_llm(ticket_id, PRODUCT_SPECIALIST)
    elif intent.choice == "return_exchange":
        handle_with_llm(ticket_id, RETURNS_SPECIALIST)
    elif intent.choice == "complaint":
        low_confidence = complexity.confidence < 0.5
        # A higher complexity.score leans toward the "escalation needed" end of the scale.
        if complexity.score > 1 or low_confidence:
            # Too complex for safe automation, or we're not sure about the complexity; route to a human.
            route_to_human_agent(ticket_id)
        else:
            handle_with_llm(ticket_id, COMPLAINT_RESOLUTION)

Pour la sélection d'outils à proprement parler, TypeSafe propose deux cookbooks. Le cookbook function calling associe un nom de fonction et ses arguments à ensemble fermé (littéraux et booléens) à des questions Choice et Noul, avec une requête par commande. Les arguments entiers, en texte libre et de type date gardent leurs valeurs par défaut, ce qui montre où s'arrête l'approche : Jev choisit la fonction, mais ne remplit pas les valeurs ouvertes. Le cookbook de suggestion de skills utilise deux requêtes Jev pour choisir au plus un skill parmi 182. Dans le test de TypeSafe sur 488 requêtes face à Claude Haiku 4.5, le taux de chargement du mauvais skill est passé de 16,8 % à 7,3 %, et le chargement d'un skill alors qu'aucun ne convenait de 9,8 % à 4,0 %. C'est un résultat de l'éditeur, sur une tâche choisie par l'éditeur.

Deux limites comptent pour les menus d'outils. Un Choice contient au plus 255 options, et la documentation de TypeSafe note que Jev « penche vers l'option qui vient en premier ». Si votre liste d'outils a un ordre fixe, vérifiez que le premier outil ne l'emporte pas plus souvent qu'il ne le devrait.

Choix du modèle avec LangChain

LangChain maintient un package langchain-typesafe (alpha, 0.0.1a3 au moment de la rédaction) avec un Runnable TypeSafeClassifier et deux classes de middleware marquées expérimentales. ModelRouterMiddleware choisit le modèle qui exécute une étape. Cet extrait provient de la page fournisseur de LangChain :

from langchain.agents import create_agent
from langchain_typesafe.experimental.middleware import (
    ModelChoice,
    ModelRouterMiddleware,
)

router = ModelRouterMiddleware(
    choices={
        "fast": ModelChoice(
            model="openai:gpt-5.6-terra",
            criteria="Direct lookups, extraction, and localized changes with explicit targets.",
        ),
        "powerful": ModelChoice(
            model="openai:gpt-6-astra",
            criteria="Architecture, novel root-cause reasoning, and high-stakes decisions.",
        ),
    },
    instructions="Choose the least costly model that can complete the task safely.",
)

agent = create_agent("openai:gpt-5.6-terra", middleware=[router])

L'exemple complet de cette page se poursuit avec agent.invoke(...) et lit la route choisie dans result["model_route"].choice. Le routage de modèles fait aussi partie des usages qu'Armin Ronacher, CTO d'Earendil, a cités quand TechCrunch l'a interrogé sur Jev. Le calcul économique est simple : l'appel au routeur coûte peu, il est donc rentable s'il envoie assez d'étapes vers le modèle le moins cher sans dégrader les résultats. Savoir si c'est le cas, c'est précisément ce qu'il faut mesurer. Notre comparatif des coûts des LLM donne l'écart de prix entre les gammes de modèles qu'un tel routeur exploiterait.

Nouvelles tentatives, poursuite et escalade

Ici, la documentation est mince, et il vaut mieux être précis. Le contenu officiel de TypeSafe sur les retries concerne le transport : les SDK relancent les erreurs 429 et 529 avec un backoff exponentiel et respectent retry-after. Il n'existe aucun schéma officiel pour utiliser Jev afin de décider si un agent doit retenter une étape qui a échoué.

L'exemple documenté le plus proche est le test continuer/arrêter de Vercel, tiré du changelog d'AI Gateway :

import { TypeSafeClient } from '@typesafe-ai/sdk';

const client = new TypeSafeClient({
  apiKey: process.env.AI_GATEWAY_API_KEY,
  baseURL: 'https://ai-gateway.vercel.sh/typesafe',
});

const result = await client.systemOne({
  state: 'The agent fixed the checkout bug and all tests pass.',
  questions: {
    continueWorking: {
      type: 'noul',
      instructions: 'Should the agent take another step?',
    },
  },
});

const shouldContinue = result.answers.continueWorking.noul >= 0.8;

Une décision de nouvelle tentative pourrait suivre la même forme, et nous la présentons uniquement comme une idée de conception. Après un appel d'outil en échec, posez des questions oui/non : l'erreur semble-t-elle transitoire, le même appel avec d'autres arguments a-t-il des chances de réussir ? Gardez le compteur de tentatives et le backoff dans le code ; la documentation de Jev indique qu'il ne compte pas de manière fiable. Si les réponses sont incertaines, escaladez au lieu de retenter.

Pour les seuils d'escalade, le schéma de routage par confiance de TypeSafe présente un parcours bancaire vocal avec un plancher de confiance de 0,6 et une validation automatique d'un virement uniquement au-dessus de 0,85. Les réponses Noul n'ont pas de champ confidence : pour les questions oui/non, le seuil porte directement sur la probabilité, comme le >= 0.8 de Vercel. Un test indépendant d'AY Automate a utilisé un seuil de confiance de 0,80 pour envoyer les cas incertains à GPT-5.6 Terra et a atteint 90,0 % de précision pour environ 26 % du coût de Terra. Ces chiffres sont les leurs, sur leurs données ; vos seuils doivent venir des vôtres.

Filtrage des appels d'outils à risque

Le middleware expérimental AutoModeMiddleware(tools=[...]) de LangChain « demande la probabilité qu'un appel d'outil soit risqué ou insuffisamment autorisé ». Les appels jugés risqués renvoient un ToolMessage d'erreur au lieu d'être exécutés. L'avertissement de LangChain mérite d'être répété : « Ce middleware refuse les appels risqués. Il ne demande pas d'approbation. » Si votre agent a besoin d'une étape de validation humaine, c'est à vous de la construire.

La réserve la plus importante concerne l'injection de prompt. La documentation de Jev précise que l'état est une donnée et que le modèle « ne le considère pas comme hostile par défaut ». VentureBeat a rapporté un test d'Octomind dans lequel un faux champ « pre-approved » faisait passer la probabilité de blocage de rm -rf ~/.ssh de 0,76 à 0,48. La position de Pydantic, citée dans le même article, est la bonne : un garde-fou Jev « a sa place à côté des contrôles déterministes, pas à leur place ». Concrètement : listes d'autorisation et de refus, validation des arguments et contrôles de permissions dans le code d'abord, Jev ne notant que la zone grise que les règles ne couvrent pas.

Notes d'intégration : LangChain, Vercel, Cloudflare et Pydantic

LangChain : langchain-typesafe est maintenu dans le dépôt langchain-ai mais reste en alpha, et les deux classes de middleware sont expérimentales. Attendez-vous à des changements d'API.
Vercel AI Gateway : le modèle est typesafe-ai/jev, accessible via le client TypeSafe avec une base URL de passerelle (comme ci-dessus), un endpoint HTTP /v1/evaluate ou l'AI SDK via @ai-sdk/typesafe-ai. Les pages de Vercel ne s'accordent pas sur le nom de la fonction de l'AI SDK (experimental_evaluate dans le changelog, experimental_decide dans le guide d'intégration plus récent) : vérifiez la documentation à jour avant de copier du code. L'API native de la passerelle appelle le type oui/non boolean, avec un champ .probability, là où TypeSafe utilise noul. Vercel indique aussi que son framework d'agents eve utilise Jev comme modèle d'évaluation par défaut.
Cloudflare Workers AI : l'appel est env.AI.run('typesafe/jev', { state, questions }) avec le schéma de questions de TypeSafe (page du modèle). Cloudflare annonce la conservation zéro des données et une fenêtre de contexte de 32 000 tokens, contre 64k par requête selon TypeSafe.
Pydantic AI : TypeSafeModel et TypeSafeProvider via l'extra pydantic-ai-slim[typesafe], avec votre propre clé TypeSafe et sans streaming (Pydantic).

Quelle que soit la voie choisie, figez la version du modèle (jev-1.13.0) une fois les seuils ajustés. L'alias jev-latest va évoluer.

Comment évaluer Jev sur votre propre trafic

Les benchmarks publiés se contredisent, et les évaluations de TypeSafe notent les réponses par rapport à des labels produits par deux LLM de pointe : elles mesurent un accord, pas une justesse. Les seuls chiffres qui devraient décider d'une bascule sont ceux tirés de votre propre trafic. Une méthode qui fonctionne :

Extrayez des décisions journalisées de vos traces d'agents : l'état au moment de la décision, le choix fait par votre LLM actuel et le résultat, quand vous le connaissez.
Labellisez un échantillon à la main, cas difficiles et coûteux compris. Prendre un autre LLM comme référence reproduit le problème des benchmarks des éditeurs.
Formulez chaque décision en questions Jev atomiques. Prévoyez plusieurs itérations : dans le test de phishing résumé par Beri.net, découper une question générale en cinq a davantage changé le résultat que le choix du modèle.
Rejouez l'échantillon hors ligne dans Jev et dans votre LLM de référence actuel.
Comparez par type de décision : précision ou macro-F1, matrice de confusion pour les erreurs coûteuses, et calibration. Ajustez les seuils question par question ; Beri.net a jugé la calibration de Jev peu fiable telle quelle.
Mesurez la couverture à chaque seuil : la part que Jev traite seul et la part escaladée vers le LLM.
Mesurez la latence p50 et p95 depuis la région où vous déployez. Les chiffres des éditeurs ont été relevés sur la côte ouest des États-Unis.
Calculez le coût pour 1 000 décisions, appels LLM des cas escaladés compris.
Ajoutez un jeu adversarial avec des instructions injectées dans l'état, en particulier pour les questions sur le risque des outils.
Faites tourner le système en mode shadow sur le trafic réel avant la bascule, et gardez le chemin LLM comme solution de repli.

Si le résultat est serré, les facteurs décisifs sont en général le volume de décisions et le coût de chaque type d'erreur. Une vue plus large des coûts des agents se trouve dans notre article sur le coût de développement d'un agent IA, et les compromis généraux dans Jev vs LLM.

FAQ

Jev fonctionne-t-il avec LangChain ?

Oui. LangChain maintient langchain-typesafe, qui comprend un Runnable TypeSafeClassifier ainsi que les middlewares expérimentaux ModelRouterMiddleware pour le choix du modèle et AutoModeMiddleware pour le filtrage des appels d'outils à risque. Le package est en alpha.

Jev peut-il choisir les outils d'un agent IA ?

Oui, pour les choix fermés. Le cookbook function calling de TypeSafe associe noms de fonctions et arguments à ensemble fermé à des questions Choice et Noul ; les arguments entiers, en texte libre et de type date doivent venir d'ailleurs. Un Choice contient au plus 255 options.

Jev a-t-il une politique de nouvelles tentatives intégrée ?

Seulement pour les erreurs de transport : les SDK relancent les réponses 429 et 529 avec backoff. Décider si un agent doit retenter une étape en échec n'est pas un schéma Jev documenté, même si Vercel montre un test continuer/arrêter apparenté.

Peut-on utiliser Jev comme seul garde-fou sur les appels d'outils ?

Non. Un contenu injecté dans l'état peut faire varier ses réponses, comme l'a montré un test d'Octomind rapporté par VentureBeat. Utilisez-le avec des contrôles de permissions déterministes, et notez que le middleware de LangChain refuse les appels risqués mais ne demande pas d'approbation.

Comment fixer les seuils de confiance pour le routage ?

Ajustez-les question par question sur vos propres données labellisées. Les schémas de TypeSafe utilisent 0,5, 0,6 et 0,85 selon les exemples, et celui de Vercel applique 0,8 à une probabilité Noul, mais chacun de ces seuils a été choisi pour un exemple précis.

Construire la couche de routage

Un modèle de décision change la forme d'un agent : la logique de routage sort des prompts pour devenir des questions typées, des seuils et du code que l'on peut tester. Le système peut alors coûter moins cher à faire tourner et être plus facile à auditer, à condition que quelqu'un soit responsable de l'évaluation et des solutions de repli. AI Superior conçoit et développe des agents IA et des applications LLM pour des clients B2B, avec le routage de modèles, l'évaluation hors ligne et la maîtrise des coûts intégrés à l'architecture. Consultez nos services de déploiement de LLM si vous préparez une mise en production.

Routage d'agents avec Jev : choix d'outil, choix de modèle et nouvelles tentatives