jcode : le harnais d'agents en Rust qui démarre en 14 ms

La plupart des outils de codage assistés par IA se battent sur le modèle. jcode se bat sur tout ce qui l'entoure.

Écrit en Rust par le développeur indépendant Jesse Huang et publié sous licence MIT, jcode est un agent de code en terminal qui a dépassé les 12 000 étoiles GitHub en six mois environ. Sa proposition est inhabituelle : il n'entraîne aucun modèle, n'en affine aucun et ne revendique aucune victoire sur SWE-bench. Ce qu'il affirme, c'est que le harnais — le runtime qui garde le contexte, gère les sessions, appelle les outils et dessine l'interface — laissait sur la table des quantités considérables de performance.

Les chiffres publiés défendent la thèse sans détour.

Le benchmark qui a lancé la conversation

Les 27,8 Mo sont mesurés embeddings désactivés ; avec le système de mémoire sémantique actif, une session tourne plutôt autour de 167 Mo — soit encore moins de la moitié de la ligne de base de Claude Code. Cursor Agent se situe à 1 949 ms au premier rendu, GitHub Copilot CLI à 333 Mo par session.

L'objection évidente consiste à dire que le temps de démarrage relève de la coquetterie. C'est faux, et la raison est comportementale. Un démarrage à froid de 3,4 secondes suffit à vous dissuader d'ouvrir un second agent pour vérifier quelque chose en parallèle. À 14 ms, lancer un agent coûte moins cher qu'ouvrir un fichier — alors vous le faites en permanence. Ce chiffre de performance est en réalité un argument sur la méthode de travail, le même que défendent les worktrees Git pour agents parallèles par un autre chemin.

La mémoire comme graphe, pas comme bloc-notes

La pièce architecturale qui mérite l'étude, c'est la façon dont jcode traite la mémoire.

Le schéma dominant en 2026 est un bloc-notes markdown — CLAUDE.md, AGENTS.md, une commande /remember — doublé d'un outil de récupération que le modèle appelle quand il estime avoir besoin de l'historique. Les deux moitiés coûtent cher. Le bloc-notes grossit jusqu'à dévorer la fenêtre de contexte. L'outil de récupération brûle des tokens à chaque consultation spéculative, et le modèle doit décider de consulter — ce qu'il omet souvent de faire.

jcode remplace les deux par un pipeline automatique :

1. Chaque tour de conversation est vectorisé et écrit dans un graphe de mémoire.
2. À chaque nouveau tour, le graphe est interrogé par similarité cosinus pour retrouver les souvenirs liés.
3. Un sous-agent vérificateur distinct contrôle les résultats avant leur injection dans le contexte.
4. Une passe de consolidation en arrière-plan réconcilie les faits obsolètes ou contradictoires.

Aucun appel à /remember, aucun token dépensé en outils de recherche, aucune latitude laissée au modèle quant à l'opportunité de vérifier. L'étape de vérification est précisément celle que sautent la plupart des couches de mémoire RAG artisanales, et c'est celle qui compte : la similarité sémantique retrouve bien plus souvent ce qui est lié que ce qui est vrai maintenant. Un fait exact quarante tours plus tôt (« le gestionnaire d'authentification vit dans middleware.ts ») devient un passif actif dès que vous l'avez déplacé.

C'est un pari sensiblement différent de celui décrit dans la mémoire persistante des agents en entreprise : jcode traite la mémoire comme une couche d'infrastructure toujours active, non comme un outil que l'agent choisit d'invoquer.

Contexte append-only, et pourquoi le cache vous punit

Une optimisation plus discrète de jcode tient à l'ingénierie de contexte en append-only.

Anthropic, OpenAI et Google facturent tous les tokens d'entrée mis en cache avec une forte remise — souvent autour d'un dixième du tarif non mis en cache. Le cache fonctionne par préfixe : il tient tant que le début de votre requête est identique octet pour octet à la précédente. Changez un seul caractère en haut et tout le cache est invalidé, puis refacturé.

La plupart des harnais l'invalident sans arrêt sans s'en apercevoir. Ils retrient une liste d'outils, rafraîchissent un horodatage dans le prompt système, compactent la conversation en cours de session, ou redessinent un schéma d'outil MCP après la reconnexion d'un serveur. Chacune de ces actions transforme silencieusement une requête bon marché en requête plein tarif.

La réponse de jcode consiste à rendre le contexte strictement append-only et à mettre en cache sur disque les schémas d'outils MCP, afin qu'une reconnexion de serveur en arrière-plan ne réécrive jamais le préfixe. Les serveurs MCP se connectent de façon asynchrone pendant que l'agent tourne déjà, au lieu de bloquer le démarrage. L'outil vous avertit même avant une requête qui va tomber sur un cache Anthropic froid.

Si vous construisez votre propre boucle d'agent, c'est l'idée la plus transposable de tout l'article. La règle est simple : ne modifiez jamais quoi que ce soit qui précède le tour le plus récent. Ajoutez à la fin, ou payez plein tarif. Nous avons détaillé cette économie dans l'optimisation des coûts d'API IA.

Swarm : des agents qui se remarquent

Faire tourner plusieurs agents dans un même dépôt finit habituellement de deux façons — soit vous les isolez dans des worktrees, soit ils écrasent mutuellement leur travail.

