ms-ai-architect/skills/ms-ai-engineering/references/agent-orchestration/agent-compliance-and-audit-trails.md

# Agent Compliance and Audit Trail Management

**Last updated:** 2026-02
**Status:** GA
**Category:** Agent Orchestration & Automation
**Type:** reference

---

## Innhold

- [Introduksjon](#introduksjon)
- [Kjernekomponenter](#kjernekomponenter)
- [Action Audit Logging](#action-audit-logging)
- [Decision Trail Documentation](#decision-trail-documentation)
- [Retention Policies](#retention-policies)
- [Regulatory Alignment](#regulatory-alignment)
- [Compliance Reporting](#compliance-reporting)
- [Norsk offentlig sektor](#norsk-offentlig-sektor)
- [Beslutningsrammeverk](#beslutningsrammeverk)
- [For arkitekten](#for-arkitekten)

## Introduksjon

Compliance og revisjonsspor for AI-agenter er ikke lenger en "nice-to-have" -- det er et regulatorisk krav under EU AI Act, GDPR, og nasjonale regelverk som den norske Forvaltningsloven. Organisasjoner må dokumentere hva agenter gjør, hvilke data de aksesserer, hvilke beslutninger de tar, og hvordan disse beslutningene kan etterprøves. Uten strukturerte revisjonsspor risikerer virksomheter regulatoriske sanksjoner og tap av tillit.

Microsoft tilbyr en governance-stack for agentcompliance gjennom Microsoft Foundry Control Plane for unified agentsynlighet, Microsoft Purview Compliance Manager for regulatorisk mapping, Microsoft Entra Agent ID for identitets- og tilgangsstyring, Azure Monitor og Log Analytics for sentralisert logging, og Microsoft Agent 365 for enterprise-grade agentovervåking. Disse verktøyene til sammen sikrer at enhver agenthandling kan spores tilbake til en spesifikk brukerforespørsel, gjennom agentens resonnering, til det endelige resultatet.

For norsk offentlig sektor er kravene spesielt strenge: Forvaltningsloven krever dokumentasjon av saksbehandling, Arkivloven krever journalføring, Offentlighetsloven gir innsynsrett, og EU AI Act stiller krav til risikostyring og logging av høyrisiko AI-systemer.

## Kjernekomponenter

| Komponent | Formål | Teknologi |
|-----------|--------|-----------|
| Action Audit Logging | Logg alle agenthandlinger | Azure Monitor, Log Analytics |
| Decision Trail | Dokumentér beslutningskjeden | OpenTelemetry traces, custom attributes |
| Retention Policies | Bevar data iht. regelverk | Azure Storage lifecycle, Purview |
| Regulatory Alignment | Map kontroller til regelverk | Microsoft Purview Compliance Manager |
| Compliance Reporting | Generer compliance-rapporter | Azure Monitor Workbooks, Power BI |
| Agent Identity | Spor hvem/hva som handlet | Microsoft Entra Agent ID |

## Action Audit Logging

### Comprehensive agent audit log

```python
from dataclasses import dataclass, field
from datetime import datetime
from enum import Enum
import json

class AgentActionType(Enum):
    QUERY_RECEIVED = "query_received"
    INTENT_CLASSIFIED = "intent_classified"
    AGENT_ROUTED = "agent_routed"
    RAG_RETRIEVAL = "rag_retrieval"
    TOOL_INVOKED = "tool_invoked"
    LLM_CALLED = "llm_called"
    RESPONSE_GENERATED = "response_generated"
    RESPONSE_FILTERED = "response_filtered"
    ERROR_OCCURRED = "error_occurred"
    HUMAN_ESCALATED = "human_escalated"

@dataclass
class AgentAuditEntry:
    timestamp: str = field(
        default_factory=lambda: datetime.utcnow().isoformat()
    )
    trace_id: str = ""
    span_id: str = ""
    session_id: str = ""
    user_id: str = ""
    agent_id: str = ""
    agent_name: str = ""
    action_type: str = ""
    action_details: dict = field(default_factory=dict)
    input_summary: str = ""  # Redacted/summarized
    output_summary: str = ""  # Redacted/summarized
    data_accessed: list = field(default_factory=list)
    tools_used: list = field(default_factory=list)
    model_used: str = ""
    tokens_consumed: int = 0
    duration_ms: float = 0
    success: bool = True
    error_message: str = ""
    compliance_flags: list = field(default_factory=list)

class AgentAuditLogger:
    def __init__(self, log_analytics_client):
        self.client = log_analytics_client

    async def log(self, entry: AgentAuditEntry):
        """Logg audit entry til Azure Log Analytics"""
        await self.client.upload(
            rule_id=os.environ["DCR_IMMUTABLE_ID"],
            stream_name="Custom-AgentAuditLog_CL",
            logs=[{
                "TimeGenerated": entry.timestamp,
                "TraceId": entry.trace_id,
                "SpanId": entry.span_id,
                "SessionId": entry.session_id,
                "UserId": entry.user_id,
                "AgentId": entry.agent_id,
                "AgentName": entry.agent_name,
                "ActionType": entry.action_type,
                "ActionDetails": json.dumps(entry.action_details),
                "InputSummary": entry.input_summary,
                "OutputSummary": entry.output_summary,
                "DataAccessed": json.dumps(entry.data_accessed),
                "ToolsUsed": json.dumps(entry.tools_used),
                "ModelUsed": entry.model_used,
                "TokensConsumed": entry.tokens_consumed,
                "DurationMs": entry.duration_ms,
                "Success": entry.success,
                "ErrorMessage": entry.error_message,
                "ComplianceFlags": json.dumps(entry.compliance_flags)
            }]
        )
```

### Immutable audit log med Azure Storage

```python
# Immutable storage for regulatorisk krav
from azure.storage.blob import BlobServiceClient

class ImmutableAuditStore:
    def __init__(self, connection_string: str, container: str):
        self.client = BlobServiceClient.from_connection_string(
            connection_string
        )
        self.container = self.client.get_container_client(container)
        # Container konfigurert med immutability policy

    async def store_audit_record(self, record: AgentAuditEntry):
        """Lagre audit record i immutable blob storage"""
        blob_name = (
            f"audit/{record.timestamp[:10]}/"
            f"{record.agent_name}/{record.trace_id}.json"
        )
        blob_client = self.container.get_blob_client(blob_name)
        await blob_client.upload_blob(
            json.dumps(record.__dict__),
            overwrite=False  # Immutable -- kan ikke overskrives
        )
```

## Decision Trail Documentation

### Komplett beslutningskjede

```python
from opentelemetry import trace

tracer = trace.get_tracer("agent-decision-trail")

async def process_with_full_trail(query: str, user_id: str):
    """Dokumentér komplett beslutningskjede for etterprøvbarhet"""

    with tracer.start_as_current_span("decision_trail") as root:
        root.set_attribute("user.id", user_id)
        root.set_attribute("query.hash", hash(query))  # Ikke full tekst

        # Steg 1: Intent classification
        with tracer.start_as_current_span("classify_intent") as span:
            intent = await classify(query)
            span.set_attribute("decision.type", "intent_classification")
            span.set_attribute("decision.result", intent.label)
            span.set_attribute("decision.confidence", intent.confidence)
            span.set_attribute("decision.reasoning",
                f"Klassifisert som '{intent.label}' basert på "
                f"nøkkelord-matching og semantisk likhet"
            )

        # Steg 2: Agent selection
        with tracer.start_as_current_span("select_agent") as span:
            agent = select_best_agent(intent)
            span.set_attribute("decision.type", "agent_selection")
            span.set_attribute("decision.result", agent.name)
            span.set_attribute("decision.reasoning",
                f"Valgt '{agent.name}' basert på intent '{intent.label}' "
                f"og agent capability score {agent.score}"
            )

        # Steg 3: Data retrieval
        with tracer.start_as_current_span("retrieve_data") as span:
            docs = await retrieve(query, agent)
            span.set_attribute("decision.type", "data_retrieval")
            span.set_attribute("data.sources",
                [d.source for d in docs])
            span.set_attribute("data.doc_count", len(docs))
            span.set_attribute("decision.reasoning",
                f"Hentet {len(docs)} dokumenter fra "
                f"{set(d.source for d in docs)}"
            )

        # Steg 4: Response generation
        with tracer.start_as_current_span("generate_response") as span:
            response = await agent.invoke(query, docs)
            span.set_attribute("decision.type", "response_generation")
            span.set_attribute("model.used", response.model)
            span.set_attribute("tokens.total", response.total_tokens)
            span.set_attribute("decision.reasoning",
                f"Generert svar med {response.model}, "
                f"{response.total_tokens} tokens"
            )

        return response
```

## Retention Policies

### Data lifecycle management

| Datatype | Retensjon | Begrunnelse | Implementering |
|----------|-----------|-------------|----------------|
| Audit logs (sammendrag) | 7 år | Arkivloven, bokføringsloven | Immutable Blob Storage |
| Full traces med innhold | 12 måneder | Debugging og forbedring | Log Analytics, TTL |
| Samtalehistorikk | 6 måneder | Brukeropplevelse | Cosmos DB TTL |
| Evaluerings-data | 24 måneder | Kvalitetssikring | Log Analytics |
| PII-holdige logger | 3 måneder | GDPR dataminimering | Automatisk sletting |
| Aggregerte metrikker | Ubegrenset | Trendanalyse | Azure Monitor Metrics |

### Automatisert retensjon

```python
# Azure Storage lifecycle policy for audit data
lifecycle_policy = {
    "rules": [
        {
            "name": "audit-tier-to-cool",
            "type": "Lifecycle",
            "definition": {
                "actions": {
                    "baseBlob": {
                        "tierToCool": {"daysAfterModificationGreaterThan": 90},
                        "tierToArchive": {"daysAfterModificationGreaterThan": 365},
                        "delete": {"daysAfterModificationGreaterThan": 2555}
                        # 7 år
                    }
                },
                "filters": {
                    "blobTypes": ["blockBlob"],
                    "prefixMatch": ["audit/"]
                }
            }
        },
        {
            "name": "pii-cleanup",
            "type": "Lifecycle",
            "definition": {
                "actions": {
                    "baseBlob": {
                        "delete": {"daysAfterModificationGreaterThan": 90}
                    }
                },
                "filters": {
                    "blobTypes": ["blockBlob"],
                    "prefixMatch": ["pii-logs/"]
                }
            }
        }
    ]
}
```

## Regulatory Alignment

### EU AI Act mapping

| EU AI Act krav | Artikkel | Agent-implementering |
|----------------|---------|----------------------|
| Risikostyringssystem | Art. 9 | Trusselmodellering + continuous monitoring |
| Datakvalitet | Art. 10 | RAG data quality checks + lineage |
| Teknisk dokumentasjon | Art. 11 | Agent manifest + arkitekturdokumentasjon |
| Journalføring | Art. 12 | Audit logs med full beslutningskjede |
| Transparens | Art. 13 | AI-disclosure i brukergrensesnitt |
| Menneskelig tilsyn | Art. 14 | Human-in-the-loop for høyrisiko-beslutninger |
| Nøyaktighet og robusthet | Art. 15 | Continuous evaluation + red teaming |

### Microsoft Purview Compliance Manager

```python
# Integrer agent-compliance med Purview
# Purview Compliance Manager gir:
# 1. Pre-definerte assessment-maler for EU AI Act
# 2. Compliance score tracking over tid
# 3. Improvement actions med prioritering
# 4. Evidence collection og documentation

# Bruk Purview APIs for automatisert compliance-sjekk
from azure.purview.compliance import PurviewComplianceClient

client = PurviewComplianceClient(
    endpoint=os.environ["PURVIEW_ENDPOINT"],
    credential=DefaultAzureCredential()
)

# Sjekk compliance-status for agent-kontroller
assessment = await client.get_assessment(
    template_id="eu-ai-act-high-risk",
    group_id="ai-agents"
)

# Rapportér compliance-gap
for action in assessment.improvement_actions:
    if action.status != "Completed":
        print(f"GAP: {action.title} - {action.category}")
```

## Compliance Reporting

### KQL-basert compliance rapport

```kql
// Compliance rapport: Alle agenthandlinger siste 30 dager
let audit_summary = AgentAuditLog_CL
| where TimeGenerated > ago(30d)
| summarize
    total_actions = count(),
    unique_users = dcount(UserId),
    unique_agents = dcount(AgentName),
    errors = countif(Success == false),
    human_escalations = countif(ActionType == "human_escalated"),
    pii_access = countif(array_length(
        parse_json(ComplianceFlags)) > 0),
    total_tokens = sum(TokensConsumed),
    avg_response_time = avg(DurationMs)
    by AgentName;

// Detaljerte compliance-flagg
let compliance_flags = AgentAuditLog_CL
| where TimeGenerated > ago(30d)
| where ComplianceFlags != "[]"
| extend flags = parse_json(ComplianceFlags)
| mv-expand flag = flags
| summarize flag_count = count() by tostring(flag), AgentName
| order by flag_count desc;

audit_summary
| join kind=leftouter compliance_flags on AgentName
```

### Power BI compliance dashboard

```kql
// Data for Power BI compliance dashboard
AgentAuditLog_CL
| where TimeGenerated > ago(90d)
| extend
    Week = startofweek(TimeGenerated),
    Agent = AgentName,
    Action = ActionType,
    HasPII = array_length(parse_json(ComplianceFlags)) > 0,
    ResponseTime = DurationMs
| summarize
    Actions = count(),
    Errors = countif(Success == false),
    PIIAccess = countif(HasPII),
    AvgResponseMs = avg(ResponseTime),
    P95ResponseMs = percentile(ResponseTime, 95),
    TokensUsed = sum(TokensConsumed)
    by Week, Agent, Action
```

## Norsk offentlig sektor

### Spesifikke krav

| Regelverk | Krav | Agent-implementering |
|-----------|------|----------------------|
| Forvaltningsloven §11a | Dokumentasjonsplikt for vedtak | Komplett beslutningskjede for agenter som bidrar til vedtak |
| Arkivloven | Journalføring av korrespondanse | Agent-interaksjoner med borgere journalføres |
| Offentlighetsloven | Innsynsrett i dokumenter | Agent-logger tilgjengelig for innsynsbegjæring |
| GDPR Art. 22 | Rett til ikke å bli utsatt for automatiserte beslutninger | Human-in-the-loop for agenter som gjør enkeltvedtak |
| EU AI Act | Logging av høyrisiko AI | Full audit trail for agenter i saksbehandling |
| Sikkerhetsloven | Beskyttelse av gradert info | Isolerte audit logs for sikkerhetsgraderte agenter |
| Digdir prinsipper | Etterprøvbarhet | Transparent dokumentasjon av AI-bruk |

### Implementering for norsk offentlig sektor

```python
# Journalføring av agent-interaksjoner i henhold til arkivloven
class NorwegianPublicSectorCompliance:
    def __init__(self, noark_client, audit_logger):
        self.noark = noark_client  # NOARK 5-kompatibelt system
        self.audit = audit_logger

    async def log_citizen_interaction(
        self,
        interaction: AgentAuditEntry,
        case_number: str = None
    ):
        """Journalfør borgerinteraksjon med agent"""

        # 1. Standard audit logging
        await self.audit.log(interaction)

        # 2. NOARK-journalpost for interaksjoner som
        #    berører saksbehandling
        if interaction.action_type in [
            "response_generated", "tool_invoked"
        ]:
            await self.noark.create_journal_entry(
                title=f"AI-agent interaksjon: {interaction.agent_name}",
                case_number=case_number,
                document_type="U",  # Utgående
                classification="Offentlig",  # Eller gradert
                content_reference=interaction.trace_id,
                metadata={
                    "ai_agent": interaction.agent_name,
                    "model": interaction.model_used,
                    "trace_id": interaction.trace_id,
                    "user_id": interaction.user_id
                }
            )

    async def handle_innsyn_request(
        self, request_period: tuple, agent_name: str = None
    ) -> list:
        """Håndter innsynsbegjæring for agent-logger"""
        query = f"""
        AgentAuditLog_CL
        | where TimeGenerated between (
            datetime('{request_period[0]}') ..
            datetime('{request_period[1]}'))
        """
        if agent_name:
            query += f"| where AgentName == '{agent_name}'"

        # Rediger PII før utlevering
        results = await self.query_logs(query)
        return [self.redact_pii(r) for r in results]
```

## Beslutningsrammeverk

| Scenario | Anbefaling | Begrunnelse |
|----------|------------|-------------|
| Informasjonsagent (lav risiko) | Standard audit logging + 12 mnd retensjon | Tilstrekkelig for debugging og kvalitet |
| Saksbehandlingsagent | Full beslutningskjede + NOARK-integrasjon + 7 år | Regulatorisk krav |
| Borgerrettet agent | Audit + GDPR-compliance + innsynsstøtte | Offentlighetsloven + GDPR |
| Sensitiv data-agent | Immutable storage + strengere access control | Personvern og sikkerhet |
| Multi-agent system | Distribuert tracing + sentralisert audit | Etterprøvbarhet på tvers av agenter |

## For arkitekten

- **Audit logging er ikke valgfritt** -- det er et regulatorisk krav under EU AI Act Art. 12 og norsk forvaltningsrett. Implementer fra dag 1, ikke som etterpåklok.
- **Beslutningskjeden er det viktigste** -- logg ikke bare hva agenten svarte, men HVORFOR: hvilken intent ble klassifisert, hvilken agent ble valgt, hvilke data ble hentet, hvilken modell ble brukt.
- **Retensjonspolicies må differensieres** -- PII-holdige logger slettes etter 3 måneder (GDPR), men audit-sammendrag bevares i 7 år (Arkivloven). Automatisér med Azure Storage lifecycle policies.
- **For norsk offentlig sektor**: Integrer agent-logging med NOARK 5 for journalføring, implementer innsynsstøtte for Offentlighetsloven, og sørg for human-in-the-loop for GDPR Art. 22.
- **Microsoft Purview Compliance Manager** er verktøyet for å spore EU AI Act-compliance -- bruk pre-definerte assessment-maler og automatisér evidence collection.