azure ai-foundry multi-agent claims insurance observability

Triaje de siniestros de seguros con múltiples agentes en Microsoft Foundry

Triaje de siniestros de seguros en Microsoft Foundry: un coordinador junto con agentes de cobertura, fraude y liquidación, puntos de control, App Insights y alojamiento de Container Apps.

Editor: REACTAPP.TOPAñadido a este sitio 26 sept 202613 min de lectura2993 palabras

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

Imagínese a una compañía de seguros que recibe miles de nuevas reclamaciones diariamente a través de formularios en la web y líneas telefónicas transcritas. Antes del pago, son importantes tres aspectos: la cobertura del seguro en la fecha del incidente, las señales de fraude que mantiene el equipo de SIU y el rango de liquidación basado en la estimación de los daños. La revisión manual secuencial es lenta. Una triaje con múltiples agentes alojada en Foundry permite trabajar de forma paralela a los especialistas, reservando a los humanos para los casos excepcionales.

Herramientas utilizadas

Despliegues de modelos en Azure AI Foundry, un marco de trabajo para agentes/orquestación con transferencias de tareas, puntos de control para ejecuciones duraderas, Application Insights para el seguimiento de actividades, y Container Apps con identidad gestionada para el alojamiento.

Requisitos previos

Una suscripción a Azure con acceso a Foundry, capacidad para desplegar aplicaciones en contenedores, un espacio de trabajo de App Insights y cargas de prueba de reclamaciones para pruebas.

Arquitectura del proyecto

Un coordinador asigna las tareas a tres especialistas (cobertura, fraude, liquidación). Las herramientas incluyen búsquedas de pólizas, verificaciones de listas de fraudes y reglas de clasificación. Los puntos de control conservan el estado del reclamo en curso. La telemetría se activa en cada transferencia de tarea.

Paso 1. Crear el recurso Foundry e implementar los modelos

Provea los recursos del proyecto e implante el modelo o modelos de chat que utilizarán los agentes. Anote cuidadosamente los nombres de las implementaciones.

Paso 2. Instalar el framework e indicar al cliente de chat que use 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

Configure el endpoint, la implementación y la autenticación mediante Entra/managed identity; evite incluir claves API en las imágenes de contenedor.

Paso 3. Defina al coordinador y a los tres especialistas

Dé a cada especialista una instrucción de sistema específica y un conjunto limitado de herramientas. El coordinador solo dirige y agrega información; no debe volver a implementar la lógica de los especialistas.

Paso 4. Conecte el grafo de transferencia

Los enlaces explícitos de transferencia son mejores que un conjunto caótico e ilimitado de herramientas. La secuencia Cobertura → Fraude → Liquidación es un valor por defecto razonable; permita una conexión directa a SIU cuando la puntuación de fraude aumente significativamente.

Paso 5. Proporcione herramientas reales a los especialistas

Las herramientas deben conectarse con sistemas reales o con versiones simplificadas que sigan los esquemas correspondientes. Las herramientas falsas que siempre “aprueban” no enseñan nada útil.

Paso 6. Cree puntos de control para evitar perder reclamaciones en curso al reiniciar

Guarde el estado de la solicitud o del hilo después de cada especialista. Los reinicios del contenedor durante una solicitud deben permitir continuar con ella, sin realizar pagos duplicados.

Paso 7. Envíe registros y métricas a Application Insights

Emita eventos personalizados para las transferencias de tarea, la latencia de las herramientas y el resultado final. Los paneles de control deben mostrar el tiempo medio hasta la triaje en comparación con la línea base manual.

Paso 8. Ejecute una reclamación y lea el resultado

Utilice una reclamación de referencia con resultados conocidos en cuanto a cobertura y fraude. Asegúrese de que el paquete final del coordinador incluya los resultados de los tres especialistas.

Paso 9. Implemente en Container Apps con identidad gestionada

Conceda derechos de identidad a las implementaciones en Foundry y a todas las API backend que utilicen las herramientas. Restrinja el acceso entrante.

Solución de problemas

Un resultado vacío de los especialistas suele indicar un nombre de implementación incorrecto o un JSON de la herramienta truncado. Los bucles a menudo se deben a la falta de condiciones de finalización para las transferencias de tarea. Los fallos de autenticación se deben a políticas RBAC, no a que “el modelo esté inactivo”.

Costo de ejecutar esto

