IA agentive vs IA générative : Allier autonomie et création

IA Agentique vs. IA Générative : Mélanger Autonomie et Création

Le débat autour de l’intelligence artificielle s’est scindé en deux paradigmes dominants : **l’IA générative**, qui produit du nouveau contenu — texte, images, code, musique — et **l’IA agentique**, qui agit de manière autonome pour atteindre des objectifs, interagir avec des outils et prendre des décisions. Bien que souvent présentées comme des approches concurrentes, les systèmes les plus puissants de la prochaine décennie combineront les deux : des agents qui non seulement créent, mais aussi agissent sur leurs créations.

Dans cet article, nous examinerons les différences, explorerons comment elles se complètent et détaillerons une implémentation concrète qui associe un modèle de langage génératif à un cadre d’agent autonome. À la fin, vous disposerez d’un prototype fonctionnel capable de générer une réponse puis d’effectuer une action — envoyer un courriel ou mettre à jour un fichier — à partir de cette génération.

Comprendre les paradigmes

IA générative : la créatrice

Les modèles d’IA générative — comme GPT-4, Claude, DALL·E ou Stable Diffusion — sont entraînés à prédire et à générer des résultats originaux. Ils excellent dans la production de textes cohérents, d’images réalistes et même de code exécutable. Leur force réside dans la **création de contenu**, mais ils sont fondamentalement réactifs : ils répondent à des invites et nécessitent qu’un humain soit dans la boucle pour chaque interaction significative.

Les sources de la page **OpenAI News** et de la page **Anthropic News** soulignent que ces modèles deviennent plus performants, plus sûrs et mieux alignés sur les intentions humaines. Pourtant, sans orchestration, un modèle génératif ne peut pas réserver un vol, envoyer un courriel de suivi ou itérer sur une tâche jusqu’à son achèvement.

IA agentique : l’exécutante

L’IA agentique désigne des systèmes capables de percevoir leur environnement, de définir des sous-objectifs, d’utiliser des outils (API, systèmes de fichiers, navigateurs) et d’agir sans guidance humaine continue. Le **Microsoft AI Blog** et le **NVIDIA AI Blog** ont expliqué comment les agents sont construits pour automatiser des flux de travail, gérer des simulations complexes et même concevoir du matériel.

Un agent pourrait décider : « Je dois vérifier la météo, puis s’il fait beau, générer une image de pique-nique et la publier sur une API de réseau social. » La caractéristique clé est l’**autonomie d’action**.

Le fossé et l’opportunité

L’IA générative sans agentivité est un outil brillant mais passif. L’IA agentique sans création générative se limite à des comportements basés sur des règles ou préprogrammés. Les combiner donne un système capable de **créer un plan et de l’exécuter** — rédiger un rapport et l’envoyer par courriel, concevoir un graphique et le redimensionner, écrire du code et l’exécuter.

Prérequis

Pour suivre la partie pratique de cet article, vous aurez besoin de :

• **Python 3.10 ou plus récent** installé sur votre système (Linux/macOS/WSL recommandé).
• **pip** (gestionnaire de paquets Python) mis à jour vers la dernière version.
• Une **clé API OpenAI** (ou un accès à n’importe quelle API LLM ; nous utiliserons OpenAI comme exemple).
• Une familiarité de base avec la ligne de commande et les opérations sur fichiers.

Nous allons construire un agent simple qui : 1. Accepte un objectif de haut niveau (par exemple : « Rédiger un mot de remerciement à Alice et l’enregistrer dans un fichier »). 2. Utilise un modèle génératif pour rédiger le mot. 3. Exécute l’action (écrire le fichier) de manière autonome.

Installation pas à pas

1. Créer et activer un environnement virtuel

L’isolation des dépendances évite les conflits avec d’autres projets Python.

python3 -m venv agentic-venv
source agentic-venv/bin/activate   # Sur Windows : agentic-venv\Scripts\activate

2. Installer les paquets requis

Nous avons besoin de la bibliothèque `openai` pour le modèle génératif et de `requests` pour les éventuels appels HTTP.

pip install --upgrade openai requests

3. Définir votre clé API

Stockez votre clé API comme variable d’environnement. Cela la garde en dehors du code source.

export OPENAI_API_KEY="sk-votre-clé-ici"

Pour une configuration permanente, ajoutez la ligne ci-dessus à votre `~/.bashrc` ou `~/.zshrc`.

4. Vérifier l’installation

Exécutez un script Python rapide pour tester la connectivité à l’API OpenAI.

import openai
import os

openai.api_key = os.getenv("OPENAI_API_KEY")

response = openai.ChatCompletion.create(
    model="gpt-4",
    messages=[{"role": "user", "content": "Dis 'hello world' en un mot."}]
)

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

python test_openai.py

Sortie attendue : `hello` (ou similaire). Si vous voyez une erreur, vérifiez votre clé API et votre connexion Internet.

Exemples d’utilisation : mélanger capacités génératives et agentiques

Exemple 1 : Un agent génératif qui écrit et enregistre un mot

