IA agentique : la prochaine évolution au-delà de l'IA générative

IA agentique : la prochaine évolution au-delà de l'IA générative

Si vous avez suivi le paysage du machine learning ces dernières années, vous savez déjà à quel point l'IA générative a transformé les flux de travail. Les modèles qui produisent du texte, des images, du code et de l'audio sont passés de curiosités de recherche à des systèmes de production utilisés par des millions de personnes. Pourtant, l'industrie déplace déjà son attention. La prochaine évolution, c'est l'*IA agentique* — des systèmes qui ne se contentent pas de générer du contenu, mais qui planifient, raisonnent et agissent par eux-mêmes pour accomplir des tâches complexes en plusieurs étapes.

Les principaux acteurs qui suivent cette transition — NVIDIA à travers ses blogs développeurs et IA, OpenAI via son newsroom, Microsoft grâce à son blog de recherche en IA, et Anthropic à travers ses annonces produit et sécurité — pointent tous dans une direction commune. La valeur de l'IA ne réside plus seulement dans la réponse qu'elle produit, mais dans le travail qu'elle peut accomplir de manière autonome. Cet article explique ce qu'est l'IA agentique, pourquoi elle importe, et comment vous pouvez commencer à créer vos propres agents dès aujourd'hui avec des outils gratuits et ouverts.

Le changement : de la réponse à l'action

Les modèles d'IA générative sont entraînés pour prédire le prochain jeton d'une séquence. Donnez-leur un prompt, et ils répondent avec une continuation plausible. Cette seule capacité alimente les chatbots, les copilotes, les résumeurs et les générateurs d'images. Ce sont tous des systèmes *réactifs* : ils attendent une entrée, produisent une sortie, puis s'arrêtent.

L'IA agentique modifie le modèle d'interaction de manière fondamentale. Au lieu de répondre à un simple prompt, un agent reçoit un *objectif*, puis décide des étapes à suivre pour l'atteindre. Il peut décomposer la tâche en sous-tâches, appeler des outils externes, récupérer des informations sur le web ou dans des bases de données, écrire et exécuter du code, inspecter les résultats de ses propres actions, et itérer jusqu'à ce que l'objectif soit rempli.

Un système agentique fonctionne en boucle, approximativement :

1. Observer l'état actuel. 2. Raisonner sur l'action à entreprendre ensuite. 3. Entreprendre cette action (par exemple, appeler un outil, exécuter un script, interroger une base de données). 4. Observer le résultat. 5. Répéter jusqu'à ce que l'objectif soit satisfait.

C'est le paradigme classique ReAct (Reasoning + Acting), et c'est l'épine dorsale architecturale de la plupart des frameworks d'agents modernes. Le modèle sous-jacent reste un modèle génératif — mais c'est le *système qui l'entoure* qui rend l'IA agentique.

Capacités fondamentales d'un agent

Pour qualifier un système d'« agentique », je recherche quatre capacités :

**Utilisation d'outils.** L'agent peut appeler des fonctions externes — recherches web, interpréteurs de code, calculatrices, API REST, opérations sur le système de fichiers. C'est la caractéristique déterminante, car elle permet au modèle d'agir sur le monde réel. Le modèle ne se contente pas d'affirmer « Il fait soleil à Lisbonne » ; il appelle une API météo et vérifie la réponse.

**Planification.** Face à un objectif de haut niveau, l'agent peut le décomposer en une séquence d'étapes exécutables, les réordonner si nécessaire, et se remettre d'échecs en cours de plan.

**Mémoire.** Un agent a besoin à la fois d'une mémoire à court terme (l'état actuel de la conversation et de la tâche) et d'une mémoire à long terme (plongements d'interactions passées ou de connaissances stockées dans une base vectorielle). La mémoire lui permet de maintenir sa cohérence sur des tâches longues de plusieurs heures.

**Auto-réflexion.** L'agent évalue ses propres sorties. Il peut exécuter un test sur du code généré, constater que le test échoue, puis réessayer avec une approche différente. Cela boucle la boucle et rend le système réellement utile pour des tâches complexes, plutôt qu'un générateur à un seul passage.

