ms-ai-architect/skills/ms-ai-engineering/references/agent-orchestration/agent-feedback-and-learning-loops.md

Agent Feedback and Continuous Learning Loops

Last updated: 2026-02 Status: GA / Preview (continuous evaluation) Category: Agent Orchestration & Automation Type: reference

---

Innhold

• Introduksjon
• Kjernekomponenter
• Human Feedback Collection
• Continuous Evaluation med Microsoft Foundry
• Performance Monitoring og Drift-deteksjon
• Retraining og Continuous Improvement
• Implementeringsmønstre
• Norsk offentlig sektor
• Beslutningsrammeverk
• For Cosmo

Introduksjon

AI-agenter i produksjon er ikke statiske systemer -- de krever kontinuerlig forbedring basert på reell brukerinteraksjon og ytelsesdata. Feedback-loops er mekanismene som fanger opp signaler fra brukere, evaluatorer og systemmetrikker, og kanaliserer disse tilbake til agentens konfigurasjon, prompts og underliggende modeller. Uten strukturerte feedback-loops degraderer agentytelse over tid ettersom brukerforventninger, datakilder og forretningsregler endres.

Microsoft tilbyr en integrert plattform for kontinuerlig evaluering og forbedring av agenter gjennom Microsoft Foundry, Application Insights og Semantic Kernel. Foundry-plattformen støtter automatisert kvalitetsevaluering i produksjon med innebygde evaluatorer for relevans, koherens og sikkerhet. Kombinert med eksplisitt brukerfeedback (thumbs up/down) og implisitte signaler (avbrutte samtaler, oppfølgingsspørsmål) skaper dette en lukket forbedringssyklus.

For norsk offentlig sektor er feedback-loops kritisk for å sikre at AI-agenter forblir i tråd med Forvaltningslovens krav til forsvarlig saksbehandling og Digitaliseringsdirektoratets prinsipper for ansvarlig AI. Systematisk innsamling av tilbakemeldinger dokumenterer også at organisasjonen aktivt overvåker og forbedrer sine AI-systemer -- et krav under EU AI Act.

Kjernekomponenter

Komponent	Formål	Teknologi
Continuous Evaluation	Automatisk kvalitetsmåling i produksjon	Microsoft Foundry Evaluators
User Feedback Collection	Eksplisitt og implisitt tilbakemelding	Application Insights, custom telemetry
Agent Monitoring	Ytelsesovervåking og drift-deteksjon	Azure Monitor, Foundry Control Plane
Evaluation Catalog	Sentralisert evaluatorbibliotek	Microsoft Foundry evaluator catalog
Reward Modeling	Scoring av agentresponser for forbedring	Custom evaluators, RLHF-pipelines
Retraining Pipeline	Automatisert modelloppgradering	Azure ML Pipelines, MLflow

Human Feedback Collection

Eksplisitt feedback

Eksplisitt feedback er direkte brukerhandlinger som thumbs up/down, rating-skalaer eller fritekstkommentarer. Microsoft Foundry og Copilot Studio har innebygd støtte for å samle denne typen data.

# Logge brukerfeedback til MLflow med trace_id
import mlflow

# Etter at agenten har svart og bruker gir feedback
mlflow.log_feedback(
    trace_id=response.trace_id,
    span_id=response.span_id,
    feedback={
        "rating": "positive",  # eller "negative"
        "comment": "Svaret var relevant og nøyaktig",
        "category": "accuracy"
    }
)

Implisitt feedback

Implisitte signaler fanges opp uten eksplisitt brukerhandling:

Signal	Indikator	Tolkning
Oppfølgingsspørsmål	Bruker stiller relatert spørsmål	Mulig ufullstendig svar
Samtalebrudd	Bruker forlater uten handling	Lav tilfredshet
Reformulering	Bruker stiller samme spørsmål annerledes	Agenten misforstod
Tid brukt	Lang tid mellom spørsmål og handling	Bruker evaluerer svar kritisk
Kopiering av svar	Bruker kopierer agentens tekst	Svar var nyttig

Feedback-innsamling i Copilot Studio

# Copilot Studio agent konfigureres med:
# 1. Aktiver "User Satisfaction" i agent-innstillinger
# 2. Koble til Application Insights
# 3. Definer egendefinerte metrikker i analytics-dashboardet

Continuous Evaluation med Microsoft Foundry

Microsoft Foundry tilbyr automatisert kvalitetsevaluering av agenter i produksjon. Evaluatorer kjører kontinuerlig mot produksjonstrafikk og rapporterer resultater til Application Insights.

