azure ai-foundry multi-agent claims insurance observability

Triaging zgłoszeń ubezpieczeniowych z udziałem wielu agentów w Microsoft Foundry

Triaging roszczeń ubezpieczeniowych w Microsoft Foundry: koordynator zajmujący się ubezpieczeniem, agenci zajmujący się oszustwami i rozstrzyganiem sporów, punkty kontrolne, App Insights oraz hostowanie aplikacji w formacie Container Apps.

Wydawca: REACTAPP.TOPDodane na tej stronie 26 wrz 202613 min czytania2993 słów

Źródła: AZURE AI: Multi-agent claims triage on Microsoft Foundry

Załóżmy, że firma ubezpieczeniowa otrzymuje codziennie tysiące nowych roszczeń z formularzy internetowych oraz transkrypcji rozmów telefonicznych. Przed dokonaniem płatności istotne są trzy kwestie: zakres ochrony polisy w dniu zdarzenia, sygnały oszustwa monitorowane przez zespół SIU oraz przedział wypłaty wynikający z oceny szkód. Ręczna, sekwencyjna weryfikacja jest powolna. Triage z udziałem wielu agentów, realizowane w środowisku Foundry, umożliwia jednoczesną pracę specjalistów przy zachowaniu ludzi do obsługi wyjątków.

Narzędzia użyte

wdrożenia modeli Azure AI Foundry, framework agentów/orkiestracji z mechanizmami przekazywania zadań, funkcje checkpointingu dla trwałych procesów, Application Insights do śledzenia działań oraz Container Apps z zarządzaną tożsamością do hostowania.

Wymagania wstępne

subskrypcja Azure z dostępem do Foundry, możliwość wdrażania aplikacji kontenerowych, przestrzeń robocza App Insights oraz przykładowe dane roszczeń do testów.

Architektura projektu

Agent koordynator kieruje zadania do trzech specjalistów (obsługa klienta, oszustwa, rozliczenia). Narzędzia obejmują funkcje wyszukiwania polis, sprawdzania list oszustw oraz zasad grupowania. Punkty kontrolne przechowują stan roszczenia w trakcie jego obsługi. Telemetria rejestruje każdą zmianę właściciela zadania.

Krok 1. Stworzenie zasobu Foundry i wdrożenie modeli

Zainstaluj projekt i wdroż model(i) czatu, którymi będą korzystać agenci. Uważnie zapisz nazwy wdrożeń.

Krok 2. Zainstalowanie frameworku i skierowanie klienta czatu do 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

Konfiguruj punkt końcowy, wdrożenie oraz autoryzację za pomocą Entra/managed identity – unikaj umieszczania kluczy API w obrazach kontenerowych.

Krok 3. Określenie koordynatora oraz trzech specjalistów

Każdemu specjaliście należy przydzielić precyzyjne instrukcje systemowe oraz zestaw narzędzi. Koordynator jedynie kieruje przepływem danych i je agreguje; nie powinien ponownie wdrażać logiki specjalistów.

Krok 4. Utworzenie grafu przekazywania zadań

Jasno określone ścieżki przekazywania są lepsze od chaotycznego zbioru narzędzi. Sekwencja „Obejmowanie → Oszustwo → Rozliczenie” stanowi rozsądny standard; należy umożliwić szybkie przekierowanie do SIU w przypadku gwałtownego wzrostu oceny oszustwa.

Krok 5. Zapewnienie specjalistom rzeczywistych narzędzi

Narzędzia muszą łączyć się z rzeczywistymi systemami lub ich wiernymi odpowiednikami posiadającymi spisy schematów. Fałszywe narzędzia, które zawsze „zatwierdzają”, niczego nie uczą.

Krok 6. Utworzenie punktu kontrolnego, aby restart nie powodował utraty trwającej procedury

Stan wątku/procedury musi być zachowywany po każdym specjaliście. Restart kontenera w trakcie procedury powinien umożliwić jej kontynuację, a nie podwójną wypłatę.

