IA agentique vs. IA générative : de la création de contenu à l'action

IA agentique vs. IA générative : de la création de contenu à l'action

L'IA générative a dominé les conversations autour de l'intelligence artificielle ces dernières années. Les outils qui rédigent des essais, génèrent des images et synthétisent du code sont devenus des incontournables des flux de travail professionnels et personnels. Pourtant, en observant les dernières avancées d'organisations comme OpenAI, Microsoft, Anthropic et NVIDIA, un nouveau paradigme, plus ambitieux, émerge : l'**IA agentique**. Au lieu de simplement produire du contenu, les systèmes agentiques peuvent raisonner sur un objectif, planifier une séquence d'actions et les exécuter à travers plusieurs outils et API.

Ce changement est bien plus qu'un mot à la mode. Il redéfinit le rôle de l'IA, qui passe d'un assistant répondant à des invites à un travailleur autonome poursuivant des objectifs. Dans cet article, nous clarifierons la différence entre l'IA générative et l'IA agentique, explorerons les voies d'implémentation pratiques, et vous montrerons comment passer de la création de contenu à l'action avec du code réel.

Comprendre l'IA générative

L'IA générative désigne une classe de modèles—typiquement les grands modèles de langage (LLM) et les modèles de diffusion—entraînés pour générer de nouveaux contenus. Ces modèles apprennent des motifs statistiques à partir de vastes ensembles de données et les utilisent pour produire du texte, des images, de l'audio et de la vidéo à partir d'une invite fournie par l'utilisateur. L'opération de base est simple : étant donné une entrée, produire une sortie probabiliste qui continue, transforme ou complète cette entrée.

Les exemples les plus connus incluent la série GPT d'OpenAI, les modèles Claude d'Anthropic, et les travaux de NVIDIA sur l'infrastructure de l'IA générative. L'IA générative excelle dans des tâches telles que la rédaction d'e-mails, la synthèse de documents, la traduction de langues et la création d'œuvres artistiques originales. C'est une interaction en une seule étape : l'utilisateur soumet une invite et le modèle renvoie une réponse. Même lorsqu'un système comprend plusieurs appels au modèle, chaque appel reste indépendant, sauf si le développeur enchaîne explicitement les résultats.

La limite fondamentale de l'IA générative est qu'elle vit dans le contexte du modèle. Elle peut raisonner sur un document placé dans son invite, mais elle ne peut pas naviguer sur le web, consulter une base de données ou modifier un fichier, à moins que ces capacités ne soient manuellement intégrées et orchestrées par le développeur. L'intelligence est générative, pas opérationnelle.

Présentation de l'IA agentique

L'IA agentique étend l'IA générative avec un ajout crucial : l'**autonomie**. Un agent est un système qui utilise un LLM comme « moteur de raisonnement » central, mais qui est enveloppé dans une boucle qui perçoit son environnement, prend des décisions et effectue des actions. Lorsque nous qualifions une IA d'« agentique », cela signifie qu'elle peut poursuivre un objectif avec une intervention humaine minimale, en décomposant cet objectif en sous-tâches, en appelant des outils externes, en évaluant les résultats et en adaptant son plan au fur et à mesure.

Par exemple, un système d'IA générative peut rédiger un brouillon de rapport hebdomadaire. Un système d'IA agentique peut collecter les données de vente depuis votre CRM, interroger la base de données analytique, générer des graphiques, rédiger le texte narratif, créer un PDF et l'envoyer par e-mail à l'équipe de direction—tout cela sans qu'un humain ne rédige chaque étape.

La différence peut se résumer en une phrase : **l'IA générative crée du contenu, tandis que l'IA agentique exécute des flux de travail.**

Les grandes entreprises technologiques poussent activement cette frontière. Le blog IA de Microsoft explique comment les assistants IA évoluent de simples interfaces de discussion vers des couches d'orchestration qui coordonnent les processus métier. Les annonces d'Anthropic mettent l'accent sur les capacités des modèles qui prennent en charge l'utilisation d'outils et les tâches à long horizon. NVIDIA, à travers son blog sur l'IA générative, souligne l'infrastructure nécessaire pour prendre en charge à la fois l'inférence générative et le raisonnement agentique à grande échelle. La convergence est claire : l'industrie construit des systèmes qui non seulement parlent, mais qui agissent.

Différences clés : génératif vs. agentique

| Aspect | IA générative | IA agentique | |--------|---------------|--------------| | Fonction principale | Produire du contenu | Atteindre des objectifs | | Modèle d'interaction | Cycle unique invite/réponse | Boucle multi-étapes avec retour d'information | | Outils externes | Généralement aucun | Appels API, bases de données, web, fichiers | | Mémoire | Limitée au contexte de l'invite | État persistant à travers les étapes | | Récupération après échec | Aucune—coup unique | Peut réessayer, s'adapter, replanifier | | Rôle humain | Rédige l'invite | Fixe l'objectif et supervise |

L'IA agentique ne remplace pas l'IA générative ; elle en est un sur-ensemble. Chaque agent s'appuie sur un modèle génératif pour ses capacités de raisonnement et de génération de contenu. L'innovation réside dans l'architecture environnante : l'agent décide *quand* appeler le modèle, *quoi* faire de la sortie et *quelle* action entreprendre ensuite.

