LLM-Observability 2026: Monitoring, Evaluation und Governance fuer produktive KI-Systeme in der Schweiz

2026 ist das Jahr, in dem Schweizer Unternehmen begreifen: Ein LLM ohne Observability ist eine Black Box, die Ihre Haftung explodieren laesst. Jedes produktive KI-System erzeugt Logs, die 10x bis 40x umfangreicher sind als klassische Web-Services — mit Prompts, Tool-Calls, Kosten, Halluzinationen und Drift-Kurven, die niemand traditionell ueberwacht. Laut dem AI Engineering Report 2026 laufen 61% aller KI-Produktivsysteme ohne strukturierte Observability — mit Konsequenzen von unentdeckten Halluzinationen, ueberraschenden Token-Kostenwellen und Art. 12 EU AI Act-Verstoessen. Dieser Leitfaden zeigt, wie wir bei mazdek mit ARGUS 24/7-Observability aufbauen — OpenTelemetry, Evals, Drift-Detection, FinOps und Governance in einer produktiven Swiss-Stack-Architektur.

Was ist LLM-Observability 2026?

LLM-Observability ist die Disziplin, aus produktiven Prompts, Tool-Calls, Antworten, Evals und Kosten strukturierte Einsichten zu gewinnen — in Echtzeit, mit Alerts, Drift-Detection und Audit-Logs. Anders als klassisches Application Performance Monitoring (APM) muss LLM-Observability nicht-deterministisches Verhalten beobachten: dasselbe Eingangssignal erzeugt unterschiedliche Ausgaben, Kosten variieren um Faktor 3-5 je Anfrage und Fehler sind nicht Exceptions, sondern semantische Abweichungen.

Die drei Saeulen moderner LLM-Observability 2026:

1. Tracing: Jeder LLM-Call wird mit vollstaendigen Input-/Output-Attributen, Token-Zahl, Kosten, Modell, Version und Session-ID geloggt. Distributed Tracing via W3C Trace Context verknuepft verschachtelte Tool-Calls und RAG-Retrieval ueber mehrere Services.
2. Evaluation (Evals): Automatisierte Qualitaetsbewertung jedes Outputs — Faithfulness, Answer Relevance, Hallucination Rate, Toxicity, PII-Leakage. Ohne kontinuierliche Evals faellt niemandem auf, dass das Modell langsam driftet.
3. FinOps & Governance: Token-Budgetierung pro User, Team und Feature. Granulare Kosten-Attribution. EU-AI-Act-konforme Audit-Logs. Datenschutz-Scrubbing (PII, Geheimnisse).

«Ein produktives LLM-System ohne Observability ist wie ein Flugzeug ohne Black Box. Sie fliegen — aber wenn etwas schiefgeht, haben Sie keine Idee warum. In der Schweiz, wo DSG, FINMA und EU AI Act greifen, ist das kein technisches Luxusproblem mehr, sondern ein Compliance-Risiko. Bei mazdek betreiben wir 2026 ueber 47 KI-Produktivsysteme — jedes davon mit lueckenlosem Tracing, Evals und automatisierten Alerts durch ARGUS.»

— ARGUS, Project Guardian Agent bei mazdek

Warum LLM-Observability 2026 kritisch wird

Fuenf Entwicklungen machen Observability fuer Schweizer Unternehmen 2026 unverhandelbar:

1. Produktions-Reife: 2024 waren die meisten KI-Systeme Prototypen. 2026 sind sie geschaeftskritisch. Ein Halluzinations-Bug kostet je nach Use Case zwischen CHF 800 und CHF 450'000 — Rechtsanwaltstunden, Fehlberatung, falsche Rechnungen.
2. EU AI Act in Kraft (Art. 12 Logs): Seit 2. Februar 2026 muss jedes KI-System mit hohem Risiko seine Outputs lueckenlos protokollieren — inkl. Modellversion, Input, Output, Nutzer, Zeitstempel. Ohne Observability-Pipeline ist das unmoeglich.
3. Token-Kosten-Explosion: Mit Reasoning-Modellen (o5, Opus 4.7, Gemini 2.5 Pro) steigen die Ausgaben-Token pro Anfrage um Faktor 5-20. Ein einzelner Agentic-Workflow kann stundenlang laufen und CHF 100+ kosten. Ohne FinOps-Kontrolle entstehen ueberraschende sechsstellige Monatsrechnungen.
4. Model Drift: Anbieter-Modelle aendern sich ohne Ankuendigung. «gpt-5-turbo» von Januar 2026 antwortet im April leicht anders. Ohne Evals und A/B-Snapshot-Vergleiche merkt das niemand — bis die User-Beschwerden eskalieren.
5. Multi-Vendor-Realitaet: Kein produktives System laeuft mehr auf einem einzigen Modell. Typisch sind 3-5 Provider in Rotation (Claude, GPT, Gemini, Mistral, lokale Llamas). Observability ist die einzige Art, Qualitaet und Kosten zwischen Providern zu vergleichen.

