IA agentique en 2025 : pourquoi le passage en production reste le vrai défi

/dans /par



En 2025, l’IA agentique s’impose comme une tendance majeure. Mais derrière les démonstrations, une question domine : comment passer réellement en production, de façon maîtrisée, durable et responsable ? Cet article synthétise les principaux freins observés et les exigences de gouvernance, d’orchestration et d’observabilité nécessaires pour industrialiser des agents IA.

IA agentique en 2025 : pourquoi le passage en production reste le vrai défi

En quelques mois, l’IA agentique est devenue l’un des sujets les plus visibles de l’écosystème IA. Agents autonomes, systèmes multi-agents, orchestration de tâches complexes : les promesses sont fortes et les démonstrations souvent convaincantes.

Pourtant, un constat s’impose en 2025 : le passage en production des agents IA reste rare, complexe et largement sous-estimé. Derrière les PoC et les approches “show”, très peu d’organisations ont réellement industrialisé des agents IA dans des environnements critiques, gouvernés et durables.

Ce décalage n’est pas anecdotique. Il reflète une réalité structurelle : les agents IA posent des défis spécifiques en matière de gouvernance, d’orchestration, de monitoring, d’observabilité et de responsabilité [1][2][3].

L’illusion du PoC : quand l’agent IA ne quitte jamais le laboratoire

De nombreux projets d’IA agentique restent bloqués au stade du prototype. Les cadres récents sur la gouvernance des agents montrent un schéma récurrent : les agents sont souvent conçus comme des artefacts expérimentaux, sans exigences explicites de déploiement opérationnel [1].

Un PoC d’agent IA peut fonctionner dans un périmètre restreint, mais il repose généralement sur des hypothèses implicites :

  • qualité et stabilité des données et des systèmes environnants ;
  • périmètre d’action limité (peu d’intégrations, peu d’exceptions) ;
  • faible exposition aux cas d’échec, aux comportements inattendus et aux interactions non prévues.

En production, ces hypothèses se brisent rapidement. L’agent devient un acteur à part entière du système, capable d’interagir avec des ressources, des humains, d’autres agents et des processus métiers, avec des conséquences concrètes [2].

Le passage en production n’est donc pas qu’une “montée en charge” : c’est un changement de nature du système et des risques associés.

Qu’est-ce qui change avec un agent IA en production ?

Les publications de référence convergent sur un point essentiel : un agent IA ne se résume pas à un modèle, ni même à une application conversationnelle. C’est un système qui peut percevoir, planifier, agir, et adapter sa stratégie en fonction du contexte, parfois avec une autonomie significative [1][2].

En production, cela impose de clarifier le niveau d’autonomie et les garde-fous associés :

  1. Périmètre d’action : ce que l’agent a le droit de faire, sur quels systèmes, avec quels accès.
  2. Responsabilités : qui porte la redevabilité lorsque l’agent déclenche une action ou une décision [2].
  3. Supervision : à quel moment l’humain doit valider, arbitrer ou reprendre la main [1][3].
  4. Gestion de l’échec : comment l’agent se met en sécurité, escalade et se rend “stopp-able” en cas d’anomalie [3].

Gouvernance des agents IA : on ne gouverne pas un agent comme un modèle

La gouvernance “classique” de l’IA (centrée sur les modèles, la donnée et l’évaluation) reste nécessaire, mais elle est insuffisante pour des agents capables de planifier et d’exécuter des actions dans des environnements réels [1][2].

Les cadres dédiés à l’agentique mettent l’accent sur des exigences supplémentaires :

  • Définir des rôles, objectifs et limites : mandat explicite, seuils d’autonomie, règles d’engagement [1].
  • Attribuer des responsabilités humaines : supervision, validation, arbitrage, redevabilité [2].
  • Mettre en place des mécanismes d’intervention : suspension, reprise, escalade, contrôles de sécurité [3].
  • Formaliser la conformité et l’accountability : comment l’organisation démontre qu’elle maîtrise les effets produits par les agents [2].

En pratique, cela exige que la gouvernance des agents IA soit conçue comme un dispositif transversal : technique, juridique, organisationnel, et opérationnel [1][2][3].

Orchestration des agents IA : le problème système que les PoC évitent

