IA agentive vs IA générative : le passage des résultats statiques à l'action autonome

IA agentique vs IA générative : le passage des sorties statiques à l'action autonome

L'intelligence artificielle évolue à un rythme effréné, et deux termes dominent les discussions en 2025 : **l'IA générative** et **l'IA agentique**. Bien que toutes deux trouvent leurs racines dans l'apprentissage profond et les grands modèles de langage, leurs paradigmes diffèrent fondamentalement. L'IA générative crée du contenu – texte, images, code, musique – à partir de prompts. L'IA agentique, quant à elle, va plus loin : elle agit de manière autonome pour atteindre un objectif, prend des décisions, utilise des outils et s'adapte à des environnements changeants. Ce passage des sorties statiques à l'action autonome transforme tout, du développement logiciel à l'automatisation des processus métier.

Dans cet article technique pratique, nous clarifierons la distinction, puis nous détaillerons un exemple concret : la construction d'un système agentique simple capable d'effectuer des recherches web, de lire des pages et de résumer les résultats à partir d'un objectif de haut niveau. Nous aborderons également la pile technologique sous-jacente et comment vous pouvez commencer dès aujourd'hui.

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

L'IA générative désigne les modèles qui produisent du nouveau contenu en se basant sur des motifs appris à partir de données d'entraînement. Les exemples populaires incluent GPT-4 d'OpenAI, Claude d'Anthropic et les générateurs d'images comme DALL-E. Ces systèmes sont réactifs : ils reçoivent un prompt et renvoient une complétion. Bien qu'ils puissent être enchaînés dans des pipelines complexes, l'interaction de base est sans état et se fait en un seul tour (ou plusieurs tours avec mémoire, mais reste principalement réactive).

Le blog NVIDIA AI a mis en évidence comment l'IA générative est utilisée pour tout, de la découverte de médicaments à la génération de code. La sortie du modèle est statique – une fois générée, elle ne change pas à moins d'un nouveau prompt. Il n'y a pas de capacité inhérente à « réessayer » ou à « aller chercher des données supplémentaires » à moins que cette logique ne soit explicitement programmée en dehors du modèle.

Qu'est-ce que l'IA agentique ?

L'IA agentique décrit des systèmes qui agissent de manière indépendante pour atteindre un objectif. Un agent possède un état, un plan, un ensemble d'outils (comme des calculatrices, la recherche web, des systèmes de fichiers) et une mémoire qui persiste entre les actions. Il décide de ses prochaines étapes en fonction de ses observations actuelles et des retours de ses actions précédentes.

La page d'actualités d'Anthropic a documenté les avancées en matière de « capacité d'utilisation d'outils » et de « capacité d'utilisation d'ordinateur » dans leurs modèles, permettant à Claude d'agir pour le compte d'un utilisateur. Le blog AI de Microsoft a couvert AutoGen, un framework pour construire des conversations multi-agents. Les actualités d'OpenAI ont présenté les plugins ChatGPT qui transforment le modèle en un agent capable de récupérer des données en temps réel et d'effectuer des actions comme la réservation de vols.

La différence clé : **l'IA générative se termine par une sortie ; l'IA agentique commence par une sortie et continue d'agir jusqu'à ce qu'un objectif soit satisfait.**

Pourquoi ce changement est important

L'IA générative est excellente pour la création en un seul coup, mais elle montre ses limites lorsque la tâche nécessite un raisonnement en plusieurs étapes, des outils externes ou une adaptation. Par exemple, « Écris un article de blog sur l'informatique quantique » est une tâche générative. « Recherche les dernières startups en informatique quantique, compile une liste de leurs levées de fonds, rédige un résumé de 1000 mots et envoie-le par email à mon équipe » est une tâche agentique. Cette dernière exige que l'IA effectue une recherche web, analyse les résultats, décide quelles sources sont crédibles, compose le texte, puis envoie un email – le tout sans intervention manuelle à chaque étape.

Ce changement a des implications massives pour la productivité. Au lieu de solliciter un modèle à plusieurs reprises, vous lui donnez un objectif et le laissez orchestrer le travail.

Prérequis pour construire un système agentique

Avant de plonger dans le code, listons ce dont nous avons besoin :