Los tokens del modelo dominan; el almacenamiento de puntos de control y App Insights son relativamente pequeños. Establezca un límite máximo de turnos por reclamación y consultas a la política de caché.

Limpieza

Elimine las aplicaciones en contenedor, identidades y despliegues que creó para la guía, para que los recursos de demostración no permanezcan en la factura.

Cierre

La triaje de reclamaciones multiagente funciona cuando los especialistas son específicos, las herramientas son reales, los puntos de control son duraderos y la telemetría demuestra que la latencia es un factor decisivo. Foundry proporciona el entorno del modelo; la disciplina de grafos y operaciones suministra el producto.

Agregue un nodo de aprobación humana para los rangos de liquidación por encima de un umbral. Los agentes deben acelerar el triaje, no autorizar en silencio pagos elevados.

Guarde las reglas contra el fraude de versiones por separado de los prompts del modelo. Cuando SIU actualiza una lista de señales, no debería ser necesario cambiar el prompt para detectarlas; las herramientas deben leer la lista actual.

Ejecutar pruebas de carga con solicitudes concurrentes para verificar los límites de tasa en la implementación de Foundry. Se debe definir el comportamiento ante desbordamiento de colas: rechazar, retrasar o pasar a un proceso manual.

Privacidad: el texto de las solicitudes es sensible. Asegúrese de que los registros eliminen los números de seguro social y otros datos personales identificables, y de que la toma de muestras de App Insights no almacene información personal sin procesar en dimensiones personalizadas.

Mantener una prueba de caos que detenga el contenedor a mitad de una solicitud y verifique que pueda reanudarse desde un punto de control sin efectos secundarios duplicados en las herramientas; son obligatorias las claves de idempotencia en las operaciones de escritura.

Agregar un nodo de aprobación humana para los casos de liquidación por encima de un umbral determinado. Los agentes deben acelerar el proceso de triaje, en lugar de autorizar silenciosamente pagos importantes.

Vincular las reglas contra el fraude por separado de los prompts del modelo. Cuando SIU actualice la lista de señales, no debería ser necesario cambiar los prompts para incorporar esas actualizaciones; las herramientas deben leer la lista actual.

Mantener una prueba de caos que detenga el contenedor a mitad de una solicitud y verifique si es posible reanudarla desde un punto de control, sin efectos secundarios duplicados en las herramientas; son obligatorias las claves de idempotencia en las operaciones de escritura.

Vincular las reglas contra el fraude en una versión separada de los prompts del modelo. Cuando SIU actualice la lista de señales, no debería ser necesario cambiar los prompts para incorporar esas actualizaciones; las herramientas deben leer la lista actual.

Mantener una prueba de caos que detenga el contenedor a mitad de una solicitud y verifique si es posible reanudarla desde un punto de control sin efectos secundarios en las herramientas, siendo obligatorias las claves de idempotencia en las operaciones de escritura.

Verificar las reglas contra el fraude por separado de los prompts del modelo. Cuando SIU actualice la lista de señales, no debería ser necesario cambiar los prompts para incorporar esas actualizaciones; las herramientas deben leer la lista actual.

Mantener una prueba de caos que detenga el contenedor a mitad de una solicitud y verifique que pueda reanudarse desde un punto de control sin efectos secundarios en las herramientas, siendo obligatorias las claves de idempotencia en las operaciones de escritura.

Realice pruebas de carga con solicitudes concurrentes para evaluar los límites de tasa en la implementación de Foundry. Se debe definir el comportamiento ante el desbordamiento de la cola: rechazar, retrasar o pasar a un proceso manual.

Mantenga una prueba de caos que detenga el contenedor a mitad de una solicitud y verifique si es posible reanudarla desde un punto de control, sin efectos secundarios duplicados en la herramienta; las claves de idempotencia en las operaciones de escritura son obligatorias.

Las indicaciones para los especialistas deben prohibir la creación de cláusulas de política arbitrarias. Si la herramienta de cobertura devuelve resultados vacíos, el especialista debe elevar el caso, en lugar de suponer que “probablemente esté cubierto”.

Implemente validación de esquema en los argumentos de la herramienta. Un ID de solicitud escrito incorrectamente debe hacer que la llamada a la herramienta falle antes de que se genere una narrativa de investigación errónea.

