"Sie sind ein hilfreicher Kundenbetreuer für Acme Corp. 
Beantworten Sie Kundenanfragen höflich, professionell und präzise. 
Verwenden Sie die bereitgestellte Wissensdatenbank, um Fragen zu beantworten. 
Wenn Sie etwas nicht wissen, eskalieren Sie an einen menschlichen Agenten."

┌─────────────────────────────────────────────────────────────────┐
│                    Der Feedback-Loop-Zyklus                     │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│    ┌──────────────┐      ┌──────────────┐      ┌──────────────┐ │
│    │  AUSFÜHREN   │─────▶│  BEOBACHTEN  │─────▶│  EVALUIEREN  │ │
│    │              │      │              │      │              │ │
│    │ Aufgabe      │      │ Daten        │      │ Leistung     │ │
│    │ ausführen    │      │ erfassen     │      │ bewerten     │ │
│    │ Ausgabe      │      │ Ergebnisse   │      │ vs. Zielen   │ │
│    │ generieren   │      │ protokollieren│     │              │ │
│    └──────────────┘      └──────────────┘      └──────┬───────┘ │
│           ▲                                          │          │
│           │                                          ▼          │
│           │                                   ┌──────────────┐ │
│           └───────────────────────────────────│   ANPASSEN   │ │
│                                               │              │ │
│                                               │ Parameter    │ │
│                                               │ anpassen     │ │
│                                               │ Regeln       │ │
│                                               │ aktualisieren│ │
│                                               └──────────────┘ │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────┐
│                    Loop Engineering Stack                       │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  ┌──────────────────────────────────────────────────────────┐  │
│  │                   ORCHESTRATION LAYER                    │  │
│  │              (n8n, OpenClaw, LangChain)                  │  │
│  └──────────────────────────────────────────────────────────┘  │
│                              │                                   │
│  ┌───────────────────────────┼───────────────────────────────┐  │
│  │                           ▼                               │  │
│  │  ┌─────────────┐  ┌─────────────┐  ┌─────────────────┐   │  │
│  │  │   AGENT     │  │    AGENT    │  │     AGENT       │   │  │
│  │  │  AUSFÜHRUNG │  │ BEOBACHTUNG │  │   EVALUIERUNG   │   │  │
│  │  └─────────────┘  └─────────────┘  └─────────────────┘   │  │
│  └──────────────────────────────────────────────────────────┘  │
│                              │                                   │
│  ┌───────────────────────────▼───────────────────────────────┐  │
│  │                   ZUSTANDSVERWALTUNG                       │  │
│  │     (Redis, PostgreSQL, Vector Store, n8n Memory)        │  │
│  └──────────────────────────────────────────────────────────┘  │
│                              │                                   │
│  ┌───────────────────────────▼───────────────────────────────┐  │
│  │                   FEEDBACK-PIPELINE                      │  │
│  │    (Webhooks, Message Queues, Event Streams, APIs)       │  │
│  └──────────────────────────────────────────────────────────┘  │
│                              │                                   │
│  ┌───────────────────────────▼───────────────────────────────┐  │
│  │              ANPASSUNGS- & LERN-ENGINE                  │  │
│  │  (Prompt-Versionierung, Parameter-Tuning, Modellauswahl)│  │
│  └──────────────────────────────────────────────────────────┘  │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Ausführung → Aufteilung in Variante A oder B → Ergebnisse vergleichen 
→ Besser performende Variante übernehmen → Wiederholen mit neuen Variationen

Ausführen → Fehler erkannt → Fehlertyp analysieren → 
Wiederherstellungsstrategie anwenden → Retry mit Anpassungen → 
Erfolg/Fehler → Fehlerbehandlungs-Regeln aktualisieren

Ausführen → Leistung messen (Latenz, Kosten, Genauigkeit) → 
Engpässe identifizieren → Optimieren → Verbesserung validieren → 
Deployen → Weiter überwachen

Ausführen → Wissenslücke erkennen → Aktualisierte Informationen abrufen → 
Gegen Quellen validieren → Wissensdatenbank aktualisieren → 
Mit neuem Wissen erneut ausführen

┌─────────────────────────────────────────────────────────────────┐
│           Selbstverbessernde Support-Agent-Architektur          │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  Webhook (Eingehende Nachricht)                                  │
│       │                                                          │
│       ▼                                                          │
│  Session-Speicher abrufen (PostgreSQL)                          │
│       │                                                          │
│       ▼                                                          │
│  AI Agent Node (GPT-4o mit dynamischem System-Prompt)          │
│       │                                                          │
│       ▼                                                          │
│  Antwort senden + Implizites Feedback sammeln (Antwortzeit)     │
│       │                                                          │
│       ▼                                                          │
│  Auf explizites Feedback warten (Daumen hoch/runter Webhook) │
│       │                                                          │
│       ▼                                                          │
│  Evaluieren: Zufriedenheits-Score berechnen                     │
│       │                                                          │
│       ├── Zufrieden (>80%) ──▶ In Erfolgsmustern speichern    │
│       │                                                          │
│       └── Unzufrieden (<80%) ──▶ Anpassungs-Loop auslösen       │
│                                     │                            │
│                                     ▼                            │
│                              Fehler analysieren                  │
│                                     │                            │
│                                     ▼                            │
│                              Prompt-Regeln aktualisieren         │
│                                     │                            │
│                                     ▼                            │
│                              Verbesserung für nächste Session loggen│
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

// Im AI Agent Node System-Prompt
{{$json.currentPrompt}}

// currentPrompt wird aus PostgreSQL abgerufen und vom Anpassungs-Loop aktualisiert

// Anpassungs-Workflow-Logik
// 1. Letzte 50 negative Feedback-Instanzen abrufen
// 2. Nach Fehlertyp gruppieren (Ton, Genauigkeit, Vollständigkeit, etc.)
// 3. Prompt-Anpassungen mit LLM generieren
// 4. Anpassungen gegen Erfolgsmuster validieren
// 5. Konfigurationstabelle aktualisieren
// 6. Änderungen mit Rollback-Fähigkeit loggen