Beaucoup de démonstrations mettent en scène un agent unique. Or, les cas d’usage industriels mènent souvent vers des architectures plus complexes : chaînes d’agents spécialisés, systèmes multi-agents, interactions agent-agent et agent-humain [1][3].

L’orchestration devient alors centrale :

  • Qui déclenche l’agent et dans quel contexte ?
  • Comment s’enchaînent les étapes, avec quelles dépendances ?
  • Comment éviter les boucles, conflits ou escalades d’actions non maîtrisées ?
  • Quels points de contrôle et validations humaines sont requis ?

Sans orchestration explicite et gouvernée, un système d’agents peut devenir imprévisible à l’échelle globale, même si chaque agent semble “fonctionner” isolément [1].

Monitoring et observabilité des agents IA : rendre l’action auditables, pas seulement les réponses

Le passage en production échoue fréquemment sur un point : l’incapacité à observer et auditer ce que fait réellement un agent. Les cadres de gouvernance insistent sur le fait qu’un agent doit être observable non seulement sur ses outputs, mais sur ses décisions, actions et interactions [1][3].

Une observabilité “production-grade” implique notamment :

  • Traçabilité : journalisation des actions, outils utilisés, ressources appelées, résultats obtenus [3].
  • Contexte et décision : capacité à reconstruire le chemin décisionnel (dans la limite des contraintes) pour comprendre “pourquoi” [1].
  • Détection d’anomalies : dérives, boucles, escalades, comportements inattendus, dégradations de performance [1][3].
  • Auditabilité et conformité : preuves exploitables pour la redevabilité, l’analyse d’incident et la conformité [2].

Sans ces mécanismes, il devient difficile de sécuriser, industrialiser et améliorer un agent IA dans la durée [2][3].

Responsabilité, conformité, redevabilité : le “mur” du passage en production

Les agents IA transforment la question du risque : ce n’est plus seulement la qualité d’une réponse, mais l’impact d’actions déclenchées. Les analyses sur la gouvernance globale soulignent que la question centrale devient : qui est responsable de ce qu’un agent fait, et avec quels outils de contrôle et d’accountability ? [2]

En production, cela pousse les organisations à articuler :

  • gouvernance IA, gouvernance IT, gouvernance métier ;
  • cadres de conformité, politiques internes, processus d’escalade ;
  • mécanismes de supervision humaine, contrôles, audits, et documentation [1][2][3].

Sans ce socle, l’agentique reste cantonnée à l’expérimentation, faute de garanties suffisantes pour un usage réel à grande échelle [1][2].

Conclusion

En 2025, l’IA agentique entre dans une phase où le différenciateur n’est plus la démonstration, mais la capacité à passer en production de manière maîtrisée. Les organisations qui réussiront ne seront pas celles qui accumulent les PoC, mais celles qui investissent tôt dans :

  1. la gouvernance (mandats, limites, redevabilité) [1][2] ;
  2. l’orchestration (contrôles, points de décision, supervision) [1][3] ;
  3. le monitoring et l’observabilité (traçabilité, auditabilité, détection d’anomalies) [1][3].

Autrement dit : industrialiser l’IA agentique n’est pas un sujet de “fabrication de démos”, c’est un sujet de gouvernance et d’ingénierie opérationnelle. Et c’est précisément là que se joue la création de valeur durable.

Références

[1] https://partnershiponai.org/resource/preparing-for-ai-agent-governance/
[2] https://partnershiponai.org/resource/ai-agents-global-governance-analyzing-foundational-legal-policy-and-accountability-tools/
[3] https://adoption.microsoft.com/files/copilot-studio/Agent-governance-whitepaper.pdf

RAG

Introduction aux RAG (Retrieval Augmented Generation) avec LangChain et Ollama

/dans /par

1. Pourquoi parle-t-on des RAG aujourd’hui ?

Les modèles d’IA générative (comme GPT, Claude, ou encore LLaMA) sont capables de produire du texte fluide et pertinent. Mais ils ont une limite majeure : ils ne savent répondre qu’avec ce qu’ils ont appris lors de leur entraînement. Ils peuvent donc :

  • Fournir des informations obsolètes.
  • Inventer des faits inexistants (hallucinations).
  • Ignorer des données spécifiques à une entreprise ou un domaine.

C’est là qu’interviennent les RAG (Retrieval Augmented Generation) : ils combinent la puissance des modèles génératifs avec une base de connaissances externe (documents, bases de données, fichiers internes, etc.).

