IA agentique vs IA générative : Relier la création et l'action

IA agentique vs IA générative : relier la création et l'action

Ces deux dernières années ont transformé l’intelligence artificielle, la faisant passer d’une curiosité à un outil de productivité quotidien. Si vous suivez les canaux d’information officiels des principaux fournisseurs d’IA — OpenAI, Microsoft, NVIDIA et Anthropic — vous remarquerez une tendance claire. La conversation est passée de « que peut générer un modèle ? » à « que peut réellement accomplir un modèle ? ». Ce changement illustre la différence entre l’IA générative et l’IA agentique. L’une crée. L’autre agit. Comprendre les deux est important, mais c’est en les reliant que l’on trouve la véritable valeur.

L’état de l’IA : des chatbots aux travailleurs numériques

L’IA générative est devenue grand public avec l’arrivée des grands modèles de langage capables d’écrire des essais, de générer du code et de produire des images saisissantes. Les pages d’actualités d’OpenAI, le blog IA de Microsoft et les mises à jour d’Anthropic reflètent tous cette vague. La promesse initiale était simple : saisissez une invite, obtenez un résultat de haute qualité.

Mais une invite, à elle seule, n’accomplit pas une tâche. Rédiger un brouillon de rapport n’est pas la même chose que produire un rapport final, l’enregistrer dans le bon dossier, l’envoyer aux bonnes personnes et mettre à jour un outil de suivi de projet. C’est pourquoi l’industrie s’est orientée vers l’IA agentique. Le blog développeur de NVIDIA, par exemple, a consacré beaucoup de temps à expliquer comment les modèles génératifs sont transformés en systèmes autonomes qui interagissent avec des outils, des API et des environnements.

L’IA agentique ne remplace pas l’IA générative. Elle en est la couche supérieure. Si l’IA générative est le cerveau qui pense, l’IA agentique est le corps qui agit. Cet article explore la différence, vous montre pourquoi les deux comptent, et vous propose un chemin pratique pour construire votre premier système agentique.

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

L’IA générative désigne les modèles qui créent du nouveau contenu. À partir d’une invite, un modèle génératif produit du texte, du code, de l’audio, des images ou des vidéos. La caractéristique principale est que le modèle a appris des motifs à partir des données d’entraînement et peut générer des continuations statistiquement plausibles.

Exemples :

• Rédiger un e-mail à partir de quelques puces
• Ébaucher du code Python à partir d’un commentaire
• Générer une image marketing à partir d’une description textuelle
• Résumer un long document

Les modèles génératifs sont généralement **sans état**. Ils reçoivent une entrée, produisent une sortie et oublient l’interaction, sauf si vous conservez manuellement un historique de conversation. La sortie est le produit. Vous la prenez, vous la révisez et vous décidez de la suite.

En pratique, l’IA générative est un **assistant** incroyable. Elle peut vous rendre plus rapide en produisant des brouillons de haute qualité. Mais elle ne peut pas, à elle seule, boucler la boucle. Elle ne peut pas vérifier si sa sortie est correcte, s’intégrer à des systèmes externes ou se remettre d’erreurs imprévues.

Qu’est-ce que l’IA agentique ?

L’IA agentique s’appuie sur l’IA générative, mais elle déplace l’attention de la production d’une sortie vers l’accomplissement d’un objectif. Un agent est un système capable de planifier, de raisonner, d’utiliser des outils et d’exécuter des flux de travail en plusieurs étapes. Le modèle génératif joue toujours un rôle central — il sert de moteur de raisonnement à l’agent — mais la sortie n’est plus le produit final. L’objectif atteint l’est.

Considérez la différence :

• **L’IA générative** rédige un résumé de l’actualité du marché du jour.
• **L’IA agentique** lit l’actualité du marché du jour, rédige un résumé, analyse une base de données financière, met à jour un tableau de bord et vous envoie une notification avec un lien vers les résultats.

Un agent décide de ce qui doit se passer, dans quel ordre et avec quels outils. Si la première approche échoue, l’agent peut en essayer une autre. Si un outil renvoie des données inattendues, l’agent peut ajuster son plan. C’est ce que les ingénieurs appellent une **boucle fermée**.

Le blog IA de Microsoft a mis en avant cette idée à plusieurs reprises : les agents ne sont pas seulement des modèles, mais des « systèmes d’action ». Ils combinent un modèle avec une mémoire, des outils et une boucle d’exécution. Les actualités d’Anthropic ont également abordé « l’utilisation d’outils » comme une capacité centrale, où les modèles apprennent quand et comment appeler des fonctions externes.