// Fehlerbehebungs-Sub-Workflow

// Input: Fehlerdetails von fehlgeschlagener Ausführung
const errorType = categorizeError($json.error);

const recoveryStrategies = {
  "RATE_LIMIT": {
    action: "retry",
    delay: "exponential_backoff",
    params: { baseDelay: 1000, maxRetries: 5 }
  },
  "TIMEOUT": {
    action: "retry",
    delay: "fixed",
    params: { delay: 5000, maxRetries: 3 }
  },
  "AUTHENTICATION": {
    action: "refresh_token",
    then: "retry"
  },
  "VALIDATION": {
    action: "modify_payload",
    strategy: "llm_fix",
    then: "retry"
  },
  "UNKNOWN": {
    action: "escalate",
    notify: ["admin", "error_log"]
  }
};

const strategy = recoveryStrategies[errorType] || recoveryStrategies["UNKNOWN"];

// Fehler-Statistiken aktualisieren
await updateErrorStats(errorType, $json.workflowId);

// Wenn Fehlerrate Schwellenwert überschreitet, Anpassung auslösen
const errorRate = await getErrorRate($json.workflowId, "1h");
if (errorRate > 0.05) {
  await triggerAdaptation($json.workflowId, errorType);
}

return { strategy, shouldRetry: strategy.action !== "escalate" };

// Leistungs-Monitor-Workflow (läuft jede Stunde)

const metrics = await collectMetrics({
  timeRange: "1h",
  metrics: ["execution_time", "api_calls", "token_usage", "success_rate"]
});

// Unterperformende Workflows identifizieren
const underperforming = metrics.filter(m => 
  m.avgExecutionTime > threshold.executionTime ||
  m.successRate < threshold.successRate ||
  m.costPerExecution > threshold.cost
);

for (const workflow of underperforming) {
  // Engpässe analysieren
  const bottlenecks = await analyzeBottlenecks(workflow.id);
  
  // Optimierungsvorschläge generieren
  const suggestions = await generateOptimizations(bottlenecks);
  
  // Optimierungen im Shadow-Modus testen
  await deployShadowTest(workflow.id, suggestions);
  
  // Wenn Shadow-Test Verbesserung zeigt, in Produktion deployen
  if (await validateShadowTest(workflow.id)) {
    await deployOptimization(workflow.id, suggestions);
    await notify("Optimierung deployed", { workflow: workflow.name, improvements: suggestions });
  }
}

// SKILL.md für einen selbstverbessernden Skill

# Name: kundenbetreuungs-assistent
# Version: 1.2.3

## Loop-Konfiguration

feedback_sammlung:
  kanäle: ["discord", "slack"]
  methoden: ["reaktion", "antwort", "korrektur"]
  
evaluierung:
  kriterien:
    - genauigkeit: { gewicht: 0.4, min: 0.85 }
    - hilfreichkeit: { gewicht: 0.3, min: 0.80 }
    - ton: { gewicht: 0.2, min: 0.75 }
    - effizienz: { gewicht: 0.1, max_tokens: 500 }
  
anpassung:
  auslöser: "evaluierung.wert < 0.80"
  strategie: "prompt_verfeinerung"
  max_iterationen: 5
  rollback_bei_fehler: true

## Ausführungslogik

async function execute(message, context) {
  // Aktuelle Prompt-Version laden
  const promptVersion = context.state.promptVersion || "1.0";
  const prompt = await loadPrompt("kundenbetreuung", promptVersion);
  
  // Antwort generieren
  const response = await llm.generate({
    prompt: prompt.template,
    context: message,
    history: context.memory.last(5)
  });
  
  // Ausführung für Feedback protokollieren
  await logExecution({
    executionId: generateId(),
    promptVersion,
    input: message,
    output: response,
    timestamp: Date.now()
  });
  
  return response;
}

## Feedback-Handler

async function handleFeedback(executionId, feedback) {
  // Ausführungskontext abrufen
  const execution = await getExecution(executionId);
  
  // Evaluierungs-Score berechnen
  const score = calculateScore(feedback, execution);
  
  // Feedback speichern
  await storeFeedback({ executionId, feedback, score });
  
  // Prüfen, ob Anpassung nötig
  if (score < CONFIG.anpassung.threshold) {
    await triggerAdaptation(execution);
  }
  
  // Skill-Statistiken aktualisieren
  await updateStats({ score, execution });
}

## Anpassungslogik

async function adapt() {
  // Kürzlich schlecht bewertete Ausführungen sammeln
  const poorPerformers = await getExecutions({
    score: { $lt: CONFIG.anpassung.threshold },
    timeRange: "24h",
    limit: 50
  });
  
  // Muster analysieren
  const patterns = await analyzePatterns(poorPerformers);
  
  // Verbesserten Prompt generieren
  const newPrompt = await generateImprovedPrompt({
    current: await loadPrompt("kundenbetreuung"),
    failures: patterns,
    successes: await getSuccessPatterns()
  });
  
  // Verbesserung validieren
  const validation = await validatePrompt(newPrompt);
  
  if (validation.score > CONFIG.anpassung.improvementThreshold) {
    // Neue Version deployen
    await deployPrompt("kundenbetreuung", newPrompt);
    await notify(`Prompt auf Version ${newPrompt.version} aktualisiert`);
  }
}

