Un agent IA n'est pas un microservice : l'héberger comme un workload Kubernetes

KubeCon NA 2026 a donné aux agents IA leur runtime Kubernetes. Pourquoi le pod par agent ne tient pas, et ce qu'Agent Substrate change, mesuré dans un lab kind.

TP
Thomas Perelle
Fondateur, Gravitek
13 min de lecture

Les agents IA arrivent sur les plateformes Kubernetes, et on a tendance à les déployer comme n'importe quel service : un pod par agent. Ils n'en ont pourtant ni le rythme ni le profil de risque. KubeCon NA 2026 a apporté une réponse standardisée. Nous l'avons installée sur un portable pour voir ce qu'elle change vraiment.

Pendant la semaine de KubeCon + CloudNativeCon North America 2026, à Salt Lake City, il était difficile d'échapper au sujet : les agents IA deviennent un workload Kubernetes à part entière. Selon le compte rendu de Virtualization Review, Jonathan Bryce, directeur exécutif de la CNCF, a avancé en keynote que les agents génèrent désormais 70 % du trafic d'inférence observé. La source de ce chiffre n'est pas précisée, mais la tendance, elle, ne fait guère débat.

La question que se posent les équipes plateforme est donc moins « faut-il héberger des agents ? » que « comment les héberger sans les traiter comme ce qu'ils ne sont pas ? ». Cet article part de ce décalage, présente ce que KubeCon a acté, puis l'illustre avec un lab que vous pouvez rejouer : gravitek-io/lab-agents-workload-kubernetes.

Un agent n'est pas un microservice

Un microservice classique est sans état. Il reçoit beaucoup de requêtes courtes, se met à l'échelle en ajoutant des répliques, et n'importe quelle réplique peut répondre à n'importe quelle requête.

Un agent IA a presque le profil inverse. Il porte un état : l'historique d'une conversation, des fichiers de travail, parfois un dépôt cloné. Il travaille par à-coups : un tour dure de quelques secondes à quelques minutes, le temps d'appeler le modèle et ses outils. Entre deux tours, il attend, et c'est l'essentiel de sa vie : il attend l'humain, la réponse du modèle, un outil, un événement. Enfin, il exécute du code qu'il n'a pas écrit : des commandes et des scripts produits par un modèle, qu'il faut considérer comme non fiables.

Le réflexe consiste à donner un pod à chaque agent. C'est simple et lisible, mais ce modèle paie au prix fort chacune de ces caractéristiques. Chaque agent qui attend garde son pod, sa réservation de mémoire, son adresse IP et ses objets dans le plan de contrôle. Le mettre à l'échelle zéro fait payer un démarrage à froid au prochain message. Et tous ces conteneurs partagent le noyau de l'hôte avec le code généré qu'ils exécutent.

