azure ai-foundry multi-agent claims insurance observability

Tri des demandes d’assurance multi-agents sur Microsoft Foundry

Tri des demandes d’assurance sur Microsoft Foundry : un coordinateur chargé de la couverture, des agents chargés de la fraude et des règlements, des points de contrôle, ainsi que de l’hébergement d’App Insights et de Container Apps.

Éditeur : REACTAPP.TOPAjouté sur ce site 26 sept. 202613 min de lecture2993 mots

Sources: AZURE AI: Multi-agent claims triage on Microsoft Foundry

Imaginez qu’une compagnie d’assurance reçoive chaque jour des milliers de nouvelles demandes d’indemnisation via des formulaires en ligne et des lignes téléphoniques transcrittes. Avant le paiement, trois éléments sont essentiels : la couverture de l’assurance à la date de l’incident, les signaux de fraude enregistrés par l’équipe SIU, et la fourchette de règlement déterminée d’après l’estimation des dommages. Une vérification manuelle séquentielle est lente. Un système de tri multi-agents hébergé sur Foundry permet de traiter en parallèle les cas gérés par des spécialistes, tout en laissant les humains s’occuper des exceptions.

Outils utilisés

Déploiements de modèles Azure AI Foundry, un cadre d’agent/orchestration avec des transferts de tâches, un système de points de contrôle pour assurer la persistance des exécutions, Application Insights pour le suivi des activités, ainsi que Container Apps avec une identité gérée pour l’hébergement.

Prérequis

Une abonnement Azure avec accès à Foundry, la capacité de déployer des applications containerisées, un espace de travail App Insights, et des exemples de données de demandes d’indemnisation pour les tests.

Architecture du projet

coordonnateur assigne les tâches à trois spécialistes (couverture, fraude, règlement). Des outils gèrent la recherche de polices, les vérifications des listes de fraude et les règles de classification. Les points de contrôle conservent l’état en cours de demande. La télémétrie suit chaque transfert.

Étape 1. Créer la ressource Foundry et les déploiements des modèles

Mettre en place le projet et déployer les modèles de chat que les agents utiliseront. Noter soigneusement les noms des déploiements.

Étape 2. Installer le framework et orienter un client de chat vers Foundry

az group create \
  --name rg-claims-prod-uks \
  --location uksouth

az cognitiveservices account create \
  --name fdy-claims-prod-uks \
  --resource-group rg-claims-prod-uks \
  --location uksouth \
  --kind AIServices \
  --sku S0 \
  --assign-identity

az cognitiveservices account deployment create \
  --name fdy-claims-prod-uks \
  --resource-group rg-claims-prod-uks \
  --deployment-name gpt-4o \
  --model-name gpt-4o \
  --model-version 2024-08-06 \
  --model-format OpenAI \
  --sku-capacity 200 \
  --sku-name GlobalStandard

az cognitiveservices account deployment create \
  --name fdy-claims-prod-uks \
  --resource-group rg-claims-prod-uks \
  --deployment-name gpt-4o-mini \
  --model-name gpt-4o-mini \
  --model-version 2024-07-18 \
  --model-format OpenAI \
  --sku-capacity 400 \
  --sku-name GlobalStandard

python -m venv .venv
source .venv/bin/activate
pip install agent-framework azure-monitor-opentelemetry azure-identity azure-cosmos

# claims/clients.py
import os
from azure.identity import DefaultAzureCredential
from agent_framework.azure import AzureOpenAIChatClient

credential = DefaultAzureCredential()

coordinator_client = AzureOpenAIChatClient(
    endpoint=os.environ["FOUNDRY_ENDPOINT"],
    deployment_name="gpt-4o",
    credential=credential,
)

specialist_client = AzureOpenAIChatClient(
    endpoint=os.environ["FOUNDRY_ENDPOINT"],
    deployment_name="gpt-4o-mini",
    credential=credential,
)

# claims/agents.py
from claims.clients import coordinator_client, specialist_client

coordinator = coordinator_client.create_agent(
    name="triage",
    instructions=(
        "You are the first-line claims triage officer for a UK motor insurer. "
        "Read the claim and decide which specialist should handle it next. "
        "Route to 'policy_agent' when cover or policy dates are in question. "
        "Route to 'fraud_agent' when the description contains any indicator of "
        "staged loss, late notification, or inconsistent detail. "
        "Route to 'settlement_agent' when cover is confirmed and only the payout "
        "figure remains. Call the matching handoff tool, for example "
        "handoff_to_fraud_agent. Never state a settlement figure yourself."
    ),
)