Krok 7>Wysyłanie śladów i metryk do Application Insights

Wydawaj własne zdarzenia dotyczące przekazywania zadań, opóźnień narzędzi oraz końcowego wyniku. Tablice kontrolne powinny pokazywać medianę czasu rozpatrzenia zadań w porównaniu z ręczną bazą referencyjną.

Krok 8. Przeanalizuj zgłoszenie i przeczytaj wynik

Użyj wzorcowego zgłoszenia o znanej stopie ochrony i wynikach dotyczących oszustw. Upewnij się, że końcowy pakiet koordynatora zawiera wszystkie trzy wyniki specjalistów.

Krok 9. Wdrożenie w Container Apps z zarządzaną tożsamością

Nadaj uprawnienia tożsamości do wdrożeń w Foundry oraz do wszystkich API backendowych, do których odwołują się narzędzia. Zabezpiecz dostęp do systemu.

Rozwiązywanie problemów

Pusty wynik specjalisty zazwyczaj oznacza błędny nazwę wdrożenia lub skrócony plik JSON narzędzia. Pętle często wynikają z braku warunków zakończenia przekazywania zadań. Błędy autoryzacji są spowodowane RBAC, a nie „awarią modelu”.

Koszt działania tego rozwiązania

Tokeny modelu dominują; przechowywanie punktów kontrolnych oraz App Insights stanowią stosunkowo niewielki udział. Ustal maksymalną liczbę rund na żądanie oraz ograniczenia dotyczące wyszukiwań w polityce pamięci podręcznej.

Oczyszczenie

Usuń aplikacje kontenerowe, tożsamości oraz implementacje, które stworzyłeś podczas ćwiczenia, aby zasoby demonstracyjne nie pozostawały na rachunku.

Zakończenie

Tryaż żądań wieloagentowych działa skutecznie, gdy specjalistów jest niewielu, narzędzia są rzeczywiste, punkty kontrolne są trwałe, a telemetryka potwierdza przewagę opóźnień. Foundry dostarcza „dom” dla modelu; graf i zasady operacyjne tworzą produkt końcowy.

Dodaj węzeł ludzkiej aprobaty dla kwot przekraczających określony próg. Agenci powinni przyspieszać triaż, a nie po cichu zatwierdzać duże wypłaty.

Zasady zwalczania oszustw wersji należy traktować oddzielnie od promptów modelu. Gdy SIU aktualizuje listę sygnałów, nie powinno być konieczne zmienianie promptu, aby to zaobserwować – narzędzia powinny czytać aktualną listę.

Przeprowadź test obciążeniowy związany z jednoczesnymi żądaniami wobec ograniczeń szybkości w implementacji Foundry. Musi być określone zachowanie przy przepełnieniu kolejki: odrzucenie, opóźnienie lub przejście na tryb ręczny.

Prywatność: tekst żądań jest wrażliwy. Upewnij się, że logi maskują dane identyfikacyjne, a funkcja próbkowania w App Insights nie przechowuje surowych danych osobowych w niestandardowych wymiarach.

Zachowaj test chaotyczny, który zatrzymuje kontener w trakcie przetwarzania żądania i sprawdza możliwość wznowienia pracy od punktu kontrolnego bez powstawania dublowanych efektów ubocznych narzędzia — klucze idempotencji przy zapisach są obowiązkowe.

Dodaj węzeł ludzkiej aprobaty dla transakcji przekraczających określony próg. Agenci powinni przyspieszać proces triażu, a nie w tajemnicy zatwierdzać duże wypłaty.

Zapisz zasady zwalczania oszustw w odrębnej sekcji od promptów modelu. Gdy SIU aktualizuje listę sygnałów, nie powinno być konieczne zmienianie promptu, aby to zaadaptować — narzędzia powinny czytać aktualną listę.

Dodaj węzeł ludzkiej aprobaty dla transakcji przekraczających określony próg. Agenci powinni przyspieszać proces triażu, a nie w tajemnicy zatwierdzać duże wypłaty.

