Comment créer votre première boucle d'agent IA avec Kimi K3 (Configuration détaillée incluse)

Une boucle d'agent, c'est la différence entre demander de l'aide à une IA et se réveiller avec le travail terminé. La plupart des gens n'en construisent jamais une parce que cent itérations sur un modèle de pointe coûtent cher.

À l'intérieur : le pattern de la boucle expliqué en un diagramme, deux configurations exactes (Claude Code et API brute), et les maths du cache qui font de K3 la machine à boucler.

Ta première boucle tourne ce soir pour environ 0,39 $ par tour.

Voici la configuration complète 👇

Avant de plonger, je partage des notes quotidiennes sur l'IA et le vibe coding dans ma chaîne Telegram : https://t.me/zodchixquant 🧠

Ce qu'est vraiment une boucle

Enlève le marketing, une boucle c'est quatre étapes en répétition :

1OBJECTIF → TENTATIVE → VÉRIFICATION → (mieux ? garder : réessayer)
2        ↑__________________________|

• Objectif : une ligne d'arrivée mesurable, pas une ambiance. « Tous les tests passent », « la page se charge en moins d'1 s », « score supérieur à 90 »
• Tentative : le modèle effectue une unité de travail vers cet objectif
• Vérification : quelque chose valide le résultat par rapport à l'objectif. Une suite de tests, un linter, un second modèle
• Répéter : renvoyer le résultat de la vérification, recommencer, s'arrêter quand l'objectif est atteint ou que le budget est épuisé

C'est tout. Tout le reste (mémoire, sous-agents, exécutions nocturnes) n'est que décoration sur ce cycle.

Pourquoi K3 spécifiquement : l'économie de la boucle

Les boucles relisent le même contexte à chaque tour : le code source, l'objectif, l'historique. Sur la plupart des modèles, tu paies le plein tarif pour cette répétition. Sur K3, non :

1Coût par tour = fresh_tokens × $3/M + cached_tokens × $0.30/M
2
3Forme réelle (800K contexte stable + 50K nouveaux par tour) :
4K3 :       $0.24 + $0.15 = $0.39/tour
5Fable 5 :  850K × $10/M  = $8.50/tour

Une boucle nocturne de 50 tours : environ 20 $ sur K3, environ 425 $ sur Fable 5. Ce n'est pas une réduction, c'est la différence entre « laisse tourner » et « surveille comme un aigle ».

La seule règle : garde ton contexte stable comme un préfixe identique à chaque tour, la tâche à la fin, pour que le cache touche effectivement.

Configuration A : Claude Code (le chemin en 5 minutes)

Si tu vis dans Claude Code, les boucles sont intégrées et K3 s'insère en dessous via la configuration officielle de Moonshot :

1export ANTHROPIC_BASE_URL=https://api.moonshot.ai/anthropic
2export ANTHROPIC_AUTH_TOKEN=${YOUR_MOONSHOT_API_KEY}
3export ANTHROPIC_MODEL=kimi-k3
4export ANTHROPIC_DEFAULT_OPUS_MODEL=kimi-k3
5export ANTHROPIC_DEFAULT_SONNET_MODEL=kimi-k3
6export ANTHROPIC_DEFAULT_HAIKU_MODEL=kimi-k3
7export CLAUDE_CODE_SUBAGENT_MODEL=kimi-k3
8export ENABLE_TOOL_SEARCH=false
9export CLAUDE_CODE_AUTO_COMPACT_WINDOW=1048576
10claude

Ensuite, la boucle tient en deux commandes :

• /goal définit la ligne d'arrivée : « tous les tests dans tests/ passent et la couverture reste au-dessus de 80 % ». Claude Code continue de travailler jusqu'à l'atteindre au lieu de s'arrêter à la première réponse
• /loop la rend récurrente : la session se relance selon un planning ou jusqu'à ce que l'objectif tienne