policy_agent = specialist_client.create_agent(
    name="policy_agent",
    instructions=(
        "You verify whether the policy was in force on the incident date and "
        "whether the peril is covered. Use the lookup_policy tool. State the "
        "cover position plainly and cite the policy section. If cover is void, "
        "say so and stop; do not speculate on settlement."
    ),
)

fraud_agent = specialist_client.create_agent(
    name="fraud_agent",
    instructions=(
        "You score claims against the SIU signal list using the score_fraud_signals "
        "tool. Report each signal that fired and the aggregate score. Any score at "
        "or above 0.6 must be handed to policy_agent for a cover check before it "
        "goes anywhere near settlement."
    ),
)

settlement_agent = specialist_client.create_agent(
    name="settlement_agent",
    instructions=(
        "You band the damage estimate and propose a settlement using the "
        "band_settlement tool. Anything above 15000 GBP must be flagged for human "
        "authorisation in your response. Never approve a payment."
    ),
)

# claims/workflow.py
from agent_framework import HandoffBuilder
from claims.agents import coordinator, policy_agent, fraud_agent, settlement_agent

def build_triage_workflow():
    return (
        HandoffBuilder(
            name="claims_triage",
            description="Motor claims triage: cover, fraud signals, settlement banding.",
            participants=[coordinator, policy_agent, fraud_agent, settlement_agent],
        )
        .set_coordinator(coordinator)
        .add_handoff(coordinator, [policy_agent, fraud_agent, settlement_agent])
        .add_handoff(fraud_agent, policy_agent)
        .add_handoff(policy_agent, settlement_agent)
        .with_interaction_mode("autonomous", autonomous_turn_limit=12)
        .with_termination_condition(
            lambda conv: any(
                "AUTHORISATION REQUIRED" in (msg.text or "")
                for msg in conv[-2:]
            )
        )
        .build()
    )

# claims/tools.py
from typing import Annotated
from datetime import date
import httpx

POLICY_API = "https://pas.internal.claims-leeds.co.uk/v2"

async def lookup_policy(
    policy_number: Annotated[str, "The policy number, format MOT-00000000"],
    incident_date: Annotated[str, "Incident date as YYYY-MM-DD"],
) -> dict:
    """Return cover status and policy sections in force on the incident date."""
    async with httpx.AsyncClient(timeout=10.0) as client:
        r = await client.get(
            f"{POLICY_API}/policies/{policy_number}/cover",
            params={"as_at": incident_date},
        )
        r.raise_for_status()
        return r.json()

SIU_SIGNALS = {
    "late_notification_days": 14,
    "no_police_reference": True,
    "prior_claims_12m": 2,
}

def score_fraud_signals(
    description: Annotated[str, "Free-text claim description"],
    notified_after_days: Annotated[int, "Days between incident and notification"],
    prior_claims_12m: Annotated[int, "Claims by this policyholder in last 12 months"],
) -> dict:
    """Score a claim against the SIU signal list. Returns fired signals and aggregate."""
    fired = []
    if notified_after_days > SIU_SIGNALS["late_notification_days"]:
        fired.append("late_notification")
    if prior_claims_12m >= SIU_SIGNALS["prior_claims_12m"]:
        fired.append("claim_frequency")
    if "no witnesses" in description.lower():
        fired.append("no_independent_witness")
    return {"signals_fired": fired, "score": round(len(fired) / 3, 2)}

def band_settlement(
    estimate_gbp: Annotated[float, "Repair or replacement estimate in GBP"],
) -> dict:
    """Band an estimate and return the proposed settlement and authorisation route."""
    if estimate_gbp <= 2500:
        return {"band": "A", "proposed_gbp": estimate_gbp, "route": "auto"}
    if estimate_gbp <= 15000:
        return {"band": "B", "proposed_gbp": estimate_gbp, "route": "team_leader"}
    return {"band": "C", "proposed_gbp": estimate_gbp, "route": "AUTHORISATION REQUIRED"}

policy_agent = specialist_client.create_agent(
    name="policy_agent",
    instructions="...",
    tools=[lookup_policy],
)

fraud_agent = specialist_client.create_agent(
    name="fraud_agent",
    instructions="...",
    tools=[score_fraud_signals],
)

settlement_agent = specialist_client.create_agent(
    name="settlement_agent",
    instructions="...",
    tools=[band_settlement],
)

# claims/checkpoints.py
from agent_framework import InMemoryCheckpointStorage

# Tests and local runs
storage = InMemoryCheckpointStorage()

workflow = build_triage_workflow_with_storage(storage)

async for event in workflow.run_stream(claim_text, session_id=claim_id):
    handle(event)