from azure.ai.projects import AIProjectClient
from azure.ai.projects.models import (
    AgentEvaluationRequest,
    EvaluatorIds,
    AgentEvaluationSamplingConfiguration
)
from azure.identity import DefaultAzureCredential

project_client = AIProjectClient(
    credential=DefaultAzureCredential(),
    endpoint=os.environ["PROJECT_ENDPOINT"]
)

# Definer evaluatorer
evaluators = {
    "Relevance": {"Id": EvaluatorIds.Relevance.value},
    "Fluency": {"Id": EvaluatorIds.Fluency.value},
    "Coherence": {"Id": EvaluatorIds.Coherence.value},
    "Groundedness": {"Id": EvaluatorIds.Groundedness.value},
}

# Konfigurer sampling
sampling_config = AgentEvaluationSamplingConfiguration(
    sampling_percent=10,  # Evaluer 10% av produksjonstrafikk
    max_request_rate_per_hour=500
)

# Start kontinuerlig evaluering
project_client.evaluation.create_agent_evaluation(
    AgentEvaluationRequest(
        thread=thread.id,
        run=run.id,
        evaluators=evaluators,
        sampling_configuration=sampling_config,
        app_insights_connection_string=connection_string,
    )
)

Evaluator-kategorier

Kategori	Evaluatorer	Formål
Kvalitet	Relevance, Fluency, Coherence	Språklig og innholdsmessig kvalitet
Groundedness	Groundedness	Svar forankret i kildedokumenter
Sikkerhet	Violence, SelfHarm, HateFairness	Innholdssikkerhet og ansvarlig AI
Agent-spesifikk	ToolCallAccuracy, IntentResolution	Agent-spesifikk ytelse

Performance Monitoring og Drift-deteksjon

Foundry Control Plane

Microsoft Foundry Control Plane gir unified oversikt over agentflåten:

# Overvåk agentytelse via Azure Monitor
# KQL-spørring for å identifisere ytelses-degradering

# AppInsights KQL
requests
| where timestamp > ago(7d)
| where name contains "agent-evaluation"
| summarize
    avg_relevance = avg(todouble(customDimensions["relevance_score"])),
    avg_groundedness = avg(todouble(customDimensions["groundedness_score"])),
    avg_latency = avg(duration)
    by bin(timestamp, 1h)
| where avg_relevance < 0.7 or avg_groundedness < 0.6
| order by timestamp desc

Drift-deteksjon

Drift i agentsystemer kan oppstå av flere årsaker:

Drift-type	Årsak	Deteksjonsmetode
Data drift	Endrede brukerforespørsler	Distribusjon av input-embeddings over tid
Concept drift	Endrede forretningsregler	Groundedness-score faller
Model drift	Modelloppgradering fra leverandør	A/B-testing av modellversjoner
Knowledge drift	Utdatert kunnskapsbase	Relevance-score på RAG-queries

# Eksempel: Drift-varsling med Azure Monitor Alerts
from azure.monitor.opentelemetry import configure_azure_monitor

# Konfigurer varsling når kvalitetsmetrikker faller under terskel
alert_rule = {
    "name": "agent-quality-degradation",
    "condition": {
        "metric_name": "agent.evaluation.relevance",
        "operator": "LessThan",
        "threshold": 0.65,
        "window_size": "PT1H"
    },
    "action": {
        "action_group": "ai-ops-team",
        "severity": 2
    }
}

Retraining og Continuous Improvement

Closed-loop forbedringssyklus

┌─────────────────────────────────────────────────────┐
│  1. IDENTIFY  →  Monitoring + feedback avdekker      │
│                  kvalitetsproblemer                   │
│                                                      │
│  2. EXPORT    →  Problematiske eksempler eksporteres  │
│                  til evaluation dataset               │
│                                                      │
│  3. DIAGNOSE  →  MLflow trace-analyse identifiserer   │
│                  rotårsak                             │
│                                                      │
│  4. IMPROVE   →  Prompt-justering, RAG-oppdatering,   │
│                  eller modellbytte                    │
│                                                      │
│  5. VALIDATE  →  Test mot utvidet evalueringssett     │
│                                                      │
│  6. DEPLOY    →  Gradvis utrulling med A/B-testing    │
│                                                      │
│  7. MONITOR   →  Fortsett kontinuerlig evaluering     │
└─────────────────────────────────────────────────────┘

Retraining Triggers