Separar las herramientas de lectura de las de escritura. Los agentes de triaje funcionan por defecto en modo solo lectura; las escrituras relacionadas con liquidaciones requieren la aprobación de un nodo y una clave de idempotencia.

Asignar las fallas de Application Insights a los responsables adecuados: en caso de un aumento en los tiempos de espera de las herramientas contra el fraude, los responsables son los encargados de la integración con SIU, y no por defecto el equipo de la plataforma LLM.

Mantener las reclamaciones sintéticas en un conjunto de casos límite que incluya situaciones como pólizas vencidas, puntajes de fraude cercanos al umbral y accidentes con múltiples vehículos que pongan a prueba el sistema de enrutamiento.

Al demostrar la funcionalidad a los ejecutivos, mostrar el flujo de seguimiento correspondiente a una reclamación. Lo importante son la orquestación y los controles, no los nombres de las marcas de modelos.

Los prompts dirigidos a especialistas deben prohibir la creación de cláusulas en las pólizas. Si la herramienta de cobertura devuelve resultados vacíos, el especialista debe elevar el caso, en lugar de suponer que “probablemente esté cubierto”.

Aplicar la validación de esquemas a los argumentos de la herramienta. Un ID de reclamación escrito incorrectamente debe hacer que la llamada a la herramienta fracase antes de que se convierta en una narrativa de investigación falsa.

Separar las herramientas de lectura de las de escritura. Los agentes de triaje funcionan por defecto en modo solo lectura; las operaciones de escritura para liquidaciones requieren la aprobación del nodo correspondiente y una clave de idempotencia.

Asignar los fallos de Application Insights a acciones concretas: un aumento en los tiempos de espera de las herramientas contra el fraude debe ser atendido por los responsables de la integración SIU, y no por el equipo de la plataforma LLM por defecto.

Al demostrar la herramienta a los ejecutivos, mostrar el flujo de trazas correspondiente a una reclamación. La historia que se cuenta debe centrarse en la orquestación y los controles, no en los nombres de las marcas de modelos.

Los prompts para especialistas deben prohibir la creación de cláusulas en las pólizas. Si la herramienta de cobertura devuelve un resultado vacío, el especialista debe elevar el caso, en lugar de suponer que “probablemente esté cubierto”.

Implemente la validación de esquemas en los argumentos de la herramienta. Un ID de reclamo escrito incorrectamente debe hacer que la llamada a la herramienta fracase antes de que se genere una narrativa de investigación errónea.

Separen las herramientas de lectura de las de escritura. Los agentes de triaje operan por defecto en modo solo lectura; las operaciones de liquidación requieren la aprobación del nodo correspondiente y una clave de idempotencia.

Asocie los fallos de Application Insights con acciones concretas: un aumento en los tiempos de espera de la herramienta contra el fraude debe ser atendido por los responsables de la integración con SIU, y no por el equipo de la plataforma LLM por defecto.

Mantenga las reclamaciones sintéticas en un conjunto de casos límite que incluya situaciones como pólizas vencidas, puntajes de fraude cercanos al umbral y accidentes con múltiples vehículos que someten a prueba el sistema de enrutamiento.

Al hacer demostraciones a los ejecutivos, muestre la secuencia de seguimiento para una reclamación. Lo importante son la orquestación y los controles, no los nombres de las marcas de modelos.

Los prompts para especialistas deben prohibir la creación de cláusulas en las pólizas. Si la herramienta de cobertura devuelve resultados vacíos, el especialista debe elevar el caso, en lugar de suponer que “probablemente esté cubierto”.

Implemente validación de esquemas en los argumentos de la herramienta. Un ID de reclamación escrito incorrectamente debe hacer que la llamada a la herramienta falle antes de que se genere una narrativa de investigación errónea.

Separe las herramientas de lectura de las de escritura. Los agentes de triaje operan por defecto en modo solo lectura; las operaciones de liquidación requieren la aprobación del nodo correspondiente y una clave de idempotencia.

Mantenga las solicitudes sintéticas en un paquete de casos de uso que incluya situaciones límite: pólizas vencidas, puntajes de fraude cercanos al umbral y accidentes con múltiples vehículos que generan estrés en el proceso de enrutamiento.

Al realizar demostraciones ante ejecutivos, muestre el flujo de seguimiento para una solicitud. Lo importante son la orquestación y los controles, no los nombres de las marcas de modelos.

← Todos los artículos Enviar el brief