Performances
Le temps que prend zn-gate : les hooks des agents et le scanner local, avec la version, la date, la machine et la méthode de chaque mesure.
zn-gate s'exécute sur votre machine : son coût est du temps à chaque appel d'outil, pas un aller-retour réseau. Cette page donne les chiffres mesurés, indique de quelle version et de quel jour vient chacun, et ce qu'ils ne couvrent pas. Ces chiffres sont des mesures sur une seule machine, pas une promesse de la même vitesse sur la vôtre.
Hooks des agents
Chaque fois qu'un agent de code appelle un outil, il lance le hook de zn-gate et l'attend : une fois avant l'appel (par exemple une commande shell) et une fois après, avec la sortie de l'outil.
Mesuré le 2026-10-17 sur un runner ubuntu-latest de GitHub Actions (4 vCPU AMD EPYC 7763) avec Node.js 22.23, avec le code des hooks du dépôt zn-gate de ce jour (version du paquet 1.11.0). Temps en millisecondes. Un node -e "" à vide prend 25 ms (p50) sur la même machine.
| Agent | Événement | p50 (ms) | p95 (ms) |
|---|---|---|---|
| Claude Code | PreToolUse, commande shell | 51 | 54.7 |
| Codex CLI | PreToolUse, commande shell | 52 | 53.8 |
| Cursor | beforeShellExecution | 51.7 | 58.6 |
| Claude Code | PostToolUse, 1 Ko | 63 | 65 |
| Codex CLI | PostToolUse, 1 Ko | 62.2 | 65.3 |
| Cursor | postToolUse (MCP), 1 Ko | 62.2 | 64 |
| Claude Code | PostToolUse, 100 Ko | 67.5 | 70.4 |
| Codex CLI | PostToolUse, 100 Ko | 67 | 68.8 |
| Cursor | postToolUse (MCP), 100 Ko | 66.9 | 68.9 |
| Claude Code | PostToolUse, 100 Ko avec 2 secrets | 73.8 | 76.3 |
| Codex CLI | PostToolUse, 100 Ko avec 2 secrets | 74.7 | 77.5 |
| Cursor | postToolUse (MCP), 100 Ko avec 2 secrets | 75.9 | 77.9 |
| Claude Code | PostToolUse, 1000 Ko | 85.8 | 89.4 |
| Codex CLI | PostToolUse, 1000 Ko | 86.4 | 88.5 |
| Cursor | postToolUse (MCP), 1000 Ko | 88.9 | 92.3 |
L'essentiel de ce temps est le démarrage de Node.js. Pour lire le tableau : une commande shell coûte environ 50 ms avant de s'exécuter, et un résultat d'outil jusqu'à 1000 Ko environ 90 ms au plus (p95). Cursor ne laisse zn-gate réécrire que la sortie MCP, d'où des lignes après appel pour des outils MCP. OpenCode n'est pas dans le tableau : son plugin zn-gate s'exécute dans le processus d'OpenCode, donc aucun processus de hook n'est lancé.
Comment les hooks ont été mesurés
- Le benchmark lance
node lib/hooks/runner.js <agent>avec l'événement de l'agent sur stdin, exactement comme le fait l'agent, et chronomètre jusqu'à la fin du processus. - Les sorties font 1 Ko, 100 Ko (aussi avec deux secrets dedans) et 1000 Ko de texte proche de code source.
- Le coffre est verrouillé : les valeurs détectées sont donc masquées définitivement et aucun processus en arrière-plan n'intervient.
- Chaque cas s'exécute 40 fois après une exécution d'échauffement. p95 est le 38e des 40 temps (rang le plus proche).
- Des valeurs fictives sont générées à chaque exécution. Un cas échoue si l'une d'elles revient du hook, si le hook n'a pas pu vérifier la sortie ou si un cas avec secrets n'a pas de marqueur zn-gate à leur place.
Un contrôle de CI exécute ce benchmark à chaque modification du code des hooks. Il compare le p95 de chaque cas divisé par le temps de démarrage de Node dans la même exécution, si bien qu'une machine plus rapide ou plus lente change peu le résultat, et échoue si ce rapport dépasse de plus de 20 % la référence enregistrée.
Scanner local
Le scanner est la partie de zn-gate qui vérifie le texte avec ses règles et masque les secrets. Il s'exécute dans le processus, sans réseau. Il y a deux mesures, prises à des moments différents sur une machine AWS avec un Intel Xeon Platinum 8259CL. Toutes deux ont utilisé des entrées bénignes que le scanner n'avait jamais vues (sans cache).
Vérifier un résultat d'outil (règles et masquage des secrets)
Mesuré le 2026-10-11 avec zn-gate 1.4.1, sur une machine AWS de 2 vCPU avec Node.js 24. C'est l'appel complet à check_tool_result, dans le processus. p50 est la médiane de 3 exécutions et p99 la pire des 3.
| Taille d'entrée | p50 (ms) | p99 (ms) |
|---|---|---|
| 200 o | 0.045 | 0.19 |
| 4 Ko | 0.30 | 0.81 |
| 64 Ko | 3.8 | 6.7 |
Les règles seules
Mesuré le 2026-10-10 avec zn-gate 1.4.0 (version des règles 2026-09-29.1), sur une machine à 2,5 GHz avec Node.js 24.21, 20 000 échantillons par taille. C'est la vérification des règles sans masquage des secrets.
| Taille d'entrée | p50 (ms) | p95 (ms) |
|---|---|---|
| 200 caractères | 0.013 | 0.028 |
| 1000 caractères | 0.047 | 0.077 |
| 4000 caractères | 0.173 | 0.372 |
| 16 000 caractères | 0.681 | 1.179 |
Les règles prennent moins de 0,1 ms (p50) pour des entrées jusqu'à environ 1000 caractères. Le temps croît proportionnellement à la longueur de l'entrée : n'appliquez pas ce chiffre à des textes bien plus longs.
Limites
- Les chiffres des hooks viennent d'un seul runner de CI. Sur votre ordinateur, les temps seront différents ; l'essentiel de l'écart suit le démarrage de Node.js, pas zn-gate.
- Les chiffres du scanner ont été mesurés avec zn-gate 1.4.0 et 1.4.1. Ils n'ont pas été remesurés sur des versions ultérieures et cette page ne les présente pas comme tels.
- Les chiffres du scanner valent pour du texte que le scanner n'a jamais vu ; ils sont dans le processus et n'incluent ni le démarrage de Node.js ni celui de l'agent.
- Cette page ne couvre pas la vérification cloud optionnelle, qui ajoute un appel réseau et ne fait pas partie des chiffres locaux. Aucune latence de bout en bout n'est publiée ici pour elle.
- Ces nombres sont des médianes et des percentiles élevés de quelques exécutions sur une machine chacun, pas des garanties.
Les scripts du benchmark et les fichiers de mesure se trouvent dans le dossier bench du dépôt zn-gate. Pages liées : Masquage des secrets et Configuration.