Lorsque ces quatre capacités sont combinées, un système d'IA devient quelque chose de plus proche d'un collègue autonome que d'un chatbot.

Prérequis

Pour suivre les exemples pratiques ci-dessous, vous aurez besoin d'une machine avec les éléments suivants :

• **Système d'exploitation :** Linux, macOS ou Windows (les utilisateurs Windows devraient installer WSL2 pour une expérience optimale).
• **Python 3.10 ou plus récent** — Python est le langage principal des frameworks d'agents.
• **Environ 8 Go de RAM libre** — suffisant pour exécuter un modèle de langage local modeste. Pour les modèles plus volumineux, 16 Go ou plus sont recommandés.
• **Une clé API gratuite** (facultative mais recommandée) si vous préférez utiliser un modèle hébergé plutôt qu'un modèle local. Dans les exemples ci-dessous, j'utilise un modèle local via Ollama, donc aucune clé API cloud n'est requise.
• **Git** (facultatif, pour cloner des référentiels).

La pile logicielle de base que nous utiliserons :

• **Ollama** — un runtime minimal qui exécute des modèles open-weight (Llama, Mistral, Qwen, etc.) localement et expose une API compatible OpenAI.
• **Paquets Python :** `openai` (le SDK officiel, qui fonctionne non seulement avec les endpoints OpenAI mais aussi avec tout serveur compatible OpenAI), `python-dotenv` pour la gestion des secrets, et éventuellement `langchain` ou `crewai` pour une abstraction plus lourde. Dans cet article, j'éviterai les frameworks lourds et vous montrerai une boucle d'agent minimale qui vous donne une visibilité totale sur ce qui se passe.

Installation pas à pas

Toutes les commandes ci-dessous sont pour un shell bash sous Linux/macOS (ou WSL2 sous Windows).

1. Installer Ollama

Ollama est le moyen le plus simple d'obtenir un endpoint de modèle local compatible OpenAI. Sous Linux et macOS, exécutez :

curl -fsSL https://ollama.com/install.sh | sh

Une fois l'installation terminée, démarrez le serveur Ollama en arrière-plan :

ollama serve

Gardez ce terminal ouvert ou exécutez-le comme un service. Le serveur écoute sur `http://localhost:11434` par défaut.

2. Télécharger un modèle

Ensuite, téléchargez un modèle de qualité, ajusté pour l'instruction. Un bon point de départ qui fonctionne avec 8 Go de RAM est `llama3.1:8b` :

ollama pull llama3.1:8b

Si vous avez une machine plus modeste, `qwen2.5:3b` convient également. Vérifiez que le modèle répond :

ollama run llama3.1:8b "Dis bonjour en une phrase."

Vous devriez voir une brève salutation. Appuyez sur Ctrl+D ou tapez `/bye` pour quitter l'interface de chat.

3. Configurer l'environnement Python

Créez un répertoire pour votre projet d'agent et un environnement virtuel :

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

L'environnement virtuel isole vos dépendances du reste du système.

4. Installer les paquets Python requis

Nous avons besoin du SDK Python OpenAI pour pouvoir parler à l'endpoint compatible OpenAI d'Ollama :

pip install --upgrade openai python-dotenv

Le paquet `openai` fonctionne avec Ollama si nous remplaçons `base_url`. Le paquet `python-dotenv` ne sera pas strictement nécessaire ici, mais il est utile si vous décidez plus tard de passer à un modèle hébergé avec une clé API.

Exemples d'utilisation : construire un agent minimal

Nous arrivons maintenant au cœur de cet article. Nous allons construire un agent minuscule mais pleinement fonctionnel en Python pur. Il utilisera la capacité d'*appel d'outils* du modèle Llama pour décider quand utiliser une calculatrice, invoquer une fonction Python locale, puis fournir une réponse finale.

La boucle de l'agent

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

import json
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"  # requis par le SDK, n'importe quelle chaîne convient
)

MODEL = "llama3.1:8b"

# ----------------------------------------------------------------------
# 1. Définir les outils disponibles pour l'agent
# ----------------------------------------------------------------------