Nous allons créer un agent qui utilise GPT-4 pour générer un mot de remerciement poli, puis l’écrit automatiquement dans un fichier.

**Créez un fichier `agentic_note.py`** :

import openai
import os

openai.api_key = os.getenv("OPENAI_API_KEY")

def generate_note(recipient: str, reason: str) -> str:
    """Utilise l'IA générative pour rédiger un mot de remerciement."""
    prompt = f"Écris un mot de remerciement court et chaleureux à {recipient} pour {reason}."
    response = openai.ChatCompletion.create(
        model="gpt-4",
        messages=[{"role": "user", "content": prompt}],
        temperature=0.7
    )
    return response.choices[0].message.content

def save_note_to_file(content: str, filename: str = "note.txt") -> None:
    """Action agentique : écrire le contenu dans un fichier."""
    with open(filename, "w") as f:
        f.write(content)
    print(f"Mot enregistré dans {filename}")

if __name__ == "__main__":
    recipient = input("Entrez le nom du destinataire : ")
    reason = input("Entrez la raison du remerciement : ")

    note_text = generate_note(recipient, reason)
    print("\nMot généré :\n", note_text)

    save_note_to_file(note_text)

**Exécutez l’agent** :

python agentic_note.py

Saisissez « Alice » et « pour son aide sur le projet ». L’agent générera un mot et l’écrira dans `note.txt` sans autre intervention. C’est un mélange minimal : le modèle génératif crée, la logique agentique exécute.

Exemple 2 : Un agent multi-étapes qui génère et envoie un courriel

Étendons maintenant le concept : l’agent générera un objet et un corps, puis appellera une API d’envoi de courriel (nous simulerons avec une fonction placeholder, mais vous pouvez la remplacer par un véritable appel SMTP ou SendGrid).

**Créez `agentic_email.py`** :

import openai
import os

openai.api_key = os.getenv("OPENAI_API_KEY")

def generate_email_content(goal: str) -> dict:
    """Demande à GPT de produire un objet et un corps pour un courriel."""
    system_prompt = "Vous êtes un assistant utile. Renvoyez un JSON avec les clés 'subject' et 'body'."
    user_prompt = f"Rédigez un courriel professionnel avec l'objectif suivant : {goal}"
    response = openai.ChatCompletion.create(
        model="gpt-4",
        messages=[
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": user_prompt}
        ],
        response_format={"type": "json_object"}
    )
    import json
    return json.loads(response.choices[0].message.content)

def send_email(to: str, subject: str, body: str) -> bool:
    """Simule l'envoi d'un courriel. Remplacez par du code SMTP réel."""
    print(f"Simulation d'envoi de courriel à {to}")
    print(f"Objet : {subject}")
    print(f"Corps :\n{body}")
    return True

if __name__ == "__main__":
    recipient = "boss@example.com"
    goal = "Demander l'approbation pour les vacances de la semaine prochaine"

    email_parts = generate_email_content(goal)
    send_email(recipient, email_parts["subject"], email_parts["body"])

**Exécutez-le** :

python agentic_email.py

L’agent décide de manière autonome de l’objet et du corps, puis « envoie » le courriel. En production, vous remplaceriez `send_email` par une véritable authentification SMTP ou un fournisseur de courriel transactionnel.

Exemple 3 : Une boucle d’agent complète avec utilisation d’outils

Pour un exemple plus avancé, nous pouvons construire une boucle simple qui permet à l’agent d’appeler des outils externes (par exemple, une recherche web ou une lecture de fichier) en fonction des décisions du modèle génératif. Ce motif est utilisé dans des frameworks comme LangChain et Auto‑GPT.

Voici une implémentation minimale utilisant une boucle `while`. Le modèle génératif décide de l’action suivante.

import openai
import os

openai.api_key = os.getenv("OPENAI_API_KEY")

def ask_agent(prompt: str) -> str:
    """Requête générale au LLM."""
    response = openai.ChatCompletion.create(
        model="gpt-4",
        messages=[{"role": "user", "content": prompt}]
    )
    return response.choices[0].message.content

def search_web(query: str) -> str:
    """Recherche web fictive. Remplacez par une vraie API."""
    return f"Résultats simulés pour : {query}"

def write_file(filename: str, content: str) -> str:
    """Action agentique : écrire le contenu dans un fichier."""
    with open(filename, "w") as f:
        f.write(content)
    return f"Fichier {filename} écrit."

# Dictionnaire des outils
tools = {
    "search": search_web,
    "write": write_file
}