Le mode swarm de jcode emprunte la voie du dépôt partagé et y ajoute de la coordination. Un serveur en arrière-plan suit les fichiers que chaque agent a lus et ceux qu'il a écrits. Quand l'agent A modifie un fichier que l'agent B a ouvert, B est notifié et examine le diff avant de continuer. Les agents peuvent aussi se parler directement, diffuser un message au groupe, ou créer leurs propres équipes de travailleurs subordonnés.

On est plus proche du modèle d'orchestration multi-agents que du parallélisme naïf, et c'est un problème réellement difficile : sans conscience des conflits, N agents parallèles dans un dépôt produisent environ N fois la douleur de fusion. Précisons qu'il s'agit de coordination, pas de sécurité transactionnelle — continuez à committer entre les étapes significatives.

Mise en route

# macOS / Linux
curl -fsSL https://jcode.sh/install | bash
 
# Windows (PowerShell 5.1+)
irm https://jcode.sh/install.ps1 | iex
 
# Homebrew
brew tap 1jehuang/jcode && brew install jcode

Ou compilez depuis les sources, ce qui prend quelques minutes :

git clone https://github.com/1jehuang/jcode.git
cd jcode && cargo build --release

Authentifiez-vous auprès du fournisseur que vous payez déjà :

jcode login --provider claude

Les commandes qui comptent au quotidien :

jcode                    # interface terminal interactive
jcode run "corrige le test d'authentification qui échoue"   # exécution unique
jcode --resume fox       # reprendre une session nommée
jcode serve              # serveur en arrière-plan
jcode connect            # y attacher un client

Routage des fournisseurs et porte de sortie

jcode dialogue avec Claude, OpenAI, Gemini, GitHub Copilot, Azure, Alibaba, OpenRouter, DeepSeek, Mistral, Groq, Perplexity, Fireworks, Ollama, LM Studio et n'importe quel point de terminaison compatible OpenAI — plus de 30 au total, via OAuth ou clé API.

Ajouter votre propre passerelle tient en quelques lignes de TOML dans ~/.jcode/config.toml :

[providers.my-api]
type = "openai-compatible"
base_url = "https://llm.example.com/v1"
api_key_env = "JCODE_PROVIDER_API_KEY"

La conséquence pratique, c'est la liberté vis-à-vis des fournisseurs. Quand un abonnement atteint sa limite, /account bascule sur un autre en pleine session ; quand un fournisseur tombe, vous repointez ailleurs au lieu d'arrêter de travailler. C'est le même argument de résilience que dans la stratégie de repli multi-modèles, implémenté cette fois au niveau du harnais plutôt que de l'application.

Pour les équipes en Tunisie, en Arabie saoudite et plus largement dans la région MENA, cette couche de routage a une dimension supplémentaire : elle rend trivial le fait de faire tourner des modèles open-weight moins chers via Groq ou une instance Ollama locale pour le travail de routine, et de réserver les modèles de pointe aux tâches qui l'exigent vraiment.

Ce qui mérite du scepticisme

Rien n'est gratuit ici.

Les benchmarks sont auto-publiés. Ils mesurent la consommation de ressources et la latence de démarrage — des propriétés réelles et vérifiables — pas des taux de réussite sur des tâches. jcode ne rend pas votre modèle meilleur pour corriger des bugs ; il rend l'enveloppe autour du modèle plus rapide et moins coûteuse.

Le mode auto-développement est une arme chargée. jcode peut modifier son propre code source, recompiler le binaire et le recharger à chaud en pleine session. C'est une démonstration impressionnante de l'auto-amélioration récursive en pratique, et c'est aussi un agent doté d'un accès en écriture sur ce qui l'encadre. À traiter comme une fonctionnalité de laboratoire.

Un seul mainteneur, six mois d'existence. Douze mille étoiles, c'est de l'élan, pas de la stabilité. La version 0.56.0 est sortie le 24 juillet 2026 et la cadence de publication est rapide — ce qui coupe dans les deux sens.

Terminal uniquement. Pas d'intégration IDE comparable à ce que proposent Cursor ou Windsurf. Une application iOS native est annoncée ; rien d'autre.

Pourquoi cela dépasse un seul outil

L'affirmation intéressante dans jcode n'est pas le facteur 245. C'est ce qu'elle implique.

Pendant deux ans, l'industrie a traité le harnais comme de la plomberie — une fine couche entre un terminal et une API, où toute inefficacité n'était qu'une erreur d'arrondi face au coût d'inférence. Les mesures de jcode disent que cette fine couche coûtait 3,4 secondes de démarrage, 360 Mo de RAM par session et une pile inconnue mais substantielle de caches refacturés. Ce ne sont plus des erreurs d'arrondi quand votre méthode de travail repose sur dix agents lancés en même temps.

Que jcode devienne ou non l'outil que vous adoptez, le schéma qu'il démontre est celui à intégrer : contexte append-only, mémoire automatique vérifiée, parallélisme conscient des conflits. Ces trois idées ont leur place dans toute boucle d'agent que vous construirez en 2026, quel que soit le harnais retenu.

Le dépôt est 1jehuang/jcode. L'essayer ne coûte rien — et environ quatorze millisecondes pour savoir.