┌─────────────────────────────────────────────────────────────────┐
│              OpenClaw + n8n Loop-Integration                    │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│   OpenClaw Agent                     n8n Workflow               │
│   ──────────────                     ─────────────             │
│                                                                  │
│   Benutzer-Interaktion ──Webhook──▶ Workflow-Trigger            │
│         │                                                        │
│         │                            ┌──────────────────┐       │
│         │                            │ Anfrage verarbeiten│       │
│         │                            │ - Daten abrufen   │       │
│         │                            │ - Logik ausführen │       │
│         │                            └────────┬─────────┘       │
│         │                                     │                  │
│         │                            ┌────────▼─────────┐       │
│         │                            │ AI Agent Node     │       │
│         │                            │ Antwort generieren│       │
│         │                            └────────┬─────────┘       │
│         │                                     │                  │
│         │                            ┌────────▼─────────┐       │
│         └──────────Webhook───────────│ Antwort zurückgeben│       │
│                                      └──────────────────┘       │
│                                                   │              │
│                                      ┌────────────▼─────────┐   │
│                                      │ Feedback-Sammlung    │   │
│                                      │ - Ausführung speichern│   │
│                                      │ - Auf Benutzer warten │   │
│                                      │   Feedback            │   │
│                                      └────────────┬─────────┘   │
│                                                   │              │
│                                      ┌────────────▼─────────┐   │
│                                      │ Anpassungs-Loop      │   │
│                                      │ - Ergebnisse evaluieren │   │
│                                      │ - OpenClaw Konfig    │   │
│                                      │   aktualisieren      │   │
│                                      └──────────────────────┘   │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Benutzer: "Wie setze ich mein Passwort zurück?"

KI: "Sie können Ihr Passwort zurücksetzen, indem Sie 'Passwort vergessen' 
     auf der Login-Seite klicken. Eine E-Mail mit Anweisungen 
     wird an Ihre registrierte Adresse gesendet.
     
     War das hilfreich? [👍 Ja] [👎 Nein] [💬 Nachfrage]"
     
Benutzer klickt 👍

System: Loggt positives Feedback, ordnet Antwort zu

// Antwortgenerierung mit Inline-Feedback
const response = await generateResponse(userMessage);

const responseWithFeedback = {
  text: response.text,
  buttons: [
    { label: "👍 Ja", value: "feedback:positiv", style: "primary" },
    { label: "👎 Nein", value: "feedback:negativ", style: "danger" },
    { label: "💬 Nachfrage", value: "feedback:nachfrage", style: "secondary" }
  ]
};

// Antwort senden
await sendMessage(userId, responseWithFeedback);

// Webhook einrichten, um Button-Klicks zu erfassen
// Webhook-Handler extrahiert executionId aus Button-Wert
// und routet an Feedback-Verarbeitungs-Workflow

Tag 0: KI qualifiziert Lead, plant Demo
Tag 1: Lead nimmt an Demo teil
Tag 7: Lead konvertiert zum Kunden (oder nicht)
Tag 7: System evaluiert Gesprächseffektivität
        basierend auf tatsächlichem Konversionsergebnis

// Nach initialer Interaktion
await scheduleDelayedFeedback({
  executionId: currentExecution.id,
  delay: "7d",
  evaluationCriteria: "conversion_outcome",
  dataSource: "crm"
});

// Verzögerter Feedback-Workflow (von Cron getriggert)
const pendingFeedback = await getPendingFeedback();

for (const item of pendingFeedback) {
  const outcome = await checkOutcome(item.executionId);
  const feedback = convertOutcomeToFeedback(outcome);
  await processFeedback(item.executionId, feedback);
}

// Implizite Feedback-Signale

const signals = {
  // Engagement-Signale
  "schnelle_antwort": { gewicht: 0.3, sentiment: "positiv" },
  "folgefrage": { gewicht: 0.4, sentiment: "positiv" },
  "gespräch_fortgesetzt": { gewicht: 0.2, sentiment: "positiv" },
  
  // Desengagement-Signale  
  "keine_antwort_24h": { gewicht: 0.5, sentiment: "negativ" },
  "gespräch_abgebrochen": { gewicht: 0.4, sentiment: "negativ" },
  "zu_mensch_eskaliert": { gewicht: 0.6, sentiment: "negativ" },
  
  // Erfolgs-Signale
  "aufgabe_abgeschlossen": { gewicht: 0.8, sentiment: "positiv" },
  "empfehlung_akzeptiert": { gewicht: 0.7, sentiment: "positiv" },
  "positives_sentiment_erkannt": { gewicht: 0.5, sentiment: "positiv" }
};

// Impliziten Score berechnen
function calculateImplicitScore(execution, events) {
  let score = 0.5; // Neutraler Ausgangswert
  
  for (const event of events) {
    const signal = signals[event.type];
    if (signal) {
      score += signal.gewicht * (signal.sentiment === "positiv" ? 1 : -1);
    }
  }
  
  return Math.max(0, Math.min(1, score)); // Auf [0, 1] begrenzen
}

// Experten-Review-Warteschlange

const reviewQueue = await getExecutionsRequiringReview({
  criteria: [
    "confidence_score < 0.8",
    "user_expressed_dissatisfaction",
    "escalated_to_human"
  ],
  limit: 10
});

// Experten-Review-Interface präsentiert:
// - Vollen Gesprächskontext
// - KI-Antworten mit spezifischen Feedback-Punkten
// - Vergleich mit idealer Antwort
// - Strukturiertes Evaluierungsformular

const expertFeedback = {
  executionId: execution.id,
  reviewer: expert.id,
  ratings: {
    accuracy: 4,      // 1-5 Skala
    helpfulness: 3,
    tone: 5,
    efficiency: 4
  },
  corrections: {
    improvedResponse: "Bessere Formulierung wäre...",
    reasoning: "Die technische Erklärung war zu komplex..."
  },
  tags: ["technical_depth", "jargon"]
};

await storeExpertFeedback(expertFeedback);

// Konfiguration: Letzte N Nachrichten behalten
{
  "mode": "window",
  "windowSize": 10,
  "persistence": "redis"
}

// Anwendungsfall: Chatbot pflegt Gesprächskontext
// Das Fenster gleitet, hält aktuellen Kontext verfügbar
// Älterer Kontext wird zusammengefasst oder archiviert

// Konfiguration: Unbegrenzte Historie mit Token-Limit
{
  "mode": "buffer",
  "maxTokens": 8000,
  "persistence": "postgresql"
}

// Anwendungsfall: Kunden-Support-Session wo
// volle Konversation für Kontext wichtig ist
// Verwaltet automatisch Token-Budget

// Konfiguration: Cross-Execution-Persistenz
{
  "mode": "session",
  "sessionKey": "user_{{$json.userId}}",
  "persistence": "postgresql",
  "ttl": "30d"
}

// Anwendungsfall: Benutzerpräferenzen über
// mehrere Konversationen über Wochen lernen

