Orchestration d’agents IA et RPA : de la preuve de concept à la production

L’automatisation d’entreprise vit une nouvelle phase : la convergence entre RPA et agents IA. Les robots exécutent des actions fiables sur des systèmes parfois anciens, tandis que les agents IA gèrent la compréhension, la décision et la génération de contenu. Combinés, ils permettent d’automatiser des processus entiers, y compris ceux auparavant trop ambigus pour la RPA seule.

Dans cet article, nous partageons une architecture de référence, des bonnes pratiques de sécurité, d’observabilité et de gouvernance, ainsi qu’un exemple technique. Objectif : passer d’un POC enthousiasmant à une mise en production robuste, mesurable et maintenable.

Pourquoi combiner RPA et agents IA

• Couvrir l’ambiguïté métier : l’IA classe, résume, extrait et décide quand la logique déterministe est insuffisante.
• Étendre la surface d’automatisation : e-mails, documents non structurés, chat interne, notes de service.
• Réduire les ruptures de chaîne : l’agent IA peut orchestrer RPA, API et microservices dans une même exécution.
• Améliorer l’expérience employé : assistants qui pré-remplissent, vérifient, justifient et documentent les actions.

Architecture de référence

Une architecture typique assemble orchestrateur de workflow, runtime d’agents IA, connectivité RPA/API, store de connaissances et observabilité.

[Canaux] -> [API Gateway] -> [Orchestrateur de workflows]
                               |               |
                               |               +--> [Queues / Sagas / Retries]
                               |
                               +--> [Agent IA Runtime (LLM + Tools)]
                                        |     |       |
                                        |     |       +--> [RAG / Vector store]
                                        |     +--> [Policies / Guardrails]
                                        +--> [Feature flags / Eval]
                               |
                               +--> [Connecteurs : UiPath/Power Automate/Make.com]
                               +--> [APIs métiers / ERP / CRM / DWH]
                               |
                               +--> [Observabilité : logs, traces, métriques]

• Orchestrateur de workflows: UiPath Orchestrator, Power Automate, Make.com, ou un moteur comme Temporal/Camunda pour les parcours de bout en bout, SLA, retry, compensation.
• Agent IA runtime: Azure OpenAI/OpenAI + outillage d’out-of-the-box ou framework interne pour le tool-calling, la mémoire de session, la politique de sécurité et la journalisation.
• Connectivité: robots RPA pour interfaces legacy, APIs pour ERP/CRM (SAP, Odoo, Dynamics, Oracle), microservices pour logique métier.
• Connaissance: RAG avec un store vectoriel pour contextualiser l’agent (politiques, procédures, gabarits).
• Observabilité: traçabilité fine des décisions IA, des outils appelés et des coûts.

Orchestration vs chorégraphie

• Orchestration (recommandée) : un chef d’orchestre central gère les dépendances, délais, échecs et compensations (pattern Saga).
• Chorégraphie : services s’évènementialisent entre eux. Plus souple mais plus complexe à auditer et gouverner pour des parcours IA.

Fiabilité et résilience

• Idempotence et déduplication: clés métier (ex: id_facture) et verrous optimistes pour éviter les doublons.
• Retries exponentiels: distinguer erreurs transitives (réseaux) et logiques (données invalides) avec politiques distinctes.
• Timeouts et cut-offs: éviter les boucles d’agents; imposer nombre max d’itérations et temps total.
• Compensations (Sagas): si l’étape N+1 échoue, revenir à un état cohérent (ex: annuler un brouillon d’écriture comptable).
• Caching: mémoïsation des résultats de classification / extraction IA pour rejouabilité et réduction de coûts.

Sécurité, conformité et gouvernance

• Cloisonnement des données: pas d’envoi de PII non nécessaire au modèle; masquage et minimisation systématiques.
• Secret management: clés API et credentials stockés dans un coffre-fort (Azure Key Vault, AWS Secrets Manager).
• Allowlist des outils: l’agent ne peut appeler que des fonctions/business APIs pré-autorisées.
• Prévention d’injection de prompt: gabarits signés, séparateurs forts, post-traitements pour refuser les instructions externes non autorisées.
• Journaux d’audit: trace signée des prompts, outils appelés, versions de modèles et décisions pour répondre aux audits.
• Gouvernance des modèles: versions figées en prod, processus de validation des mises à jour, sandbox de tests.

Observabilité et évaluation continue

• Traces: corrélation bout-en-bout (trace_id) entre orchestrateur, agent et connecteurs.
• Métriques: taux de réussite par scénario, temps moyen, coûts par exécution, triggers humains (HITL).
• Évaluation IA: jeux d’items de référence, grading automatique par rubriques, suivi de déviations.
• Feedback humain: boucle de révision pour cas ambigus avec apprentissage supervisé ultérieur.
• Feature flags: activer/désactiver l’IA par segment d’utilisateurs, A/B testing sur prompts ou modèles.

Exemple minimaliste de harness d’évaluation en Python pour une tâche d’extraction:

from typing import List, Dict
import json

def grade_extraction(pred: Dict, ref: Dict) -> Dict:
    fields = ["date", "montant", "fournisseur", "numero"]
    scores = {f: int(str(pred.get(f, "")).strip() == str(ref.get(f, "")).strip()) for f in fields}
    return {"score": sum(scores.values())/len(fields), "details": scores}

def run_eval(model_fn, dataset: List[Dict]):
    results = []
    for item in dataset:
        pred = model_fn(item["input"])  # votre agent d'extraction
        g = grade_extraction(pred, item["reference"])
        results.append(g["score"])
    return sum(results)/len(results)