def calculator(expression: str) -> float:
    """Évalue une expression arithmétique simple en toute sécurité."""
    # N'autoriser que les chiffres, les opérateurs et les espaces
    allowed = set("0123456789+-*/(). ")
    if not all(c in allowed for c in expression):
        raise ValueError("Caractères non autorisés dans l'expression")
    return eval(expression, {"__builtins__": {}}, {})  # noqa: S307 - assaini ci-dessus

TOOLS = [
    {
        "type": "function",
        "function": {
            "name": "calculator",
            "description": "Évalue une expression arithmétique numérique.",
            "parameters": {
                "type": "object",
                "properties": {
                    "expression": {
                        "type": "string",
                        "description": "L'expression à évaluer, ex. '3 * (2 + 5)'",
                    }
                },
                "required": ["expression"],
            },
        },
    }
]

# ----------------------------------------------------------------------
# 2. Boucle principale de l'agent
# ----------------------------------------------------------------------

def run_agent(user_prompt: str, max_iterations: int = 5) -> None:
    messages = [{"role": "user", "content": user_prompt}]

    for step in range(max_iterations):
        print(f"\n--- Étape {step + 1} ---")

        response = client.chat.completions.create(
            model=MODEL,
            messages=messages,
            tools=TOOLS,
        )

        message = response.choices[0].message

        # Le modèle peut nous demander d'invoquer un outil
        if message.tool_calls:
            messages.append(message)

            for tool_call in message.tool_calls:
                fn_name = tool_call.function.name
                args = json.loads(tool_call.function.arguments)
                print(f"  [Agent] appel de {fn_name}({args})")

                if fn_name == "calculator":
                    result = calculator(args["expression"])
                else:
                    result = "Outil inconnu"

                # Renvoyer le résultat de l'outil au modèle
                messages.append({
                    "role": "tool",
                    "tool_call_id": tool_call.id,
                    "content": str(result),
                })
                print(f"  [Outil] a retourné {result}")
            continue  # boucler à nouveau pour que le modèle produise une réponse finale

        # Pas d'appel d'outil -> réponse finale
        print(f"  [Réponse] {message.content}")
        break
    else:
        print("Nombre maximal d'itérations atteint sans réponse finale.")


if __name__ == "__main__":
    prompt = (
        "Quel est le résultat de (1234 * 4321) - (99 / 3) ? "
        "Utilisez l'outil calculatrice, puis donnez-moi le nombre final."
    )
    run_agent(prompt)

Exécution de l'agent

Activez votre environnement et exécutez le script :

source venv/bin/activate
python agent.py

Ce qui doit se produire est exactement la boucle agentique décrite au début de cet article :

1. Le modèle reçoit le prompt arithmétique. 2. Il raisonne qu'il ne peut pas calculer le produit de manière fiable et appelle l'outil `calculator` avec une expression. 3. L'outil retourne le nombre. 4. Le modèle reçoit ce nombre et émet une réponse finale et vérifiée.

La transcription affichée ressemblera à ceci :

--- Étape 1 ---
  [Agent] appel de calculator({'expression': '(1234 * 4321) - (99 / 3)'})
  [Outil] a retourné 5332759.0
--- Étape 2 ---
  [Réponse] Le résultat de (1234 × 4321) - (99 ÷ 3) est 5 332 759.

Étendre l'agent

Le modèle s'adapte. Pour donner plus de capacités à votre agent, il suffit d'ajouter d'autres fonctions à la liste `TOOLS` et d'autres branches dans le bloc d'appel d'outils. Par exemple, vous pouvez ajouter un outil `web_search` qui interroge une API de recherche, un outil `read_file`, ou un outil `run_python` qui exécute du code arbitraire en sandbox.

Une approche plus orientée production consiste à utiliser un framework comme LangGraph, CrewAI ou le SDK OpenAI Agents, qui gèrent l'état de la conversation, les appels d'outils parallèles et les points de contrôle humain dans la boucle. Mais la boucle minimale ci-dessus est idéale pour comprendre ce que ces frameworks font sous le capot. Une fois que vous avez vu cette boucle en dix étapes, les frameworks d'agents cessent d'être magiques.

Le paysage : des copilotes aux collaborateurs

