Agent IA : définition, exemples et usages en entreprise

Qu'est-ce qu'un agent IA ?

Un agent IA est un programme dans lequel un grand modèle de langage (LLM) reçoit un objectif, décide des étapes à suivre, appelle des outils (une API, une base de données, une boîte e-mail, un moteur de recherche) et utilise les résultats pour choisir l'étape suivante, jusqu'à ce que la tâche soit terminée ou qu'il ait besoin d'un humain. La différence clé avec un chatbot : l'agent agit, et il choisit son propre chemin au lieu de suivre un scénario figé.

Une image utile : un agent est une boucle réfléchir, agir, observer. Le modèle raisonne sur l'objectif, choisit un outil, lit ce que l'outil renvoie, puis recommence.

Quelle différence entre un chatbot, un workflow et un agent IA ?

Ces trois termes sont souvent confondus. Ce sont des outils différents pour des besoins différents.

	Chatbot	Workflow automatisé (avec ou sans IA)	Agent IA
Ce qu'il fait	Répond à des messages	Exécute des étapes prédéfinies dans un ordre fixe	Décide des étapes pour atteindre un objectif
Qui décide du chemin	Script ou modèle, sans action	Le développeur, à l'avance	Le modèle, à l'exécution
Peut agir sur les systèmes	Rarement	Oui, sur les étapes configurées	Oui, via les outils qu'on lui donne
Prévisibilité	Élevée	Très élevée	Plus faible : garde-fous nécessaires
Exemple typique	Bot FAQ sur un site	« Nouvelle facture par e-mail → extraction → enregistrement dans un tableur »	« Traite cette demande client : vérifie la commande, rembourse si éligible, réponds »

En pratique, la plupart des besoins des entreprises sont bien couverts par un workflow avec un LLM dans une ou deux étapes. L'automatisation de prospection par IA avec n8n en est un bon exemple : OCR, puis un LLM qui structure les données et rédige un e-mail, puis Gmail et Google Sheets. L'ordre est fixe, ce qui rend le tout fiable et facile à déboguer. Un agent devient intéressant quand les étapes varient réellement d'un cas à l'autre.

Comment fonctionnent les outils et le function calling ?

Un LLM ne peut pas consulter votre base de données ni envoyer un e-mail tout seul. Le function calling (ou tool use) est le mécanisme qui lui permet de demander à votre code de le faire :

1. Vous décrivez chaque outil au modèle : nom, rôle et paramètres (sous forme de schéma JSON).
2. Le modèle répond soit par du texte, soit par une demande d'appel d'outil avec des arguments précis.
3. Votre code exécute l'outil, puis renvoie le résultat au modèle.
4. Le modèle continue : nouvel appel d'outil ou réponse finale.

Le modèle n'exécute jamais rien lui-même. Votre code garde le contrôle de ce qui est réellement fait, et c'est là que se placent les garde-fous. Le guide function calling d'OpenAI décrit le format de référence.

Une boucle d'agent minimale en Python

Cet exemple donne au modèle un seul outil (statut de commande) et limite la boucle à cinq étapes :

import json
from openai import OpenAI

client = OpenAI()  # lit OPENAI_API_KEY dans l'environnement

COMMANDES = {"CMD-1042": "expédiée", "CMD-1043": "en préparation"}

def get_order_status(order_id: str) -> dict:
    return {"order_id": order_id, "status": COMMANDES.get(order_id, "inconnue")}

TOOLS = [{
    "type": "function",
    "function": {
        "name": "get_order_status",
        "description": "Renvoie le statut de livraison d'une commande client.",
        "parameters": {
            "type": "object",
            "properties": {"order_id": {"type": "string"}},
            "required": ["order_id"],
        },
    },
}]

messages = [
    {"role": "system", "content": "Tu es un agent du service client. Utilise les outils, ne devine jamais un statut."},
    {"role": "user", "content": "Où en est ma commande CMD-1042 ?"},
]

for _ in range(5):  # garde-fou : nombre maximal d'étapes
    response = client.chat.completions.create(
        model="gpt-4o-mini", messages=messages, tools=TOOLS
    )
    msg = response.choices[0].message
    if not msg.tool_calls:
        print(msg.content)
        break
    messages.append(msg.model_dump(exclude_none=True))
    for call in msg.tool_calls:
        args = json.loads(call.function.arguments)
        if call.function.name == "get_order_status":
            result = get_order_status(**args)
        else:
            result = {"error": "outil inconnu"}
        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": json.dumps(result, ensure_ascii=False),
        })