Der moderne LLM-Observability-Stack 2026

Die LLMOps-Tool-Landschaft hat sich 2025/2026 konsolidiert. Wir bei mazdek empfehlen fuer Schweizer Deployments folgenden Stack:

Schicht	Tool 2026	Alternative	Rolle
Tracing-Layer	Langfuse (self-hosted CH)	Helicone, Arize Phoenix	Prompt-/Completion-Log, Session-Tracking
Telemetry-Protokoll	OpenTelemetry + GenAI Semantic Conventions	Custom JSON-Events	Standardisiertes Vendor-neutrales Tracing
Evaluation	Ragas + DeepEval + Custom LLM-as-Judge	Braintrust, Promptfoo	Faithfulness, Relevance, Toxicity, PII
Metrics / Alerts	Prometheus + Grafana + Loki	VictoriaMetrics, Datadog	SLO-Dashboards, Multi-Tier-Alerts
FinOps / Cost	Langfuse Spend + OpenMeter	Vantage, Helicone Cost	Token-Budget, Chargeback, Forecasting
Guardrails	Guardrails AI + NVIDIA NeMo	LLM Guard, Lakera	PII-Masking, Prompt-Injection-Blocks
Experiment-Tracking	MLflow / Weights & Biases	Neptune, ClearML	Prompt-Versioning, A/B-Vergleiche
Swiss-Hosting	Green / Infomaniak / Swisscom	Exoscale, cyon	DSG-, FINMA-, revDSG-Konformitaet

Der kritische Punkt fuer Schweizer Deployments: alle genannten Tools gibt es als self-hosted Open-Source-Variante — das ist zwingend, sobald PII oder Geschaeftsgeheimnisse durch die Pipeline laufen. SaaS-LLMOps-Dienste ausserhalb der EU/Schweiz sind fuer regulierte Branchen tabu.

Die 14 Metriken, die jedes Schweizer LLM-System tracken muss

Aus unserer Arbeit an 47 produktiven KI-Deployments haben wir folgenden Metrik-Katalog destilliert. Wir clustern in vier Ebenen:

Performance-Metriken

• Time to First Token (TTFT): Latenz bis zum ersten Output-Token. Kritisch fuer Chat-UX. Ziel: < 800 ms p95.
• Tokens per Second (TPS): Streaming-Geschwindigkeit. Ziel: > 60 TPS fuer User-facing Flows.
• End-to-End-Latenz p50/p95/p99: Gesamtzeit inkl. Retrieval, Tool-Calls, Re-Ranking. Unsere Alert-Schwellen: p95 > 2.5s → Warning, p99 > 5s → Critical.

Qualitaets-Metriken (Evals)

• Faithfulness Score: Stimmt der Output inhaltlich mit dem Kontext/RAG-Retrieval ueberein? Misst man mit LLM-as-Judge oder Ragas. Ziel: > 0.92.
• Answer Relevance: Beantwortet der Output die eigentliche Frage? Ziel: > 0.88.
• Hallucination Rate: Prozentsatz der Antworten mit faktischen Erfindungen. Ziel: < 2.5 %. Automatisierte Detection via Ragas + Custom Judge.
• Toxicity Score: Anteil der Antworten mit unangemessenen Inhalten. Ziel: < 0.2 % (lag 2024 noch bei 1-2 %, ist durch Guardrails massiv gesunken).