D'un point de vue pratique, cela signifie que les développeurs ont besoin d'un nouvel ensemble d'outils. Au lieu d'écrire un simple appel API, ils doivent construire des boucles d'orchestration, définir des schémas d'outils, gérer l'état et traiter les erreurs d'exécution.

Prérequis

Pour suivre les exemples pratiques de cet article, vous aurez besoin de :

• **Python 3.9 ou version ultérieure** installé sur votre système.
• Une clé API valide auprès d'un fournisseur d'IA générative. Les exemples utilisent l'API d'OpenAI car elle est largement utilisée et bien documentée dans ses annonces. Les mêmes schémas s'appliquent à l'API Claude d'Anthropic.
• `pip` pour installer les paquets Python.
• Une familiarité de base avec Python et les outils en ligne de commande.

Nous allons construire un agent minimal à partir de zéro. L'objectif est de comprendre l'architecture, pas de s'appuyer sur un framework lourd. Une fois que vous aurez saisi la boucle, vous pourrez adopter des frameworks de production comme LangChain, CrewAI ou AutoGen de Microsoft en toute confiance.

Installation étape par étape

Tout d'abord, créez un environnement Python isolé pour garder les dépendances propres :

mkdir agentic-demo && cd agentic-demo
python3 -m venv venv
source venv/bin/activate

Cela crée et active un environnement virtuel nommé `venv`.

Ensuite, installez le SDK OpenAI, que nous utiliserons pour accéder au modèle génératif :

pip install openai

Le paquet OpenAI fournit l'interface client pour les complétions génératives et les schémas d'appel d'outils agentiques.

Maintenant, définissez votre clé API comme variable d'environnement. Remplacez `votre-clé-api` par une clé réelle provenant de votre fournisseur :

export OPENAI_API_KEY="votre-clé-api"

Garder la clé dans une variable d'environnement évite de la coder en dur dans les fichiers et simplifie la gestion de la sécurité.

Vérifiez l'installation en affichant la version installée :

python -c "import openai; print(openai.__version__)"

Si la commande affiche un numéro de version, vous êtes prêt à continuer.

Exemples d'utilisation

Étape 1 : Un appel génératif de base

Commençons par le schéma génératif classique : une seule invite et une seule réponse.

from openai import OpenAI

client = OpenAI()

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "Vous êtes un assistant utile."},
        {"role": "user", "content": "Rédigez un résumé de projet en deux phrases."}
    ]
)

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

Dans ce code, nous initialisons le client OpenAI, envoyons une liste de messages au modèle et affichons le contenu renvoyé. L'interaction commence et se termine dans cet unique appel.

Étape 2 : Ajout de la boucle agentique

La transition du génératif à l'agentique est réalisée en enveloppant l'appel au modèle dans une boucle et en donnant au modèle accès à des outils. Voici une implémentation minimale :

import json
from openai import OpenAI

client = OpenAI()

# Définissons un outil simple : obtenir la météo actuelle d'une ville.
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Obtenir la météo actuelle pour une ville donnée.",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "Nom de la ville"}
                },
                "required": ["city"]
            }
        }
    }
]

def get_weather(city: str) -> str:
    """Implémentation simulée d'un outil météo."""
    return f"Le temps à {city} est de 21°C avec un ciel dégagé."

messages = [
    {"role": "user", "content": "Quel temps fait-il à Berlin ? Répondez en une phrase."}
]

# Boucle agentique : appeler le modèle, vérifier les appels d'outils, les exécuter, répéter.
for _ in range(5):
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=messages,
        tools=tools,
    )

    message = response.choices[0].message

    # Si le modèle demande un outil, l'exécuter et ajouter le résultat.
    if message.tool_calls:
        messages.append(message)
        for tool_call in message.tool_calls:
            if tool_call.function.name == "get_weather":
                arguments = json.loads(tool_call.function.arguments)
                result = get_weather(arguments["city"])
                messages.append({
                    "role": "tool",
                    "tool_call_id": tool_call.id,
                    "content": result
                })
    else:
        # Pas d'appel d'outil signifie que le modèle a terminé.
        print(message.content)
        break

Examinons ce qui se passe ici :

1. Le modèle reçoit la question de l'utilisateur ainsi qu'une déclaration de l'outil disponible. 2. Le modèle répond avec un `tool_call`, indiquant qu'il souhaite invoquer `get_weather` avec `{"city": "Berlin"}`. 3. Notre code exécute la fonction et ajoute le résultat à la conversation sous forme de message d'outil. 4. La boucle se répète, envoyant la conversation enrichie au modèle. 5. Cette fois, le modèle inclut la météo dans sa réponse et renvoie un contenu régulier, donc la boucle se termine.

C'est l'essence de l'IA agentique : le système appelle activement une fonction externe pour recueillir des informations, puis utilise ces informations pour atteindre son objectif.

Étape 3 : Un agent multi-étapes

Élargissons le schéma à un agent légèrement plus réaliste qui peut à la fois récupérer des données et effectuer un calcul :

