Comment intégrer Jev dans Grok Bot : Le meilleur agent que j'ai créé

Grok Bot offre à chaque utilisateur un ordinateur cloud et permet aux bots d'y exécuter un shell. La plupart des gens l'orientent vers des tâches et le regardent répéter inlassablement les mêmes échecs.

Tu ajoutes une compétence de routage, tu la laisses journaliser pendant une semaine avant qu'elle ne puisse agir, et tu gardes un coupe-circuit sous la main.

Si tu la branches correctement, les nouvelles tentatives s'arrêtent avant de te coûter quoi que ce soit.

Voici la configuration complète 👇

Avant de commencer, je publie les guides complets sur mon Substack : https://zodchiii.substack.com/ 🧠

Ce que Jev renvoie comme réponse

Jev est le modèle System One de TypeSafe. Il répond par une valeur typée plutôt que par du texte libre, et il embarque trois primitives :

• Choice sélectionne une option dans une liste que tu définis, et renvoie le choix, les probabilités et le niveau de confiance
• Score évalue l'état par rapport à une grille de critères
• Noul indique si une affirmation est vraie, sous forme de nombre entre 0 et 1

Comme la réponse revient sous forme de valeur, tu peux la journaliser, comparer deux semaines de décisions entre elles et les rejouer sur le trafic d'hier.

L'appel ressemble à ceci :

1from typesafe_sdk import Choice, TypeSafeClient
2
3with TypeSafeClient(model="jev-latest") as client:   # lit TYPESAFE_API_KEY
4    r = client.system_one(
5        state=f"goal: {goal}\ntask: {task_type}\nlast error: {err} x{repeats}",
6        questions={
7            "action": Choice(
8                instructions="Que doit faire l'agent ensuite",
9                criteria={
10                    "proceed": "Rien n'indique que l'étape suivante va échouer",
11                    "reuse_cache": "Un nouvel artefact pour cela existe déjà",
12                    "stop_retry": "La même approche a échoué de la même manière",
13                    "research_capped": "Suffisamment de sources sont déjà rassemblées",
14                    "ask_human": "L'étape envoie, publie, paie ou supprime",
15                },
16            )
17        },
18    )
19
20print(r.choices["action"].choice, r.choices["action"].confidence)

Le routeur choisit l'une de ces cinq options et n'a aucun moyen de répondre autre chose.

Étape 1 : obtenir la clé API

Ouvre ton tableau de bord TypeSafe et crée une clé API. Garde-la hors du chat, hors du dépôt et hors de toute compétence que tu prévois de partager.

Étape 2 : placer la clé sur l'ordinateur

Utilise le flux de demande de secret masqué. La clé ne transite jamais par le chat.

Une chose à savoir avant de l'ajouter : ton ordinateur cloud Grok Bot est une machine unique par compte, et chaque bot que tu y exécutes voit les mêmes fichiers, sessions et identifiants. La clé que tu y déposes est lisible par tous.

1Je dois te transmettre un identifiant API pour TypeSafe. Utilise le flux de demande de secret masqué, pas le chat. La valeur doit arriver sous forme de variable d'environnement TYPESAFE_API_KEY sur ton ordinateur, et elle ne doit apparaître dans aucun fichier, journal, compétence ou dépôt que tu crées. Confirme-moi uniquement que la variable est définie et lisible, jamais sa valeur.

Étape 3 : installer le SDK et le tester rapidement

1Sur ton ordinateur, exécute : pip install typesafe-sdk
2
3Ensuite, écris /work/jev/smoke.py qui ouvre TypeSafeClient(model="jev-latest") et envoie un appel system_one avec une seule question Choice. État : "goal: ouvrir un ticket de support. task: routage. last error: none x0". Critères : facturation, technique, ventes.
4
5Exécute-le et montre-moi l'objet de réponse brut : le choix, les probabilités et le niveau de confiance. Si TYPESAFE_API_KEY est manquante, arrête-toi et préviens-moi, ne code rien en dur.

Tu cherches trois choses dans la sortie : une valeur issue de ta propre liste, une répartition des probabilités et un score de confiance. S'il manque l'un de ces éléments, c'est que le SDK parle à autre chose.

Étape 4 : construire le routeur

1Construis un module de routage dans /work/jev/router.py avec une seule fonction :
2
3    route(goal: str, task_type: str, last_error: str, repeats: int) -> dict
4
5Elle envoie exactement ces quatre champs à Jev comme état, avec une question Choice nommée "action" et ces critères :
6
7  proceed          rien n'indique que l'étape suivante va échouer
8  reuse_cache      un nouvel artefact pour cela existe déjà
9  stop_retry       la même approche a échoué de la même manière
10  research_capped  suffisamment de sources sont déjà rassemblées
11  ask_human        l'étape envoie, publie, paie ou supprime
12
13Renvoie le choix, le niveau de confiance et les probabilités. Ajoute chaque appel à /work/jev/decisions.jsonl avec un horodatage, les quatre entrées et la réponse complète. Lis le comportement depuis /work/jev/config.json avec deux clés : "enabled" et "mode" ("shadow" ou "active"). Par défaut, enabled est à false.
14
15Aucun texte de prompt dans l'état au-delà de ces quatre champs. Montre-moi le fichier avant de l'exécuter.