En clair : avant de générer une réponse, le modèle va chercher les informations pertinentes dans vos données, puis il s’appuie dessus pour formuler une réponse précise.

Remarque : certains outils comme ChatGPT avec navigation web ou Perplexity donnent l’impression que le modèle connaît Internet en temps réel. En réalité, ils combinent un modèle génératif avec un mécanisme externe de recherche en ligne. Ce fonctionnement s’apparente déjà à une forme de RAG, mais appliqué au web public. L’intérêt des RAG personnalisés est de pouvoir appliquer le même principe… sur vos propres données privées (documents internes, bases clients, rapports, etc.).

2. Le principe d’un RAG

Un pipeline RAG fonctionne en trois étapes :

  1. Indexation des documents
    On découpe vos textes en petits morceaux (chunks), puis on les transforme en vecteurs numériques (embeddings) afin de pouvoir les rechercher efficacement.
  2. Recherche contextuelle
    Lors d’une question, le système cherche dans vos documents les passages les plus pertinents grâce à une base vectorielle.
  3. Génération augmentée
    Le modèle de langage prend ces passages comme contexte et génère une réponse plus fiable, avec éventuellement les sources utilisées.

3. Les outils que nous allons utiliser

Pour notre exemple, nous allons construire un petit RAG avec :

  • LangChain : un framework Python qui facilite la création de chaînes IA (LLM + retrieval + mémoire…).
  • Ollama : un outil qui permet de télécharger et exécuter facilement des modèles de langage en local (par exemple LLaMA, Mistral, Gemma). Dans notre code, nous utilisons un petit modèle local gemma3:1b.
  • FAISS : une librairie de Meta pour gérer les recherches vectorielles.
  • HuggingFace Embeddings : pour transformer nos textes en vecteurs numériques.

ℹ️ Il n’est pas obligatoire d’utiliser Ollama ou des modèles ouverts, vous pouvez choisir le modèle de votre choix : open source (LLaMA, Mistral, Gemma…) ou fermé (GPT, Claude, etc.).

4. Mise en pratique pas à pas

Nous allons partir d’un fichier doc.txt (notre base de connaissances). Voici le fichier que nous utilisons ici pour l’exemple :

Bio of a Fictional Person

Name: Clara Mendoza
Age: 34
Location: Barcelona, Spain
Profession: Environmental Policy Analyst

Clara Mendoza is a passionate environmental policy analyst dedicated to shaping sustainable urban development. With over a decade of experience in climate policy and renewable energy initiatives, she has worked with NGOs, municipal governments, and international organizations to design strategies that balance economic growth with environmental preservation.

She holds a master’s degree in Environmental Policy and Governance from the London School of Economics, where her thesis focused on community-driven renewable energy projects in Southern Europe. Fluent in Spanish, English, and French, Clara has presented her work at global conferences, advocating for greener cities and stronger cross-border collaborations.

Beyond her professional life, Clara is an avid traveler and amateur photographer. Her weekends often involve hiking in the Pyrenees, experimenting with plant-based recipes, or capturing urban landscapes through her camera lens. She also volunteers as a mentor for young women entering the field of environmental science and policy.

a) Charger le document

from langchain.docstore.document import Document

# Ouverture du document
with open("./doc.txt", "r", encoding="utf-8") as f:
    input_doc = f.read()

document = Document(page_content=input_doc)

Ici, on lit notre fichier texte et on le convertit en un objet Document utilisable par LangChain.

b) Découper le texte en morceaux (chunks)

from langchain.text_splitter import RecursiveCharacterTextSplitter

splitter = RecursiveCharacterTextSplitter(chunk_size=150, chunk_overlap=40)
chunks = splitter.split_documents([document])

On segmente le document en petits morceaux de 150 caractères, avec un recouvrement de 40 caractères pour éviter de couper une idée en deux.

c) Créer la base vectorielle

from langchain.embeddings import HuggingFaceEmbeddings
from langchain.vectorstores import FAISS

embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
vector_store = FAISS.from_documents(chunks, embeddings)

Chaque chunk est transformé en vecteur numérique grâce à un modèle de HuggingFace, puis stocké dans une base vectorielle FAISS.

d) Construire la chaîne RAG