Le passage de l'IA générative à l'IA agentique n'est pas qu'un exercice d'ingénierie ; c'est un changement dans la façon dont les entreprises conçoivent l'automatisation. À l'ère générative, des produits comme les chatbots et les copilotes exigeaient qu'un humain reste dans la boucle pour chaque étape significative. Les dernières annonces d'OpenAI, d'Anthropic et de Microsoft mettent toutes l'accent sur des agents qui opèrent sur des horizons temporels plus longs et avec une plus grande indépendance. Le blog IA de Microsoft, par exemple, présente systématiquement l'IA comme un « assistant de travail » qui agit en votre nom, tandis que les pages actualités et sécurité d'Anthropic consacrent un espace considérable à l'« utilisation de l'ordinateur » et à l'interaction agentique responsable avec les outils. NVIDIA, de son côté, considère les agents comme la prochaine charge de travail qui stimulera à la fois l'efficacité des modèles et la demande en centres de données, son blog développeur suivant la pile complète de frameworks, de GPU et de logiciels d'inférence qui rendent les systèmes multi-agents pratiques.

Cette convergence est un signal fort : l'industrie croit que la prochaine phase de valeur de l'IA ne viendra pas des artefacts générés, mais des *résultats accomplis*.

Il vaut également la peine d'être lucide sur les défis ouverts. Les systèmes agentiques sont plus complexes à évaluer. Une simple complétion de chat peut être jugée sur sa cohérence ; un agent doit être jugé sur son taux d'achèvement de tâches, le coût par tâche réussie et la sécurité. Ils introduisent également de nouveaux modes de défaillance : un appel d'outil peut échouer, un plan peut dérailler, ou un modèle peut halluciner une fonction qui n'existe pas. La conception de systèmes de production s'appuie donc fortement sur des garde-fous : listes blanches d'outils autorisés, modes lecture seule, budgets de jetons et points de contrôle d'approbation humaine pour les actions à fort impact. Comme le soutiennent les écrits d'Anthropic sur la sécurité de l'IA, plus nous accordons d'autonomie aux modèles, plus notre travail d'alignement et d'évaluation doit être rigoureux.

Si vous commencez à passer de l'IA générative à l'IA agentique, voici le chemin pragmatique que je recommande :

1. **Maîtrisez la boucle minimale.** Faites exactement ce que nous avons fait ci-dessus : un modèle, un outil, un objectif clair. 2. **Ajoutez des outils progressivement** — recherche web, mémoire vectorielle, exécution de code — et observez où le modèle réussit et où il échoue. 3. **Ajoutez de l'observabilité.** Consignez chaque prompt, appel d'outil et résultat. Les systèmes agentiques sont gourmands en débogage, et vous vous remercierez d'avoir un bon traçage. 4. **Passez ensuite aux frameworks** une fois que vous comprenez la boucle. Vous pourrez lire leur documentation avec une véritable compréhension, plutôt que de traiter leurs abstractions comme des boîtes noires.

Conclusion

L'IA générative nous a donné des modèles capables de composer des mots, des images et du code. L'IA agentique prend cette capacité brute et l'enveloppe dans une boucle de planification, d'utilisation d'outils, de mémoire et de réflexion — transformant un modèle en acteur dans un monde d'API et de fichiers. Le résultat est un passage de « demande-moi n'importe quoi » à « fais-le ».

L'infrastructure technologique pour cette transition est désormais accessible à tout développeur avec un ordinateur portable. Avec Ollama, un modèle open-weight local, et environ quarante lignes de Python, vous pouvez construire un agent qui raisonne, appelle des outils, vérifie les résultats et accomplit une tâche de bout en bout. Les leaders de l'écosystème — NVIDIA, OpenAI, Microsoft et Anthropic — construisent tous sur le même principe fondamental : les modèles de raisonnement combinés à des boucles d'action définiront la prochaine décennie de l'intelligence artificielle appliquée. La question n'est plus de savoir *si* l'IA agira ; c'est de savoir *avec quelle qualité* nous pourrons lui apprendre à agir en toute sécurité, de manière fiable, et au service de véritables objectifs humains.