Les principales différences en un coup d’œil

| Aspect | IA générative | IA agentique | |---|---|---| | Sortie principale | Contenu (texte, code, image) | Tâche accomplie | | État | Sans état par appel | Maintient mémoire et contexte | | Flux | Invite unique → réponse | Plan en plusieurs étapes → exécuter → vérifier | | Outils | Optionnels, généralement manuels | Essentiels, automatiques | | Gestion des erreurs | Aucune par elle-même | Peut réessayer et s’adapter | | Exemple d’utilisation | Rédiger un brouillon d’article de blog | Publier l’article et le partager |

Le tableau est simplifié, mais il capture la distinction fondamentale. L’IA générative concerne la **création**. L’IA agentique concerne l’**action**, rendue possible par la création.

Pourquoi cette distinction compte dans le travail réel

Pensez au flux de travail d’un développeur logiciel typique. Un modèle génératif peut écrire une fonction qui valide les adresses e-mail. C’est utile. Mais un véritable agent pourrait :

1. Lire le code source pour comprendre la logique de validation existante 2. Identifier les incohérences entre les modules 3. Écrire la nouvelle fonction de validation 4. Exécuter la suite de tests existante 5. Corriger les tests qui échouent 6. Créer une demande d’extraction (pull request) 7. Mentionner un relecteur

Chaque étape implique de la génération, mais le système global est agentique. La valeur ne réside pas dans l’extrait de code individuel. La valeur tient au fait qu’un processus en plusieurs étapes s’est déroulé sans qu’un humain soit présent à chaque étape.

C’est pourquoi les entreprises s’intéressent autant aux systèmes agentiques. Selon la couverture continue du blog développeur de NVIDIA, des outils comme la génération augmentée par récupération (RAG) et l’appel de fonctions ouvrent la voie à des agents capables de s’ancrer dans des données réelles et d’accomplir des actions concrètes. La conséquence pratique est que l’IA passe d’un moteur de suggestions à un moteur d’exécution.

Prérequis

Avant de commencer, voici ce dont vous aurez besoin pour la partie pratique de cet article.

• **Python 3.10 ou plus récent** : la plupart des frameworks d’IA modernes exigent des versions récentes de Python.
• **pip** : le gestionnaire de paquets de Python, inclus avec la plupart des installations.
• **Une clé API** : par exemple, une clé API OpenAI ou Anthropic. De nombreux frameworks utilisent par défaut des points de terminaison compatibles OpenAI.
• **Un terminal** : Terminal macOS, Windows PowerShell ou tout shell Linux.
• **Un accès Internet** : pour installer les paquets et appeler des modèles distants.

En option, un éditeur de code comme VS Code facilite la modification des scripts que nous allons créer.

Installation pas à pas

Laissez-moi vous guider dans l’installation des outils nécessaires pour construire à la fois une application générative et une petite équipe agentique.

Étape 1 : Créer un environnement virtuel

Un environnement virtuel garde les dépendances de votre projet isolées du reste de votre système. Dans votre terminal, exécutez :

python3 -m venv ai-env

Cela crée un dossier nommé `ai-env` contenant une installation Python isolée. Activez-le ensuite :

source ai-env/bin/activate

Sous Windows, la commande d’activation est légèrement différente :

ai-env\Scripts\activate

Étape 2 : Mettre à jour pip

Mettez d’abord à jour pip pour vous assurer d’obtenir les dernières versions des paquets :

pip install --upgrade pip

Étape 3 : Installer les paquets principaux

Nous allons installer deux bibliothèques. Le paquet `openai` nous permet d’appeler directement les modèles génératifs. Le paquet `crewai` nous permet d’orchestrer plusieurs agents travaillant vers un objectif commun.

pip install openai crewai

Cette commande télécharge les bibliothèques et leurs dépendances. Selon la vitesse de votre réseau, cela peut prendre une minute ou deux.

Étape 4 : Configurer votre clé API

La plupart des frameworks agentiques ont besoin d’une clé API pour appeler le modèle sous-jacent. Exportez-la comme variable d’environnement :

export OPENAI_API_KEY="votre-cle-api-ici"

Si vous utilisez plutôt des modèles Anthropic, vous exporteriez `ANTHROPIC_API_KEY`. Pour ce tutoriel, nous resterons avec OpenAI. Assurez-vous de remplacer `votre-cle-api-ici` par une vraie clé provenant de la plateforme OpenAI.

Étape 5 : Vérifier l’installation

Maintenant, effectuez une vérification rapide pour confirmer que tout est correctement installé :

python -c "import openai, crewai; print('Tous les paquets sont installés avec succès.')"

