Tu as écrit cinquante lignes de Python. Un system prompt, une liste d'outils, un appel au modèle. Ton agent réserve des salles, interroge des bases de données, envoie des emails. Ça marche parfaitement dans ton terminal. On met en prod ?

Ouvre ton fichier de tests d'abord. Vas-y. Essaie d'écrire un test pour quelque chose qui donne une réponse différente à chaque fois qu'on lui pose la question.

Le problème du non-déterminisme dont personne ne veut parler

Voilà à quoi ressemble un test Python classique :

def test_add():
    assert add(2, 2) == 4  # déterministe. toujours 4.

Voilà à quoi ressemble un test d'agent :

def test_booking_agent():
    result = agent.run("Réserve une salle demain 14h")
    assert result == ???  # on met quoi ici ?
    # L'agent pourrait dire "C'est fait ! Salle A réservée à 14h"
    # ou "J'ai réservé la salle de conférence A pour demain à 14:00"
    # ou "Réservé ! Salle A, 27 avril, 14h00"
    # Toutes correctes. Toutes différentes.

Un LLM — le cerveau derrière ChatGPT, Claude, Gemini — est non-déterministe. Même entrée, sortie différente. À chaque fois. Ton assertEqual ne sert à rien. Ce n'est pas un bug. C'est la propriété fondamentale qui rend les agents utiles. Et c'est ce qui les rend quasi impossibles à tester avec les outils sur lesquels les développeurs s'appuient depuis des décennies.

Trois SDK sortis ce mois-ci. Zéro commande de test.

Trois SDK majeurs pour agents — des boîtes à outils pour construire des agents IA — sont sortis en avril. Anthropic a lancé Managed Agents API le 8 avril. OpenAI a mis à jour son Agents SDK le 15 avril. Google a livré ADK 1.0 avec Agent Simulation au Cloud Next le 22 avril. Les trois te filent des primitives de build et de run. Aucun n'inclut une commande de test.

Ce n'est pas une comparaison de trois éditeurs. C'est un pattern. L'industrie entière — chaque grand labo d'IA — a décidé que les tests, c'était ton problème.

Ce qu'ils proposent à la place

Google s'en est le plus approché. Au Cloud Next, ils ont annoncé Agent Evaluation — un service cloud qui note ton agent sur la complétion des tâches, l'utilisation des outils et la sécurité. Vraiment utile pour les métriques système. Mais ça tourne sur Vertex AI, ça coûte environ 0,50 à 2,00 $ par évaluation selon la complexité, et ça prend plusieurs minutes. Lance-le à chaque pull request sur un repo actif et tu te retrouves avec 300 $+ par mois rien qu'en frais d'évaluation — avant les appels API. Ce n'est pas un test unitaire. C'est un événement de facturation.

L'API Managed Agents d'Anthropic fournit du tracing — un log de chaque étape de ton agent — mais zéro utilitaire de test. Pas de mock model, pas d'enregistrement de réponses, pas de helpers d'assertion.

OpenAI propose un paramètre seed pour une reproductibilité partielle, mais "partielle" signifie "parfois la même sortie, parfois non". Essaie de construire du CI/CD — des pipelines de déploiement automatisé — sur du "parfois".

Le pattern d'assertion comportementale

La communauté a trouvé un contournement. Au lieu d'asserter sur du texte exact, on asserte sur des patterns comportementaux — quels outils l'agent a appelés, dans quel ordre, et s'il s'est arrêté quand il le devait :

def test_booking_agent_behavior(recorded_responses):
    trace = agent.run("Réserve une salle demain 14h")
    
    # Assert sur les appels d'outils, pas sur le texte
    assert trace.tool_calls[0].name == "check_availability"
    assert trace.tool_calls[1].name == "create_booking"
    assert "room" in trace.tool_calls[1].args
    assert trace.completed  # pas de boucle infinie

Des projets open-source comme DeepEval et Promptfoo ouvrent la voie. Aucun ne s'intègre nativement avec les trois SDK. Tu recolles les morceaux toi-même.

Chaque contournement a un prix

Mocker le modèle ? Tu perds le raisonnement du LLM qui fait la valeur des agents — tu testes une marionnette, pas un agent. Les tests par snapshot — enregistrer une réponse exacte pour la comparer plus tard ? Ils cassent à chaque mise à jour du modèle ou modification de prompt. Les évaluations cloud ? Des minutes et des euros par pull request. Les assertions comportementales ? Difficiles à écrire, encore plus à maintenir, et tu construis essentiellement un framework de test from scratch pour chaque projet.

La tension de fond : les ingénieurs ont construit des outils de test pour du logiciel déterministe. Les agents ne sont ni déterministes ni, à proprement parler, du logiciel au sens traditionnel. Ce sont des systèmes stochastiques déguisés en logiciel.

Ce qu'il faut faire concrètement maintenant

Aucun éditeur ne viendra te sauver. Voilà ce qui marche, en assumant pleinement l'absurdité — tu inventes de l'infrastructure de test en 2026 parce que trois entreprises pesant des milliers de milliards n'ont pas jugé bon de s'en occuper :

  1. Enregistre de vraies réponses LLM comme fixtures de référence — des réponses validées que tu rejoues dans tes tests au lieu d'appeler le modèle à chaque fois. Oui, tu construis à la main de la plomberie de test que le SDK aurait dû livrer. Non, l'ironie ne nous échappe pas.

  2. Asserte sur les séquences d'appels d'outils, pas sur le texte final. L'agent a-t-il appelé check_availability avant create_booking ? Ça suffit. Ton cerveau formaté à assertEqual va hurler. Laisse-le faire.

  3. Lance des smoke tests contre de vrais modèles via un cron quotidien, pas à chaque pull request. Détecte la dérive du modèle sans cramer ton budget CI.

  4. Traite les tests d'agents comme des tests d'intégration — plus lents, moins nombreux, plus utiles — pas comme des tests unitaires. Cinq bons tests comportementaux battent cinquante snapshots fragiles. Quiconque te dit de "juste écrire plus de tests" n'a jamais essayé de tester un truc qui génère un haïku différent sur les réservations de salles à chaque exécution.

# Pratique : pattern record & replay
import json

def record_golden_fixture(agent, prompt, path):
    """Lance une fois contre le vrai modèle, sauvegarde la trace."""
    trace = agent.run(prompt)
    with open(path, "w") as f:
        json.dump(trace.to_dict(), f)
    return trace

def test_from_fixture(mock_agent, fixture_path):
    """Rejoue la trace sauvegardée, asserte sur la structure."""
    with open(fixture_path) as f:
        golden = json.load(f)
    mock_agent.load_trace(golden)
    result = mock_agent.replay()
    assert [c["name"] for c in result.tool_calls] == [
        "check_availability", "create_booking"
    ]

Le premier éditeur qui livre agent test rafle la mise

Django a capté les développeurs web avec manage.py test. Rails l'a fait avec rails test. Le premier SDK d'agents qui fera du test une primitive par défaut — pas un upsell cloud à 0,50 $ le run, pas un addon tiers, mais une commande locale qui marche hors ligne — capturera la couche développeur au-dessus de la qualité du modèle et du nombre d'outils.

L'agent non testable, c'est le nouveau microservice non testé. Tout le monde le met en prod. Tout le monde le regrette six mois plus tard. À l'heure actuelle, cette commande agent test n'existe dans aucun des trois SDK majeurs.

Ton fichier de tests est toujours vide.