from langchain_ollama.llms import OllamaLLM
from langchain.chains import RetrievalQA

qa_chain = RetrievalQA.from_chain_type(
    llm=OllamaLLM(model="gemma3:1b"),  # modèle local exécuté avec Ollama
    retriever=vector_store.as_retriever(),
    return_source_documents=True,
    chain_type="stuff",
)

Ici, on assemble tout :

  • Le LLM (gemma3:1b via Ollama).
  • Le moteur de recherche vectoriel.
  • Une chaîne qui envoie les passages trouvés au modèle.

e) Poser une question

result = qa_chain.invoke({"query": "What languages does Clara speak ?"})
print("Answer:", result['result'])

print("\nSource Documents:")
for doc in result['source_documents']:
    print(f"- {doc.page_content}")

Quand on pose la question « What languages does Clara speak ? », le système va chercher dans notre doc.txt et donner la réponse :

Answer: Clara speaks Spanish, English, and French.
Source Documents:
- Clara Mendoza est une analyste en politiques environnementales [...]
  Elle parle couramment espagnol, anglais et français.

5. Code complet

Voici le module Python complet que vous pouvez exécuter directement :

from langchain.docstore.document import Document
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import HuggingFaceEmbeddings
from langchain.vectorstores import FAISS
from langchain_ollama.llms import OllamaLLM
from langchain.chains import RetrievalQA

# Ouverture du document (base de connaissances pour le RAG)
with open("./doc.txt", "r", encoding="utf-8") as f:
    input_doc = f.read()

document = Document(page_content=input_doc)

# Séparation automatique en morceaux (chunks)
splitter = RecursiveCharacterTextSplitter(chunk_size=150, chunk_overlap=40)
chunks = splitter.split_documents([document])

# Transformations des chunks en vecteurs (embeddings)
embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
vector_store = FAISS.from_documents(chunks, embeddings)

qa_chain = RetrievalQA.from_chain_type(
    llm=OllamaLLM(model="gemma3:1b"),  # On utilise le modèle gemma3:1b installé en local
    retriever=vector_store.as_retriever(),
    return_source_documents=True,
    chain_type="stuff",
)

# Prompt et récupération de la réponse (et des sources)
result = qa_chain.invoke({"query": "What languages does Clara speak ?"})
print("Answer:", result['result'])
print("\nSource Documents:")
for doc in result['source_documents']:
    print(f"- {doc.page_content}")

6. Conclusion

Les RAG permettent de transformer un modèle de langage générique en assistant spécialisé, capable de s’appuyer sur vos propres données.

  • Les applications sont nombreuses : chatbots d’entreprise, assistants de recherche, outils pédagogiques…
  • Grâce à des frameworks comme LangChain et des outils comme Ollama, il devient facile de monter un prototype fonctionnel.

Et surtout, vous gardez le contrôle : vous pouvez choisir vos propres données et vos propres modèles (open source ou fermés).

 

Pour aller plus loin, découvrez notre article autour de l’automatisation et de l’IA agentique.

Ressources utiles :

agentic AI

Premiers pas avec l’automatisation des workflows et l’IA agentique

/dans /par

Si vous souhaitez approfondir ce sujet, vous pouvez visionner le webinaire complet ici (en anglais) : A gentle introduction to workflow automation and agentic AI.

Pourquoi l’automatisation des workflows et l’IA agentique sont essentielles aujourd’hui

L’intelligence artificielle (IA) est devenue l’une des tendances technologiques les plus rapides. Deux concepts en particulier, l’automatisation des workflows et l’IA agentique, transforment la manière dont les entreprises rationalisent leurs opérations, améliorent leur productivité et créent de nouvelles opportunités.

Selon un rapport de McKinsey datant de juin 2025 [1], l’IA générative et agentique pourrait débloquer entre 2 600 et 4 400 milliards de dollars de valeur supplémentaire, au-delà de l’IA analytique traditionnelle. Pourtant, la plupart des organisations rencontrent encore des difficultés : 78 % des entreprises déclarent avoir déployé l’IA générative, mais 80% ne constatent pas de résultats tangibles et seulement 1 % considèrent leur stratégie IA comme mature.

Ce paradoxe illustre l’écart entre l’expérimentation et l’impact réel sur le business, un écart que l’automatisation et l’IA agentique peuvent contribuer à combler.

