IA agentielle vs IA générative : Comprendre le passage de la création à l'action

IA agentique vs IA générative : Comprendre le passage de la création à l'action

Le paysage de l'intelligence artificielle connaît une transformation profonde. Depuis deux ans, les discussions sont dominées par l'**IA générative** — des modèles qui créent du texte, des images, du code et de la musique à partir de simples instructions. Mais un nouveau paradigme émerge : l'**IA agentique** — des systèmes qui non seulement génèrent du contenu, mais agissent également dessus, prennent des décisions, exécutent des workflows multi-étapes et interagissent avec le monde.

Cet article explore les différences fondamentales entre l'IA générative et l'IA agentique, pourquoi ce changement est important, et comment vous pouvez commencer à construire des systèmes agentiques dès aujourd'hui avec des exemples concrets et pratiques.

Qu'est-ce que l'IA générative ?

L'IA générative désigne des modèles qui produisent du nouveau contenu à partir de motifs appris sur de vastes ensembles de données. Ces modèles — comme GPT-4, DALL·E et Claude — excellent dans :

• **La génération de texte** : Rédaction d'articles, de code, de poésie ou de résumés.
• **La création d'images** : Production de visuels à partir de descriptions textuelles.
• **La synthèse audio** : Génération de musique ou de parole.
• **L'augmentation de données** : Création d'ensembles de données synthétiques.

L'IA générative est **réactive** : elle répond à une instruction et produit un résultat. Elle ne planifie pas intrinsèquement, ne raisonne pas sur des objectifs à long terme et n'interagit pas avec des systèmes externes. Le résultat est la fin du processus.

Qu'est-ce que l'IA agentique ?

L'IA agentique représente un pas au-delà de la génération. Un agent IA est un système qui :

• **Perçoit** son environnement (via des API, des bases de données, des capteurs ou des entrées utilisateur).
• **Raisonner** sur des objectifs et des sous-tâches.
• **Agit** en exécutant des commandes, en appelant des outils ou en modifiant l'état.
• **Apprend** des retours pour améliorer ses actions futures.

Les agents peuvent décomposer un objectif complexe comme « Planifier un séminaire d'équipe à San Francisco » en sous-tâches : rechercher des lieux, vérifier la disponibilité, comparer les prix, réserver des vols et envoyer des invitations de calendrier. Chaque étape implique des décisions et des interactions avec des systèmes externes.

La distinction clé : **l'IA générative crée ; l'IA agentique exécute.**

Principales différences en un coup d'œil

| Dimension | IA générative | IA agentique | |-----------|---------------|--------------| | **Résultat principal** | Contenu (texte, image, code) | Actions (appels API, opérations fichiers, décisions) | | **Style d'interaction** | Tour unique (instruction → réponse) | Boucles multi-tours orientées objectif | | **Gestion d'état** | Sans état (généralement) | Avec état (suit la progression, mémoire) | | **Utilisation d'outils** | Rare (sauf dans certains outils basés sur des instructions) | Capacité centrale (appelle des API externes, bases de données) | | **Récupération d'erreurs** | Limitée (régénère le résultat) | Proactive (réessaie, ajuste la stratégie) | | **Niveau d'autonomie** | Faible (humain dans la boucle typique) | Moyen à élevé (peut fonctionner indépendamment) |

Pourquoi ce changement est important

Le passage de l'IA générative à l'IA agentique est motivé par des besoins pratiques :

• **Automatisation** : Les entreprises veulent une IA qui non seulement rédige un email mais aussi l'envoie, planifie des suivis et met à jour les enregistrements CRM.
• **Workflows complexes** : Des tâches comme « Déployer un serveur cloud et configurer un pare-feu » nécessitent plusieurs étapes, une logique conditionnelle et une gestion des erreurs — au-delà de ce qu'un seul appel génératif peut faire.
• **Fiabilité** : Les agents peuvent vérifier les résultats, réessayer les opérations échouées et escalader les problèmes, réduisant ainsi le besoin de supervision humaine constante.

Le blog Microsoft AI a souligné comment les agents sont intégrés dans les outils de productivité, tandis que les actualités Anthropic ont discuté des implications de sécurité liées à l'octroi de plus d'autonomie aux modèles. Le blog NVIDIA AI a couvert l'infrastructure nécessaire pour exécuter des systèmes agentiques à grande échelle.

Prérequis pour construire un système agentique

Pour suivre les exemples ci-dessous, vous aurez besoin de :

