Agents d’IA pour les ingénieurs de demain : mémoire, outils et boucles de contrôle
Une carte pratique des éléments de base des agents — planification, outils, mémoire et évaluation — sans un vocabulaire exagéré qui viendrait remplacer la notion de conception.
Ce guide permet de reconstituer un parcours fonctionnel pour : Tout ce que les ingénieurs en IA doivent savoir sur les agents d’IA. L’accent est mis sur les contrats, les vérifications et le code que l’on peut intégrer dans un dépôt sans devoir deviner l’intention derrière lui. Pour une vue d’ensemble, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans avoir à deviner l’état caché. Préférez des unités petites et testables plutôt que des scripts complexes. Lorsqu’une étape échoue, l’échec doit indiquer une seule responsabilité plutôt qu’un processus embrouillé.
Comment les agents prennent des actions
Pour déterminer la manière dont les agents agissent, il convient de définir les entrées, le responsable de l’étape et les critères de fin avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu, sans avoir à deviner l’état caché. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Donnez des noms aux artefacts, définites des vérifications de succès et refusez les terminaisons partielles silencieuses. Restreignez strictement les schémas des outils. Des arguments de texte libre trop larges favorisent les injections et rendent les audits coûteux.
import requests
def search_web(query: str) -> list[dict]:
response = requests.get(
"https://serpapi.com/search",
params={"q": query, "api_key": "YOUR_API_KEY", "num": 5},
)
results = response.json()["organic_results"]
return [
{"title": r["title"], "url": r["link"], "snippet": r["snippet"]}
for r in results
]
results = search_web("best sourdough recipe")
for r in results:
print(r["title"], "-", r["url"])
import anthropic
client = anthropic.Anthropic()
# The menu of tools the model can choose from
tools = [
{
"name": "web_search",
"description": "Search the web for current information.",
"input_schema": {
"type": "object",
"properties": {
"query": {"type": "string", "description": "The search query"}
},
"required": ["query"],
},
}
]
response = client.messages.create(
model="claude-sonnet-4-6",
max_tokens=1024,
tools=tools,
messages=[{"role": "user", "content": "What's the weather in Seattle right now?"}],
)
print(response.content)
# [ToolUseBlock(name='web_search', input={'query': 'Seattle weather today'})]
# 1. Parse the LLM response to find the tools it wants to run
tool_calls = [block for block in response.content if block.type == "tool_use"]
# 2. Run the functions directly, OUTSIDE of the LLM
# (this is our search_web function from earlier -- plain Python,
# the model never sees this code)
tool_results = []
for call in tool_calls:
if call.name == "web_search":
output = search_web(call.input["query"])
tool_results.append(
{
"type": "tool_result",
"tool_use_id": call.id,
"content": str(output),
}
)
# 3. Hand the results back -- from the model's perspective,
# the answer just shows up in the chat
final = client.messages.create(
model="claude-sonnet-4-6",
max_tokens=1024,
tools=tools,
messages=[
{"role": "user", "content": "What's the weather in Seattle right now?"},
{"role": "assistant", "content": response.content},
{"role": "user", "content": tool_results},
],
)
print(final.content[0].text)
# "It's 62 and cloudy in Seattle."
Tâches à plusieurs étapes
Pour les tâches à plusieurs étapes, définissez les entrées, le responsable de chaque étape ainsi que les critères d’achèvement avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu, sans avoir à deviner l’état caché. Enregistrez les temps d’exécution et les coûts à côté des résultats fonctionnels. Une visibilité précoce évite des factures inattendues lorsque le processus passe d’un environnement de démonstration à un environnement partagé. Restreignez strictement les schémas des outils ; des arguments de texte libre trop larges facilitent les injections et rendent les audits coûteux.
# The ReAct loop
while True:
response = client.messages.create(
model="claude-sonnet-4-6",
max_tokens=1024,
tools=tools,
messages=messages,
)
messages.append({"role": "assistant", "content": response.content})
# If the model didn't ask for any tools, it's done -- that's its final answer
if response.stop_reason != "tool_use":
break
# Otherwise: run the tools, append the results, and go around again
tool_results = []
for block in response.content:
if block.type == "tool_use":
output = run_tool(block.name, block.input)
tool_results.append(
{"type": "tool_result", "tool_use_id": block.id, "content": str(output)}
)
messages.append({"role": "user", "content": tool_results})
print(response.content[0].text)
# "Booked it into your calendar -- cheapest flight was the 9:15am Alaska
# departure Friday at $138. Event added from 9:15am to 11:30am."
Résultats fiables
Pour des résultats fiables, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans devoir lire l’ensemble du système. Restreignez strictement les schémas des outils. Des arguments de texte libre trop larges favorisent les injections et rendent les audits coûteux. Pour des résultats fiables, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Préférez des unités petites et testables à des scripts complexes. Lorsqu’une étape échoue, l’échec doit pointer vers une seule responsabilité plutôt que vers un pipeline embrouillé.
system_prompt = """You have access to a web_search tool.
To use it, respond with JSON in this format:
{"name": "web_search", "input": {"query": "..."}}
CRITICAL: You MUST respond with ONLY valid JSON. NO other text.
NO markdown. NO code fences. NO explanations before or after.
Your ENTIRE response must be parseable by json.loads().
DO NOT FORGET THE COMMAS. CHECK YOUR BRACKETS.
If you output anything that is not valid JSON, the system WILL CRASH.
THIS IS EXTREMELY IMPORTANT. VALID JSON ONLY.
"""
Entrées de haute qualité
Pour des entrées de haute qualité, définissez les entrées, le responsable de l’étape et les critères de fin avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Donnez des noms aux artefacts, définites des vérifications de succès et refusez les terminations partielles silencieuses. Créez un point de contrôle après des appels coûteux au modèle afin qu’un nouvel essai ne facture pas à nouveau le même travail.
tools = [
{
"name": "web_search",
"description": "Search the web for current information.",
"input_schema": {
"type": "object",
"properties": {"query": {"type": "string"}},
"required": ["query"],
},
},
{
"name": "add_calendar_event",
"description": "Add an event to the user's calendar.",
"input_schema": {
"type": "object",
"properties": {
"title": {"type": "string"},
"start_time": {"type": "string"},
},
"required": ["title", "start_time"],
},
},
# ...plus read_email, send_email, get_flights, book_flight,
# read_file, write_file, run_code, and 20 more
]
Faire confiance à votre agent
Pour faire confiance à votre agent, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Enregistrez les temps d’exécution et les coûts à côté des résultats fonctionnels. Une visibilité précoce évite des factures inattendues lorsque le processus passe d’un environnement de démonstration à un environnement partagé. Créez un point de contrôle après des appels de modèles coûteux afin qu’un nouvel essai ne génère pas à nouveau des frais pour le même travail.
Liste de contrôle opérationnelle
Pour la liste de contrôle opérationnelle, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché.
Dokumentez ensemble le parcours normal et le parcours de récupération. Les tentatives de relance, les contrôles humains et la gestion des messages non traités font partie intégrante du produit, et non d’une amélioration ultérieure.
Point de contrôle après les appels aux modèles coûteux afin qu’une tentative de réessai ne facture pas à nouveau le même travail.
Ajoutez un test de fumée qui met en œuvre le chemin critique dans l’CI avec des fixtures lorsque les budgets le permettent.
Préférez des unités petites et testables à des scripts complexes. Lorsqu’une étape échoue, l’échec doit indiquer une seule responsabilité plutôt qu’un processus embrouillé.
Point de contrôle après les appels aux modèles coûteux afin qu’une tentative de réessai ne facture pas à nouveau le même travail.
Au préalable de promouvoir l’ensemble technique, figez les versions, conservez une transcription exemplaire pour le chemin critique et confirmez les étapes de rollback. Les environnements partagés nécessitent des limites de débit, des vérifications de location et un responsable clair pour la rotation des secrets. Préférez une fiabilité simple à des démonstrations originales mais peu fiables.
Pour la note de renforcement 0, définissez les entrées, le responsable de l’étape et les critères de sortie avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché.
Enregistrez les temps d’exécution et les coûts à côté des résultats fonctionnels. Une visibilité précoce évite des factures inattendues lorsque le processus passe de l’environnement de démonstration à des environnements partagés.
Restreignez strictement les schémas des outils. Des paramètres de texte libre trop larges facilitent les injections et rendent les audits coûteux.
Pour la note de renforcement 1, définissez les entrées, le responsable de l’étape et les critères de sortie avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché.
Dokumentez ensemble le parcours normal et le parcours de récupération. Les tentatives de répétition, les contrôles humains et la gestion des messages non livrés font partie intégrante du produit, et non d’une amélioration ultérieure.
Point de contrôle après les appels aux modèles coûteux afin qu’une tentative de réexécution ne facture pas à nouveau le même travail.
Pour la note 2 sur le renforcement de la sécurité, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir réexécuter l’étape à partir d’un point de contrôle connu sans deviner l’état caché.
Considérez cette étape comme un contrat entre les entrées et les sorties validées. Donnez des noms aux artefacts, définissez des vérifications de succès et refusez les terminaisons partielles silencieuses.
Séparez la planification de l’exécution des outils. Le planificateur propose ; l’exécutant modifie ; le vérificateur compare les résultats à l’objectif fixé.
Pour la note 3 sur le renforcement de la sécurité, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir réexécuter l’étape à partir d’un point de contrôle connu sans deviner l’état caché.
Gardez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans avoir à lire l’ensemble du système.
Serrée les schémas des outils utilisés. Les arguments de texte libre trop larges favorisent les injections et rendent les audits coûteux.
Pour le point 4 relatif au renforcement de la sécurité, définissez les entrées, le responsable de l’étape et les critères de fin avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché.
Préférez des unités petites et testables plutôt que des scripts complexes. Lorsqu’une étape échoue, l’échec doit indiquer une seule responsabilité et non un pipeline embrouillé.
Créez un point de contrôle après chaque appel coûteux au modèle afin qu’un nouvel essai ne nécessite pas de refaire le même travail.
Pour la note de renforcement 5, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché.
Enregistrez les temps d’exécution et les coûts à côté des résultats fonctionnels. Une visibilité précoce évite des factures inattendues lorsque le processus passe de l’environnement de démonstration à des environnements partagés.
Séparez la planification de l’exécution des outils. Le planificateur propose ; l’exécutant modifie ; le vérificateur contrôle les résultats par rapport à l’objectif.
Pour la note de renforcement 6, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché.
Dokumentez ensemble le parcours idéal et le parcours de récupération. Les tentatives de réessai, les contrôles humains et la gestion des messages non livrés font partie intégrante du produit, et non d’une mise en forme ultérieure.
Les schémas des outils doivent être strictement encadrés. Les arguments de texte libre abondants favorisent les injections et rendent les audits coûteux.
Conformément à la note 7 sur le renforcement de la sécurité, définissez les entrées, le responsable de l’étape et les critères de fin avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché.
Considérez cette étape comme un contrat entre les entrées et les sorties validées. Donnez des noms aux artefacts, définites des vérifications de succès et refusez les terminations partielles silencieuses.
Créez un point de contrôle après chaque appel coûteux au modèle afin qu’un nouvel essai ne nécessite pas de refacturer le même travail.
Conformément à la note 8 sur le renforcement de la sécurité, définissez les entrées, le responsable de l’étape et les critères de fin avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché.
Gardez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans devoir lire l’ensemble du système.
Séparez la planification de l’exécution des outils. Le planificateur propose ; l’exécutant modifie ; le vérificateur contrôle les résultats par rapport à l’objectif fixé.
Pour renforcer la sécurité selon la note 9, définissez les entrées, le responsable de chaque étape ainsi que les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu, sans avoir à deviner l’état caché du système.
Préférez des unités petites et testables plutôt que des scripts complexes. Lorsqu’une étape échoue, l’échec doit permettre d’identifier une seule responsabilité, et non un processus embrouillé.
Restreignez strictement les schémas des outils. Des arguments de texte libre trop larges facilitent les injections et rendent les audits coûteux.
Pour la note de renforcement 10, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché.
Enregistrez les temps d’exécution et les coûts à côté des résultats fonctionnels. Une visibilité précoce évite des factures inattendues lorsque le processus passe d’un environnement de démonstration à des environnements partagés.
Créez un point de contrôle après des appels de modèles coûteux afin qu’un nouvel essai ne génère pas à nouveau des frais pour le même travail.
Pour la note de renforcement 11, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché.
Dokumentez ensemble le parcours idéal et le parcours de récupération. Les tentatives de relance, les contrôles humains et la gestion des messages non livrés font partie intégrante du produit, et non d’une mise en forme ultérieure.
Séparez la planification de l’exécution des outils. Le planificateur propose ; l’exécutant modifie ; le vérificateur contrôle les résultats par rapport à l’objectif.
Pour la note de renforcement 12, définissez les entrées, le responsable de l’étape et les critères de sortie avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché.
Considérez cette étape comme un contrat entre les entrées et les sorties validées. Donnez des noms aux artefacts, définissez des vérifications de succès et refusez les terminaisons partielles silencieuses.
Restreignez strictement les schémas des outils. Des arguments de texte libre trop larges favorisent les injections et rendent les audits coûteux.
Pour la note de renforcement 13, définissez les entrées, le responsable de l’étape et les critères de sortie avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché.
Gardez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans avoir à lire l’ensemble du système.
Créez un point de contrôle après chaque appel coûteux au modèle afin qu’un nouvel essai ne nécessite pas de refaire le même travail.
Pour la note 14 relative au renforcement de la sécurité, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché.
Préférez des unités petites et testables plutôt que des scripts complexes. Lorsqu’une étape échoue, l’échec doit indiquer une seule responsabilité et non un pipeline embrouillé.
Séparez la planification de l’exécution des outils. Le planificateur propose ; l’exécutant met à jour ; le vérificateur compare les résultats avec l’objectif fixé.
Pour la note de renforcement n°15, définissez les entrées, le responsable de l’étape et les critères de fin avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché.
Enregistrez les temps d’exécution et les coûts à côté des résultats fonctionnels. Une visibilité précoce évite des factures inattendues lorsque le processus passe de l’environnement de démonstration à des environnements partagés.
Restreignez strictement les schémas des outils. Des arguments de texte libre trop larges facilitent les injections et rendent les audits coûteux.