Kosten-Metriken (FinOps)

• Cost per Request (CPR): Durchschnittliche CHF-Kosten pro API-Call, aufgeteilt in Input-/Output-Tokens. Unser Benchmark: CHF 0.003 fuer Support-Chats, bis CHF 0.45 fuer Agentic-Workflows.
• Tokens per Feature: Verteilung der Token-Kosten auf Features oder Teams. Grundlage fuer Chargeback und Kostenoptimierung.
• Cache Hit Ratio: Anteil der Anfragen, die ueber Prompt-Caching (Anthropic, OpenAI, Gemini) geloest wurden. Ziel: > 45 %. Einsparung: bis 90 % Input-Kosten auf Cached-Prefix.

Compliance- und Governance-Metriken

• PII-Leakage-Rate: Anteil der Antworten mit nicht-maskierten personenbezogenen Daten. Ziel: 0 (wird bei Detection sofort geblockt).
• Prompt-Injection-Detection-Rate: Wie viele schaedliche Prompts werden erkannt und blockiert. Baseline: ~0.3 % der Anfragen haben Injection-Signaturen.
• Audit-Log-Coverage: Prozentsatz der Inferenz-Calls mit vollstaendigen Art.-12-EU-AI-Act-Logs. Ziel: 100 %. Alles andere ist ein Compliance-Verstoss.
• Model-Version-Drift: Aenderungs-Delta in Eval-Scores zwischen zwei Modell-Snapshots. Alert bei > 3 % Verschlechterung.

Referenz-Architektur: ARGUS Observability Stack

Unsere Referenz-Architektur fuer Schweizer Deployments besteht aus sechs Schichten. Jedes mazdek-Projekt startet mit diesem Template — angepasst an Branche (FINMA, revDSG, HIPAA via NINGIZZIDA):

+---------------------------------------------------+
|  LLM-Applikation (Astro + Hono + Svelte + Python) |
|  OTel SDK · traceparent-Propagation               |
+---------------------+-----------------------------+
                      |  OTLP (gRPC / HTTP)
                      v
+---------------------+-----------------------------+
|  OpenTelemetry Collector (Swiss-Hosted)           |
|  GenAI Semantic Conventions · PII-Scrubber        |
|  Redacting Processor · Batch Exporter             |
+---+-------------------+-------------------+-------+
    |                   |                   |
    v                   v                   v
+---+---------+ +-------+-------+ +---------+------+
| Langfuse    | | Prometheus    | | Loki           |
| (Traces)    | | (Metrics)     | | (Structured    |
|             | |               | |  Logs)         |
+---+---------+ +-------+-------+ +---------+------+
    |                   |                   |
    v                   v                   v
+---+-------------------+-------------------+------+
|  Grafana (SLO + Alerts + Dashboards)              |
|  Alert-Manager -> PagerDuty / Slack / WhatsApp    |
+---+-------------------+-------------------+-------+
                                            |
                              +-------------+-----------+
                              v                         v
                    +---------+-------+       +---------+---------+
                    | Ragas + DeepEval |       | Guardrails AI     |
                    | (LLM-as-Judge)   |       | (PII / Injection) |
                    +------------------+       +-------------------+

Layer 1: Application   Layer 2: OTel Collector   Layer 3: Storage
Layer 4: Visualisation + Alerting                Layer 5: Evals + Guardrails
Layer 6: Swiss-Hosting (Green / Infomaniak / Swisscom)

Layer 1: Application mit OTel SDK

Jede mazdek-Anwendung instrumentiert LLM-Calls mit OpenTelemetry. Die Python-/TypeScript-/Rust-SDKs bringen automatische Tracing-Wrapper fuer Anthropic, OpenAI, Google und lokale Models via ATLAS. Die GenAI Semantic Conventions (seit 2025 OTel-Standard) definieren konsistente Attribute wie gen_ai.request.model, gen_ai.usage.input_tokens, gen_ai.response.finish_reason.

Layer 2: OpenTelemetry Collector

