Un agent de codage est un système d’IA qui utilise un grand modèle de langage comme noyau de raisonnement pour écrire, exécuter et itérer sur du code de manière autonome. Contrairement à un assistant de codage qui suggère des complétions dans votre éditeur, un agent de codage exécute une boucle complète d’observation-décision-action : il lit des fichiers, écrit des modifications, exécute des commandes, vérifie la sortie et révise jusqu’à ce que la tâche soit accomplie.
Cet article explique le fonctionnement de cette boucle — le planificateur, la couche d’inférence LLM, les outils et l’environnement d’exécution en bac à sable — puis montre comment en assembler un en utilisant l’API LLM de Novita et le bac à sable Agent Sandbox. Si vous voulez la couche d’outils prêts à l’emploi plutôt que la couche agent, consultez Meilleurs outils de codage IA en 2026. Si vous voulez la variante spécifique à Claude de cette boucle, lisez Qu’est-ce qu’un agent de codage Claude ?.
Si vous voulez la version pratique du workflow de cette même boucle, voir Comment automatiser des tâches avec l’IA.
Si vous comparez spécifiquement les outils open source, voir Agents de codage open source : meilleurs outils et comment en construire un.
Ce qui fait d’un agent un agent de codage
La différence entre un assistant de codage et un agent de codage réside dans l’exécution. Un assistant de codage génère une suggestion et s’arrête. Un agent de codage IA génère du code, l’exécute, lit le résultat et continue jusqu’à ce que l’objectif soit atteint — ou jusqu’à ce qu’il se bloque.
Cette capacité d’exécution a trois exigences concrètes :
- Accès aux outils — la capacité de lire des fichiers, d’écrire des fichiers et d’exécuter des commandes shell
- Un environnement en bac à sable — un endroit pour exécuter du code sans endommager le système hôte en cas d’erreur
- Un contexte persistant — les sorties des outils sont renvoyées dans le contexte du modèle afin qu’il puisse raisonner sur ce qui s’est passé
Sans ces trois éléments, vous avez un chatbot qui peut écrire du code. Avec ces trois éléments, vous avez un agent.
Le terme « agent de code » est utilisé de manière large pour couvrir tout, des suggestions en ligne dans l’IDE aux systèmes entièrement autonomes capables de prendre une tâche vague, de déterminer quels fichiers sont concernés, d’apporter des modifications et de vérifier qu’elles fonctionnent — sans intervention humaine à chaque étape. Lorsque les développeurs comparent les options du « meilleur agent de code », ils font généralement référence à ce dernier type : des systèmes qui accomplissent de manière fiable des tâches de codage en plusieurs étapes avec un minimum d’accompagnement.
Les quatre couches d’un agent de codage
Chaque agent de codage IA de qualité production possède quatre composants reconnaissables. Les détails d’implémentation varient — différents frameworks, différents LLM, différents fournisseurs de bac à sable — mais l’architecture est cohérente.
1. Le planificateur
Le planificateur reçoit la description de la tâche et la décompose en étapes que l’agent exécutera. Pour les tâches simples, cela se produit implicitement dans le raisonnement du modèle. Pour les tâches complexes — « migrer ce service pour utiliser la nouvelle bibliothèque d’authentification » — une étape de planification explicite produit une liste de tâches numérotées que le modèle parcourt, en mettant à jour l’état après chaque étape.
La planification détermine également quand s’arrêter. Un agent sans critère de complétion continuera à ajouter des améliorations indéfiniment ou, pire, bouclera sur une étape échouée. La plupart des implémentations codent la condition de réusite de la tâche dans le prompt systèm et laissent le modèle déider quand il a fini.
2. La couche d’inférence LLM
Le LLM est le noyau de raisonnement de tout agent de codage IA. Il déide quel outil appeler ensuite, quels argiments passer et comment interpréter le résutat. Cete déision est exprimée comme un apel d’outil structuré — un objt JSON avec le nom de la fonctin et les paramètres — que le framework envoie à la couche d’éxécution réele.
Pour les agents de codage, le LLM doit gérer de longues contextes de manière fiable (les résutats des outils s’accumulent vite), renvoyer des apels d’outil bien formés de manière cohérete (un JSON mal structuré à l’éape 6 d’un workflow en 10 éapes casse toute l’écution), et raisoner sur les changements d’état à travers de nombrux apels d’outil séquntiels.
Le fourniseur d’inférence importe ici. Vous avez besoin d’une API qui supporte l’apel de fonction en format compatible OpenAI, des sorties structurées pour forcer un JSON valide au niveau du modèle, et des limies de concurrence suffisantes pour les charhes d’agent qui génèrent des sous-têches parallèles. L’API LLM de Novita AI couvre tout cela avec un point de termaison compatible OpenAI, ce qui signifie que vous pouvez changer de modèle sans rere la logice de parsage des apels d’outil.
3. La couche d’outils
Les outils sont l’interface de l’agent avec le monde. Un agent de codage minimal a besoin de quatre outils :
| Outil | Ce qu’il fait |
|---|---|
read_file |
Renvoyer le contenu d’un fichier à un chemin donné |
write_file |
Écrire une chaîne dans un chemin de fichier |
run_command |
Exécuter une commande shell et renvoyer stdout + stderr |
list_directory |
Lister les fichiers et dossiers à un chemin |
Chaque outil doit renvoyer une sortie complète. Des résultats tronqués ou des échecs silencieux corrompent le modèle de l’agent sur la base de code et provoquent des erreurs cumulatives plus tard. L’outil run_command en particulier doit capturer à la fois stdout et stderr — l’agent apprend souvent plus des sorties d’erreur que des sorties de succès.
Certains agents ajoutent un outil search_files pour une rechche de type grep sur une base de code, ou un outil fetch_url pour lire de la documention exerne. L’enemble approprié déend du domaine de la tâche. Pour le travail de codage pur, les quatre ci-dessus couvrent la plupar des cas.
4. Le bac à sable
Le bac à sable est un environement Linux complètement isolé où les commandes de l’agent sont réellement exécutées. Cela importe pour deux raisons.
Premièrement, la séurité. Les agents génèrent du code à partir de prompt utilisateur, de documention récupérée et de motif inférés. Même un agent bien intnionné peut produire du code qui suprime des fichirs, ouvre des connexions réseau ou conomme des ressourc illimitées. Un bac à sable contient tout dégât à l’intérieur d’un environement isolé.
Deuxièmement, l’état. Un bon bac à sable préserve l’état du système de fichirs à travers les apels d’outil au sein d’une session. Si l’agent crée un fichir à l’éape 2, il doit encre être là à l’éape 8. Les approch de conteneur sans état — où chaque commande s’exécute dans un environement frais — ne fonctonnet pas pour les tâch de codage réeles.
Le bac à sable d’agent Novita est basé sur des microVM Firecracker, offrant une isolation au niveau du noyau plus forte que les conteneurs standrd. Les sessions peuvent durer jusqu’à 24 heurs, l’état du système de fichirs perste à travers les commandes, et le démarage à froid est inférir à 200 ms. C’est assz rapide pour que l’atente du bac à sable n’inerrompt pas un workflow interctif.
Comment fonctonne la boucle d’éxécution
Un exmple conret rend la boucle plus facile à suivre. Imaginons que la tâche soit : « Ajouter une limitiion de débit à l’point de termaison /login. »
- Plnifier — le modèle lit la tâche et idntifie ce dont il a besoin : trouver la route de connexion, comprndre le gestinnaire actuel, ajouter un middleware de limitiion de débit, vérifer avec un test.
- Observer — l’agent apèle
list_directorypour trouver les fichirs de route, puisread_filesur le gestinnaire de connexion. Le contenu des fichirs est ajouté au contecte du modèle. - Décider — le modèle raisonne sur le code actuel et déide ce qu’il faut faire : inaler la bibliothèqe de limitiion de débit, modificr le gestinnaire, ajouter un test.
- Agir — l’agent apèle
run_command("pip install slowapi"), puiswrite_fileavec le gestinnaire modifié, puisrun_command("pytest tests/test_login.py"). - Observer à nouveau — la sortie du test est renvoyée dans le contexte. Si les tests échouent, le modèle lit la trace, idntifie l’erreur et écrit un fichir corigé.
- Terminer — quand les tests passent et que le modèle n’a plus d’étapes en atente, il renvoie un résumé final.
Cete boucle s’exécute au sein d’une seule session. La fenêtre de contecte est la mémoire de travail de l’agent — chaque fichir lu, chaque sortie de commande, chaque apel d’outil s’y accolule. C’est pourquou la longueur du contecte importe taut pour les agents de codage : une tâche de refctoring réele peut facilement remplir 100K token à l’éape15. Voir comment les agents solcitent différment les fourniseurs d’inférence que le chat à un seul tour.
Conruire un agent de codage avec Novita
L’exmple suivant assemble l’API LLM de Novita et le bac à able d’agent. Il utilize le SDK Python OpenAI pointé vers l’point de termaisn de Novita — les modèles de Novita utilizing la même interface d’apel de fonctin que l’API d’OpenAI, donc l’intégration ne nécessite pas de parsage personnalisé.
import os
import json
from openai import OpenAI
from novita_sandbox.code_interpreter import Sandbox
client = OpenAI(
base_url="https://api.novita.ai/openai",
api_key=os.environ["NOVITA_API_KEY"],
)
sandbox = Sandbox.create(timeout=1800)
def read_file(path: str) -> str:
try:
return sandbox.files.read(path)
except Exception as e:
return f"Error: {e}"
def write_file(path: str, content: str) -> str:
try:
sandbox.files.write(path, content)
return f"Written to {path}"
except Exception as e:
return f"Error: {e}"
def run_command(cmd: str) -> str:
try:
result = sandbox.commands.run(cmd)
return str(result)
except Exception as e:
return f"Error: {e}"
tools = [
{
"type": "function",
"function": {
"name": "read_file",
"description": "Read the contents of a file",
"parameters": {
"type": "object",
"properties": {"path": {"type": "string"}},
"required": ["path"],
},
},
},
{
"type": "function",
"function": {
"name": "write_file",
"description": "Write content to a file",
"parameters": {
"type": "object",
"properties": {
"path": {"type": "string"},
"content": {"type": "string"},
},
"required": ["path", "content"],
},
},
},
{
"type": "function",
"function": {
"name": "run_command",
"description": "Run a shell command in the sandbox and return output",
"parameters": {
"type": "object",
"properties": {"cmd": {"type": "string"}},
"required": ["cmd"],
},
},
},
]
dispatch = {
"read_file": read_file,
"write_file": write_file,
"run_command": run_command,
}
def run_agent(task: str, model: str) -> str:
messages = [
{
"role": "system",
"content": (
"You are a coding agent with access to a Linux sandbox. "
"Complete tasks by calling tools. When done, return a plain-text summary."
),
},
{"role": "user", "content": task},
]
while True:
response = client.chat.completions.create(
model=model,
messages=messages,
tools=tools,
tool_choice="auto",
)
msg = response.choices[0].msg
messages.append(msg)
if not msg.tool_calls:
return msg.content
for call in msg.tool_calls:
fn = dispatch[call.function.name]
args = json.loads(call.function.arguments)
result = fn(**args)
messages.append(
{
"role": "tool",
"tool_call_id": call.id,
"content": result,
}
)
# Remplacez <model-id> par un modèle d'appel de fonction depuis novita.ai/docs
result = run_agent(
task="Write a Python script that counts words in a text file and run it on a sample input",
model="<model-id>",
)
print(result)
sandbox.kill()
Quelques points à noter sur cette implémentation :
- La boucle
while Trues’éxécute jusqu’à ce que le modèle renvoie un message sans apel d’outil — c’est le signl que l’agent considère la tâch termnée. - Les résutats des outls sont ajoutés à
messagesen tan qu’éntrésrole: tool`. C’est ce qui cosntruit le contexte partagé à travers les étapes. sandbox.kill()libère les ressourc de calcul. Appelez-le toujour quand la session se termine.
Pour les IDs de modèles d’apel de fonction pris en charge, conultez la documentation d’apel de fonction Novita. Pour une procédure plus complète incluant une interface Gradio, voir Conruire un agent de codage avec le bac à able d’agent Novita.
Choisir le bon LLM pour les agents de codage
HumanEval et SWE-bench mesurent la génération de code en un seul tour. Les charg de travail des agents sont différnts — ce qui casse réellement les agents de codage de production, ce sont les échecs de formatage des apels d’outil. Un modèle qui obtient de bons scoores sur les benchmarks mais renvoi occasionellement du JSON mal formé lor de sessions complexes à plusieurs trours échouera de manière difficile à déboguer.
Les critèr d’évaluation pratiue pour les agents de codage IA :
- Fiabilité des apels d’outil — avec quelle consistance le modèle renvoie-t-il des apels d’outil bien formés sur des sessions de plsu de 20 étapes ?
- Rétention du contecte — le modèle réfénce-t-il corectement un fichier qu’il a lu il y a 40 étapes ?
- Respect des instructions — l’agent reste-t-il sur la tâch, ou commence-t-il à modifier des fichirs sans rappport ?
- C rectude du code — le code généré s’éxécute-t-il rélemment, ou nécessite-t-il plusieur boucles de corection ?
Exécuter un ensembl représentatif de tâch de codage réelles et mesurer le taux d’achèvement est plus infrmatif que n’impor quel benchmark public. Chosissez 20 à 30 tâch de votre propre base de code, exécutez-les contre des modèles candidats et compter combien se terminent sans interventon humaine.
La tarification d’inférence se comose rapidement à l’échelle des agents. Une seule session peut conommer 200K à 500K tokens sur tous les tours. Les fourniseurs qui offrent du caching de prompt et des tarifs compétitifs par token changent coonsidérablement l’économie lorsque vous exécutez des centaines de sessions d’agent par jour.
Les modèles open source comme voie éconmique
Les modèles frontir closed-source ont été en têe sur les benchmarks de codage, mais l’écart avec les modèles open source haut de gamme s’est consdérablement rétréti. Des modèles comme DeepSeek V3 et Qwen3 sont maintenant compétitifs sur la génération de code et l’utilisation d’outils — et parce qu’ils sont servis via des API compatibles OpenAI, changer de modèle est un changment d’une ligne dans le paramètre model.
Les deux sont disponbles via l’API LLM de Novita. Vous bénéficiez du même point de termaison, de la même interface d’apel de fonction, et de la même intégration avec le bac à able d’agent — sans gérer vous-même l’infrastrcture GPU. Cela importe car l’orchestration GPU, le batchin et l’ingénierie de fiabilité sont non trivials ; les déléguer à une API gérée vous permet de vous concentrer sur la logique de l’agent.
Pourquoi cela importe spécifiqulement pour les agents de codage : les coûts de token par session détermnent l’éconmie des charg de travail des agents plsu que les frais de license. Une ééquip exécutant 200 sessions d’agent de codage par jour qui atteint des taux d’achèvement de tâch comparabes avec un modèle open source peut réduire consdérablement les dépns d’inférence sans changer du tout leur code d’intégration.
Le test pratique : exécutez 50 tâch de codage réprésntatives avec votre modèle cible, mesurez le taux de succès des apels d’outil et le taux d’achèvement de tâche, puis comparz au coût par session. Les chiffres de benchmark ne répondront pas à cette queston — votre charge de travail réelle le fera.
FAQ
Quelle est la différence entre un agent de codage et un assistant de codage ?
Un assitant de codage (comme les suggetions en ligne de Gitub Copilot) génère des complétions et s’arrête. Un agent de codage éxécute le code, lit la sortie et itère. La caractéristque déffinissante est la boucle d’éxécution : lire, déider, agir, observer, répéter. Voir Agent de codage en CLI vs IDE pour une comparaison de la façn dont différnts facteurs d’agent utilisent cete boucle.
Ai-je besoin d’un bac à able pour contruire un agent de codage ?
Oui, si l’agent doit exécuter du code généré à partir de saisie utilisateur ou de sources exernes. Sans isoltion, une génration de code bugguée peut endommager le système de fichirs hôte ou conommer des ressourc illimitées. Même pour les cas d’usage interne seul, un bac à able empêche les processus incontrôlés d’afecter l’hôte. Les conteneurs fournisent une isoltion de base ; les bacs à able basés sur microVM comme celui de Novita offrent une séparation plus forte au niveau du noyau pour les charges de travail multi-locatai ou sensibles à la séurité.
Un agent de codage peut-il fonctioner sans accès Internet ?
Pour la plupar des tâchs de codage pur, oui. La lecture/écriture de fichirs et l’éxécution de commandes local c orient la majorité des workflows. Restrindre les sorties au sein du bac à able est en fait un bon principe par défaut — cela empêche le code généré de faire des requetes exernes inatendues et simplifie votre modèle de menaces.
Qu’est-ce qui détermin le meillur agent de codage pour une tâche donnée ?
La fiabité des apels d’outil et le taux d’achèvement de tâche sur votre charge de travail rélle. Les classements de benchmark publics sont un point de départ pour préséectioner des modèles, pas une répnse finle. Exécutez vos tâches répréntatives, mesurez le taux d’achèvement et tenez compte du coût en token par session. Le meillur agent de codage pour une petite startu qui fait de la réfactoration légère peut être très différnt de la meillre option pour une ééquipe d’enterprise exécutant une révision autoatique de PR à grande échelle.
Combien de temps une session d’agent de codage peut-elle durer ?
Cela dépend du fourniseur de bac à able. Le bac à sable d’agent Novita supporte des sessions jusqu’à 24 heurs, avec l’état du système de fichirs préservé à travers les commandes, ce qui couvre mème des tâch de réfactoration ou de migration étendues sans nécessiter de logice de chèque/restauration dans votre code d’agent.