Si vous voyez le message de succès, vous êtes prêt à continuer.

Exemples d’utilisation

Construisons deux petits programmes pour voir la différence entre les approches générative et agentique en action.

Exemple 1 : Un appel d’IA purement génératif

Ce script utilise directement le SDK OpenAI. Il envoie une seule invite et affiche la réponse. Rien de plus.

from openai import OpenAI

client = OpenAI(api_key="VOTRE_CLE_API")

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {
            "role": "system",
            "content": "Vous êtes un rédacteur technique concis."
        },
        {
            "role": "user",
            "content": "Expliquez la différence entre l'IA générative et l'IA agentique en trois phrases."
        }
    ]
)

print(response.choices[0].message.content)

Avant d’exécuter ce script, enregistrez-le sous le nom `generative_example.py`. Dans votre terminal, exécutez :

python generative_example.py

Vous verrez une courte explication générée par l’IA. Elle est utile, mais il s’agit d’une interaction unique. L’IA ne recherche rien, ne vérifie rien et ne prend aucune autre mesure. La création et la responsabilité des étapes suivantes vous incombent entièrement.

Exemple 2 : Une petite équipe agentique

Construisons maintenant quelque chose de plus ambitieux. Nous allons définir deux agents. L’un recherche des sujets d’IA récents sur les pages d’actualités officielles des principaux fournisseurs. L’autre prend ces recherches et rédige une note dans un fichier markdown.

Enregistrez le code suivant sous `agentic_example.py` :

from crewai import Agent, Task, Crew, Process

researcher = Agent(
    role="Analyste de recherche en IA",
    goal="Identifier les tendances récentes de l'IA à partir des pages d'actualités des principaux fournisseurs d'IA.",
    backstory=(
        "Vous êtes un analyste expérimenté qui suit OpenAI News, "
        "le blog IA de Microsoft, le blog IA de NVIDIA et Anthropic News. "
        "Vous résumez les tendances sans inventer de détails."
    ),
    verbose=True
)

writer = Agent(
    role="Rédacteur de notes techniques",
    goal="Transformer les notes de recherche en une note concise et l'enregistrer dans un fichier.",
    backstory=(
        "Vous êtes un rédacteur technique qui crée des notes claires et actionnables. "
        "Vous enregistrez toutes vos sorties sous forme de fichiers markdown."
    ),
    verbose=True
)

research_task = Task(
    description=(
        "Examinez les derniers sujets abordés sur les pages d'actualités d'OpenAI, Microsoft, "
        "NVIDIA et Anthropic. Rapportez les thèmes généraux que vous observez. "
        "N'inventez pas de déclarations ou de statistiques spécifiques."
    ),
    expected_output="Une liste à puces des thèmes observés.",
    agent=researcher
)

writing_task = Task(
    description=(
        "Utilisez les notes de recherche pour rédiger une courte note markdown intitulée "
        "'ai_provider_updates.md'. Incluez une introduction et une liste à puces des thèmes. "
        "Le fichier doit être enregistré dans le répertoire courant."
    ),
    expected_output="Un fichier markdown nommé ai_provider_updates.md.",
    agent=writer
)

crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task],
    process=Process.sequential
)

result = crew.kickoff()
print(result)

Exécutez le script :

python agentic_example.py

Vous devriez voir les deux agents agir à tour de rôle. Le chercheur identifie les thèmes à partir des pages d’actualités. Le rédacteur convertit ces thèmes en fichier markdown. Une fois le script terminé, un nouveau fichier nommé `ai_provider_updates.md` devrait exister dans le répertoire courant.

Remarquez ce qui vient de se passer. Le système n’a pas seulement produit du texte. Il a accompli une tâche en plusieurs étapes :

• Il a consulté des sources externes,
• Il a raisonné sur les résultats,
• Il a rédigé un document structuré,
• Et il a enregistré ce document sur le disque.

C’est le cœur du comportement agentique : non pas seulement générer, mais **faire**, avec plusieurs étapes orchestrées vers un objectif.

Exemple 3 : Un modèle génératif dans une boucle d’agent

Si vous voulez comprendre le pont plus en profondeur, imaginez construire vous-même une simple boucle d’agent. L’idée est d’appeler un modèle génératif plusieurs fois, d’utiliser la sortie pour décider quel outil appeler, et de répéter jusqu’à ce que l’objectif soit atteint.

Voici un squelette en Python :

import json
from openai import OpenAI

client = OpenAI(api_key="VOTRE_CLE_API")

def calculer_somme(a, b):
    return a + b