Qu’est-ce qu’un agent IA ?

Le terme agent IA est largement utilisé mais rarement défini de manière uniforme. À son cœur, un agent IA est un système capable de :

  1. Percevoir son environnement (entrée)
  2. Prendre des décisions (raisonnement ou planification)
  3. Agir pour atteindre un objectif
  4. S’adapter grâce au feedback et à l’apprentissage

On peut situer les agents IA sur un spectre :

  • Agents spécialisés : champ d’action très limité (ex. classer des emails, détecter un sentiment)
  • Agents autonomes : capables d’agir à partir d’objectifs sans instructions pas à pas (ex. un assistant IA qui gère un agenda)
  • Systèmes multi-agents : réseaux d’agents collaborant pour résoudre des tâches complexes comme l’optimisation d’une chaîne logistique

Le paysage de l’automatisation : par où commencer

Avant de plonger dans l’automatisation enrichie par l’IA, il est souvent recommandé de débuter par les outils d’automatisation de workflows traditionnels comme :

Ces plateformes permettent de connecter des applications et services avec une logique “si ceci, alors cela”, réduisant ainsi les tâches manuelles répétitives.

Avantages : simplicité d’utilisation, peu ou pas de code requis, accélère les workflows structurés.
Inconvénients : règles rigides, fragilité face aux changements, incapacité à traiter des données non structurées comme les PDFs ou les emails libres.

Ce que l’IA apporte à l’automatisation des workflows

L’ajout de composants IA rend l’automatisation plus intelligente, flexible et proche du comportement humain. Parmi les avantages clés :

  • Compréhension des données non structurées (emails, documents, images, vidéos)
  • Prise de décision contextuelle
  • Adaptation dynamique aux nouvelles informations
  • Compréhension et génération de langage naturel
  • Raisonnement multi-étapes et autonomie

Exemples concrets :

  1. Triage des emails avec NLP : l’IA détecte l’intention et oriente automatiquement vers la bonne personne ou le bon système.
  2. Traitement intelligent des documents : l’IA extrait et valide des données à partir de PDFs ou de formulaires scannés.
  3. Réponses client générées par IA : rédige des réponses personnalisées qui peuvent être validées avant envoi.

De l’automatisation simple à l’IA agentique

Le chemin vers l’IA agentique suit une progression de maturité :

  1. Automatisation traditionnelle : workflows structurés et basés sur des règles
  2. Automatisation + IA : modules IA intégrés dans les workflows (chatbots, NLP, routage intelligent)
  3. IA agentique : systèmes capables de générer leur propre plan d’action, de raisonner sur plusieurs étapes et d’agir de manière autonome

Par exemple, alors que Make.com peut automatiser l’enregistrement et la réponse aux emails, des plateformes de nouvelle génération comme Manus ou le mode Agent de ChatGPT démontrent des agents autonomes capables de planifier et d’effectuer des tâches de manière indépendante.

Prochaines étapes : aller vers le “technique”

Une fois que vous avez expérimenté l’automatisation no-code, la prochaine étape est d’explorer des cadres et protocoles pour agents tels que :

  • LangChain, LangGraph, LlamaIndex : pour construire des workflows IA avancés.
  • MCP (Model Context Protocol) et A2A (Agent-to-Agent Protocol) : pour permettre aux agents de collaborer entre eux ou avec des systèmes traditionnels.

Ces outils ouvrent la voie à des systèmes IA scalables et maintenables au-delà de simples prototypes.

Conclusion

L’automatisation des workflows et l’IA agentique marquent une évolution : on passe de processus rigides à des systèmes intelligents et adaptatifs. Que vous commenciez avec Zapier ou Make, ou que vous exploriez des systèmes multi-agents, l’important est d’expérimenter tout en gardant en tête la valeur business et la scalabilité.

Cependant, avant de vous lancer tête baissée dans l’IA agentique, prenez le temps d’ancrer une vision stratégique claire et d’acculturer vos dirigeants, comme expliqué dans notre guide sur l’intégration de l’IA en entreprise en 2025.

Pour aller plus loin, visionnez le webinaire complet (en anglais) : A gentle introduction to workflow automation and agentic AI.

Références

 

[1] https://www.mckinsey.com/capabilities/quantumblack/our-insights/seizing-the-agentic-ai-advantage