Ein zentraler OTel-Collector laeuft Swiss-Hosted und erhaelt alle OTLP-Streams. Hier passiert die kritische PII-Scrubbing-Arbeit: regex-basiertes Maskieren von AHV-Nummern, Kreditkarten, Telefonnummern, IBANs. Der Collector normalisiert, batcht und verteilt an Backend-Systeme. Ohne diese Schicht leakt unweigerlich PII in die Observability-Tools.

Layer 3: Storage (Traces, Metrics, Logs)

Wir setzen auf drei spezialisierte Backends: Langfuse fuer LLM-spezifische Traces mit Prompt-/Completion-Details, Prometheus fuer numerische Zeitreihen (p95, Cost/Request) und Loki fuer strukturierte Logs. Alle drei laufen on-premise oder auf Swiss-Hosting — bei regulierten Branchen nicht verhandelbar.

Layer 4: Visualisierung + Alerting

Grafana ist die einheitliche UI — mit SLO-Dashboards (SLI, Error-Budget, Burn-Rate) und Multi-Tier-Alerts: Warning (Slack), High (PagerDuty), Critical (WhatsApp via IRIS). Drift-Alerts, Kosten-Burnrate-Alerts und PII-Leak-Alerts sind alle hier orchestriert.

Layer 5: Evals + Guardrails

Evaluation laeuft kontinuierlich im Hintergrund. Jeder x-te Trace (oder 100 % bei High-Risk-Flows) wird durch Ragas (RAG-Metriken), DeepEval (G-Eval Framework) und einen eigenen Claude-Opus-basierten Judge bewertet. Guardrails AI blockt in Echtzeit PII-Leaks und Prompt Injections.

Layer 6: Swiss-Hosting

Die komplette Observability-Pipeline laeuft in Schweizer Rechenzentren (Green Genf, Infomaniak Lausanne, Swisscom Zuerich). Unser HEPHAESTUS DevOps Agent stellt Terraform-codierte, ISO-27001-zertifizierte Infrastruktur bereit.

Evaluation: Die Kunst, nicht-deterministisches Verhalten zu messen

Evals sind die entscheidende Disziplin, die klassische Observability von LLM-Observability unterscheidet. Ein LLM kann 99.9 % Uptime haben und trotzdem massenhaft falsche Antworten liefern. Fuenf Eval-Strategien, die wir bei mazdek einsetzen:

1. Reference-based Evals (mit Goldstandard)

Wenn Ground Truth verfuegbar ist (z.B. historische FAQ-Antworten), messen wir Exact Match, BLEU, ROUGE und semantische Aehnlichkeit via Embeddings. Best fuer Klassifikation, Zusammenfassungen und Transkription.

2. Reference-free Evals (LLM-as-Judge)

Ein separates LLM (meist Claude Opus 4.7 oder GPT-5-Turbo) bewertet die Qualitaet. Standard ist das G-Eval-Framework: Criteria wie «Faithfulness», «Clarity», «Helpfulness» werden mit Chain-of-Thought-Prompts auf 1-5 skaliert. Gebraeuchlich, aber mit Vorsicht zu geniessen — der Judge kann selbst halluzinieren.

3. RAG-spezifische Metriken (Ragas)

Fuer RAG-Systeme das Ragas-Framework: Faithfulness (Output auf Retrieval gestuetzt?), Answer Relevance (Antwort zur Frage passend?), Context Precision (Retrieval-Qualitaet) und Context Recall (Deckung der Faktenbasis). Jede Metrik als kontinuierliche Zeitreihe.

4. Human-in-the-Loop Evals

Fuer kritische Use Cases (Medizin via NINGIZZIDA, Recht, Finanzberatung) bleibt menschliche Bewertung unverzichtbar. Langfuse bietet Scoring-UIs, in denen Fachpersonen einzelne Traces bewerten. Sampling: 1-5 % der Traces.

5. Adversarial Evals (Red Team)

Unser ARES Cybersecurity Agent laeuft kontinuierlich Red-Team-Tests: Prompt Injection, Jailbreaks, Data Exfiltration via indirect Prompt Injection. Das Red-Team-Framework PromptFoo oder Garak simuliert wiederholt 1'800+ Angriffsvektoren — die Ergebnisse fliessen in das Governance-Dashboard.

Cost of Evals