def executer_agent(tache):
    schema_outil = {
        "name": "calculer_somme",
        "description": "Additionne deux nombres.",
        "parameters": {
            "type": "object",
            "properties": {
                "a": {"type": "number"},
                "b": {"type": "number"}
            }
        }
    }

    messages = [
        {"role": "system", "content": "Vous êtes un agent qui utilise des outils."},
        {"role": "user", "content": tache}
    ]

    for _ in range(5):
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=messages,
            tools=[{"type": "function", "function": schema_outil}],
            tool_choice="auto"
        )
        message = response.choices[0].message

        if message.tool_calls:
            for call in message.tool_calls:
                args = json.loads(call.function.arguments)
                result = calculer_somme(args["a"], args["b"])
                messages.append({
                    "role": "tool",
                    "tool_call_id": call.id,
                    "content": json.dumps({"result": result})
                })
        else:
            return message.content

    return "L'agent n'a pas terminé la tâche."

print(executer_agent("Quel est le résultat de 12 plus 34 ? Veuillez utiliser l'outil disponible."))

Cet exemple montre la boucle : modèle → appel d’outil → résultat d’outil → modèle à nouveau. Le modèle génératif décide de l’action à entreprendre, l’action s’exécute, et le résultat est réinjecté dans le modèle. C’est exactement ainsi que fonctionnent les agents en production.

Relier les deux : conseils pratiques

La frontière entre l’IA générative et l’IA agentique n’est pas un mur. En pratique, chaque agent contient des composants génératifs. La question est de savoir comment architecturer le système autour de ces composants. Voici quelques principes clés à garder à l’esprit.

Utilisez les modèles génératifs pour le raisonnement, pas pour la mémoire

Les modèles génératifs excellent dans le raisonnement sur un contexte donné. Ils sont moins doués pour tout retenir d’une tâche de longue durée. Laissez la mémoire externe gérer l’état. Les bases de données, les magasins de vecteurs et les fichiers doivent servir de mémoire. Le modèle n’est que le décideur.

Ajoutez une validation dans le monde réel

Un agent doit vérifier son propre travail. S’il génère du code, il doit exécuter les tests. S’il génère un e-mail client, il doit le vérifier par rapport aux directives de ton. S’il rédige un résumé, il doit le comparer aux contraintes de la source. L’IA générative produit des sorties assurées. Les systèmes agentiques doivent ajouter du scepticisme.

Gardez un humain dans la boucle pour les actions à enjeux élevés

Toutes les actions ne doivent pas être entièrement autonomes. Pour les systèmes agentiques qui envoient des e-mails, approuvent des achats ou modifient des bases de données, exigez une étape d’approbation humaine. Le blog IA de Microsoft a mis l’accent sur la conception responsable de l’IA. Un agent bien conçu sait quand s’arrêter et demander confirmation.

Commencez petit

Ne construisez pas un essaim de vingt agents dès la première tentative. Commencez par un seul agent capable d’appeler deux ou trois outils. Mesurez ses performances. N’ajoutez un deuxième agent que lorsque le premier est fiable. L’architecture doit grandir avec votre confiance.

Conclusion

L’IA générative et l’IA agentique sont les deux faces d’une même pièce. L’IA générative fournit le noyau créatif — la capacité de produire du texte, du code, des images et des plans. L’IA agentique enveloppe ce noyau dans un système d’action : outils, mémoire, itération et exécution. La première produit du contenu. La seconde produit des résultats.

Comme le montrent les canaux officiels d’OpenAI, de Microsoft, de NVIDIA et d’Anthropic, l’industrie évolue résolument vers le paradigme agentique. Mais cela ne rend pas l’IA générative obsolète. Chaque agent que vous construirez s’appuiera sur des modèles génératifs pour penser, planifier et communiquer. La véritable compétence réside dans l’architecture : connecter un modèle puissant aux bons outils et au bon flux de travail.

Les exemples de cet article vous ont donné un point de départ. Un simple appel API est génératif. Une équipe d’agents qui recherche, rédige et enregistre un fichier est agentique. Le pont entre la création et l’action n’est pas une technologie — c’est un motif de conception. Avec le bon environnement, quelques lignes de Python et un objectif clair, vous pouvez franchir ce pont dès aujourd’hui.

Ressources

Pour un contexte continu sur ces sujets, consultez directement les sources officielles :

• Blog IA de NVIDIA : https://developer.nvidia.com/blog/category/generative-ai/
• Actualités OpenAI : https://openai.com/news/
• Blog IA de Microsoft : https://www.microsoft.com/en-us/ai/blog/
• Actualités Anthropic : https://www.anthropic.com/news