• Python 3.10+
• Une clé API OpenAI (ou Anthropic, ou tout LLM prenant en charge l'utilisation d'outils)
• La bibliothèque `requests` pour les appels HTTP
• `beautifulsoup4` pour l'analyse HTML
• `python-dotenv` pour gérer les clés API
• Un éditeur de texte ou IDE moderne

Nous allons construire un agent de recherche minimal capable de : 1. Accepter une question de recherche. 2. Effectuer une recherche web via une API gratuite (DuckDuckGo via la bibliothèque `duckduckgo_search`). 3. Lire le contenu du premier résultat. 4. Le résumer à l'aide de GPT-4o. 5. Répéter éventuellement le cycle pour affiner la réponse.

Cette boucle autonome est l'essence même de l'IA agentique.

Installation pas à pas

Commencez par configurer un environnement virtuel et installer les dépendances. Ouvrez votre terminal.

# Créer un répertoire de projet
mkdir agent-demo
cd agent-demo

# Créer un environnement virtuel Python
python3 -m venv venv

# L'activer (Linux/macOS)
source venv/bin/activate

# Ou sous Windows : venv\Scripts\activate

Installez maintenant les paquets nécessaires. Nous utiliserons `openai` pour l'accès à GPT, `duckduckgo_search` pour la recherche web, et `requests`/`beautifulsoup4` pour le scraping.

# Installer les paquets principaux
pip install openai duckduckgo_search requests beautifulsoup4 python-dotenv

Créez un fichier nommé `.env` à la racine du projet et ajoutez votre clé OpenAI :

OPENAI_API_KEY=sk-votre-clé-ici

Exemple d'utilisation : un agent de recherche simple

Nous allons écrire l'agent dans un seul fichier Python `agent.py`. L'agent aura trois fonctions principales : `search_web`, `fetch_page` et `ask_llm`. La boucle principale décidera s'il faut chercher à nouveau ou produire une réponse finale.

Commencez par charger les dépendances et la clé API.

# agent.py
import os
from dotenv import load_dotenv
from openai import OpenAI
from duckduckgo_search import DDGS
import requests
from bs4 import BeautifulSoup

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

Définissez une fonction de recherche utilisant DuckDuckGo.

def search_web(query, max_results=3):
    """Recherche sur DuckDuckGo et renvoie une liste d'URL."""
    with DDGS() as ddgs:
        results = list(ddgs.text(query, max_results=max_results))
    urls = [r["href"] for r in results if "href" in r]
    return urls[:max_results]

Maintenant, une fonction pour extraire le texte principal d'une URL.

def fetch_page(url):
    """Récupère et extrait le texte d'une page web."""
    try:
        resp = requests.get(url, timeout=10)
        resp.raise_for_status()
        soup = BeautifulSoup(resp.text, "html.parser")
        # Supprimer les éléments script/style
        for tag in soup(["script", "style"]):
            tag.decompose()
        text = soup.get_text(separator="\n", strip=True)
        # Tronquer pour éviter les limites de tokens
        return text[:3000]
    except Exception as e:
        return f"Erreur lors de la récupération de {url} : {e}"

Nous avons besoin d'une fonction pour interroger le LLM et analyser sa réponse. La magie de l'IA agentique réside dans la façon dont nous structurons le prompt : nous disons au modèle quelles actions il peut entreprendre (chercher, lire, terminer) et le laissons décider.

Nous utiliserons la fonction d'appel d'OpenAI (utilisation d'outils) pour que le modèle produise des actions structurées. Mais par souci de simplicité, utilisons une boucle textuelle où le modèle renvoie soit une réponse finale, soit une commande « SEARCH : <requête> ».

def ask_llm(messages):
    """Envoie la conversation à GPT-4o et renvoie la réponse."""
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=messages,
        temperature=0.3
    )
    return response.choices[0].message.content

Maintenant, la boucle principale de l'agent.

