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

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

Si vous suivez l'actualité de l'intelligence artificielle, vous avez probablement rencontré deux expressions qui semblent se confondre : *IA générative* et *IA agentique*. Les publications des grandes organisations de recherche, notamment le blog développeur de NVIDIA, le Newsroom d'OpenAI et le blog Microsoft AI, les traitent de plus en plus comme des étapes distinctes. Pourtant, pour les praticiens, la frontière peut sembler floue.

L'IA générative produit du contenu — texte, images, code, audio — à partir de modèles appris sur des données d'entraînement. L'IA agentique, en revanche, ne se contente pas de produire une réponse ; elle agit. Elle planifie, utilise des outils, décompose un objectif en étapes, appelle des API externes et itère jusqu'à ce que la tâche soit accomplie. Cet article explique la différence, vous montre comment configurer un environnement de travail pour les deux, et présente des exemples pratiques afin que vous puissiez constater le passage de la « création de contenu » à l'« action autonome » dans votre propre terminal.

---

De la génération à l'action

L'IA générative est ce que la plupart des gens ont découvert en premier. Demandez à un grand modèle de langage (LLM) de rédiger un résumé, d'ébaucher un e-mail ou de générer un script Python, et il produit une séquence de jetons statistiquement plausible. Le modèle est un moteur de contenu. Il répond à une invite et s'arrête. Tout ce qui suit — copier la réponse, la coller dans un système, exécuter le code — dépend de vous.

L'IA agentique inverse cette relation. Au lieu que l'humain agisse sur la sortie de la machine, c'est la machine qui agit sur l'intention de l'humain. Un système agentique reçoit un objectif de haut niveau, par exemple « analysez nos données de ventes et envoyez-moi un résumé hebdomadaire par e-mail ». Il décide ensuite quels outils utiliser, récupère les données, effectue l'analyse, rédige le résumé et envoie l'e-mail — le tout avec une intervention humaine minimale.

Les actualités publiées par Anthropic et les annonces d'OpenAI décrivent une progression constante dans cette direction : des modèles capables d'utiliser des outils, d'appeler des fonctions et d'enchaîner plusieurs étapes. Le modèle ressemble moins à une machine à écrire qu'à un coéquipier qui sait déléguer, vérifier les résultats et changer de cap lorsqu'une approche échoue. Comme l'a souligné le blog Microsoft AI, cela fait passer l'IA de la suggestion à l'exécution de workflows.

La distinction essentielle peut se résumer ainsi :

• **L'IA générative** répond à *« Que devrais-je dire ? »*
• **L'IA agentique** répond à *« Que devrais-je faire ? »* — puis le fait.

Les deux reposent sur les mêmes modèles sous-jacents à base de transformeurs. La différence réside dans l'architecture, les outils et le flux de contrôle.

---

Prérequis

Pour suivre l'installation et les exemples de cet article, vous aurez besoin de :

• **Python 3.10 ou plus récent** (idéalement installé dans un environnement virtuel)
• **`pip`** pour l'installation des paquets
• **Une clé API OpenAI** (ou un autre fournisseur de LLM comme Anthropic, ou un modèle local via Ollama)
• **Un accès à Internet** pour télécharger les paquets et appeler les API
• **Une familiarité de base avec la ligne de commande**

Les exemples ci-dessous utilisent le SDK Python d'OpenAI et le framework LangChain. Nous utiliserons également `requests` pour un simple appel d'outil basé sur HTTP. Si Python est déjà installé, vous pouvez vérifier votre version avec :

python --version

Si cette commande renvoie un numéro de version inférieur à 3.10, ou si elle renvoie une erreur, installez une version récente de Python à partir du site officiel avant de continuer.

---

Installation pas à pas

1. Créer un environnement virtuel

Un environnement virtuel isole les dépendances de votre Python système. Cela évite les conflits de version entre projets.

python -m venv agentic_env

Après avoir exécuté cette commande, un nouveau répertoire nommé `agentic_env` sera créé dans votre dossier actuel.

2. Activer l'environnement virtuel

L'activation modifie le chemin de votre shell afin que `python` et `pip` pointent vers les versions locales de l'environnement.

Sous Linux ou macOS :

source agentic_env/bin/activate

Sous Windows (Invite de commandes ou PowerShell) :

agentic_env\Scripts\activate

Votre invite devrait maintenant afficher `(agentic_env)` comme préfixe.

3. Installer les paquets Python requis

Nous allons installer le SDK OpenAI, les paquets d'intégration LangChain et quelques utilitaires.

pip install openai langchain langchain-openai langchain-community python-dotenv requests

Voici ce que fournit chaque paquet :

• `openai` – SDK officiel pour appeler les modèles OpenAI.
• `langchain` – framework pour construire des chaînes et des workflows agentiques.
• `langchain-openai` – utilitaires d'intégration OpenAI pour LangChain.
• `langchain-community` – outils et wrappers contribués par la communauté.
• `python-dotenv` – charge les clés API depuis un fichier `.env`.
• `requests` – effectue des appels HTTP pour notre exemple d'outil.