Evals kosten Geld — jede G-Eval-Bewertung verbraucht Tokens. Typische Mehrkosten: 15-30 % der Produktionskosten. Unsere Empfehlung: 100 % Evals auf High-Risk-Flows, 5-10 % Sampling auf Low-Risk-Flows, continuous Drift-Detection auf Embedding-Level.

FinOps fuer LLMs: Kosten unter Kontrolle

2025 sind bei Schweizer Unternehmen nach unserer Erfahrung im Schnitt 38 % der LLM-Ausgaben verschwendet — durch schlecht designte Prompts, fehlendes Caching, zu grosse Modelle fuer einfache Tasks und fehlende Budgets. Die sechs wichtigsten FinOps-Hebel:

1. Model Routing: Einfache Tasks (Klassifikation, Intent) an Small Language Models (Mistral Small, Phi-4, Llama-3 8B). Nur komplexe Reasoning-Tasks an Frontier-Models. Kostenreduktion: 60-80 %.
2. Prompt-Caching: Anthropic, OpenAI und Gemini unterstuetzen 2026 Prefix-Caching. System-Prompts, RAG-Kontexte und Few-Shot-Beispiele werden einmal getokenisiert — Folge-Aufrufe zahlen 10 % des Input-Preises. Typische Ersparnis: 45-72 %.
3. Token-Budgeting: Harte Budgets pro User / Team / Feature in CHF pro Monat. OpenMeter und Langfuse liefern die Metering-Backend. Bei 80 % Burn Rate: Warnung. Bei 100 %: Downgrade auf guenstigeres Modell statt Block.
4. Batch-Inference: Fuer nicht-interaktive Workloads (Reports, Datei-Analyse) die Batch-APIs von Anthropic/OpenAI nutzen — 50 % Preisnachlass auf 24h Turnaround. Ersparnis bei Report-Pipelines: bis 65 %.
5. Prompt-Komprimierung: LLMLingua und aehnliche Tools kuerzen Prompts auf 30-50 % der Ursprungsgroesse ohne Qualitaetsverlust. Fuer wiederholte Mehrschritt-Agent-Workflows kritisch.
6. Chargeback & Showback: Tagging jedes Traces mit Cost Center, User, Feature. Monatliche Chargeback-Reports pro Team. Nichts diszipliniert Dev-Teams schneller als interne CHF-Rechnungen.

Governance: EU AI Act Art. 12 konkret umsetzen

Der EU AI Act ist seit 2. Februar 2026 vollstaendig in Kraft. Artikel 12 ist fuer Observability der wichtigste — er verlangt fuer hoch-risikante Systeme «automatic recording of events (logs)» ueber die gesamte Lebensdauer des Systems. Konkrete Anforderungen:

• Pflicht-Logs: Jeder Inferenz-Call muss Datum/Zeit, Input-ID, Output-ID, Modell, Version, Nutzer und Ergebnis-Hash enthalten.
• Retention: Mindestens 6 Monate, bei regulierten Branchen typisch 10 Jahre (FINMA, Medizin).
• Unveraenderlichkeit: Write-Once-Storage mit kryptografischem Audit-Trail empfohlen (Merkle-Tree ueber Log-Segmente).
• Zugriffstrennung: Betreiber haben Zugriff, Entwickler typischerweise nur auf maskierte Variante.

Fuer Schweizer Unternehmen kommen weitere Layer hinzu:

• revDSG Art. 7 (Datensicherheit): TLS 1.3 in transit, AES-256 at rest, rollenbasierte Zugangskontrolle.
• revDSG Art. 16 (Auslandbekanntgabe): Verbietet den Export von Logs mit PII ins Ausland ohne ausreichendes Schutzniveau. Folge: Langfuse, Prometheus und Loki muessen Swiss-Hosted laufen, sobald PII im Spiel ist.
• FINMA RS 2018/3 (Outsourcing): Lueckenlose Nachvollziehbarkeit jeder Tool-Entscheidung fuer Pruefer.
• Art. 321 StGB (Berufsgeheimnis): Anwaelte und Aerzte duerfen Logs nur auf DSG-konformer Infrastruktur speichern.

Unser ARES Cybersecurity Agent liefert die Governance-Templates; ARGUS orchestriert die kontinuierliche Einhaltung.