• **Python 3.9+** installé sur votre système.
• Un **éditeur de code** (VS Code recommandé).
• Une **clé API OpenAI** (ou un accès à tout fournisseur LLM prenant en charge l'appel de fonctions).
• Une familiarité de base avec les **interfaces en ligne de commande** et les **environnements virtuels Python**.

Nous allons construire un agent simple capable d'effectuer des opérations sur fichiers et des recherches web en fonction de l'objectif d'un utilisateur.

Installation étape par étape

1. Configurer un environnement virtuel Python

Isolez les dépendances pour éviter les conflits avec d'autres projets.

python -m venv agent-env
source agent-env/bin/activate  # Sur Windows : agent-env\Scripts\activate

2. Installer les paquets requis

Nous utiliserons la bibliothèque `openai` pour l'accès LLM et `requests` pour les appels HTTP.

pip install openai requests python-dotenv

• `openai` : Client Python officiel pour l'API OpenAI.
• `requests` : Pour effectuer des requêtes HTTP vers des services externes.
• `python-dotenv` : Charge les variables d'environnement depuis un fichier `.env`.

3. Créer un fichier `.env` pour votre clé API

Stockez les identifiants sensibles en toute sécurité.

echo "OPENAI_API_KEY=votre_cle_ici" > .env

Remplacez `votre_cle_ici` par votre véritable clé API OpenAI. Ne commettez jamais ce fichier dans le contrôle de version.

4. Écrire le script agent principal

Créez un fichier nommé `agent.py` avec la structure suivante :

import os
import json
import requests
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

# Définir les outils que l'agent peut utiliser
tools = [
    {
        "type": "function",
        "function": {
            "name": "read_file",
            "description": "Lire le contenu d'un fichier texte",
            "parameters": {
                "type": "object",
                "properties": {
                    "filepath": {"type": "string", "description": "Chemin vers le fichier"}
                },
                "required": ["filepath"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "write_file",
            "description": "Écrire du contenu dans un fichier texte",
            "parameters": {
                "type": "object",
                "properties": {
                    "filepath": {"type": "string", "description": "Chemin vers le fichier"},
                    "content": {"type": "string", "description": "Contenu à écrire"}
                },
                "required": ["filepath", "content"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "web_search",
            "description": "Rechercher des informations sur le web",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "Requête de recherche"}
                },
                "required": ["query"]
            }
        }
    }
]

# Implémentations des outils
def read_file(filepath):
    with open(filepath, 'r') as f:
        return f.read()

def write_file(filepath, content):
    with open(filepath, 'w') as f:
        f.write(content)
    return f"Écrit dans {filepath}"

def web_search(query):
    # Recherche simplifiée avec DuckDuckGo (pas de clé API nécessaire)
    url = f"https://api.duckduckgo.com/?q={query}&format=json&no_html=1"
    response = requests.get(url)
    data = response.json()
    # Extraire le texte des premiers résultats
    results = data.get("AbstractText", "") or data.get("RelatedTopics", [{}])[0].get("Text", "Aucun résultat trouvé")
    return results[:500]  # Tronquer pour la brièveté

# Boucle agent
def run_agent(user_goal):
    messages = [{"role": "user", "content": user_goal}]
    
    while True:
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=messages,
            tools=tools,
            tool_choice="auto"
        )
        
        message = response.choices[0].message
        messages.append(message)
        
        if message.tool_calls:
            for tool_call in message.tool_calls:
                func_name = tool_call.function.name
                func_args = json.loads(tool_call.function.arguments)
                
                if func_name == "read_file":
                    result = read_file(**func_args)
                elif func_name == "write_file":
                    result = write_file(**func_args)
                elif func_name == "web_search":
                    result = web_search(**func_args)
                else:
                    result = f"Fonction inconnue : {func_name}"
                
                messages.append({
                    "role": "tool",
                    "tool_call_id": tool_call.id,
                    "content": str(result)
                })
        else:
            # Pas d'appels d'outils → réponse finale
            return message.content

# Exemple d'utilisation
if __name__ == "__main__":
    goal = input("Entrez votre objectif : ")
    result = run_agent(goal)
    print("\nRéponse de l'agent :\n", result)

Ce script définit trois outils (`read_file`, `write_file`, `web_search`) et une boucle qui permet au LLM de décider quels outils appeler, d'interpréter les résultats et de continuer jusqu'à ce qu'il produise une réponse finale.

Exemples d'utilisation

Exemple 1 : Résumé de fichier

Exécutez l'agent et donnez-lui un objectif impliquant la lecture d'un fichier :

python agent.py

Lorsque vous y êtes invité, entrez :

Lis le fichier notes.txt, résume-le et enregistre le résumé dans summary.txt

L'agent va : 1. Appeler `read_file("notes.txt")` pour obtenir le contenu. 2. Générer un résumé en utilisant ses propres capacités linguistiques. 3. Appeler `write_file("summary.txt", contenu_du_resume)` pour l'enregistrer.

Exemple 2 : Recherche et rapport

Entrez un objectif comme :

Recherche les dernières nouvelles sur les agents IA en 2025, puis rédige un bref rapport dans report.txt

L'agent va : 1. Appeler `web_search("agents IA 2025 actualités")` pour récupérer des informations. 2. Composer un rapport basé sur les résultats de recherche. 3. Enregistrer le rapport en utilisant `write_file`.

Exemple 3 : Workflow multi-étapes

Lis todo.txt, recherche le premier élément de cette liste et enregistre les résultats de recherche dans research.txt

Cela démontre comment l'agent enchaîne plusieurs appels d'outils : d'abord lire un fichier, puis utiliser son contenu comme requête de recherche, et enfin écrire le résultat.

Comment l'IA agentique diffère en pratique

Du point de vue d'un développeur, le passage de l'IA générative à l'IA agentique change la façon dont vous concevez les systèmes :

• **IA générative** : Vous appelez une API une fois, obtenez une réponse et la présentez à l'utilisateur. Le modèle ne maintient pas d'état ni ne se souvient des interactions précédentes.
• **IA agentique** : Vous implémentez une boucle qui échange des messages, maintient un historique des appels d'outils et des résultats, et permet au modèle de raisonner sur la suite des actions.

La boucle agent dans notre exemple est une version simplifiée du modèle **ReAct** (Raisonnement + Action), largement utilisé dans les systèmes de production. Des frameworks plus avancés comme LangChain, AutoGPT ou Semantic Kernel de Microsoft s'appuient sur ce modèle avec des fonctionnalités supplémentaires comme la mémoire, la planification et la récupération d'erreurs.

Défis et considérations

Fiabilité

Les agents peuvent commettre des erreurs, comme appeler le mauvais outil ou mal interpréter les résultats. Une gestion robuste des erreurs et une validation avec un humain dans la boucle sont essentielles.

Latence

Le raisonnement multi-étapes prend du temps. Chaque appel d'outil ajoute des allers-retours réseau et du temps d'inférence LLM. L'optimisation de la vitesse nécessite une conception minutieuse.

Sécurité

Comme l'a noté les actualités Anthropic, donner de l'autonomie aux modèles introduit des risques. Les agents pourraient exécuter des actions non intentionnelles (par exemple, supprimer des fichiers ou effectuer des appels API non autorisés). Il faut toujours cloisonner les permissions des agents et valider les appels d'outils.

Coût

Chaque étape dans une boucle agent consomme des tokens. Un seul objectif peut déclencher 5 à 10 appels LLM, augmentant les coûts par rapport à une seule requête générative.

L'avenir : Des outils aux systèmes autonomes

La trajectoire est claire : l'IA générative devient un composant au sein de systèmes agentiques plus vastes. Au lieu de demander « Écris-moi un poème », les utilisateurs diront « Planifie l'anniversaire de ma fille — envoie les invitations, commande le gâteau, réserve le lieu et configure les rappels. »

Des entreprises comme OpenAI, Microsoft et Anthropic investissent massivement dans l'infrastructure agentique. Le blog NVIDIA AI a discuté de la façon dont l'inférence accélérée par GPU permet aux agents d'effectuer des tâches de raisonnement complexes plus rapidement, tandis que le blog Microsoft AI a présenté des agents intégrés dans Office 365 et Azure.

Conclusion

L'IA générative a débloqué la capacité de créer du contenu à grande échelle. L'IA agentique s'appuie sur cette base en permettant aux systèmes d'agir — de planifier, exécuter et s'adapter pour atteindre des objectifs concrets.

Le passage de la création à l'action n'est pas seulement une évolution technique ; c'est un changement dans notre façon de concevoir le rôle de l'IA. L'IA générative est un outil que vous maniez. L'IA agentique est un collaborateur qui fait avancer les choses.

Commencez modestement : construisez un agent qui lit et écrit des fichiers. Ajoutez la recherche web. Puis étendez aux API, bases de données et services cloud. L'architecture est la même — une boucle de raisonnement, d'utilisation d'outils et d'itération. Ce qui change, c'est la complexité des objectifs que vous pouvez atteindre.

L'ère de l'IA agentique a commencé. La question n'est plus « Que peut créer l'IA ? » mais « Que peut accomplir l'IA ? »