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](#introduksjon)
- [Kjernekomponenter](#kjernekomponenter)
- [Human Feedback Collection](#human-feedback-collection)
- [Continuous Evaluation med Microsoft Foundry](#continuous-evaluation-med-microsoft-foundry)
- [Performance Monitoring og Drift-deteksjon](#performance-monitoring-og-drift-deteksjon)
- [Retraining og Continuous Improvement](#retraining-og-continuous-improvement)
- [Implementeringsmønstre](#implementeringsmønstre)
- [Norsk offentlig sektor](#norsk-offentlig-sektor)
- [Beslutningsrammeverk](#beslutningsrammeverk)
- [For Cosmo](#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.

```python
# 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

```yaml
# 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.

```python
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:

```python
# 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 |

```python
# 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

```python
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

```python
# 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.