Confirme que tu es sur K3 avec /status (le menu /model ne l'affichera pas). La fenêtre de compactage automatique de 1M dans la configuration signifie que les longues boucles se compactent rarement, ce qui maintient l'historique d'itération en vie.

Configuration B : la boucle API brute (contrôle total)

Pour les boucles en dehors de Claude Code, voici une boucle minimale complète, compatible OpenAI :

1from openai import OpenAI
2
3client = OpenAI(
4    api_key=MOONSHOT_API_KEY,
5    base_url="https://api.moonshot.ai/v1",
6)
7
8# Préfixe stable : identique à chaque tour = hits du cache à 0,30 $/M
9STABLE = f"""Tu es un agent de codage dans une boucle.
10OBJECTIF : faire passer tous les tests dans le projet ci-dessous.
11PROJET :
12{project_dump}
13RÈGLES :
14- Un changement ciblé par tour
15- Explique ce que tu as changé et pourquoi en 2 lignes
16- Si les tests passent, réponds exactement : GOAL_REACHED
17"""
18
19history = []
20MAX_TURNS = 30
21
22for turn in range(MAX_TURNS):
23    result = run_tests()          # ta vérification : pytest, npm test, etc.
24    if result.passed:
25        print(f"Fait en {turn} tours")
26        break
27
28    response = client.chat.completions.create(
29        model="kimi-k3",
30        messages=[
31            {"role": "system", "content": STABLE},
32            *history[-6:],        # 3 derniers échanges, plafonnés
33            {"role": "user", "content":
34                f"Tour {turn}. Résultat des tests :\n{result.output}\n"
35                f"Corrige la prochaine erreur."},
36        ],
37    )
38    change = response.choices[0].message.content
39    apply_change(change)          # écrire la modification, commit sur une branche
40    history += [
41        {"role": "user", "content": f"Résultat des tests du tour {turn} donné"},
42        {"role": "assistant", "content": change},
43    ]

Trois détails essentiels :

• La vérification est du code, pas des impressions. run_tests() décide du progrès, le modèle ne s'évalue jamais lui-même
• L'historique est plafonné. Seulement les 3 derniers échanges ; le préfixe stable porte le contexte durable et reste friendly pour le cache
• Chaque modification va sur une branche. La boucle peut se tromper 10 fois tant que main ne la voit jamais

Garde-fous avant de t'éloigner

• Arrêt budgétaire : compte les tokens par tour, arrête la boucle à un plafond de dollars. MAX_TURNS ne suffit pas, un tour gonflé peut consommer plus que dix tours normaux
• Arrêt sur progression : si le même test échoue 3 tours de suite, arrête et signale. Les boucles qui ne convergent pas brûlent l'argent poliment
• Un piège K3 : le raisonnement tourne en mode max-only pour l'instant, donc chaque tour produit toute la pensée à 15 $/M. Garde les tours ciblés, une erreur par tour, et le côté sortie reste raisonnable

Erreurs courantes

• Objectifs vagues. « Améliore le code » boucle à l'infini. Une boucle ne vaut que par la vérifiabilité de sa ligne d'arrivée
• Laisser le modèle s'auto-évaluer. « Ça me semble correct » est ainsi que les boucles livrent des déchets. Le vérificateur doit être externe : tests, linter, ou un second modèle avec une grille d'évaluation
• Casser le cache. Les horodatages, ID aléatoires ou fichiers réordonnés dans ton préfixe font que chaque tour est facturé à 3 $/M au lieu de 0,30 $. Identique signifie identique
• Pas de discipline de branche. Une boucle non supervisée avec accès en écriture à main est une histoire d'horreur avec des étapes supplémentaires
• Commencer par des exécutions nocturnes. Lance tes premières boucles en les surveillant, 10-15 tours. Gagne la confiance avant de dormir dessus

La configuration en 15 minutes

1. Récupère une clé API Moonshot, recharge dans la fenêtre de bonus de 10-30 %, valable jusqu'au 11 août (3 min)
2. Choisis la configuration A ou B et câble-la (5 min)
3. Écris un objectif vérifiable pour une vraie petite tâche : un test qui échoue, un passage de lint (2 min)
4. Effectue 10 tours supervisés, regarde la vérification piloter le travail (4 min)
5. Note le coût. Décide ensuite de la taille de la prochaine boucle (1 min)

La boucle est la plus vieille idée en programmation appliquée à l'outil le plus récent. K3 vient juste de la rendre assez abordable pour être réellement utilisée.

Merci d'avoir lu !

Je partage des notes quotidiennes sur l'IA et le vibe coding dans ma chaîne Telegram : https://t.me/zodchixquant 🧠