Du prompt à l'agent IA : les 3 niveaux d'autonomie

Il existe une confusion persistante dans les projets IA : on appelle "agent" à peu près tout système qui utilise un LLM. Un chatbot, un pipeline RAG, un assistant qui remplit des formulaires — tout devient "agent autonome". Cette confusion produit des architectures mal dimensionnées, des promesses non tenues, et des directions déçues.

Voici les trois niveaux réels d'autonomie — avec ce que chacun implique concrètement en termes d'architecture, de risque, et de valeur.

---

Niveau 1 — Le LLM qui répond

C'est le niveau de base. Un utilisateur pose une question, le LLM génère une réponse. Pas de mémoire, pas de décision, pas d'action sur un système externe.

Ce que c'est : un moteur de génération de texte conditionné par un prompt.

Ce que ce n'est pas : un agent.

Cas d'usage typiques :

• Résumé de document
• Génération de contenu
• Reformulation, traduction
• Q&A sur un corpus (RAG simple)

En .NET :

using Microsoft.Extensions.AI;

var client = new AzureOpenAIClient(endpoint, credential)
    .AsChatClient("gpt-4o");

var response = await client.CompleteAsync(
    "Résume ce contrat en 3 points clés : " + contractText);

Console.WriteLine(response.Message.Text);

Le LLM répond. Il ne décide pas. Il ne se souvient pas. Il n'agit pas.

---

Niveau 2 — L'agent qui décide

Un agent au sens strict est un système qui observe son environnement, décide quelle action effectuer, exécute cette action, et observe le résultat.

La différence fondamentale avec le niveau 1 : l'agent choisit ses outils.

flowchart LR
    O["👁️ Observation"] --> R["🧠 Raisonnement"]
    R --> S["🔧 Sélection\nd'outil"]
    S --> E["⚡ Exécution"]
    E --> O

    style O fill:#2A3E6F,stroke:#4A90D9,color:#E8F0FA
    style R fill:#2A3E6F,stroke:#4A90D9,color:#E8F0FA
    style S fill:#2A3E6F,stroke:#4A90D9,color:#E8F0FA
    style E fill:#3A4E7F,stroke:#E8C84A,color:#E8F0FA

Ce que ça implique architecturalement :

• Un registre d'outils (fonctions que l'agent peut appeler)
• Une boucle de raisonnement (ReAct, tool-use natif)
• Une gestion d'état entre les étapes

En .NET avec Microsoft.Extensions.AI :

using Microsoft.Extensions.AI;

// Définir les outils disponibles pour l'agent
var tools = new List<AITool>
{
    AIFunctionFactory.Create(SearchDatabase, "search_contracts",
        "Recherche dans la base de contrats"),
    AIFunctionFactory.Create(GetClientHistory, "get_client_history",
        "Récupère l'historique d'un client"),
    AIFunctionFactory.Create(CreateDraft, "create_draft",
        "Crée un brouillon de proposition")
};

var client = new AzureOpenAIClient(endpoint, credential)
    .AsChatClient("gpt-4o")
    .AsBuilder()
    .UseFunctionInvocation()
    .Build();

var messages = new List<ChatMessage>
{
    new(ChatRole.System,
        "Tu es un assistant commercial. Utilise les outils disponibles " +
        "pour analyser la situation et préparer une proposition."),
    new(ChatRole.User,
        "Prépare une proposition pour le client Durand SA, " +
        "en tenant compte de leur historique avec nous.")
};

// L'agent décide lui-même quels outils appeler et dans quel ordre
var response = await client.CompleteAsync(messages,
    new ChatOptions { Tools = tools });

La différence clé : le développeur ne décide pas de l'ordre des appels. L'agent le fait.

---

Niveau 3 — Le système qui collabore

C'est le niveau multi-agents. Plusieurs agents spécialisés travaillent ensemble, se délèguent des tâches, partagent des résultats, et coordonnent leurs actions pour accomplir un objectif commun qu'aucun d'eux ne pourrait atteindre seul.

Propriétés distinctives :

• Spécialisation : chaque agent a un domaine de compétence délimité
• Communication : les agents s'échangent des informations structurées
• Coordination : un orchestrateur ou un protocole détermine qui fait quoi
• Vérification croisée : les agents peuvent challenger les outputs des autres

En Python avec LangGraph :

from langgraph.graph import StateGraph, END
from langchain_anthropic import ChatAnthropic
from typing import TypedDict, Annotated
import operator

class CommercialState(TypedDict):
    client_id: str
    historical_analysis: str
    technical_specs: str
    pricing: str
    final_proposal: str
    messages: Annotated[list, operator.add]

# Agent 1 : analyse historique
def historical_analyst(state: CommercialState) -> dict:
    llm = ChatAnthropic(model="claude-3-5-sonnet-20241022")
    result = llm.invoke(
        f"Analyse l'historique du client {state['client_id']} "
        f"et identifie les patterns de décision."
    )
    return {"historical_analysis": result.content}

# Agent 2 : spécifications techniques
def technical_specialist(state: CommercialState) -> dict:
    llm = ChatAnthropic(model="claude-3-5-sonnet-20241022")
    result = llm.invoke(
        f"Sur la base de l'analyse : {state['historical_analysis']}, "
        f"propose les spécifications techniques adaptées."
    )
    return {"technical_specs": result.content}

# Agent 3 : pricing (utilise un moteur déterministe, pas le LLM)
def pricing_agent(state: CommercialState) -> dict:
    # Le pricing vient d'un moteur déterministe, jamais du LLM
    price = pricing_engine.compute(
        client_id=state['client_id'],
        specs=state['technical_specs']
    )
    return {"pricing": str(price)}

# Agent 4 : rédaction finale
def proposal_writer(state: CommercialState) -> dict:
    llm = ChatAnthropic(model="claude-3-5-sonnet-20241022")
    result = llm.invoke(
        f"Rédige la proposition commerciale. "
        f"Historique : {state['historical_analysis']}. "
        f"Specs : {state['technical_specs']}. "
        f"Prix : {state['pricing']}."
    )
    return {"final_proposal": result.content}

# Orchestration du workflow
workflow = StateGraph(CommercialState)
workflow.add_node("analyst",    historical_analyst)
workflow.add_node("technical",  technical_specialist)
workflow.add_node("pricing",    pricing_agent)
workflow.add_node("writer",     proposal_writer)

workflow.set_entry_point("analyst")
workflow.add_edge("analyst",   "technical")
workflow.add_edge("technical", "pricing")
workflow.add_edge("pricing",   "writer")
workflow.add_edge("writer",    END)

graph = workflow.compile()
result = graph.invoke({"client_id": "DURAND-SA-001"})

---

Pourquoi cette distinction change tout

	Niveau 1	Niveau 2	Niveau 3
Décision	Humain	Agent	Collectif
Mémoire	Aucune	Contextuelle	Distribuée
Outils	Aucun	Registre défini	Spécialisés par agent
Vérification	Humain	Optionnelle	Croisée
Risque d'erreur	Bas	Moyen	Nécessite gouvernance
Valeur potentielle	Limitée	Significative	Élevée

La règle d'or : commencer au niveau le plus bas qui répond au besoin. Le saut vers le niveau 3 se justifie uniquement quand la complexité du problème dépasse ce qu'un agent unique peut gérer.

Un système de niveau 1 qui fonctionne vaut infiniment mieux qu'un système de niveau 3 qui hallucine.

---

Olivier Alessandri — Architecte IA & .NET · Mirakai