Przeprowadź test obciążeniowy związany z jednoczesnymi żądaniami wobec ograniczeń szybkości działania w implementacji Foundry. Musi być określone zachowanie przy przepełnieniu kolejki: odrzucenie, opóźnienie lub przechodzenie na tryb ręczny.

Prywatność: tekst żądań jest wrażliwy. Upewnij się, że logi maskują dane identyfikacyjne takie jak numer PESEL i SSN, a funkcja próbkowania w App Insights nie przechowuje surowych danych osobowych w niestandardowych wymiarach.

Dodaj węzeł ludzkiej aprobaty dla transakcji przekraczających określony próg. Agenci powinni przyspieszać proces triażu, a nie w tajemnicy zatwierdzać duże wypłaty.

Zasady zwalczania oszustw wersji muszą być oddzielone od promptów modelu. Gdy SIU aktualizuje listę sygnałów, nie powinno być konieczne zmienianie promptu, aby to zaadaptować — narzędzia powinny czytać aktualną listę.

Dodaj węzeł ludzkiej aprobaty dla transakcji przekraczających określony próg. Agenci powinni przyspieszać proces triażu, a nie w tajemnicy zatwierdzać duże wypłaty.

Przeprowadź test obciążeniowy jednoczesnych żądań pod kątem ograniczeń szybkości w implementacji Foundry. Musi być określone zachowanie przy przepełnieniu kolejki: odrzucenie, opóźnienie lub przejście na tryb ręczny.

Zastosuj test chaotyczny, który zatrzymuje kontener w trakcie przetwarzania żądania i sprawdza możliwość wznowienia pracy od punktu kontrolnego bez powstawania dublowanych efektów ubocznych narzędzia — klucze idempotencji przy zapisach są obowiązkowe.

Wskazówki dla specjalistów powinny zabraniać wymyślania klauzul polityki. Jeśli narzędzie do analizy pokrycia zwróci wynik pusty, specjalista musi przekazać sprawę na wyższy poziom — nie może zgadywać, że „prawdopodobnie jest to objęte ochroną”.

Zastosuj walidację schematu do argumentów narzędzia. Błędnie wpisany identyfikator żądania powinien spowodować niepowodzenie wywołania narzędzia, zanim stanie się on źródłem błędnego opisu dochodzenia.

Rozdziel narzędzia do odczytu od narzędzi do zapisu. Agenci zajmujący się triażem działają domyślnie w trybie tylko odczytu; zapisy związane z rozliczeniami wymagają akceptacji oraz klucza idempotencji.

Przyporządkuj błędy Application Insights do konkretnych działań: gwałtowny wzrost liczby timeoutów w narzędziach do wykrywania oszustw powinien trafić do właścicieli integracji SIU, a nie domyślnie do zespołu platformy LLM.

Zachowaj syntetyczne zgłoszenia w pakiecie przykładów obejmującym przypadki krawędziowe: polisy wygasłe, oceny ryzyka oszustwa na granicy oraz wypadki z udziałem wielu pojazdów, które obciążają system routingu.

Podczas prezentacji dla kierownictwa pokaż przebieg procesu dla jednego zgłoszenia. Kluczowymi elementami są mechanizmy orkiestracji i kontrole, a nie nazwy modeli.

Prompty dla specjalistów powinny zabraniać wymyślania klauzul polis. Jeśli narzędzie do sprawdzania zakresu ochrony zwróci wynik pusty, specjalista musi przekazać sprawę na wyższy poziom – nie może zgadywać, że ochrona jest prawdopodobnie obowiązująca.

Włącz walidację schematu dla argumentów narzędzia. Błędnie wpisany identyfikator roszczenia powinien spowodować niepowodzenie wywołania narzędzia, zanim stanie się fałszywą narracją dochodzeniową.