// Beispiel: Kunden-Support-Loop-Zustand

const stateSchema = {
  // Session-Identifikation
  sessionId: "string",
  userId: "string",
  startedAt: "timestamp",
  
  // Gesprächskontext
  messages: [{
    role: "enum:user|assistant|system",
    content: "string",
    timestamp: "timestamp",
    feedback: "object|null"
  }],
  
  // Leistungs-Tracking
  metrics: {
    responseCount: "number",
    avgResponseTime: "number",
    satisfactionScore: "number",
    escalationCount: "number"
  },
  
  // Lernzustand
  userPreferences: {
    technicalLevel: "enum:beginner|intermediate|expert",
    preferredTone: "enum:formal|casual",
    commonIssues: ["string"]
  },
  
  // Konfigurations-Snapshot
  activeConfig: {
    promptVersion: "string",
    model: "string",
    parameters: "object"
  }
};

// Wenn Zustand sich ändert, Event veröffentlichen
await publishEvent("state:updated", {
  sessionId,
  changes,
  timestamp
});

// Abonnenten aktualisieren ihre Zustandskopien

// Cron-Job läuft jede Minute
const dirtySessions = await getDirtySessions();
for (const session of dirtySessions) {
  await syncToSecondaryStorage(session);
  await markClean(session.id);
}

// Wenn gleichzeitige Aktualisierungen auftreten
function resolveConflict(local, remote, strategy = "timestamp") {
  switch(strategy) {
    case "timestamp":
      return local.updatedAt > remote.updatedAt ? local : remote;
    case "merge":
      return deepMerge(local, remote);
    case "manual":
      queueForManualResolution(local, remote);
      return local;
  }
}

Aufgabe ausführen → Initiale Ausgabe generieren → Über Qualität reflektieren → 
Probleme identifizieren → Ausgabe überarbeiten → Finale Lieferung → Reflexion loggen

// Reflexions-Sub-Workflow

async function reflectOnOutput({ task, initialOutput, criteria }) {
  const reflectionPrompt = `
    Sie evaluieren Ihre eigene Arbeit. Überprüfen Sie die untenstehende Aufgabe und Ausgabe,
    identifizieren Sie dann alle Probleme oder Verbesserungsbereiche.
    
    Aufgabe: ${task}
    Ihre Ausgabe: ${initialOutput}
    
    Evaluierungskriterien:
    ${criteria.map(c => `- ${c.name}: ${c.description}`).join('\n')}
    
    Bereitstellen:
    1. Score für jedes Kriterium (1-5)
    2. Identifizierte spezifische Probleme
    3. Vorgeschlagene Verbesserungen
    4. Gesamteinschätzung: PASS oder REVISE
    
    Formatieren Sie Ihre Antwort als JSON.
  `;
  
  const reflection = await llm.generate({
    prompt: reflectionPrompt,
    temperature: 0.3,
    responseFormat: { type: "json_object" }
  });
  
  return JSON.parse(reflection);
}

// Haupt-Workflow
const initialOutput = await generateResponse(input);
const reflection = await reflectOnOutput({
  task: input.task,
  initialOutput,
  criteria: qualityCriteria
});

let finalOutput = initialOutput;
if (reflection.overallAssessment === "REVISE") {
  finalOutput = await reviseOutput(initialOutput, reflection.suggestedImprovements);
}

// Reflexion für Lernen loggen
await logReflection({
  executionId,
  reflection,
  initialOutput,
  finalOutput,
  revisionCount: reflection.overallAssessment === "REVISE" ? 1 : 0
});

const reflectionCriteria = {
  accuracy: {
    description: "Faktische Richtigkeit und Übereinstimmung mit Quellenmaterial",
    questions: [
      "Sind alle Fakten durch den bereitgestellten Kontext gestützt?",
      "Gibt es ungestützte Behauptungen?",
      "Sind die Informationen aktuell?"
    ]
  },
  completeness: {
    description: "Abdeckung aller relevanten Aspekte der Aufgabe",
    questions: [
      "Habe ich alle Teile der Benutzeranfrage adressiert?",
      "Gibt es wichtigen Kontext, den ich verpasst habe?",
      "Wären zusätzliche Informationen hilfreich?"
    ]
  },
  clarity: {
    description: "Leichtigkeit des Verständnisses und angemessener Ton",
    questions: [
      "Ist die Sprache klar und eindeutig?",
      "Ist der Ton für das Publikum angemessen?",
      "Würde ein Laie das verstehen?"
    ]
  },
  conciseness: {
    description: "Effizienz der Kommunikation",
    questions: [
      "Gibt es unnötige Wiederholungen?",
      "Könnte das kürzer gesagt werden?",
      "Sind alle enthaltenen Details relevant?"
    ]
  },
  actionability: {
    description: "Nützlichkeit für die nächsten Schritte des Benutzers",
    questions: [
      "Hilft das dem Benutzer, zu handeln?",
      "Sind nächste Schritte klar?",
      "Gibt es Mehrdeutigkeit darüber, was zu tun ist?"
    ]
  }
};

async function multiPassReflection(content, maxPasses = 3) {
  let current = content;
  let pass = 0;
  let shouldContinue = true;
  
  while (shouldContinue && pass < maxPasses) {
    const reflection = await reflectOnOutput(current);
    
    if (reflection.overallAssessment === "PASS" || 
        reflection.avgScore >= 4.5) {
      shouldContinue = false;
    } else {
      current = await reviseOutput(current, reflection.suggestedImprovements);
      pass++;
    }
    
    // Stoppen, wenn minimale Verbesserung zwischen Durchgängen
    if (pass > 0 && reflection.scoreDelta < 0.1) {
      shouldContinue = false;
    }
  }
  
  return {
    output: current,
    passes: pass + 1,
    finalReflection: reflection
  };
}

// Reflexionsdaten aggregieren
const reflectionPatterns = await aggregateReflections({
  timeRange: "7d",
  groupBy: ["criteria", "issueType"]
});

// Häufige Fehlermodi identifizieren
const commonIssues = reflectionPatterns
  .filter(r => r.frequency > threshold)
  .sort((a, b) => b.frequency - a.frequency);