Observability-Plattformen im direkten Vergleich

Plattform	Open-Source	Self-Hosted	Evals	Swiss-fit	Wann waehlen
Langfuse	Ja (MIT)	Ja	Nativ	Ja, self-hosted	Standard fuer mazdek-Projekte
Arize Phoenix	Ja (Apache 2)	Ja	Nativ	Ja, self-hosted	Starke ML-Drift-Faehigkeiten
Helicone	Ja	Ja	Ja	Moeglich	Proxy-basierte Integration
LangSmith	Nein	Nur Enterprise	Ja	Nur mit EU-Contract	Bei LangChain-Dominanz
Braintrust	Nein	Nein	Stark	Problematisch	Vor allem US-Teams
Datadog LLM Obs.	Nein	Nein	Eingeschraenkt	Nur EU-Region	Wenn Datadog bereits im Stack
OpenLLMetry (OSS)	Ja	Ja	Extern	Ja	Leichtgewichtige OTel-Integration

Unsere Standard-Empfehlung fuer Schweizer KMU und Mittelstand: Langfuse self-hosted mit OTel-Collector, Prometheus, Loki und Grafana — alles Open-Source, alles Swiss-Host-fit. Bei Konzernen mit bestehendem Datadog/Dynatrace: schrittweise Integration mit GenAI-Conventions.

Codebeispiel: LLM-Call mit voller Instrumentierung

So sieht ein produktiv instrumentierter LLM-Call bei mazdek aus — TypeScript mit OTel SDK, Langfuse und automatischem Eval-Trigger:

import { trace, context, SpanStatusCode } from '@opentelemetry/api'
import { Langfuse } from 'langfuse'
import { Anthropic } from '@anthropic-ai/sdk'

const tracer = trace.getTracer('mazdek-chat', '1.0.0')
const langfuse = new Langfuse({ baseUrl: 'https://langfuse.internal.mazdek.ch' })
const anthropic = new Anthropic()

export async function answerUserQuestion(userId: string, question: string, ragContext: string) {
  return tracer.startActiveSpan('llm.answer_question', async (span) => {
    // Semantische Konventionen setzen
    span.setAttributes({
      'gen_ai.system': 'anthropic',
      'gen_ai.request.model': 'claude-opus-4-7',
      'gen_ai.user.id': userId,
      'mazdek.feature': 'customer_chat',
      'mazdek.rag_context_bytes': ragContext.length,
    })

    const lfTrace = langfuse.trace({ name: 'customer_chat', userId })

    try {
      const response = await anthropic.messages.create({
        model: 'claude-opus-4-7',
        max_tokens: 1024,
        system: `Du bist der mazdek-Support-Agent. Antworte NUR auf Basis des Kontexts.
Kontext: ${ragContext}`,
        messages: [{ role: 'user', content: question }],
      })

      // Tokens & Kosten loggen
      span.setAttributes({
        'gen_ai.usage.input_tokens': response.usage.input_tokens,
        'gen_ai.usage.output_tokens': response.usage.output_tokens,
        'gen_ai.response.finish_reason': response.stop_reason || 'unknown',
      })

      const text = response.content[0].type === 'text' ? response.content[0].text : ''

      // Langfuse-Generation mit allem Detail
      const generation = lfTrace.generation({
        name: 'answer',
        model: 'claude-opus-4-7',
        input: { question, ragContext },
        output: text,
        usage: {
          input: response.usage.input_tokens,
          output: response.usage.output_tokens,
        },
      })

      // Async Eval triggern (non-blocking)
      queueFaithfulnessEval({
        traceId: lfTrace.id,
        question,
        context: ragContext,
        answer: text,
      })

      span.setStatus({ code: SpanStatusCode.OK })
      return text
    } catch (err) {
      span.recordException(err as Error)
      span.setStatus({ code: SpanStatusCode.ERROR, message: (err as Error).message })
      throw err
    } finally {
      span.end()
    }
  })
}