# claims/telemetry.py
import os
from azure.monitor.opentelemetry import configure_azure_monitor
from agent_framework.observability import enable_instrumentation

def init_telemetry() -> None:
    configure_azure_monitor(
        connection_string=os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"],
    )
    enable_instrumentation()

dependencies
| where timestamp > ago(24h)
| where name startswith "invoke_agent"
| extend agent = tostring(customDimensions["gen_ai.agent.name"])
| extend claim = tostring(customDimensions["session.id"])
| summarize
    hops = count(),
    total_ms = sum(duration),
    p95_ms = percentile(duration, 95)
    by agent
| order by total_ms desc

# claims/run.py
import asyncio
from agent_framework import RequestInfoEvent
from claims.telemetry import init_telemetry
from claims.workflow import build_triage_workflow

CLAIM = """
Claim MOT-40118822. Policy MOT-00318844, incident 2026-07-29, notified 2026-08-19.
Insured reports offside wing and door damage in a supermarket car park, no witnesses,
no police reference. Third party details not supplied. Estimate 3,180 GBP.
"""

async def main() -> None:
    init_telemetry()
    workflow = build_triage_workflow()

    async for event in workflow.run_stream(CLAIM, session_id="MOT-40118822"):
        if isinstance(event, RequestInfoEvent):
            # Autonomous mode only surfaces this on escalation
            print(f"HUMAN NEEDED: {event.data.prompt}")
            break
        print(event)

asyncio.run(main())

az identity create \
  --name umi-claims-triage \
  --resource-group rg-claims-prod-uks

PRINCIPAL=$(az identity show -n umi-claims-triage -g rg-claims-prod-uks --query principalId -o tsv)
CLIENT=$(az identity show -n umi-claims-triage -g rg-claims-prod-uks --query clientId -o tsv)
FOUNDRY=$(az cognitiveservices account show -n fdy-claims-prod-uks -g rg-claims-prod-uks --query id -o tsv)

az role assignment create \
  --role "Azure AI User" \
  --assignee-object-id $PRINCIPAL \
  --assignee-principal-type ServicePrincipal \
  --scope $FOUNDRY

az containerapp create \
  --name ca-claims-triage \
  --resource-group rg-claims-prod-uks \
  --environment cae-claims-prod-uks \
  --image acrclaimsproduks.azurecr.io/claims-triage:1.0.0 \
  --user-assigned umi-claims-triage \
  --min-replicas 1 \
  --max-replicas 8 \
  --cpu 1.0 \
  --memory 2.0Gi \
  --env-vars \
    FOUNDRY_ENDPOINT=https://fdy-claims-prod-uks.openai.azure.com/ \
    AZURE_CLIENT_ID=$CLIENT \
    ENABLE_INSTRUMENTATION=true \
    OTEL_SERVICE_NAME=claims-triage \
    APPLICATIONINSIGHTS_CONNECTION_STRING=secretref:appi-conn

az group delete \
  --name rg-claims-prod-uks \
  --yes \
  --no-wait

az containerapp delete \
  --name ca-claims-triage \
  --resource-group rg-claims-prod-uks \
  --yes

az cognitiveservices account deployment delete \
  --name fdy-claims-prod-uks \
  --resource-group rg-claims-prod-uks \
  --deployment-name gpt-4o-mini

Configurer l’endpoint, le déploiement ainsi que l’authentification via Entra/managed identity — éviter d’inclure des clés API dans les images de conteneur.

Étape 3. Définir le coordinateur et les trois spécialistes

Donnez à chaque spécialiste des instructions de système précises ainsi qu’un ensemble d’outils limité. Le coordinateur se contente de diriger et d’agréger les informations ; il ne doit pas réimplémenter la logique des spécialistes.

Étape 4. Configurer le graphe de transfert

Des liens de transfert explicites valent mieux qu’un ensemble d’outils non structurés. Une séquence Couverture → Fraude → Règlement constitue une configuration par défaut sensée ; permettez un court-circuit vers SIU lorsque le score de fraude augmente fortement.

Étape 5. Fournir aux spécialistes des outils réels

Les outils doivent être connectés à des systèmes réels ou à des versions simplifiées fidèles avec des schémas correspondants. Des outils fictifs qui approuvent systématiquement ne servent à rien.

Étape 6. Mettre en place des points de contrôle pour éviter la perte d’une demande en cours

Conservez l’état de la requête ou du thread après chaque traitement par un spécialiste. Un redémarrage du conteneur au milieu d’une demande doit permettre de reprendre le traitement sans double paiement.

Étape 7. Envoyer des traces et des métriques à Application Insights