// Gezielte Verbesserungen generieren
for (const issue of commonIssues) {
  const improvement = await generateImprovement({
    issue: issue.description,
    examples: issue.examples,
    currentPrompt: await getCurrentPrompt()
  });
  
  await deployImprovement(improvement);
}

const errorTaxonomy = {
  TRANSIENT: {
    description: "Vorübergehende Probleme, die bei Retry verschwinden könnten",
    examples: ["Netzwerk-Timeout", "Rate-Limit", "Service vorübergehend nicht verfügbar"],
    strategy: "RETRY_WITH_BACKOFF",
    maxRetries: 5
  },
  
  AUTHENTICATION: {
    description: "Anmelde- oder Berechtigungsprobleme",
    examples: ["Ungültiger API-Key", "Token abgelaufen", "Unzureichende Berechtigungen"],
    strategy: "REFRESH_AND_RETRY",
    maxRetries: 2
  },
  
  VALIDATION: {
    description: "Eingabe- oder Ausgabeformat-Probleme",
    examples: ["Schema-Mismatch", "Fehlendes Pflichtfeld", "Ungültiges Format"],
    strategy: "REPAIR_AND_RETRY",
    maxRetries: 3
  },
  
  DEPENDENCY: {
    description: "Erforderlicher Service oder Daten nicht verfügbar",
    examples: ["Datenbankverbindung fehlgeschlagen", "Externe API down", "Datei nicht gefunden"],
    strategy: "ESCALATE_OR_DEFER",
    maxRetries: 1
  },
  
  LOGIC: {
    description: "Workflow-Logikfehler",
    examples: ["Unerwartete Bedingung", "Endlosschleife erkannt", "Zustandsinkonsistenz"],
    strategy: "ESCALATE_TO_HUMAN",
    maxRetries: 0
  },
  
  RESOURCE: {
    description: "Ressourcenerschöpfung",
    examples: ["Speicher erschöpft", "Festplatte voll", "Rate-Limit überschritten"],
    strategy: "SCALE_OR_DEFER",
    maxRetries: 3
  }
};

async function adaptiveRetry(operation, context) {
  const errorHistory = await getErrorHistory(context.operationId);
  const baseConfig = await getRetryConfig(context.operationType);
  
  // Strategie basierend auf historischen Mustern anpassen
  const adjustedConfig = adjustStrategy(baseConfig, errorHistory);
  
  let attempt = 0;
  let lastError = null;
  
  while (attempt < adjustedConfig.maxRetries) {
    try {
      const result = await operation();
      
      // Erfolg nach vorherigen Fehlern loggen
      if (attempt > 0) {
        await logRecovery({ context, attempts: attempt, strategy: adjustedConfig });
      }
      
      return { success: true, result, attempts: attempt + 1 };
      
    } catch (error) {
      lastError = error;
      const errorType = classifyError(error);
      
      // Prüfen, ob retry-fähig
      if (!isRetryable(errorType)) {
        break;
      }
      
      // Verzögerung mit exponentiellem Backoff und Jitter berechnen
      const delay = calculateDelay(attempt, adjustedConfig, errorType);
      
      // Strategie für nächsten Versuch aktualisieren
      adjustedConfig = await updateStrategy(adjustedConfig, error, attempt);
      
      attempt++;
      await sleep(delay);
    }
  }
  
  // Alle Retries erschöpft
  await logPermanentFailure({ context, error: lastError, attempts });
  return { success: false, error: lastError, attempts };
}

function calculateDelay(attempt, config, errorType) {
  const baseDelay = config.baseDelays[errorType] || config.baseDelay;
  const exponential = Math.pow(2, attempt);
  const jitter = Math.random() * config.jitterFactor * baseDelay;
  
  return Math.min(
    baseDelay * exponential + jitter,
    config.maxDelay
  );
}

class CircuitBreaker {
  constructor(options = {}) {
    this.failureThreshold = options.failureThreshold || 5;
    this.recoveryTimeout = options.recoveryTimeout || 60000;
    this.halfOpenMaxCalls = options.halfOpenMaxCalls || 3;
    
    this.state = "CLOSED"; // CLOSED, OPEN, HALF_OPEN
    this.failures = 0;
    this.nextAttempt = Date.now();
    this.halfOpenCalls = 0;
  }
  
  async execute(operation) {
    if (this.state === "OPEN") {
      if (Date.now() < this.nextAttempt) {
        throw new CircuitOpenError("Service vorübergehend nicht verfügbar");
      }
      this.state = "HALF_OPEN";
      this.halfOpenCalls = 0;
    }
    
    if (this.state === "HALF_OPEN" && this.halfOpenCalls >= this.halfOpenMaxCalls) {
      throw new CircuitOpenError("Circuit Breaker Half-Open-Limit erreicht");
    }
    
    if (this.state === "HALF_OPEN") {
      this.halfOpenCalls++;
    }
    
    try {
      const result = await operation();
      this.onSuccess();
      return result;
    } catch (error) {
      this.onFailure();
      throw error;
    }
  }
  
  onSuccess() {
    this.failures = 0;
    this.state = "CLOSED";
  }
  
  onFailure() {
    this.failures++;
    if (this.failures >= this.failureThreshold) {
      this.state = "OPEN";
      this.nextAttempt = Date.now() + this.recoveryTimeout;
    }
  }
}

// Verwendung in n8n Function-Node
const breaker = new CircuitBreaker({
  failureThreshold: 5,
  recoveryTimeout: 60000
});

const result = await breaker.execute(() => 
  callExternalAPI(input)
);

// Fehleranalyse-Workflow
async function analyzeErrors(timeRange = "24h") {
  const errors = await getErrors({
    timeRange,
    resolved: true
  });
  
  // Nach Fehlertyp und Muster gruppieren
  const patterns = groupByPattern(errors);
  
  for (const pattern of patterns) {
    // Ursachen identifizieren
    const rootCause = await identifyRootCause(pattern);
    
    // Präventive Maßnahmen generieren
    const prevention = await generatePrevention(rootCause);
    
    // Workflows aktualisieren, wenn Konfidenz hoch
    if (prevention.confidence > 0.8) {
      await deployPrevention(prevention);
    }
    
    // Für manuelle Überprüfung loggen, wenn mittlere Konfidenz
    if (prevention.confidence > 0.5) {
      await queueForReview({ pattern, rootCause, prevention });
    }
  }
}