if __name__ == "__main__":
    goal = "Trouve la population actuelle de Tokyo et enregistre-la dans un fichier."
    max_steps = 5
    step = 0

    user_prompt = (
        f"Vous êtes un agent autonome. Votre objectif est : {goal}\n\n"
        "Vous avez accès aux outils suivants : search(query), write(filename, content).\n"
        "Pour utiliser un outil, répondez exactement :\n"
        "TOOL: nom_de_l_outil\n"
        "ARGS: arg1, arg2, ...\n\n"
        "Si l'objectif est atteint, répondez avec 'FINAL: <réponse>'.\n\n"
        "Quelle est votre prochaine action ?"
    )

    while step < max_steps:
        step += 1
        response = ask_agent(user_prompt)

        if response.startswith("FINAL:"):
            print("Objectif atteint :", response[6:])
            break

        if response.startswith("TOOL:"):
            lines = response.strip().split("\n")
            tool_name = lines[0].replace("TOOL:", "").strip()
            args_str = lines[1].replace("ARGS:", "").strip()
            args = [a.strip() for a in args_str.split(",")]

            if tool_name in tools:
                result = tools[tool_name](*args)
                print(f"L'outil '{tool_name}' a renvoyé : {result}")
                user_prompt = f"Votre objectif : {goal}\n\nVous avez utilisé {tool_name} et obtenu : {result}\n\nQuelle est votre prochaine action ?"
            else:
                print(f"Outil inconnu : {tool_name}")
                break
        else:
            print("Réponse de l'agent :", response)
            break

**Exécutez cet agent** :

python agent_loop.py

Le modèle décidera s’il doit chercher sur le web ou écrire un fichier. Dans cet environnement simulé, il produira « TOOL: search » avec la requête « population Tokyo », obtiendra un résultat simulé, puis « TOOL: write » pour enregistrer le résultat. Cela montre comment le raisonnement génératif pilote l’utilisation agentique d’outils.

Mélanger autonomie et création : considérations clés de conception

1. Gestion d’état et mémoire

Un modèle génératif pur n’a pas de mémoire au-delà de l’invite. Un système agentique doit maintenir un état (par exemple, un historique de conversation ou une liste de tâches). Lors du mélange, vous pouvez injecter les actions précédentes dans l’invite pour permettre au modèle génératif de prendre conscience du contexte.

2. Sécurité et contraintes des outils

L’autonomie signifie permettre à l’IA d’agir sur ses générations. Vous devez limiter l’ensemble des outils qu’elle peut appeler, valider les paramètres et mettre en place une intervention humaine pour les opérations destructrices (par exemple, supprimer des fichiers, envoyer des courriels en masse). Le **Microsoft AI Blog** a publié plusieurs articles sur les agents d’IA responsables, insistant sur l’application des contraintes.

3. Gestion des erreurs et relance

Les modèles génératifs peuvent produire des appels d’outils malformés. Votre couche agentique doit analyser les réponses avec soin, attraper les exceptions et renvoyer les erreurs au modèle pour auto-correction. L’exemple de boucle ci-dessus le montre : si la réponse du modèle ne correspond pas au format attendu, l’agent s’arrête.

4. Choisir le bon modèle de base

Différents modèles conviennent à différents mélanges. Pour les tâches d’agent liées au code, les modèles affinés pour l’appel de fonctions (par exemple, GPT-4 Turbo, Claude 3) sont les meilleurs. Pour les tâches créatives, des modèles avec une sortie de haute qualité et une latence plus faible peuvent être préférés. Le **NVIDIA AI Blog** couvre souvent l’affinage par domaine de modèles pour la simulation et les agents robotiques.

Applications concrètes

Les entreprises et les chercheurs mélangent déjà ces paradigmes :

• **Génération et révision autonomes de code** : Un agent génère du code, exécute des tests et soumet une pull request — tout cela sans qu’un développeur tape une ligne. Les modèles génératifs produisent le code, les processus agentiques gèrent le pipeline d’intégration continue.
• **Assistants personnels d’IA** : Des systèmes comme Microsoft Copilot utilisent des modèles génératifs pour comprendre une demande, puis des capacités agentiques pour interagir avec le calendrier, les courriels et les documents.
• **Recherche scientifique** : Un agent peut générer une hypothèse à l’aide d’un grand modèle de langage, puis exécuter de manière autonome des simulations (sur des GPU NVIDIA, par exemple) et analyser les résultats.

Les pages **OpenAI News** et **Anthropic News** notent toutes deux que la frontière entre agent et générateur s’estompe — les modèles sont entraînés à appeler directement des fonctions et à planifier des séquences, intégrant ainsi la boucle agentique.

Conclusion

L’IA générative et l’IA agentique ne sont pas des forces opposées ; elles sont complémentaires. Les modèles génératifs fournissent le moteur créatif, tandis que les cadres agentiques apportent l’autonomie d’action. En construisant des systèmes où un modèle génératif peut raisonner sur des outils et prendre des actions — comme nous l’avons fait avec les agents simples d’écriture de fichier et d’envoi de courriel — vous débloquez un nouveau niveau de productivité.

Commencez par des tâches petites et bien délimitées. Ajoutez des contraintes, testez les chemins d’erreur et étendez progressivement l’autonomie. Le paradigme combiné définira la prochaine vague d’applications intelligentes, des assistants personnels aux systèmes de recherche entièrement autonomes.

Vous avez maintenant une base de travail pour expérimenter plus avant — essayez d’intégrer une véritable API de courriel, d’ajouter une recherche web ou de construire un système multi-agents. Le mélange est là où commence la véritable intelligence.