Émettez des événements personnalisés pour les transferts, la latence des outils et le résultat final. Les tableaux de bord doivent afficher le temps moyen nécessaire pour le tri par rapport à la valeur de référence manuelle.

Étape 8. Exécuter une demande et lire le résultat

Utilisez une demande de référence dont les résultats en matière de couverture et de fraude sont connus. Assurez-vous que le package final du coordinateur inclut les résultats des trois spécialistes.

Étape 9. Déployer sur Container Apps avec une identité gérée

Accordez les droits d’identité aux déploiements de Foundry ainsi qu’aux API backend appelées par les outils. Restreignez strictement l’accès entrant.

Résolution de problèmes

Un résultat vide des spécialistes indique généralement un nom de déploiement incorrect ou un JSON de l’outil tronqué. Les boucles surviennent souvent en raison d’absence de conditions de fin de transfert. Les échecs d’authentification sont dus à des règles RBAC, et non au fait que le modèle est hors service.

Cost de l’exécution

Les tokens de modèle dominent ; le stockage des points de contrôle et App Insights sont relativement modestes. Limitez le nombre maximal de tours par demande ainsi que les recherches dans la politique de cache.

Nettoyage

Supprimez les applications conteneurisées, les identités et les déploiements que vous avez créés pour cette démonstration afin que les ressources utilisées ne restent pas enregistrées sur la facture.

Fermeture

Le tri des demandes multi-agents fonctionne lorsque les spécialistes sont bien définis, que les outils sont réels, que les points de contrôle sont durables et que la télémétrie prouve l’avantage de la latence faible. Foundry fournit l’environnement du modèle ; le graphique et les procédures opérationnelles fournissent le produit final.

Ajoutez un nœud d’approbation humaine pour les montants de règlement dépassant un certain seuil. Les agents doivent accélérer le tri, et non autoriser silencieusement de gros paiements.

Formulez les règles anti-fraude séparément des prompts du modèle. Lorsque SIU met à jour la liste des signaux, vous ne devriez pas avoir besoin de modifier les prompts pour les prendre en compte — les outils doivent pouvoir lire la liste actuelle.

Effectuer des tests de charge sur les demandes concurrentes afin d’évaluer les limites de débit dans le déploiement Foundry. Le comportement en cas de débordement de file d’attente doit être défini : rejet, retard ou basculement vers un traitement manuel.

Confidentialité : le texte des demandes est sensible. Veiller à que les journaux masquent les numéros d’assurance sociale et les numéros de sécurité sociale, et à ce que l’échantillonnage d’App Insights ne stocke pas de données personnelles brutes dans des dimensions personnalisées.

Mettre en place un test de chaos qui arrête le conteneur au milieu d’une demande et vérifie que celle-ci peut reprendre à partir du point de contrôle sans effets secondaires indésirables — les clés d’idempotence lors des écritures sont obligatoires.

Ajouter un étape d’approbation humaine pour les montants de règlement dépassant un certain seuil. Les agents doivent accélérer le tri, et non autoriser silencieusement de gros paiements.

Versionner les règles anti-fraude séparément des prompts du modèle. Lorsque SIU met à jour la liste des signaux, il ne devrait pas être nécessaire de modifier les prompts pour les prendre en compte — les outils doivent lire la liste actuelle.

Ajouter un étape d’approbation humaine pour les montants de règlement dépassant un certain seuil. Les agents doivent accélérer le tri, et non autoriser silencieusement de gros paiements.

Mettre en place un test de chaos qui arrête le conteneur au milieu d’une demande et vérifie que la reprise depuis le point de contrôle se fait sans effets secondaires indésirables — les clés d’idempotence lors des écritures sont obligatoires.

Les prompts destinés aux spécialistes doivent interdire l’invention de clauses de politique. Si l’outil d’analyse renvoie aucun résultat, le spécialiste doit faire monter l’affaire en grade — il ne doit pas supposer que la demande est « probablement couverte ».

Appliquer une validation du schéma aux arguments de l’outil. Une identifiant de demande mal saisi doit faire échouer l’appel à l’outil avant que cela ne donne lieu à une narration d’enquête erronée.

Séparez les outils de lecture des outils d’écriture. Les agents de tri fonctionnent par défaut en mode lecture seule ; les écritures liées au règlement nécessitent l’approbation d’un nœud ainsi qu’une clé d’idempotence.

Associez les pannes détectées par Application Insights à des actions concrètes : en cas d’augmentation soudaine des temps d’attente des outils de détection de fraude, c’est aux responsables de l’intégration SIU qu’il revient d’intervenir, et non par défaut à l’équipe de la plateforme LLM.