function optimizeContext(history, currentTask) {
  // Relevanz-Bewertung
  const scored = history.map(msg => ({
    ...msg,
    relevance: calculateRelevance(msg, currentTask)
  }));
  
  // Relevanteste Nachrichten innerhalb Token-Budget behalten
  const sorted = scored.sort((a, b) => b.relevance - a.relevance);
  const budget = getTokenBudget();
  
  let currentTokens = 0;
  const included = [];
  
  for (const msg of sorted) {
    const msgTokens = estimateTokens(msg.content);
    if (currentTokens + msgTokens < budget) {
      included.push(msg);
      currentTokens += msgTokens;
    }
  }
  
  // Zurück zur chronologischen Reihenfolge sortieren
  return included.sort((a, b) => a.timestamp - b.timestamp);
}

async function summarizeConversation(messages) {
  // Für lange Konversationen, kondensierte Darstellung erstellen
  if (messages.length > 20) {
    const summary = await llm.generate({
      prompt: `Fassen Sie die Hauptpunkte aus dieser Konversation in 3-5 Stichpunkten zusammen:
               ${formatMessages(messages.slice(0, -5))}`,
      maxTokens: 200
    });
    
    return [
      { role: "system", content: `Konversationszusammenfassung: ${summary}` },
      ...messages.slice(-5) // Letzte Nachrichten in voller Länge behalten
    ];
  }
  
  return messages;
}

async function selectModel(task, context) {
  const complexity = await assessComplexity(task, context);
  
  const tiers = {
    SIMPLE: { model: "gpt-4o-mini", cost: 0.15 },
    STANDARD: { model: "gpt-4o", cost: 2.50 },
    COMPLEX: { model: "gpt-4-turbo", cost: 10.00 },
    REASONING: { model: "o1-preview", cost: 15.00 }
  };
  
  const selection = tiers[complexity] || tiers.STANDARD;
  
  // Prüfen, ob Downgrade basierend auf Historie möglich
  const similarTasks = await getSimilarTaskPerformance(task);
  if (similarTasks.simpleModelSuccessRate > 0.95) {
    return tiers.SIMPLE;
  }
  
  return selection;
}

function shouldRunFullLoop(execution, config) {
  // Für triviale Aufgaben überspringen
  if (execution.complexity === "LOW") {
    return false;
  }
  
  // Überspringen, wenn kürzlich evaluiert
  const lastEvaluation = execution.lastEvaluation;
  if (lastEvaluation && Date.now() - lastEvaluation < config.minLoopInterval) {
    return false;
  }
  
  // Überspringen, wenn Konfidenz hoch
  if (execution.confidenceScore > config.confidenceThreshold) {
    return false;
  }
  
  // Immer ausführen, wenn Fehler erkannt
  if (execution.errorCount > 0) {
    return true;
  }
  
  // Nach konfigurierter Rate samplen
  return Math.random() < config.samplingRate;
}

// Kosten-Tracking-Middleware
async function trackExecutionCost(execution) {
  const costs = {
    llmCalls: execution.llmCalls * avgCostPerCall(execution.model),
    storage: execution.storageUsed * storageRate,
    compute: execution.duration * computeRate,
    bandwidth: execution.dataTransferred * bandwidthRate
  };
  
  const total = Object.values(costs).reduce((a, b) => a + b, 0);
  
  await logCost({
    executionId: execution.id,
    workflowId: execution.workflowId,
    costs,
    total,
    timestamp: Date.now()
  });
  
  // Bei anomalen Kosten alarieren
  const avgCost = await getAverageCost(execution.workflowId, "7d");
  if (total > avgCost * 3) {
    await sendAlert({
      type: "KOSTEN_ANOMALIE",
      execution: execution.id,
      cost: total,
      average: avgCost
    });
  }
  
  // Circuit Breaker für exzessive Kosten
  const dailyCost = await getDailyCost(execution.workflowId);
  const budget = await getBudget(execution.workflowId);
  if (dailyCost > budget * 0.8) {
    await activateCostLimiter(execution.workflowId);
  }
}

Agent A ───┐
           ├──▶ Geteilte Evaluierung ▶── Koordinierte Anpassung
Agent B ───┘            ▲                    │
                        └────────────────────┘

// Zentraler Koordinator verwaltet alle Agenten-Loops
class LoopCoordinator {
  constructor() {
    this.agents = new Map();
    this.sharedState = new Map();
  }
  
  registerAgent(agentId, config) {
    this.agents.set(agentId, {
      config,
      lastEvaluation: null,
      performance: []
    });
  }
  
  async coordinate(feedback) {
    // Feedback über Agenten aggregieren
    const aggregate = await this.aggregateFeedback(feedback);
    
    // System-Level-Muster identifizieren
    const patterns = await this.identifyPatterns(aggregate);
    
    // Koordinierte Anpassungen bestimmen
    const adaptations = await this.planAdaptations(patterns);
    
    // Anpassungen an Agenten verteilen
    for (const [agentId, adaptation] of adaptations) {
      await this.sendAdaptation(agentId, adaptation);
    }
    
    // Koordinationsentscheidungen loggen
    await this.logCoordination({ aggregate, patterns, adaptations });
  }
  
  async identifyPatterns(aggregate) {
    // Erkennen, wenn mehrere Agenten mit ähnlichen Aufgaben kämpfen
    const commonIssues = aggregate.filter(a => 
      a.frequency > 1 && a.affectedAgents.length > 1
    );
    
    // Ressourcenkonflikte identifizieren
    const conflicts = detectConflicts(aggregate);
    
    // Optimierungsmöglichkeiten finden
    const optimizations = findOptimizations(aggregate);
    
    return { commonIssues, conflicts, optimizations };
  }
}