def run_agent(goal, max_iterations=5):
    """Agent autonome : cherche, lit, résume jusqu'à ce que l'objectif soit atteint."""
    system_prompt = (
        "Vous êtes un agent de recherche. Vous avez accès à la recherche web et à la lecture de pages web. "
        "Pour chercher, répondez par 'SEARCH : <votre requête>'. "
        "Pour lire une page, répondez par 'READ : <URL>'. "
        "Lorsque vous avez assez d'informations, répondez par 'FINAL : <votre réponse>'. "
        "Soyez concis. Utilisez uniquement les informations que vous avez récupérées."
    )
    messages = [
        {"role": "system", "content": system_prompt},
        {"role": "user", "content": goal}
    ]

    for i in range(max_iterations):
        print(f"\n--- Itération {i+1} ---")
        response = ask_llm(messages)
        print(f"L'agent dit : {response[:100]}...")

        if response.startswith("FINAL:"):
            return response[6:].strip()
        elif response.startswith("SEARCH:"):
            query = response[7:].strip()
            print(f"Recherche de : {query}")
            urls = search_web(query)
            # Renvoyer les URL au modèle
            messages.append({"role": "assistant", "content": response})
            messages.append({"role": "user", "content": f"Voici les URL trouvées : {urls}. Choisissez-en une à lire."})
        elif response.startswith("READ:"):
            url = response[5:].strip()
            print(f"Lecture de : {url}")
            page_text = fetch_page(url)
            messages.append({"role": "assistant", "content": response})
            messages.append({"role": "user", "content": f"Contenu de la page (tronqué) :\n{page_text}\nQue concluez-vous ?"})
        else:
            # Par défaut, on traite comme une réponse finale
            return response

    return "Objectif non atteint dans la limite d'itérations."

Enfin, exécutez l'agent avec un exemple d'objectif.

if __name__ == "__main__":
    goal = "Quelles sont les dernières avancées en matière d'IA agentique selon OpenAI et Anthropic ?"
    answer = run_agent(goal)
    print("\n===== RÉPONSE FINALE =====")
    print(answer)

Exécutez le script :

python agent.py

Vous devriez voir l'agent chercher sur DuckDuckGo, lire une page sur les capacités d'utilisation d'outils d'Anthropic, et produire un résumé. Cette boucle montre comment un modèle génératif est encapsulé dans une architecture de décision autonome.

Considérations pratiques

Sélection d'outils

Pour des systèmes agentiques en production, vous pouvez vouloir des outils plus robustes :

• **Recherche web** : SerpAPI, Bing Search API
• **Scraping web** : Utilisez des API structurées (ex. NewsAPI) plutôt que du HTML brut pour éviter les blocages.
• **Mémoire** : Stockez le contexte dans une base vectorielle comme Chroma ou Pinecone.
• **Planification** : Utilisez un style de prompting « reAct » ou des frameworks comme LangChain, AutoGen ou CrewAI.

Coût et latence

Les boucles agentiques peuvent générer de nombreux appels LLM. Chaque itération consomme des tokens pour l'entrée et la sortie. Soyez attentif à la fenêtre de contexte. Utilisez des modèles plus petits (ex. GPT-4o-mini) pour les actions courantes et réservez les grands modèles pour la synthèse finale.

Sécurité et garde-fous

Accorder de l'autonomie à un agent comporte des risques. Implémentez toujours :

• **Un humain dans la boucle** pour les actions destructrices.
• **Une limitation de débit** pour éviter les appels incontrôlés.
• **Une validation des entrées** pour empêcher l'injection de prompts via le contenu récupéré.

Conclusion

L'IA générative nous a offert un puissant moteur de création de contenu. L'IA agentique ajoute le volant, permettant au moteur de naviguer vers une destination de lui-même. Le passage des sorties statiques à l'action autonome n'est pas simplement incrémental – c'est un changement de paradigme. Désormais, au lieu de demander à un modèle « Écris un article de blog », vous pouvez lui demander « Écris un article de blog après avoir effectué des recherches sur le sujet, vérifié les faits et formaté selon mon guide de style ».

Alors que le blog NVIDIA AI, les actualités OpenAI, le blog Microsoft AI et les actualités Anthropic continuent de repousser les capacités, les outils pour construire vos propres agents deviennent de plus en plus accessibles. Le simple agent que nous avons construit ici est un squelette – vous pouvez l'étendre avec des API, des bases de données et des arbres de décision pour automatiser des flux de travail entiers.

L'avenir de l'IA ne consiste pas seulement à générer du contenu ; il s'agit de créer des systèmes qui agissent en notre nom, apprennent de leur environnement et accomplissent des tâches complexes sans surveillance humaine constante. C'est là le véritable changement : passer des sorties à l'action.