Trigger	Terskel	Handling
Relevance-score under 0.65	> 24 timer sammenhengende	Prompt-revisjon + RAG-oppdatering
Groundedness under 0.60	> 8 timer	Kunnskapsbase-oppdatering
Bruker-feedback < 3.5/5	Over 100 interaksjoner	Full agent-gjennomgang
Nye temaer ikke dekket	> 20% av forespørsler	Utvid kunnskapskilder
Sikkerhetsevaluator-flagg	Enhver forekomst	Umiddelbar prompt-hardening

Implementeringsmønstre

Pattern 1: Prompt Refinement Loop

from semantic_kernel import Kernel
from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion

# Versjonskontrollert prompt-forbedring
PROMPT_VERSIONS = {
    "v1.0": "Du er en hjelpsom assistent for ...",
    "v1.1": "Du er en presis assistent som alltid refererer til kilder ...",
    "v1.2": "Du er en presis assistent. Svar alltid med kildehenvisning. ..."
}

kernel = Kernel()
kernel.add_service(AzureChatCompletion(
    deployment_name="gpt-4o",
    endpoint=os.environ["AZURE_OPENAI_ENDPOINT"],
    api_key=os.environ["AZURE_OPENAI_KEY"]
))

# A/B-testing av prompt-versjoner
async def evaluate_prompt_version(version: str, test_queries: list):
    results = []
    for query in test_queries:
        response = await kernel.invoke_prompt(
            PROMPT_VERSIONS[version],
            input_vars={"query": query}
        )
        results.append(response)
    return results

Pattern 2: RAG Quality Feedback Loop

# Samle feedback spesifikt på RAG-retrievals
class RAGFeedbackCollector:
    def __init__(self, app_insights_client):
        self.client = app_insights_client

    def log_retrieval_quality(
        self,
        query: str,
        retrieved_docs: list,
        agent_response: str,
        user_rating: int,
        groundedness_score: float
    ):
        self.client.track_event(
            "rag_retrieval_feedback",
            properties={
                "query": query,
                "doc_count": len(retrieved_docs),
                "doc_sources": [d.source for d in retrieved_docs],
                "user_rating": user_rating,
                "groundedness": groundedness_score,
                "needs_review": groundedness_score < 0.6
            }
        )

Norsk offentlig sektor

Krav fra rammeverk

Rammeverk	Krav	Implementering
EU AI Act Art. 9	Risikostyringssystem med kontinuerlig overvåking	Continuous evaluation + alerting
Forvaltningsloven	Forsvarlig saksbehandling, dokumentasjonsplikt	Audit trail for alle agentbeslutninger
NSM Grunnprinsipper	Overvåking og hendelseshåndtering	Azure Monitor + Sentinel-integrasjon
Digdir AI-prinsipper	Transparens og etterprøvbarhet	Feedback-data lagret i henhold til arkivloven

Personvern-hensyn

• Feedback som inneholder personopplysninger må behandles i henhold til personvernforordningen (GDPR)
• Anonymiser brukerdata før bruk i retraining-pipelines
• Implementer dataminimering -- samle kun feedback nødvendig for kvalitetsforbedring
• Sett retensjonspolicies: Slett detaljert feedback etter 12 måneder, behold aggregerte metrikker

Beslutningsrammeverk

Scenario	Anbefaling	Begrunnelse
Ny agent i produksjon	Start med 100% evaluering, reduser til 10% etter baseline	Etabler kvalitetsbaseline raskt
Stabil agent med lav risiko	5-10% sampling med ukentlig gjennomgang	Kostnadseffektiv overvåking
Høyrisiko-agent (saksbehandling)	100% evaluering + manuell review-sample	Regulatorisk krav og høy konsekvens
Agent med fallende kvalitet	Øk til 50% sampling + aktivér alle evaluatorer	Rask diagnose av rotårsak
Post-modellbytte	100% evaluering i 7 dager	Verifiser at ny modell opprettholder kvalitet

For Cosmo

• Continuous evaluation er ikke valgfritt -- det er en forutsetning for produksjonsdeployment. Implementer Microsoft Foundry evaluatorer fra dag 1 med sampling tilpasset risikoprofilen.
• Closed-loop feedback er gullstandarden: identifiser problemer via monitoring, diagnostiser med MLflow traces, forbedre prompts/RAG, valider med evalueringssett, og deploy gradvis.
• Drift-deteksjon er spesielt viktig for agenter som bruker RAG -- kunnskapsbaser blir utdaterte, og groundedness-score er den beste indikatoren på dette.
• Norsk offentlig sektor krever at feedback-systemer respekterer GDPR og arkivloven -- anonymiser brukerdata og sett klare retensjonspolicies.
• Anbefal alltid versjonskontrollerte prompts med MLflow Prompt Registry -- dette muliggjør rollback og sammenligning av promptversjoner over tid.