// Agenten verhandeln Anpassungen Peer-to-Peer
async function negotiateAdaptation(agentId, proposedChange) {
  // Andere Agenten nach Impact-Bewertung fragen
  const impacts = await Promise.all(
    peerAgents.map(peer => 
      assessImpact(peer, proposedChange)
    )
  );
  
  // Wenn Konflikte erkannt, Kompromiss verhandeln
  const conflicts = impacts.filter(i => i.conflict);
  if (conflicts.length > 0) {
    const compromise = await generateCompromise(proposedChange, conflicts);
    return { approved: true, adjustment: compromise };
  }
  
  // Keine Konflikte, mit Original fortfahren
  return { approved: true, adjustment: proposedChange };
}

// Multi-Level-Koordination
const coordinationHierarchy = {
  level1: {
    agents: ["support-agent", "sales-agent"],
    scope: "customer-facing",
    coordinator: "customer-coordinator"
  },
  level2: {
    agents: ["customer-coordinator", "operations-agent"],
    scope: "business-operations",
    coordinator: "operations-coordinator"
  },
  level3: {
    agents: ["operations-coordinator", "strategy-agent"],
    scope: "strategic",
    coordinator: "executive-coordinator"
  }
};

// Feedback steigt auf, Anpassungen kaskadieren nach unten
async function hierarchicalCoordination(feedback, level) {
  const config = coordinationHierarchy[level];
  
  // Auf aktuellem Level verarbeiten
  const adaptations = await processAtLevel(feedback, config);
  
  // Aufsteigen, wenn signifikant
  if (adaptations.significance > threshold && level < maxLevel) {
    await hierarchicalCoordination(adaptations, level + 1);
  }
  
  // Nach unten kaskadieren bei genehmigten Anpassungen
  for (const agent of config.agents) {
    await applyAdaptation(agent, adaptations);
  }
}

const conflictResolutionStrategies = {
  PRIORITY: (conflicts) => {
    // Höher priorisierter Agent gewinnt
    return conflicts.sort((a, b) => b.priority - a.priority)[0];
  },
  
  MERGE: (conflicts) => {
    // Versuchen, Anpassungen zu mergen
    return attemptMerge(conflicts);
  },
  
  COMPROMISE: (conflicts) => {
    // Mittelweg finden
    return findCompromise(conflicts);
  },
  
  EXPERIMENT: (conflicts) => {
    // A/B-Test durchführen
    return scheduleExperiment(conflicts);
  },
  
  ESCALATE: (conflicts) => {
    // Menschliche Entscheidung erforderlich
    return escalateToHuman(conflicts);
  }
};

Ticket empfangen → KI generiert Antwort → An Kunden senden → 
Zufriedenheit sammeln → Wenn niedrig, analysieren → Antwortstrategie aktualisieren → 
Auf zukünftige Tickets anwenden

const supportLoop = {
  triggers: ["new_ticket", "satisfaction_survey"],
  
  evaluate: async (ticket) => {
    const metrics = {
      resolvedFirstTime: ticket.resolvedWithoutFollowUp,
      csat: ticket.satisfactionRating,
      escalated: ticket.wasEscalated,
      responseTime: ticket.firstResponseTime
    };
    
    const score = weightedAverage(metrics, weights);
    return { score, metrics };
  },
  
  adapt: async (lowPerformanceInstances) => {
    // Gemeinsame Fehlermuster identifizieren
    const patterns = analyzePatterns(lowPerformanceInstances);
    
    // Wissensdatenbank-Lücken aktualisieren
    if (patterns.knowledgeGaps) {
      await queueKnowledgeUpdates(patterns.knowledgeGaps);
    }
    
    // Ton verfeinern, wenn Beschwerden über Kommunikation
    if (patterns.toneIssues) {
      await updateToneGuidelines(patterns.toneIssues);
    }
    
    // Eskalationsschwellen anpassen
    if (patterns.underEscalation) {
      await lowerEscalationThreshold();
    }
  }
};

Lead tritt Pipeline bei → KI qualifiziert → Personalisiertes Outreach → 
Engagement tracken → Konversion messen → Qualifizierungskriterien verfeinern

const salesLoop = {
  // Verzögerter Feedback-Loop
  evaluationDelay: "30d",
  
  evaluate: async (lead) => {
    const outcome = await checkOutcome(lead.id);
    return {
      converted: outcome.isCustomer,
      revenue: outcome.lifetimeValue,
      cycleDays: outcome.daysToClose,
      qualifiedCorrectly: outcome.wasQualified === outcome.shouldHaveBeenQualified
    };
  },
  
  adapt: async (results) => {
    // Qualifizierungsmodell aktualisieren
    const newCriteria = await retrainQualificationModel(results);
    await deployQualificationModel(newCriteria);
    
    // Outreach-Sequenzen optimieren
    const sequences = await optimizeSequences(results);
    await updateOutreachTemplates(sequences);
    
    // Lead-Scoring anpassen
    await updateLeadScoringWeights(results);
  }
};

Content-Entwurf generieren → Human/Editor Review → Veröffentlichen → 
Engagement tracken → Performance analysieren → Generierungsstrategie verfeinern

const contentLoop = {
  // Human-in-the-Loop für Qualität
  humanReview: true,
  
  evaluate: async (content) => {
    const performance = await getContentMetrics(content.id);
    return {
      engagement: performance.avgTimeOnPage,
      reach: performance.uniqueVisitors,
      viral: performance.shares,
      conversion: performance.conversionRate,
      seo: performance.searchRanking
    };
  },
  
  adapt: async (performanceData) => {
    // High-Performing-Content-Muster identifizieren
    const winners = performanceData.filter(p => p.conversion > threshold);
    const patterns = extractPatterns(winners);
    
    // Content-Generierungs-Richtlinien aktualisieren
    await updateContentGuidelines(patterns);
    
    // Themenauswahl anpassen
    await updateTopicModel(patterns.topics);
    
    // Ton und Stil verfeinern
    await updateStyleGuide(patterns.style);
  }
};