Rozdziel narzędzia do odczytu od narzędzi do zapisu. Agenci zajmujący się triażem działają domyślnie w trybie tylko odczytu; zapisy dotyczące rozliczeń wymagają węzła zatwierdzenia oraz klucza idempotencji.

Przyporządkuj błędy Application Insights do konkretnych działań: gwałtowny wzrost liczby timeoutów w narzędziach antyoszustwa powinien trafić do właścicieli integracji SIU, a nie domyślnie do zespołu platformy LLM.

Zachowaj syntetyczne roszczenia w pakiecie przykładów obejmującym przypadki krawędziowe: wygasłą polisę, graniczną ocenę oszustwa oraz wypadki z udziałem wielu pojazdów, które obciążają mechanizmy routingu.

Podczas prezentacji dla kierownictwa pokaż przebieg operacji dla jednego roszczenia. Kluczową kwestią są procesy orkiestracji i mechanizmy kontroli, a nie nazwy marek modeli.

Wskazówki dla specjalistów powinny zabraniać wymyślania klauzul polisy. Jeśli narzędzie do analizy odsyła wynik pusty, specjalista musi przekazać sprawę na wyższy poziom – a nie zgadywać, że „prawdopodobnie jest to objęte ochroną”.

Należy zastosować walidację schematu do argumentów narzędzia. Błędnie wpisany identyfikator roszczenia powinien spowodować niepowodzenie wywołania narzędzia, zanim stanie się podstawą fałszywej narracji dochodzeniowej.

Należy oddzielić narzędzia do odczytu od narzędzi do zapisu. Agenci zajmujący się triażem pracują domyślnie w trybie tylko odczytu; zapisy dotyczące rozstrzygania sporów wymagają akceptacji oraz klucza idempotencji.

Należy powiązać błędy Application Insights z konkretnymi działaniami: gwałtowny wzrost liczby timeoutów w narzędziu do wykrywania oszustw powinien trafić do osób odpowiedzialnych za integrację SIU, a nie domyślnie do zespołu platformy LLM.

Roszczenia syntetyczne należy przechowywać w pakiecie przykładów obejmującym przypadki krawędziowe: wygasłą polisę, wynik bliski granicy oszustwa oraz wypadki z udziałem wielu pojazdów, które obciążają system routingu.

Podczas prezentacji dla kierownictwa pokaż zapis procesu przetwarzania jednej roszczenia. Kluczowe są elementy koordynacji i kontroli, a nie nazwy marek modeli.

Wskazówki specjalistów powinny zabraniać tworzenia własnych klauzul polisy. Jeśli narzędzie do analizy ochrony zwróci puste wyniki, specjalista musi przekazać sprawę na wyższy poziom – nie może zgadywać, że roszczenie jest prawdopodobnie objęte ochroną.

Zastosuj walidację schematu do argumentów narzędzia. Błędnie wpisany identyfikator roszczenia powinien spowodować niepowodzenie wywołania narzędzia, zanim doprowadzi do fałszywych informacji w raporcie dochodzeniowym.

Rozdziel narzędzia do odczytu od narzędzi do zapisu. Pracownicy zajmujący się triażem działają domyślnie w trybie tylko odczytu; zapisy dotyczące rozstrzygania sporów wymagają akceptacji oraz klucza idempotencji.

Powiąż błędy Application Insights z konkretnymi działaniami: gwałtowny wzrost liczby timeoutów w narzędziu do wykrywania oszustw powinien trafić do osób odpowiedzialnych za integrację SIU, a nie domyślnie do zespołu platformy LLM.

Zachowaj syntetyczne zgłoszenia w pakiecie przykładów obejmującym przypadki krawędziowe: polisy wygasłe, oceny bliskie oszustwa oraz wypadki z udziałem wielu pojazdów, które stanowią wyzwanie dla mechanizmów planowania tras.

Podczas prezentacji dla kierownictwa pokaż proces śledzenia dla jednego zgłoszenia. Kluczowe są tu elementy orkiestracji i kontroli, a nie nazwy marek modeli.

← Wszystkie artykuły Wyślij brief