Gardez les demandes synthétiques dans un ensemble de cas d’usage incluant des situations limites : police expirée, score de fraude proche du seuil critique, et incidents impliquant plusieurs véhicules qui mettent à l’épreuve le système de routage.

Lors des démonstrations destinées aux dirigeants, montrez le flux de traçage pour une demande donnée. L’essentiel réside dans l’orchestration et les mécanismes de contrôle, et non dans les noms des modèles.

Les prompts destinés aux spécialistes doivent interdire l’invention de clauses dans les polices d’assurance. Si l’outil de vérification des garanties renvoie aucun résultat, le spécialiste doit faire remonter l’affaire — sans deviner que la demande est « probablement couverte ».

Activez la validation du schéma pour les arguments de l’outil. Une identifiant de réclamation mal saisi doit faire échouer l’appel à l’outil avant que cela ne devienne un récit d’enquête erroné.

Séparez les outils de lecture des outils d’écriture. Les agents de tri fonctionnent par défaut en mode lecture seule ; les écritures liées aux règlements nécessitent un nœud d’approbation ainsi qu’une clé d’idempotence.

Associez les échecs d’Application Insights à des actions concrètes : en cas d’augmentation soudaine des temps d’attente des outils de détection de fraude, c’est aux responsables de l’intégration SIU qu’il revient d’intervenir, et non par défaut à l’équipe de la plateforme LLM.

Gardez les réclamations synthétiques dans un ensemble de cas d’usage incluant des situations limites : polices expirées, scores de fraude proches du seuil critique, et incidents impliquant plusieurs véhicules qui sollicitent fortement le système de routage.

Lors des démonstrations destinées aux dirigeants, montrez le flux de traçage pour une réclamation. L’essentiel réside dans l’orchestration et les mécanismes de contrôle, et non dans les noms des modèles.

Les prompts destinés aux spécialistes doivent interdire l’invention de clauses de police d’assurance. Si l’outil de couverture renvoie des résultats vides, le spécialiste doit faire monter l’affaire en grade – et non supposer que la couverture est probable.

Mettre en place une validation du schéma pour les arguments de l’outil. Un identifiant de sinistre mal saisi doit entraîner un échec de l’appel à l’outil avant que cela ne devienne une narration d’enquête erronée.

Séparer les outils de lecture des outils d’écriture. Les agents chargés du triage fonctionnent par défaut en mode lecture seule ; les écritures liées au règlement nécessitent un nœud d’approbation ainsi qu’une clé d’idempotence.

Associer les échecs d’Application Insights à des actions concrètes : une augmentation soudaine des temps d’attente de l’outil anti-fraude doit alerter les responsables de l’intégration SIU, et non par défaut l’équipe de la plateforme LLM.

Garder les sinistres synthétiques dans un ensemble de données de test comprenant des cas limites : police d’assurance expirée, score de fraude proche du seuil critique, et accidents impliquant plusieurs véhicules qui sollicitent fortement le système de routage.

Lors de la démonstration auprès des dirigeants, affichez le diagramme en cascade des traçages pour une seule demande. L’essentiel réside dans l’orchestration et les contrôles, et non dans les noms de marques de modèles.

Les instructions destinées aux spécialistes doivent interdire l’invention de clauses de police. Si l’outil d’évaluation renvoie des résultats vides, le spécialiste doit faire remonter l’affaire — et non supposer que la demande est probablement couverte.

Mettez en place une validation du schéma pour les arguments de l’outil. Un identifiant de demande mal saisi doit entraîner un échec de l’appel à l’outil avant que cela ne devienne une narration d’enquête erronée.

Séparez les outils de lecture des outils d’écriture. Les agents chargés du triage fonctionnent par défaut en mode lecture seule ; les écritures liées au règlement nécessitent un nœud d’approbation ainsi qu’une clé d’idempotence.

Associez les échecs détectés par Application Insights à des actions concrètes : en cas d’augmentation soudaine du nombre de pages de timeout des outils anti-fraude, c’est aux responsables de l’intégration SIU qu’il revient d’intervenir, et non par défaut à l’équipe de la plateforme LLM.

Gardez les demandes synthétiques dans un ensemble de scénarios incluant des cas limites : polices expirées, scores de fraude proches du seuil, et accidents impliquant plusieurs véhicules qui mettent à l’épreuve le routage.

Lors de la démonstration auprès des dirigeants, montrez le diagramme en cascade du suivi pour une demande. L’essentiel réside dans l’orchestration et les mécanismes de contrôle, et non dans les noms des marques de modèles.

← Tous les articles Envoyer le brief