Entwickler fordert Code an → KI generiert → Entwickler verwendet → 
Akzeptanz/Ablehnung tracken → Code-Qualität messen → Generierungs-Patterns aktualisieren

const codingLoop = {
  // Multi-Level-Feedback
  feedbackLevels: ["immediate", "code_review", "production"],
  
  evaluate: async (codeBlock) => {
    const immediate = await getImmediateFeedback(codeBlock.id);
    const review = await getReviewFeedback(codeBlock.id);
    const production = await getProductionMetrics(codeBlock.id);
    
    return {
      accepted: immediate.accepted,
      modified: immediate.modificationRate,
      reviewComments: review.commentCount,
      bugsFound: production.bugCount,
      performance: production.performanceScore
    };
  },
  
  adapt: async (evaluations) => {
    // Coding-Patterns aktualisieren
    const patterns = await analyzeCodePatterns(evaluations);
    await updateCodingGuidelines(patterns);
    
    // Projekt-spezifische Konventionen lernen
    const conventions = await extractConventions(evaluations);
    await updateProjectProfile(conventions);
    
    // Für verschiedene Aufgabentypen anpassen
    await updateTaskTypeStrategies(evaluations);
  }
};

const governanceFramework = {
  // Genehmigungs-Workflows für Anpassungen
  approval: {
    automatic: {
      criteria: [
        "confidence > 0.95",
        "tested_in_staging",
        "no_security_implications",
        "rollout_percentage <= 10"
      ]
    },
    manual: {
      criteria: [
        "confidence < 0.95",
        "affects_core_functionality",
        "has_security_implications",
        "rollout_percentage > 10"
      ]
    }
  },
  
  // Audit-Logging
  audit: {
    logAll: true,
    retention: "7y",
    include: [
      "original_state",
      "proposed_change",
      "evaluation_data",
      "approval_chain",
      "deployment_timestamp",
      "outcome_metrics"
    ]
  },
  
  // Rollback-Fähigkeiten
  rollback: {
    automaticTriggers: [
      "error_rate_increase > 50%",
      "satisfaction_decrease > 20%",
      "security_alert"
    ],
    maxRollbackTime: "24h",
    preserveState: true
  }
};

async function proposeAdaptation(proposal) {
  // Sicherheits-Scan
  const securityScan = await scanForSecurityIssues(proposal);
  if (securityScan.issues.length > 0) {
    return { approved: false, reason: "security_concerns" };
  }
  
  // Richtlinien-Compliance-Check
  const compliance = await checkPolicyCompliance(proposal);
  if (!compliance.compliant) {
    return { approved: false, reason: "policy_violation", details: compliance.violations };
  }
  
  // Genehmigungspfad bestimmen
  const path = determineApprovalPath(proposal);
  
  if (path === "automatic") {
    // Zu Canary deployen
    await deployCanary(proposal);
    await scheduleEvaluation(proposal.id, "1h");
    return { approved: true, deployment: "canary" };
  }
  
  // Zur manuellen Überprüfung in Warteschlange
  await queueForReview(proposal);
  return { approved: false, status: "pending_review" };
}

async function checkForBias(feedbackData) {
  // Demografische Ungleichheiten prüfen
  const demographics = await analyzeByDemographics(feedbackData);
  
  const disparities = [];
  for (const demo of demographics) {
    const performanceGap = calculateGap(demo, overallAverage);
    if (performanceGap > threshold) {
      disparities.push({
        demographic: demo.name,
        gap: performanceGap,
        affectedMetric: demo.metric
      });
    }
  }
  
  if (disparities.length > 0) {
    await alertBias(disparities);
    
    // Korrektur anwenden
    await applyBiasCorrection(disparities);
    
    // Menschliche Überprüfung vor weiteren Anpassungen erforderlich
    await pauseAutomaticAdaptations();
  }
}

// Umfassendes Audit-Logging
async function logAdaptationEvent(event) {
  const auditRecord = {
    timestamp: Date.now(),
    eventId: generateId(),
    eventType: event.type,
    
    // Änderungsdetails
    change: {
      before: event.previousState,
      after: event.newState,
      diff: calculateDiff(event.previousState, event.newState)
    },
    
    // Entscheidungsrationale
    rationale: {
      trigger: event.trigger,
      evaluationData: event.evaluation,
      confidence: event.confidence,
      alternativesConsidered: event.alternatives
    },
    
    // Governance
    governance: {
      approvedBy: event.approver,
      approvalChain: event.approvals,
      securityScan: event.securityResult,
      complianceCheck: event.complianceResult
    },
    
    // Impact
    impact: {
      rolloutPercentage: event.rollout,
      affectedUsers: event.userCount,
      expectedOutcome: event.expectedResult
    }
  };
  
  await storeAuditRecord(auditRecord);
  await indexForCompliance(auditRecord);
}

// Neue Anpassungen parallel zu bestehenden ausführen
async function shadowTest(adaptation) {
  // Gleiche Eingabe mit altem und neuem verarbeiten
  const oldResult = await executeWithConfig(currentConfig, input);
  const newResult = await executeWithConfig(adaptation, input);
  
  // Ergebnisse vergleichen
  const comparison = await compareResults(oldResult, newResult);
  
  // Für Analyse loggen
  await logShadowTest({
    adaptation: adaptation.id,
    input: input.id,
    oldResult,
    newResult,
    comparison
  });
  
  // Nur signifikante Unterschiede anzeigen
  if (comparison.significantDifference) {
    await flagForReview({ adaptation, input, comparison });
  }
}

async function abTestAdaptation(adaptation) {
  // Traffic aufteilen
  const assignment = Math.random() < 0.5 ? "control" : "treatment";
  
  if (assignment === "treatment") {
    await applyAdaptation(adaptation);
  }
  
  // Leistung für beide Gruppen tracken
  const performance = await trackPerformance({
    adaptation: adaptation.id,
    assignment,
    duration: "7d"
  });
  
  // Statistische Signifikanz testen
  const significance = await calculateSignificance(performance);
  
  if (significance.pValue < 0.05 && performance.treatment > performance.control) {
    await fullDeployment(adaptation);
  } else {
    await rollback(adaptation);
  }
}