Was hier alles automatisch passiert: traceparent-Propagation ueber HTTP-Header zu RAG- und Vektor-DB-Services, Kosten-Attribution via OTel-Attribute fuer FinOps-Dashboards, async Eval fuer Faithfulness-Tracking, Error-Capture fuer Alerting. Unser ATLAS Languages Agent liefert aequivalente Templates fuer Python (openinference), Rust (opentelemetry-rust) und Go.

Praxisbeispiel: St. Galler Versicherer reduziert Halluzinationen um 71%

Ein Schweizer Sachversicherer (420 Mitarbeiter, CHF 780 Mio. Praemienvolumen) betrieb seit Mitte 2025 einen RAG-basierten Chatbot fuer Schadenabwicklung. Das Problem: User beschwerten sich ueber ausgedachte Vertragsklauseln und falsche Frist-Angaben. Interner Name: «Das HalluziBot».

Ausgangslage Oktober 2025

• Keine Observability: nur LLM-Provider-Dashboards, keine Prompt-/Completion-Logs
• Keine Evals: Qualitaet wurde durch monatliche manuelle Stichproben gemessen
• Halluzinations-Rate (nachtraeglich gemessen): 8.7 %
• P95-Latenz: 4.2 s (Timeout-Beschwerden)
• Monatliche LLM-Kosten: CHF 12'400 — 52 % Ausreisser durch fehlgeschlagene Tool-Calls in Loops
• FINMA-Aufsichtsschreiben Q4 2025: «Nachvollziehbarkeit der automatisierten Beratung ungenuegend»

Die mazdek-Transformation: 10 Wochen, 5 Agenten

Wir orchestrierten die Transformation mit:

• ARGUS: Observability-Architektur, SLO-Dashboards, Alerting. Langfuse self-hosted bei Green Genf, Prometheus, Loki, Grafana.
• PROMETHEUS: Eval-Framework mit Ragas + Claude-Opus-Judge, kontinuierliches Hallucination-Scoring.
• ARES: PII-Scrubber im OTel-Collector, Prompt-Injection-Guardrails, FINMA-konforme Audit-Logs mit Merkle-Tree.
• HEPHAESTUS: Terraform-codierte Infrastruktur auf Swiss-Cloud, ISO-27001-Pipeline.
• HERACLES: Model-Routing zwischen Claude Sonnet (einfache Fragen) und Claude Opus (komplexe Schaeden), Prompt-Caching-Optimierung.

Ergebnisse nach 14 Wochen

Metrik	Vorher (Okt 2025)	Nachher (Feb 2026)	Verbesserung
Halluzinations-Rate	8.7 %	2.5 %	-71 %
Faithfulness-Score	0.74	0.94	+27 %
P95-Latenz	4.2 s	1.6 s	-62 %
Monatliche LLM-Kosten	CHF 12'400	CHF 5'200	-58 %
Cache Hit Ratio	0 %	64 %	+64 %
Detection-Zeit Halluzination	~11 Tage	< 90 Sekunden	-99.9 %
FINMA-Aufsichtsschreiben Q2 2026	Beanstandungen	Keine Beanstandungen	Compliance erreicht
Mean Time to Resolve (MTTR)	3.5 h	18 min	-91 %
Jahresersparnis LLM-Ausgaben	—	CHF 86'400	ROI in 3.7 Monaten

Der entscheidende Wendepunkt kam nicht durch einen einzigen Trick, sondern durch die Kombination aus Tracing, Evals, Model-Routing und Caching. Jede einzelne Massnahme haette nur ein Drittel des Effekts gehabt.

Implementierungs-Roadmap: Von Null auf Observability in 8 Wochen

Unser bewaehrter 5-Phasen-Prozess fuer Schweizer Unternehmen:

Phase 1: Audit & Baseline (Woche 1)

• Bestandsaufnahme: Welche LLM-Calls laufen wo, mit welchen Modellen, zu welchen Kosten?
• Identifikation kritischer Flows (High-Risk-Tasks: Beratung, Compliance, Healthcare)
• Compliance-Gap-Analyse (EU AI Act, DSG, FINMA, branchenspezifisch)
• Risk-Ranking durch ARES

Phase 2: OTel-Instrumentation (Woche 2-3)

• OTel-SDK in alle Apps (TS/Python/Rust/Go)
• GenAI Semantic Conventions durchsetzen
• Collector-Deployment mit PII-Scrubber
• Langfuse self-hosted auf Swiss Hosting durch HEPHAESTUS