def calculate(expression: str) -> str:
    """Évaluer une expression mathématique en toute sécurité."""
    return str(eval(expression))

def fetch_document(url: str) -> str:
    """Récupération simulée d'un document."""
    return "Le chiffre d'affaires trimestriel est de 1,4 M USD sur trois régions."

Enregistrez ces fonctions aux côtés de `get_weather` dans la liste `tools`. Puis demandez à l'agent : *« Récupérez le rapport trimestriel et calculez le chiffre d'affaires par région. »* L'agent va :

1. Appeler `fetch_document` pour lire le document. 2. Constater que le document indique « 1,4 M USD sur trois régions. » 3. Appeler `calculate` avec `"1400000 / 3"`. 4. Renvoyer `466666.67`.

La boucle gère automatiquement tout le raisonnement intermédiaire.

De la démo à la production

La boucle minimale ci-dessus fonctionne, mais les systèmes agentiques de production nécessitent des composants supplémentaires :

• **Gestion de l'état**. Les agents doivent se souvenir du contexte sur de longs flux de travail. Utilisez une base de données, un magasin vectoriel ou un historique de conversation structuré.
• **Gestion des erreurs et nouvelles tentatives**. Les API échouent, les outils renvoient des formats inattendus et les modèles hallucinent parfois des arguments d'outils. Enveloppez les appels d'outils dans des blocs try-catch et redemandez au modèle en cas d'erreur.
• **Sécurité et garde-fous**. Un agent autonome peut prendre des actions irréversibles, comme envoyer des e-mails ou supprimer des fichiers. Ajoutez des étapes de confirmation, des vérifications de permission et une journalisation d'audit.
• **Observabilité**. Étant donné que les agents prennent plusieurs décisions, tracez chaque étape : l'invite, l'appel d'outil, le résultat et la chaîne de raisonnement. Cela rend le débogage possible.

Le blog de Microsoft souligne l'importance d'intégrer l'IA dans des systèmes d'orchestration plus vastes avec une gouvernance de niveau entreprise. Le blog de NVIDIA met en avant la nécessité d'une infrastructure accélérée pour gérer la charge de calcul accrue du raisonnement itératif et de l'exécution d'outils. Ce ne sont pas des préoccupations facultatives une fois que vous dépassez les démos.

Choisir la bonne approche

Devez-vous construire un système génératif ou agentique ? Cela dépend du problème.

Utilisez l'**IA générative** lorsque la tâche est une étape unique et bien définie de génération de contenu :

• Rédiger une description de produit.
• Résumer un long document.
• Traduire un message d'utilisateur.
• Générer un extrait de code.

Utilisez l'**IA agentique** lorsque la tâche implique plusieurs étapes séquentielles, des données externes ou une prise de décision autonome :

• Surveiller une boîte de réception et trier les e-mails urgents.
• Étudier un marché, compiler les résultats et préparer une présentation.
• Corriger automatiquement des builds CI en échec en lisant les journaux, en modifiant le code et en exécutant les tests.
• Gérer les tickets de support client de bout en bout.

Une heuristique simple : si vous pouvez obtenir le résultat avec un seul appel à un LLM, restez génératif. Si l'accomplissement de la tâche nécessite une boucle d'actions, envisagez un agent.

La voie à suivre

La frontière entre l'IA générative et l'IA agentique continuera de s'estomper. Les modèles futurs prendront nativement en charge la planification à long horizon et l'utilisation d'outils. Des fournisseurs comme OpenAI et Anthropic expédient déjà des API conçues pour les flux de travail agentiques, notamment des interfaces d'appel d'outils et des sorties structurées. Microsoft intègre ces capacités dans ses outils de productivité, tandis que NVIDIA construit la pile matérielle et logicielle pour rendre le raisonnement agentique en temps réel rentable.

Pour les développeurs, le message est clair : maîtrisez les fondamentaux de l'IA générative, mais investissez du temps dans l'apprentissage des schémas agentiques. La capacité à construire des systèmes qui agissent—plutôt que de simplement produire du contenu—définira la prochaine vague d'applications d'IA.

Conclusion

L'IA générative transforme les invites en contenu. L'IA agentique transforme les objectifs en résultats. L'une est une calculatrice pour les mots et les images ; l'autre est un travailleur qui planifie, utilise des outils et exécute. Le passage de la génération à l'agence n'est pas simplement une mise à niveau technique—c'est un changement dans la façon dont nous définissons le rôle de l'IA dans notre travail et nos vies.

Avec la simple boucle Python que nous avons construite ci-dessus, vous avez déjà franchi le seuil. En ajoutant des définitions d'outils, une boucle de décision et une gestion gracieuse des erreurs, vous pouvez passer d'une IA à qui l'on demande d'écrire pour vous à une IA qui agit pour vous. L'infrastructure de NVIDIA, les API d'OpenAI et d'Anthropic, et les plateformes d'orchestration de Microsoft convergent toutes vers cette vision. La question pratique n'est plus de savoir si l'IA peut agir ; c'est de savoir si vous construirez les systèmes qui lui permettront de le faire.