Ces quatre champs constituent tout l'état que Jev voit. Il ne reçoit jamais ton prompt, ton dépôt ou ta conversation, ainsi l'appel reste léger et le journal lisible.

Étape 5 : ajouter la compétence

1Crée une compétence appelée jev-usage-router.
2
3Déclencheur : avant toute session navigateur, toute passe de recherche, toute nouvelle tentative d'une étape échouée, et avant de générer un bot supplémentaire.
4
5Étapes : appelle route() depuis /work/jev/router.py avec l'objectif actuel, le type de tâche, le texte de la dernière erreur et le nombre de fois où elle s'est répétée. Puis respecte l'action :
6
7  proceed          continuer comme prévu
8  reuse_cache      utiliser l'artefact existant, ignorer le travail
9  stop_retry       abandonner cette approche et expliquer pourquoi
10  research_capped  s'arrêter à 5 sources et rédiger ce que tu as
11  ask_human        mettre en pause et me demander, ne pas avancer seul
12
13Limite d'approbation : ask_human n'est jamais contourné, quel que soit le niveau de confiance. Sortie : une ligne par décision dans le rapport d'exécution.

Conserve la copie de référence de cette compétence dans ton propre système de contrôle de version. Grok Bot ne garde que les 20 enregistrements d'exécution les plus récents par routine, alors pousse tout ce qui t'importe dans ton propre stockage au fur et à mesure.

Étape 6 : l'exécuter en mode shadow pendant une semaine

1Configure /work/jev/config.json sur {"enabled": true, "mode": "shadow"}.
2
3En mode shadow, appelle le routeur à chaque déclencheur et journalise la décision, puis ignore-la et fais ce que tu aurais fait de toute façon. Ne change rien à ta façon de travailler.
4
5À la fin de chaque journée, ajoute à /work/jev/report.md : le nombre d'appels, la répartition des actions, la confiance moyenne, et chaque cas où l'action journalisée différait de ce que tu as réellement fait.

Le mode shadow existe parce qu'un juge bon marché peut se tromper. Lis le journal pour repérer les désaccords. Si stop_retry se déclenche sur une approche qui aurait fonctionné à la quatrième tentative, tu veux le savoir avant qu'on l'autorise à agir.

Une semaine de trafic réel suffit pour analyser. Moins que ça, et l'échantillon est trop petit pour t'apprendre grand-chose.

Étape 7 : passer en mode actif, mais garder le coupe-circuit

1Passe le mode sur "active". À partir de maintenant, respecte l'action au lieu de simplement la journaliser.
2
3Deux coupe-circuits restent disponibles pour moi à tout moment :
4  1. "bypass jev" dans n'importe quel message, ce qui ignore le routeur pour cette exécution
5  2. {"enabled": false} dans config.json, ce qui le désactive complètement
6
7ask_human continue de me mettre en attente. Continue d'écrire decisions.jsonl exactement comme avant.

Continue de journaliser après le basculement. C'est grâce au journal que tu feras la différence entre un routeur qui te fait économiser de l'argent et un autre qui interrompt discrètement un travail qu'il aurait dû terminer.

Que router en premier ?

Commence par la routine qui n'arrête pas de retenter, et laisse le reste de ta configuration tranquille.

Les routines qui valent la peine d'être routées en premier ont un point commun : l'agent ne sait pas ce qu'il sait déjà. Il rouvre un navigateur pour un fichier présent sur le disque, lit une quatorzième source alors que cinq suffisaient à répondre à la question, ou tente la même approche une troisième fois parce que rien ne lui a dit que la deuxième avait échoué pour la même raison.

Choisis-en une, lance-la en mode shadow et lis le journal avant d'élargir.

Combien ça coûte

Un appel Jev transporte quatre champs courts, il reste donc léger. Chacun t'achète la possibilité de sauter une étape coûteuse : une session navigateur, une passe de recherche, un bot supplémentaire, une nouvelle tentative.

Mesure-le sur ton propre trafic plutôt que de croire les chiffres de quelqu'un d'autre, y compris les miens. Journalise la décision, journalise l'étape que tu as sautée, et compare une semaine en shadow à une semaine active.

Quelques limites à garder en tête

• Un ordinateur par compte. Chaque bot que tu exécutes voit les mêmes fichiers et identifiants, alors garde hors de cette machine tout ce que tu ne confierais pas à tous.
• Vingt enregistrements d'exécution par routine. Pousse tout ce qui t'importe dans ton propre stockage.
• L'utilisation n'est toujours pas illimitée. Le routeur réduit les opérations coûteuses, il ne supprime pas le plafond.

Alors, qu'est-ce que tu obtiens au final ?

Grok Bot réfléchit et travaille, Jev répond avec l'une des cinq actions, et tu gardes le dernier mot sur tout ce qui ne peut pas être annulé.

Commence par la routine qui échoue toujours de la même manière, lance-la en shadow pendant une semaine, puis bascule.

Merci de ta lecture !

Guides complets et reste de la série : https://zodchiii.substack.com/