4. Configurer votre clé API

Créez un fichier nommé `.env` dans le même répertoire. Le fichier `.env` vous évite de coder en dur vos secrets dans vos scripts.

echo "OPENAI_API_KEY=your-key-here" > .env

Remplacez `your-key-here` par votre vraie clé API OpenAI. Si vous utilisez un autre fournisseur, ajustez le nom de la variable et les noms de modèles dans les exemples ci-dessous.

5. Vérifier l'installation

Exécutez un test d'importation rapide pour confirmer que tous les paquets sont accessibles.

python -c "import openai, langchain; print('OK')"

Si vous voyez `OK`, l'environnement est prêt.

---

Exemples d'utilisation

Nous allons maintenant écrire deux scripts qui illustrent le contraste entre IA générative et IA agentique. Le premier script est purement génératif : il demande du contenu et l'affiche. Le second construit un agent minimal qui exécute une tâche en appelant un outil.

Exemple 1 : IA générative — création de contenu uniquement

Créez un fichier nommé `generate.py` :

from dotenv import load_dotenv
from openai import OpenAI

load_dotenv()

client = OpenAI()

prompt = "Write a concise, professional one-paragraph summary of the benefits of using AI-powered developer tools."

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": "You are a technical writer."},
        {"role": "user", "content": prompt},
    ],
    max_tokens=300,
)

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

Exécutez le script :

python generate.py

Le programme envoie le message de l'utilisateur au modèle, reçoit le texte en réponse et l'affiche. C'est tout. Le script n'a aucune mémoire au-delà des messages inclus dans la requête. Il n'y a pas d'action ultérieure. La sortie est statique. Si vous souhaitez utiliser le texte généré dans une autre application, vous devez le copier ou écrire du code supplémentaire pour le traiter. C'est l'IA générative classique : une invite en entrée, une complétion en sortie, et un humain qui fait le pont entre les deux.

Exemple 2 : IA agentique — planification, utilisation d'outils et action autonome

Nous allons maintenant construire un agent minimal. L'agent reçoit un objectif, décide quel outil appeler, lit le résultat de l'outil et produit une réponse finale. Pour garder l'exemple sans dépendances supplémentaires, nous utiliserons un simple outil de calculatrice exposé comme fonction Python.

Créez un fichier nommé `agent.py` :

import json
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, ToolMessage
from langchain_core.tools import tool

load_dotenv()

# Define a tool the agent can call.
@tool
def multiply(a: int, b: int) -> int:
    """Multiply two integers and return the product."""
    return a * b

# Define a second tool.
@tool
def add(a: int, b: int) -> int:
    """Add two integers and return the sum."""
    return a + b

# Register both tools with the model.
tools = [multiply, add]

model = ChatOpenAI(model="gpt-4o-mini")
model_with_tools = model.bind_tools(tools)

# The goal: perform a small arithmetic calculation.
messages = [
    HumanMessage(content="What is 7 multiplied by 8, plus 9? Use the tools when appropriate.")
]

# Step 1: Ask the model what to do.
response = model_with_tools.invoke(messages)

# Step 2: If the model requested tool calls, execute them.
if response.tool_calls:
    for tool_call in response.tool_calls:
        selected_tool = {"multiply": multiply, "add": add}[tool_call["name"]]
        result = selected_tool.invoke(tool_call["args"])
        # Append the tool output to the conversation history.
        messages.append(ToolMessage(content=str(result), tool_call_id=tool_call["id"]))
    # Step 3: Ask the model again, now with tool results in hand.
    final_response = model_with_tools.invoke(messages)
    print(final_response.content)
else:
    print(response.content)

Exécutez l'agent :

python agent.py

La sortie attendue ressemble à :

65

ou, si le modèle choisit d'expliquer :

7 multiplied by 8 is 56, and adding 9 gives 65.

Plus important que la réponse spécifique, c'est le workflow qui compte. L'agent n'a pas simplement généré du texte en une seule passe. Il a reçu un objectif, émis une demande structurée pour appeler `multiply(7, 8)`, reçu le résultat (`56`), puis appelé `add(56, 9)` (ou simplement calculé la somme à partir de la valeur renvoyée), reçu `65`, et enfin composé une réponse en langage naturel. Le modèle a fonctionné comme un contrôleur qui a décidé quoi faire, l'a réellement fait, et a vérifié le résultat.

Si un appel d'outil avait échoué ou renvoyé une valeur inattendue, l'agent aurait pu le gérer en appelant un autre outil ou en demandant des précisions. Cette boucle fermée — *action, observation, continuation* — est l'essence du comportement agentique.

Étendre l'agent à des API externes

Le même schéma fonctionne avec les API web. Par exemple, vous pourriez définir un outil qui appelle une API météo ou une requête de base de données. L'agent appellerait la fonction outil, la fonction effectuerait une requête HTTP avec `requests`, et le résultat serait renvoyé au modèle. Un système agentique construit de cette façon peut réellement interagir avec le monde extérieur : prendre des rendez-vous, mettre à jour des feuilles de calcul, déclencher des pipelines CI/CD ou envoyer des messages.