# dataset = [{"input": "...pdf...", "reference": {...}}, ...]

Cas d’usage types

• Comptabilité fournisseurs: classification des pièces, extraction champs clés, lettrage et création d’écritures dans l’ERP.
• Onboarding RH: lecture de pièces justificatives, vérifications croisées et création de comptes/applications.
• Service client: compréhension d’e-mails entrants, enrichissement CRM, réponse contextualisée et création de tickets.
• Achats: rapprochement devis-commande-livraison, détection d’anomalies et relances automatiques.

Exemple technique: traitement de factures de bout en bout

Objectif: recevoir une facture par e-mail, extraire les champs, la valider, créer une écriture brouillon dans l’ERP, puis notifier un approbateur.

Pipeline:

1. Déclencheur: arrivée d’un e-mail avec pièce jointe (Power Automate/Make.com).
2. OCR si nécessaire (UiPath Document Understanding ou service OCR).
3. Agent IA: extraction + validation sur règles métier.
4. Création dans l’ERP via API.
5. Notification Teams/Slack avec lien vers la pièce.

Extrait de code côté agent (Python) avec tool-calling et garde-fous:

import requests
from pydantic import BaseModel, ValidationError, Field

class Invoice(BaseModel):
    numero: str = Field(min_length=1)
    date: str
    fournisseur: str
    montant: float
    devise: str

def post_to_odoo(invoice: Invoice, token: str, base_url: str):
    resp = requests.post(
        f"{base_url}/api/invoices",
        headers={"Authorization": f"Bearer {token}"},
        json=invoice.model_dump()
    )
    resp.raise_for_status()
    return resp.json()

def validate_business_rules(inv: Invoice):
    assert inv.montant > 0, "Montant invalide"
    assert inv.devise in {"EUR","USD","GBP"}, "Devise non supportée"
    # autres contrôles (doublons, seuils d'approbation, etc.)

def agent_extract(text: str, llm_call) -> Invoice:
    # Prompt structuré et réduction de fuite de consignes
    system = (
        "Tu es un extracteur de champs. "
        "Renvoie strictement un JSON avec numero, date, fournisseur, montant, devise."
    )
    user = f"Extrait les champs depuis ce contenu:\n{text}\n"
    raw = llm_call(system, user)  # retourne un texte JSON
    try:
        data = Invoice.model_validate_json(raw)
    except ValidationError as e:
        # fallback: tentative de correction
        corrected = llm_call(system, f"Corrige ce JSON invalide:\n{raw}\nErreurs:{e}")
        data = Invoice.model_validate_json(corrected)
    validate_business_rules(data)
    return data

def run_pipeline(attachment_bytes: bytes, ocr_fn, llm_call, odoo_cfg):
    text = ocr_fn(attachment_bytes)
    invoice = agent_extract(text, llm_call)
    result = post_to_odoo(invoice, token=odoo_cfg["token"], base_url=odoo_cfg["url"])
    return {"status": "ok", "erp_id": result["id"], "numero": invoice.numero}

Sur l’orchestrateur, un scénario Make.com lisible et traçable peut ressembler à:

{
  "modules": [
    {"name": "Watch Email", "type": "imap", "filters": {"hasAttachment": true}},
    {"name": "HTTP OCR", "type": "http", "method": "POST", "map": {"file": "attachment"}},
    {"name": "Agent IA", "type": "http", "url": "https://agent.kairox.io/extract", "body": {"text": "{{2.text}}"}},
    {"name": "ERP Create", "type": "http", "url": "https://erp/api/invoices", "body": "{{3.json}}"},
    {"name": "Notify Teams", "type": "teams", "message": "Facture {{3.numero}} créée (#{{4.id}})"}
  ],
  "onError": "rollback-or-notify"
}

Bonnes pratiques intégrées:

• Idempotence sur la clé facture (numero + fournisseur + date).
• Si l’ERP refuse, compensation via suppression du brouillon.
• Journal d’audit: conserver prompts/outputs IA et réponse ERP.

Déploiement et exploitation

• Cadrage: cartographier processus, risques, données sensibles, critères de succès et points de contrôle humains.
• Design: choix orchestrateur, politique de prompts, inventory des outils exposés à l’agent, plan de sécurité.
• POC supervisé: petit périmètre, dataset d’évaluation, HITL obligatoire.
• Industrialisation: packaging conteneurisé, secrets, CI/CD, observabilité, feature flags, jeu d’or approuvé.
• Go-live progressif: ramp-up par lot ou population, seuils d’alerte, rollbacks prêts.
• Amélioration continue: revue mensuelle des traces, affinement règles métier et prompts, mise à jour contrôlée des modèles.

Indicateurs à suivre

• Taux d’automatisation par étape et bout-en-bout.
• Temps moyen par cas, files d’attente, re-traitements.
• Taux de correction humaine et motifs (qualité OCR, ambiguïté, règles).
• Coûts unitaires IA et infrastructure.
• Incidents sécurité/qualité et temps de résolution.

Comment Kairox vous accompagne

Kairox conçoit et opère des chaînes d’automatisation hybrides mêlant RPA, API et agents IA, avec une exigence de sécurité, de gouvernance et d’observabilité. Nos équipes interviennent de l’architecture à la mise en production, intègrent vos ERP et SI existants, et mettent en place les garde-fous nécessaires pour des gains durables et maîtrisés.

Vous souhaitez évaluer un premier cas d’usage ou auditer un POC existant ? Contactez-nous pour un atelier de cadrage et une feuille de route pragmatique vers la production.