Trois besoins en découlent : densité (ne pas payer pour des agents qui attendent), sommeil et réveil rapides (garder l'état sans garder le processus), isolation forte (ne pas confier la frontière de sécurité au noyau partagé).

Ce que KubeCon NA 2026 a acté

La réponse la plus structurante s'appelle Agent Substrate. C'est un projet Google, construit avec Solo.io, open source depuis mai 2026. Google le décrit comme « un plan de contrôle et de données à base d'acteurs, bâti au-dessus de Kubernetes ». Sa version 1.0 est sortie le 5 novembre, le jour où Google a annoncé sa donation à la CNCF ; le projet a rejoint la CNCF en Sandbox le 10 novembre.

Le principe : une instance d'agent devient un acteur, qui n'est pas lié à un pod. Des workers, des sandboxes pré-démarrées gérées par Kubernetes, exécutent les acteurs quand ils ont du travail. Entre deux tours, l'acteur est mis en sommeil : son état part en snapshot dans un stockage objet, et le worker est rendu au pool. Au message suivant, il est restauré sur n'importe quel worker disponible.

Les chiffres annoncés sont ceux de Google, pas des mesures indépendantes : une densité dix fois supérieure à celle des runtimes de conteneurs classiques, plus de 1 000 agents en sommeil par hôte, une reprise en moins de 500 ms et plus de 500 réveils par seconde. Solo.io décrit de son côté une démonstration qui multiplexe environ 250 sessions sur 8 pods.

Autour de Substrate, plusieurs briques ont avancé en même temps :

  • gVisor, le noyau applicatif qui isole les sandboxes de Substrate, a rejoint la CNCF à l'automne, et son checkpoint/restore est devenu cinq fois plus rapide, ce qui rend le cycle sommeil/réveil praticable.
  • kagent 1.0, publié par Solo.io pendant KubeCon, est désormais bâti entièrement sur Agent Substrate : on y déclare des agents, des modèles et des outils comme des ressources Kubernetes.
  • Côté primitives, le projet agent-sandbox du SIG Apps propose depuis l'été des ressources Sandbox standard pour les workloads isolés, et NVIDIA a apporté OpenShell à la CNCF.
  • Côté éditeurs, Mirantis a annoncé en disponibilité générale une plateforme d'agents centrée sur la gouvernance : plafonds de dépense, traces d'audit, validation humaine.

Le lab

Pour aller au-delà des annonces, nous avons installé kagent 1.0 et Agent Substrate sur un cluster kind local, sur un MacBook Pro avec Docker Desktop. Agent Substrate demande Kubernetes 1.37 au minimum, mais aucune distribution particulière : kind convient très bien.

git clone https://github.com/gravitek-io/lab-agents-workload-kubernetes.git
cd lab-agents-workload-kubernetes
cp .env.example .env   # puis renseigner la clé OpenRouter
mise install
mise run all

En six minutes environ, le lab crée le cluster, installe kagent et Substrate, branche un modèle via OpenRouter, puis enchaîne les trois démonstrations des sections suivantes. Les mesures sont écrites dans des fichiers CSV versionnés avec le lab, d'où sont tirés les graphiques de cet article.

Un choix assumé : le lab ne montre que la nouvelle approche. Il ne rejoue pas un « pod par agent » pour chiffrer le gain, et les ordres de grandeur ci-dessus restent ceux des éditeurs. Ce qu'il montre, c'est le mécanisme, de façon reproductible.

Densité : des conversations, pas des pods

Première surprise en lisant la documentation de kagent : un acteur ne correspond pas à un agent, mais à une conversation. Un agent est une définition (un modèle, un prompt système, des outils) ; chaque session ouverte avec lui devient un acteur Substrate, créé directement en sommeil.

Le lab ouvre donc 1, puis 10, puis 30 conversations réparties sur trois agents, et mesure ce qui se passe dans le cluster.

Trente conversations, trente acteurs endormis, et toujours un seul pod worker, qui n'occupe qu'une quinzaine de mégaoctets. Le nombre de pods ne dépend que du nombre de répliques du WorkerPool, la seule variable de capacité. On le dimensionne pour les tours qui tournent en même temps, pas pour le nombre d'agents ou de conversations. Dans le lab, un même worker a d'ailleurs fait tourner plusieurs acteurs à la fois ; ce sont ses limites de ressources qui fixent le plafond (par défaut, kagent réserve 1 Go par tour en cours).

Pour un responsable de plateforme, cela change la question à se poser. On ne demande plus « combien d'agents allons-nous héberger ? », mais « combien de tours vont tourner en même temps, au pic ? ».

Dormir sans coûter : suspend/resume

Une conversation passe l'essentiel de son temps à dormir. Quand un message arrive, Substrate attribue un worker à l'acteur, le restaure depuis son snapshot, l'agent répond, puis l'acteur est remis en sommeil dès la fin du tour.

Dans le lab, la restauration elle-même prend entre 75 et 140 ms selon les essais, appel au modèle non compris. C'est cohérent avec les « moins de 500 ms » annoncés par Google, sur une machine bien moins puissante qu'un nœud de production.

Le journal du worker détaille chaque restauration. Il raconte un point que les annonces passent sous silence.

La moitié du temps sert à attendre que l'agent redémarre. Dans la configuration de kagent 1.0, le snapshot ne contient que le volume /data de l'agent, pas la mémoire de son processus : à chaque réveil, le conteneur redémarre et relit son état sur disque. gVisor sait restaurer un sandbox mémoire comprise, mais ce n'est pas ce que nous avons observé avec kagent.

Trois conséquences pour qui conçoit ou héberge des agents :

  • L'état doit vivre sur disque. Tout ce qui n'est pas dans /data est perdu au tour suivant, y compris les connexions réseau ouvertes.
  • Chaque message paie un réveil. kagent n'applique pas de délai d'inactivité : il endort la conversation à chaque fin de tour. Le démarrage de l'agent doit donc être rapide et sans effet de bord.
  • Un agent ne surveille rien tout seul. Puisqu'il dort entre deux messages, la surveillance d'un système se confie à un composant déterministe qui le réveille quand un événement survient.

Isoler : le noyau n'est pas la frontière

Un agent exécute du code produit par un modèle. Le principe qui s'impose est simple : on considère que l'agent peut être compromis, et on place les contrôles en dehors de lui.

Substrate en applique deux. D'abord, chaque acteur tourne dans un sandbox gVisor, un noyau applicatif qui traite les appels système en espace utilisateur. Dans le lab, la sandbox voit un noyau 4.19.0-gvisor, alors que l'hôte tourne sur 6.12.76-linuxkit : pour atteindre le noyau de l'hôte, il faudrait d'abord casser gVisor.

Ensuite, tout le trafic sortant passe par une passerelle d'egress, fermée par défaut. Un agent n'atteint que ce que son modèle d'agent déclare : le fournisseur de modèle, ses serveurs MCP, et les destinations ouvertes explicitement par une EgressPolicy.

apiVersion: api.kagent.dev/v1alpha3
kind: EgressPolicy
metadata:
  name: lab-allow-example
  namespace: kagent
spec:
  destinations:
    - origin: https://example.com

Dans le lab, une destination non déclarée ne se résout même pas (Could not resolve host). Une fois la politique appliquée, example.com répond en 200, la passerelle journalise la requête, et le reste d'Internet reste fermé.

Le dernier contrôle concerne les secrets. L'agent ne détient jamais la clé du fournisseur de modèle : sa variable d'environnement ne contient qu'un leurre, kagent-credential-injected, que la passerelle remplace par la vraie clé à la sortie. Dans le lab, nous avons demandé à l'agent d'afficher cette variable avec son propre outil bash : il n'a vu que le leurre. Un agent compromis ne peut donc pas exfiltrer une clé qu'il ne possède pas.

Ce que ça change pour votre plateforme

Si vous envisagez d'héberger des agents sur votre plateforme Kubernetes, voici les points que le lab nous a fait toucher du doigt :

  • Kubernetes 1.37 au minimum. Substrate s'appuie sur les API PodCertificateRequest et ClusterTrustBundle, disponibles par défaut à partir de cette version.
  • Dimensionner pour les tours simultanés. Le WorkerPool se règle sur le pic de tours en cours, avec des limites de ressources explicites sur les workers.
  • Un stockage objet durable pour les snapshots. L'installation d'évaluation embarque un petit stockage local ; en production, les snapshots doivent vivre dans un vrai bucket.
  • Une base PostgreSQL de production. kagent et Substrate y gardent leur état, chacun dans son schéma.
  • L'egress comme du code. Chaque modèle d'agent déclare ses destinations, et chaque EgressPolicy se relit comme une règle de pare-feu.
  • Des secrets hors des agents. Les clés restent dans des Secrets Kubernetes, et la passerelle les injecte à la sortie. Ces Secrets peuvent eux-mêmes être alimentés depuis votre gestionnaire de secrets (Vault, Infisical, celui de votre cloud…) par External Secrets Operator, comme pour le reste de la plateforme : la rotation d'une clé ne touche jamais les agents.
  • Des agents conçus pour redémarrer. État sur disque, démarrage idempotent, reconnexion systématique.
  • Des versions épinglées. Dans notre lab, la documentation « latest » de kagent référençait déjà une image plus récente que la version 1.0.0, incompatible avec elle. Sur un projet aussi jeune, on épingle tout et on vérifie.

Ce que ça ne règle pas

Ces briques résolvent la densité, le sommeil et l'isolation. Elles laissent plusieurs questions ouvertes.

  • Les chiffres de densité restent ceux des éditeurs. Notre lab montre le mécanisme ; il ne mesure pas le gain face à un pod par agent, et un portable n'est pas un nœud de production.
  • Le projet est jeune. Agent Substrate est public depuis six mois et sa version 1.0 a quelques jours. kagent 1.0 change d'API et de runtime : il n'y a pas de mise à jour en place depuis la version 0.x.
  • Les GPU ne sont pas de la partie. La documentation GKE exclut le passthrough GPU : Substrate vise les agents qui appellent un modèle distant, pas ceux qui font tourner un modèle local.
  • La gouvernance reste à construire. Substrate fournit les mécanismes : sandbox, egress fermé, clés injectées. Décider qui a droit à quoi, plafonner les dépenses, auditer et rejouer ce qu'un agent a fait relève d'une autre couche. C'est ce que commencent à proposer des outils comme Kyverno derrière Agent Router, ou des plateformes comme celle de Mirantis. Ce sera le sujet d'un prochain article.

Un agent IA n'est pas un microservice, et KubeCon NA 2026 a donné à Kubernetes les primitives pour le traiter comme tel. Reste à les intégrer à la plateforme existante, avec les mêmes exigences que pour le reste : versions maîtrisées, contrôles en dehors du workload, et une gouvernance que l'on peut expliquer.

Pour aller plus loin

Le lab

Agent Substrate et kagent

Isolation et gVisor

Primitives Kubernetes et écosystème

© Gravitek. Tous droits réservés.

logo

Gravitek est une Société à taille humaine, guidée par la qualité de service et la construction d'une relation durable avec ses clients.