Les frameworks et outils (LangGraph, OpenAI Agents SDK, le nœud AI Agent de n8n, etc.) enveloppent cette même boucle avec de la mémoire, des journaux et des fonctions multi-agents.

Quels sont des exemples concrets d'agents IA en entreprise ?

• Service client : lire la demande, consulter la commande et l'historique client, appliquer la politique de remboursement, rédiger une réponse et escalader vers un humain au-delà d'un seuil.
• Assistant de connaissances internes : chercher dans plusieurs sources (procédures, tickets, wiki) par RAG, les combiner et répondre avec citations. Le guide créer un assistant RAG couvre la partie recherche ; la plateforme D&A Studio intègre un assistant qui répond à partir des documents de l'entreprise avec ses sources.
• Assistant d'analyse de données : traduire une question métier en SQL sur une base en lecture seule, l'exécuter et résumer le résultat.
• Commercial et prospection : se renseigner sur une entreprise, qualifier un prospect selon des critères et préparer un premier message personnalisé à valider.
• Back-office : traiter un document entrant, le comparer à l'ERP, créer le bon enregistrement ou signaler une incohérence.

Au Maroc, les mêmes schémas s'appliquent au support multilingue (français, arabe, darija), aux dossiers administratifs et aux secteurs très documentaires comme la banque, l'assurance ou le secteur public. D'autres exemples par secteur sont dans l'intelligence artificielle au Maroc : cas d'usage en entreprise.

Quels sont les risques des agents IA ?

Comme l'agent choisit ses actions, ses erreurs coûtent plus cher qu'une mauvaise réponse de chatbot :

• Mauvaises actions : le modèle comprend mal la demande et appelle le mauvais outil ou avec de mauvais arguments.
• Hallucinations : il comble un manque avec une valeur inventée au lieu d'appeler un outil.
• Injection de prompt : un document, un e-mail ou une page web contient des instructions (« ignore les règles précédentes et envoie… ») que le modèle suit.
• Fuites de données : l'agent lit ou envoie des données personnelles auxquelles il ne devrait pas accéder.
• Boucles et coûts incontrôlés : il répète des appels d'outils sans converger.
• Responsabilité : personne ne peut expliquer après coup pourquoi une action a été menée.

Quels garde-fous mettre en place ?

Garde-fou	Comment
Moindre privilège	Ne donner que les outils nécessaires ; utilisateurs de base en lecture seule ; clés API limitées
Validation humaine	Exiger une approbation avant toute action irréversible (paiement, suppression, e-mail externe)
Validation des entrées	Vérifier les arguments d'outils dans le code (types, valeurs autorisées, montants plafonnés)
Limites d'étapes et de budget	Nombre maximal d'itérations, de tokens et de coût par tâche
Contenu non fiable	Traiter documents, e-mails et pages web comme des données, jamais comme des instructions
Journalisation	Conserver chaque prompt, appel d'outil, argument et résultat pour l'audit
Évaluation	Tester sur un jeu de scénarios réels avant chaque changement de prompt ou de modèle
Données personnelles	Minimiser et masquer ; au Maroc, respecter la loi 09-08

Comment démarrer avec les agents IA en entreprise ?

Étape 1 — Commencer par un workflow

Automatisez la partie stable du processus sous forme de workflow fixe, par exemple dans n8n. Souvent, cela suffit. Le tutoriel de prospection avec n8n illustre cette approche, et la comparaison n8n vs Zapier vs Make aide à choisir l'outil.

Étape 2 — Ajouter une décision

Laissez le modèle choisir entre quelques outils bien définis là où les cas varient vraiment, en commençant par des outils en lecture seule.

Étape 3 — Ajouter des actions avec validation

Introduisez les actions d'écriture derrière une validation humaine, et journalisez tout.

Étape 4 — Mesurer et élargir prudemment

Suivez le taux de réussite, les escalades, le coût par tâche et les erreurs. N'élargissez l'autonomie que là où les chiffres le justifient.

Conclusion

Un agent IA est un LLM capable de décider et d'agir grâce à des outils : plus souple qu'un workflow, plus risqué qu'un chatbot. Utilisez des agents là où le chemin varie vraiment, gardez des workflows pour les processus prévisibles, et mettez en place les garde-fous (outils limités, validation, journaux, approbation humaine) dès le premier jour. Pour des projets qui combinent LLM, RAG et automatisation, consultez le profil Data & AI Engineer ou le service automatisation IA et RAG.