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 :

L'essentiel tient en deux gestes : déclarer le registre d'outils, puis activer l'invocation automatique sur le client. L'agent se charge du reste.

using Microsoft.Extensions.AI;

// Registre d'outils que l'agent pourra appeler de lui-même
var tools = new List<AITool>
{
    AIFunctionFactory.Create(SearchDatabase, "search_contracts", "..."),
    AIFunctionFactory.Create(GetClientHistory, "get_client_history", "..."),
    AIFunctionFactory.Create(CreateDraft, "create_draft", "...")
};

var client = new AzureOpenAIClient(endpoint, credential)
    .AsChatClient("gpt-4o")
    .AsBuilder()
    .UseFunctionInvocation()   // ← active la boucle tool-use
    .Build();

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

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

© 2026 Mirakai — Olivier Alessandri. Tous droits réservés. Cet article, son code et ses ressources sont protégés par le droit d'auteur. Toute reproduction ou diffusion sans autorisation écrite est interdite.