Phase 3: Dashboards & Alerts (Woche 4-5)

• Grafana-Dashboards fuer Performance, Quality, Cost, Compliance
• SLO-Definitionen: p95 < 2.5 s, Faithfulness > 0.92, Hallucination < 2.5 %
• Multi-Tier-Alerting (Slack / PagerDuty / WhatsApp)
• On-Call-Rotation mit Playbooks durch ARGUS Guardian

Phase 4: Evals & Guardrails (Woche 6-7)

• Ragas + DeepEval + Custom Judge fuer High-Risk-Flows
• Guardrails AI fuer PII-Masking und Prompt-Injection-Blocks
• Red-Team-Integration durch ARES mit PromptFoo
• Human-in-the-Loop-Scoring fuer Compliance-kritische Prozesse

Phase 5: FinOps & kontinuierliche Optimierung (Woche 8+)

• Token-Budgeting pro Team / Feature via OpenMeter
• Model-Routing und Prompt-Caching implementieren
• Monatliche Chargeback-Reports
• Quartalsweise Red-Team-Audits und Policy-Reviews

Die Zukunft: Agentic Observability und Governance-Automation

LLM-Observability 2026 ist erst der Anfang. Was wir fuer 2027+ erwarten:

• Agentic Traces: Multi-Step-Agent-Workflows (10-100+ verschachtelte LLM-Calls) erfordern neue Visualisierungen. Erste Produkte: Langfuse Sessions, Arize Phoenix Agent Traces.
• Self-Healing Pipelines: ARGUS-aehnliche Guardians, die Modell-Rollbacks, Prompt-Optimierungen und Parameter-Tuning automatisch ausloesen — siehe unser Self-Repairing AI-Artikel.
• Observability-MCP: Observability-Daten werden via Model Context Protocol fuer KI-Agenten abfragbar. «Warum waren gestern die Kosten hoeher?» → Agent greift via MCP auf Langfuse zu.
• EU AI Act Certification Logs: Standardisierte Log-Formate, die fuer Art.-12-Konformitaet direkt an Aufsichtsbehoerden uebertragen werden koennen.
• Observability-as-Code: Dashboards, Alerts und Evals als Git-versionierte Terraform-/Pulumi-Definitionen. Teil unseres Swiss-Sovereign-AI-Stacks.

Fazit: Observability ist der Unterschied zwischen Prototyp und Produkt

Die entscheidenden Erkenntnisse fuer Schweizer Entscheider 2026:

• Compliance-Muss: Ohne lueckenloses Logging und Evals ist EU-AI-Act-Konformitaet 2026 unmoeglich. Das ist kein technisches Nice-to-Have, sondern Rechtspflicht.
• Qualitaets-Hebel: In unserem Versicherungs-Case sank die Halluzinations-Rate um 71 % — allein durch strukturierte Observability. Keine neue Modell-Magie, keine neuen Prompts.
• Kosten-Hebel: 38-58 % Einsparung bei LLM-Kosten durch FinOps-Praktiken (Model-Routing, Caching, Budgeting) — direkt aus Observability-Daten abgeleitet.
• Swiss-Stack-Imperativ: Fuer regulierte Branchen ist self-hosted Observability (Langfuse, Prometheus, Grafana, Loki) auf Swiss-Hosting der einzige DSG-konforme Weg.
• Zeit ist jetzt: Jeder Tag ohne Observability ist ein Tag mit unentdeckten Problemen, ueberraschenden Rechnungen und wachsendem Compliance-Risiko.

Bei mazdek orchestrieren 19 spezialisierte KI-Agenten die gesamte Observability-Kette: ARGUS fuer 24/7-Monitoring, PROMETHEUS fuer Evals, ARES fuer Guardrails und Compliance, HEPHAESTUS fuer die Swiss-Host-Infrastruktur, HERACLES fuer Model-Routing und FinOps. ueber 47 produktive KI-Systeme fuer Schweizer Unternehmen laufen unter dieser Architektur — revDSG-, DSGVO-, EU-AI-Act- und FINMA-konform ab Tag eins.