Voici un squelette pour un outil basé sur HTTP :

import requests
from langchain_core.tools import tool

@tool
def fetch_article_snippet(url: str) -> str:
    """Fetch a plain-text snippet from a given URL."""
    response = requests.get(url, timeout=10)
    response.raise_for_status()
    return response.text[:500]

Remplacez les outils `multiply` et `add` dans le script de l'agent par `fetch_article_snippet`, et l'agent sera capable de naviguer sur le web selon vos instructions.

---

Quand utiliser chaque approche

L'IA générative est efficace lorsque le livrable est le contenu lui-même. Utilisez-la pour la rédaction, la synthèse, la traduction, la complétion de code et l'écriture créative. C'est rapide, peu coûteux et prévisible. La charge d'intégrer la sortie dans un processus plus large vous incombe.

L'IA agentique brille lorsque le livrable est une tâche accomplie. Utilisez-la lorsque le travail implique plusieurs étapes, des sources de données externes ou des points de décision. Les cas courants incluent :

• Les assistants de recherche qui rassemblent des informations à partir de plusieurs pages et les synthétisent.
• Les agents d'ingénierie logicielle qui lisent un dépôt, modifient des fichiers et exécutent des tests.
• Les agents d'exploitation qui surveillent les journaux, détectent des anomalies et déclenchent des mesures correctives.
• Les assistants personnels qui gèrent les calendriers, les e-mails et les rappels.

Le coût des systèmes agentiques est une complexité accrue. Vous devez définir une interface d'outils, gérer les erreurs, limiter les itérations pour éviter les comportements incontrôlés, et mettre en place des garde-fous autour des actions ayant des effets secondaires irréversibles. Un appel génératif pur écrit du texte ; un agent pourrait supprimer une ligne de base de données si vous le laissez faire. Ajoutez des permissions et des points de contrôle avec intervention humaine en conséquence.

Comme la trajectoire globale des produits d'OpenAI et le blog Microsoft AI l'ont tous deux souligné, l'industrie évolue vers des systèmes où les modèles sont intégrés dans des workflows plutôt qu'utilisés comme des points de terminaison de chat isolés. Les ressources développeur de NVIDIA décrivent le même schéma : les modèles agissent de plus en plus au nom des utilisateurs, opérant dans des environnements variés avec leur propre raisonnement et leur propre récupération d'outils. L'infrastructure est encore en maturation, mais la direction est claire.

---

La route à venir

La ligne entre IA générative et IA agentique n'est pas un mur. Les agents modernes sont construits sur des modèles génératifs, et les modèles génératifs sont souvent utilisés comme composants à l'intérieur des agents. Le changement pratique est une question d'accent dans la conception :

• **L'IA générative optimise la qualité du flux de jetons de sortie.**
• **L'IA agentique optimise la réussite de l'exécution de la tâche entière.**

Un système agentique traite chaque sortie de texte comme une étape intermédiaire. Il se demande : « Étant donné ce résultat, quelle est la prochaine action ? » Le raisonnement du modèle est l'orchestrateur ; les outils sont ses mains ; l'observation est ses yeux ; et vos instructions définissent la mission.

Pour les développeurs, le message immédiat est pragmatique. Si vous utilisez actuellement un LLM pour générer du code, demandez-vous si le modèle doit simplement émettre du code ou réellement l'exécuter contre une suite de tests, lire les messages d'erreur et itérer jusqu'à ce que les tests passent. Si vous utilisez un LLM pour rédiger des rapports d'état, demandez-vous s'il devrait également rassembler les données, générer le graphique et envoyer l'e-mail.

Les exemples de cet article sont volontairement petits, mais ils démontrent le processus cognitif en deux étapes qui sépare un chatbot d'un agent : *décider quoi appeler*, puis *appeler*. Une fois que vous ajoutez des outils plus sophistiqués, de la mémoire et des politiques d'exécution sécurisées, la même structure s'étend à des tâches opérationnelles réelles.

Commencez par la génération. Puis enveloppez-la dans l'action. C'est le chemin le plus court de la création de contenu à l'action autonome.

---

Conclusion

L'IA générative et l'IA agentique représentent deux étapes de la même technologie. La première produit un contenu sophistiqué en réponse à une invite. La seconde transforme les invites en projets, les projets en plans, et les plans en actions exécutées. En configurant un environnement Python, en installant le SDK OpenAI et LangChain, et en parcourant les deux exemples ci-dessus, vous avez vu les deux paradigmes dans leur forme la plus basique : un appel de modèle unique, et une boucle multi-étapes avec utilisation d'outils.

Les systèmes les plus productifs des années à venir combineront probablement les deux approches — utilisant les modèles génératifs pour leur fluidité et leur créativité, et les soutenant par des architectures agentiques qui planifient, agissent et s'adaptent. Quel que soit le côté par lequel vous commencez, l'objectif est le même : faire passer la machine d'un générateur de mots à un partenaire qui mène les choses à bien.