"You are a helpful customer support representative for Acme Corp. 
Respond to customer inquiries politely, professionally, and accurately. 
Use the provided knowledge base to answer questions. If you don't know 
something, escalate to a human agent."

┌─────────────────────────────────────────────────────────────────┐
│                    The Feedback Loop Cycle                      │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│    ┌──────────────┐      ┌──────────────┐      ┌──────────────┐ │
│    │   EXECUTE    │─────▶│   OBSERVE    │─────▶│   EVALUATE   │ │
│    │              │      │              │      │              │ │
│    │ Perform task │      │ Capture data │      │ Assess       │ │
│    │ Generate     │      │ Log outcomes │      │ performance  │ │
│    │ output       │      │ Record context│     │ vs. goals    │ │
│    └──────────────┘      └──────────────┘      └──────┬───────┘ │
│           ▲                                           │          │
│           │                                           ▼          │
│           │                                    ┌──────────────┐ │
│           └────────────────────────────────────│    ADAPT     │ │
│                                                │              │ │
│                                                │ Adjust       │ │
│                                                │ parameters   │ │
│                                                │ Update rules │ │
│                                                └──────────────┘ │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────┐
│                    Loop Engineering Stack                       │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  ┌──────────────────────────────────────────────────────────┐  │
│  │                   ORCHESTRATION LAYER                    │  │
│  │              (n8n, OpenClaw, LangChain)                  │  │
│  └──────────────────────────────────────────────────────────┘  │
│                              │                                   │
│  ┌───────────────────────────┼───────────────────────────────┐  │
│  │                           ▼                               │  │
│  │  ┌─────────────┐  ┌─────────────┐  ┌─────────────────┐   │  │
│  │  │  AGENT      │  │   AGENT     │  │     AGENT       │   │  │
│  │  │  EXECUTION  │  │  OBSERVATION│  │   EVALUATION    │   │  │
│  │  └─────────────┘  └─────────────┘  └─────────────────┘   │  │
│  └──────────────────────────────────────────────────────────┘  │
│                              │                                   │
│  ┌───────────────────────────▼───────────────────────────────┐  │
│  │                   STATE MANAGEMENT                         │  │
│  │     (Redis, PostgreSQL, Vector Store, n8n Memory)        │  │
│  └──────────────────────────────────────────────────────────┘  │
│                              │                                   │
│  ┌───────────────────────────▼───────────────────────────────┐  │
│  │                   FEEDBACK PIPELINE                      │  │
│  │    (Webhooks, Message Queues, Event Streams, APIs)       │  │
│  └──────────────────────────────────────────────────────────┘  │
│                              │                                   │
│  ┌───────────────────────────▼───────────────────────────────┐  │
│  │              ADAPTATION & LEARNING ENGINE                  │  │
│  │  (Prompt versioning, Parameter tuning, Model selection)  │  │
│  └──────────────────────────────────────────────────────────┘  │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Execution → Split to Variant A or B → Compare Outcomes 
→ Adopt Better Performing Variant → Repeat with New Variations

Execute → Error Detected → Analyze Error Type → 
Apply Recovery Strategy → Retry with Adjustments → 
Success/Failure → Update Error Handling Rules

Execute → Measure Performance (latency, cost, accuracy) → 
Identify Bottlenecks → Optimize → Validate Improvement → 
Deploy → Continue Monitoring

Execute → Detect Knowledge Gap → Retrieve Updated Information → 
Validate Against Sources → Update Knowledge Base → 
Re-execute with New Knowledge

┌─────────────────────────────────────────────────────────────────┐
│              Self-Improving Support Agent Architecture          │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  Webhook (Incoming Message)                                      │
│       │                                                          │
│       ▼                                                          │
│  Retrieve Session Memory (PostgreSQL)                           │
│       │                                                          │
│       ▼                                                          │
│  AI Agent Node (GPT-4o with dynamic system prompt)              │
│       │                                                          │
│       ▼                                                          │
│  Send Response + Collect Implicit Feedback (response time)        │
│       │                                                          │
│       ▼                                                          │
│  Wait for Explicit Feedback (Thumbs up/down webhook)           │
│       │                                                          │
│       ▼                                                          │
│  Evaluate: Calculate satisfaction score                          │
│       │                                                          │
│       ├── Satisfied (>80%) ──▶ Store in Success Patterns       │
│       │                                                          │
│       └── Unsatisfied (<80%) ──▶ Trigger Adaptation Loop         │
│                                     │                            │
│                                     ▼                            │
│                              Analyze Failure                     │
│                                     │                            │
│                                     ▼                            │
│                              Update Prompt Rules                 │
│                                     │                            │
│                                     ▼                            │
│                              Log Improvement for Next Session  │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

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

// currentPrompt is retrieved from PostgreSQL and updated by the adaptation loop

// Adaptation Workflow Logic
// 1. Retrieve last 50 negative feedback instances
// 2. Group by error type (tone, accuracy, completeness, etc.)
// 3. Generate prompt adjustments using LLM
// 4. Validate adjustments against success patterns
// 5. Update configuration table
// 6. Log changes with rollback capability

// Error Recovery Sub-Workflow

// Input: Error details from failed execution
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"];

// Update error statistics
await updateErrorStats(errorType, $json.workflowId);

// If error rate exceeds threshold, trigger adaptation
const errorRate = await getErrorRate($json.workflowId, "1h");
if (errorRate > 0.05) {
  await triggerAdaptation($json.workflowId, errorType);
}

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

// Performance Monitor Workflow (runs every hour)

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

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

for (const workflow of underperforming) {
  // Analyze bottlenecks
  const bottlenecks = await analyzeBottlenecks(workflow.id);
  
  // Generate optimization suggestions
  const suggestions = await generateOptimizations(bottlenecks);
  
  // Test optimizations in shadow mode
  await deployShadowTest(workflow.id, suggestions);
  
  // If shadow test shows improvement, deploy to production
  if (await validateShadowTest(workflow.id)) {
    await deployOptimization(workflow.id, suggestions);
    await notify("Optimization deployed", { workflow: workflow.name, improvements: suggestions });
  }
}

// SKILL.md for a self-improving skill

# Name: customer-support-assistant
# Version: 1.2.3

## Loop Configuration

feedback_collection:
  channels: ["discord", "slack"]
  methods: ["reaction", "reply", "correction"]
  
evaluation:
  criteria:
    - accuracy: { weight: 0.4, min: 0.85 }
    - helpfulness: { weight: 0.3, min: 0.80 }
    - tone: { weight: 0.2, min: 0.75 }
    - efficiency: { weight: 0.1, max_tokens: 500 }
  
adaptation:
  trigger: "evaluation.score < 0.80"
  strategy: "prompt_refinement"
  max_iterations: 5
  rollback_on_failure: true

## Execution Logic

async function execute(message, context) {
  // Load current prompt version
  const promptVersion = context.state.promptVersion || "1.0";
  const prompt = await loadPrompt("customer-support", promptVersion);
  
  // Generate response
  const response = await llm.generate({
    prompt: prompt.template,
    context: message,
    history: context.memory.last(5)
  });
  
  // Record execution for feedback
  await logExecution({
    executionId: generateId(),
    promptVersion,
    input: message,
    output: response,
    timestamp: Date.now()
  });
  
  return response;
}

## Feedback Handler

async function handleFeedback(executionId, feedback) {
  // Retrieve execution context
  const execution = await getExecution(executionId);
  
  // Calculate evaluation score
  const score = calculateScore(feedback, execution);
  
  // Store feedback
  await storeFeedback({ executionId, feedback, score });
  
  // Check if adaptation needed
  if (score < CONFIG.adaptation.threshold) {
    await triggerAdaptation(execution);
  }
  
  // Update skill statistics
  await updateStats({ score, execution });
}

## Adaptation Logic

async function adapt() {
  // Collect recent low-scoring executions
  const poorPerformers = await getExecutions({
    score: { $lt: CONFIG.adaptation.threshold },
    timeRange: "24h",
    limit: 50
  });
  
  // Analyze patterns
  const patterns = await analyzePatterns(poorPerformers);
  
  // Generate improved prompt
  const newPrompt = await generateImprovedPrompt({
    current: await loadPrompt("customer-support"),
    failures: patterns,
    successes: await getSuccessPatterns()
  });
  
  // Validate improvement
  const validation = await validatePrompt(newPrompt);
  
  if (validation.score > CONFIG.adaptation.improvementThreshold) {
    // Deploy new version
    await deployPrompt("customer-support", newPrompt);
    await notify(`Prompt updated to version ${newPrompt.version}`);
  }
}

┌─────────────────────────────────────────────────────────────────┐
│              OpenClaw + n8n Loop Integration                    │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│   OpenClaw Agent                     n8n Workflow             │
│   ──────────────                     ─────────────             │
│                                                                  │
│   User Interaction ───────Webhook────▶ Workflow Trigger          │
│         │                                                          │
│         │                            ┌──────────────────┐       │
│         │                            │ Process Request   │       │
│         │                            │ - Retrieve data   │       │
│         │                            │ - Execute logic   │       │
│         │                            └────────┬─────────┘       │
│         │                                     │                  │
│         │                            ┌────────▼─────────┐       │
│         │                            │ AI Agent Node     │       │
│         │                            │ Generate response │       │
│         │                            └────────┬─────────┘       │
│         │                                     │                  │
│         │                            ┌────────▼─────────┐       │
│         └──────────Webhook───────────│ Return Response   │       │
│                                      └──────────────────┘       │
│                                                   │              │
│                                      ┌────────────▼─────────┐   │
│                                      │ Feedback Collection   │   │
│                                      │ - Store execution     │   │
│                                      │ - Wait for user        │   │
│                                      │   feedback            │   │
│                                      └────────────┬─────────┘   │
│                                                   │              │
│                                      ┌────────────▼─────────┐   │
│                                      │ Adaptation Loop      │   │
│                                      │ - Evaluate results    │   │
│                                      │ - Update OpenClaw     │   │
│                                      │   skill config        │   │
│                                      └──────────────────────┘   │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

User: "How do I reset my password?"

AI: "You can reset your password by clicking 'Forgot Password' 
     on the login page. An email with reset instructions 
     will be sent to your registered address.
     
     Was this helpful? [👍 Yes] [👎 No] [💬 Ask follow-up]"
     
User clicks 👍

System: Logs positive feedback, associates with response

// Response generation with inline feedback
const response = await generateResponse(userMessage);

const responseWithFeedback = {
  text: response.text,
  buttons: [
    { label: "👍 Yes", value: "feedback:positive", style: "primary" },
    { label: "👎 No", value: "feedback:negative", style: "danger" },
    { label: "💬 Ask follow-up", value: "feedback:followup", style: "secondary" }
  ]
};

// Send response
await sendMessage(userId, responseWithFeedback);

// Set up webhook to capture button clicks
// Webhook handler extracts executionId from button value
// and routes to feedback processing workflow

Day 0: AI qualifies lead, schedules demo
Day 1: Lead attends demo
Day 7: Lead converts to customer (or doesn't)
Day 7: System evaluates conversation effectiveness
        based on actual conversion outcome

// After initial interaction
await scheduleDelayedFeedback({
  executionId: currentExecution.id,
  delay: "7d",
  evaluationCriteria: "conversion_outcome",
  dataSource: "crm"
});

// Delayed feedback workflow (triggered by cron)
const pendingFeedback = await getPendingFeedback();

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

// Implicit feedback signals

const signals = {
  // Engagement signals
  "quick_response": { weight: 0.3, sentiment: "positive" },
  "follow_up_question": { weight: 0.4, sentiment: "positive" },
  "conversation_continued": { weight: 0.2, sentiment: "positive" },
  
  // Disengagement signals  
  "no_response_24h": { weight: 0.5, sentiment: "negative" },
  "conversation_ended_abruptly": { weight: 0.4, sentiment: "negative" },
  "escalated_to_human": { weight: 0.6, sentiment: "negative" },
  
  // Success signals
  "task_completed": { weight: 0.8, sentiment: "positive" },
  "recommendation_accepted": { weight: 0.7, sentiment: "positive" },
  "positive_sentiment_detected": { weight: 0.5, sentiment: "positive" }
};

// Calculate implicit score
function calculateImplicitScore(execution, events) {
  let score = 0.5; // Neutral baseline
  
  for (const event of events) {
    const signal = signals[event.type];
    if (signal) {
      score += signal.weight * (signal.sentiment === "positive" ? 1 : -1);
    }
  }
  
  return Math.max(0, Math.min(1, score)); // Clamp to [0, 1]
}

// Expert review queue

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

// Expert review interface presents:
// - Full conversation context
// - AI responses with specific feedback points
// - Comparison with ideal response
// - Structured evaluation form

const expertFeedback = {
  executionId: execution.id,
  reviewer: expert.id,
  ratings: {
    accuracy: 4,      // 1-5 scale
    helpfulness: 3,
    tone: 5,
    efficiency: 4
  },
  corrections: {
    improvedResponse: "Better phrasing would be...",
    reasoning: "The technical explanation was too complex..."
  },
  tags: ["technical_depth", "jargon"]
};

await storeExpertFeedback(expertFeedback);

// Configuration: Keep last N messages
{
  "mode": "window",
  "windowSize": 10,
  "persistence": "redis"
}

// Use case: Chatbot maintaining conversation context
// The window slides, keeping recent context available
// Older context is summarized or archived

// Configuration: Unlimited history with token limit
{
  "mode": "buffer",
  "maxTokens": 8000,
  "persistence": "postgresql"
}

// Use case: Customer support session where
// full conversation matters for context
// Automatically manages token budget

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

// Use case: Learning user preferences across
// multiple conversations over weeks

// Example: Customer support loop state

const stateSchema = {
  // Session identification
  sessionId: "string",
  userId: "string",
  startedAt: "timestamp",
  
  // Conversation context
  messages: [{
    role: "enum:user|assistant|system",
    content: "string",
    timestamp: "timestamp",
    feedback: "object|null"
  }],
  
  // Performance tracking
  metrics: {
    responseCount: "number",
    avgResponseTime: "number",
    satisfactionScore: "number",
    escalationCount: "number"
  },
  
  // Learning state
  userPreferences: {
    technicalLevel: "enum:beginner|intermediate|expert",
    preferredTone: "enum:formal|casual",
    commonIssues: ["string"]
  },
  
  // Configuration snapshot
  activeConfig: {
    promptVersion: "string",
    model: "string",
    parameters: "object"
  }
};

// When state changes, publish event
await publishEvent("state:updated", {
  sessionId,
  changes,
  timestamp
});

// Subscribers update their state copies

// Cron job runs every minute
const dirtySessions = await getDirtySessions();
for (const session of dirtySessions) {
  await syncToSecondaryStorage(session);
  await markClean(session.id);
}

// When concurrent updates occur
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;
  }
}

Execute Task → Generate Initial Output → Reflect on Quality → 
Identify Issues → Revise Output → Final Delivery → Log Reflection

// Reflection sub-workflow

async function reflectOnOutput({ task, initialOutput, criteria }) {
  const reflectionPrompt = `
    You are evaluating your own work. Review the task and output below,
    then identify any issues or areas for improvement.
    
    Task: ${task}
    Your Output: ${initialOutput}
    
    Evaluation Criteria:
    ${criteria.map(c => `- ${c.name}: ${c.description}`).join('\n')}
    
    Provide:
    1. Score for each criterion (1-5)
    2. Specific issues identified
    3. Suggested improvements
    4. Overall assessment: PASS or REVISE
    
    Format your response as JSON.
  `;
  
  const reflection = await llm.generate({
    prompt: reflectionPrompt,
    temperature: 0.3,
    responseFormat: { type: "json_object" }
  });
  
  return JSON.parse(reflection);
}

// Main 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);
}

// Log reflection for learning
await logReflection({
  executionId,
  reflection,
  initialOutput,
  finalOutput,
  revisionCount: reflection.overallAssessment === "REVISE" ? 1 : 0
});

const reflectionCriteria = {
  accuracy: {
    description: "Factual correctness and alignment with source material",
    questions: [
      "Are all facts supported by the provided context?",
      "Are there any unsupported claims?",
      "Is the information up-to-date?"
    ]
  },
  completeness: {
    description: "Coverage of all relevant aspects of the task",
    questions: [
      "Did I address all parts of the user's request?",
      "Is there important context I missed?",
      "Would additional information be helpful?"
    ]
  },
  clarity: {
    description: "Ease of understanding and appropriate tone",
    questions: [
      "Is the language clear and unambiguous?",
      "Is the tone appropriate for the audience?",
      "Would a non-expert understand this?"
    ]
  },
  conciseness: {
    description: "Efficiency of communication",
    questions: [
      "Is there unnecessary repetition?",
      "Could this be said more briefly?",
      "Are all included details relevant?"
    ]
  },
  actionability: {
    description: "Utility for the user's next steps",
    questions: [
      "Does this help the user take action?",
      "Are next steps clear?",
      "Is there ambiguity about what to do?"
    ]
  }
};

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++;
    }
    
    // Stop if minimal improvement between passes
    if (pass > 0 && reflection.scoreDelta < 0.1) {
      shouldContinue = false;
    }
  }
  
  return {
    output: current,
    passes: pass + 1,
    finalReflection: reflection
  };
}

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

// Identify common failure modes
const commonIssues = reflectionPatterns
  .filter(r => r.frequency > threshold)
  .sort((a, b) => b.frequency - a.frequency);

// Generate targeted improvements
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: "Temporary issues that may resolve on retry",
    examples: ["Network timeout", "Rate limit", "Service temporarily unavailable"],
    strategy: "RETRY_WITH_BACKOFF",
    maxRetries: 5
  },
  
  AUTHENTICATION: {
    description: "Credential or permission issues",
    examples: ["Invalid API key", "Token expired", "Insufficient permissions"],
    strategy: "REFRESH_AND_RETRY",
    maxRetries: 2
  },
  
  VALIDATION: {
    description: "Input or output format issues",
    examples: ["Schema mismatch", "Missing required field", "Invalid format"],
    strategy: "REPAIR_AND_RETRY",
    maxRetries: 3
  },
  
  DEPENDENCY: {
    description: "Required service or data unavailable",
    examples: ["Database connection failed", "External API down", "File not found"],
    strategy: "ESCALATE_OR_DEFER",
    maxRetries: 1
  },
  
  LOGIC: {
    description: "Workflow logic errors",
    examples: ["Unexpected condition", "Infinite loop detected", "State inconsistency"],
    strategy: "ESCALATE_TO_HUMAN",
    maxRetries: 0
  },
  
  RESOURCE: {
    description: "Resource exhaustion",
    examples: ["Out of memory", "Disk full", "Rate limit exceeded"],
    strategy: "SCALE_OR_DEFER",
    maxRetries: 3
  }
};

async function adaptiveRetry(operation, context) {
  const errorHistory = await getErrorHistory(context.operationId);
  const baseConfig = await getRetryConfig(context.operationType);
  
  // Adjust strategy based on historical patterns
  const adjustedConfig = adjustStrategy(baseConfig, errorHistory);
  
  let attempt = 0;
  let lastError = null;
  
  while (attempt < adjustedConfig.maxRetries) {
    try {
      const result = await operation();
      
      // Log success after previous failures
      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);
      
      // Check if retryable
      if (!isRetryable(errorType)) {
        break;
      }
      
      // Calculate delay with exponential backoff and jitter
      const delay = calculateDelay(attempt, adjustedConfig, errorType);
      
      // Update strategy for next attempt
      adjustedConfig = await updateStrategy(adjustedConfig, error, attempt);
      
      attempt++;
      await sleep(delay);
    }
  }
  
  // All retries exhausted
  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 temporarily unavailable");
      }
      this.state = "HALF_OPEN";
      this.halfOpenCalls = 0;
    }
    
    if (this.state === "HALF_OPEN" && this.halfOpenCalls >= this.halfOpenMaxCalls) {
      throw new CircuitOpenError("Circuit breaker half-open limit reached");
    }
    
    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;
    }
  }
}

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

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

// Error analysis workflow
async function analyzeErrors(timeRange = "24h") {
  const errors = await getErrors({
    timeRange,
    resolved: true
  });
  
  // Group by error type and pattern
  const patterns = groupByPattern(errors);
  
  for (const pattern of patterns) {
    // Identify root causes
    const rootCause = await identifyRootCause(pattern);
    
    // Generate preventive measures
    const prevention = await generatePrevention(rootCause);
    
    // Update workflows if confidence is high
    if (prevention.confidence > 0.8) {
      await deployPrevention(prevention);
    }
    
    // Log for manual review if medium confidence
    if (prevention.confidence > 0.5) {
      await queueForReview({ pattern, rootCause, prevention });
    }
  }
}

function optimizeContext(history, currentTask) {
  // Relevance scoring
  const scored = history.map(msg => ({
    ...msg,
    relevance: calculateRelevance(msg, currentTask)
  }));
  
  // Keep most relevant messages within token budget
  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;
    }
  }
  
  // Sort back to chronological order
  return included.sort((a, b) => a.timestamp - b.timestamp);
}

async function summarizeConversation(messages) {
  // For long conversations, create condensed representation
  if (messages.length > 20) {
    const summary = await llm.generate({
      prompt: `Summarize the key points from this conversation in 3-5 bullet points:
               ${formatMessages(messages.slice(0, -5))}`,
      maxTokens: 200
    });
    
    return [
      { role: "system", content: `Conversation summary: ${summary}` },
      ...messages.slice(-5) // Keep recent messages in full
    ];
  }
  
  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;
  
  // Check if we can downgrade based on history
  const similarTasks = await getSimilarTaskPerformance(task);
  if (similarTasks.simpleModelSuccessRate > 0.95) {
    return tiers.SIMPLE;
  }
  
  return selection;
}

function shouldRunFullLoop(execution, config) {
  // Skip for trivial tasks
  if (execution.complexity === "LOW") {
    return false;
  }
  
  // Skip if recently evaluated
  const lastEvaluation = execution.lastEvaluation;
  if (lastEvaluation && Date.now() - lastEvaluation < config.minLoopInterval) {
    return false;
  }
  
  // Skip if confidence is high
  if (execution.confidenceScore > config.confidenceThreshold) {
    return false;
  }
  
  // Always run if errors detected
  if (execution.errorCount > 0) {
    return true;
  }
  
  // Sample at configured rate
  return Math.random() < config.samplingRate;
}

// Cost 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()
  });
  
  // Alert on anomalous costs
  const avgCost = await getAverageCost(execution.workflowId, "7d");
  if (total > avgCost * 3) {
    await sendAlert({
      type: "COST_ANOMALY",
      execution: execution.id,
      cost: total,
      average: avgCost
    });
  }
  
  // Circuit breaker for excessive costs
  const dailyCost = await getDailyCost(execution.workflowId);
  const budget = await getBudget(execution.workflowId);
  if (dailyCost > budget * 0.8) {
    await activateCostLimiter(execution.workflowId);
  }
}

Agent A ───┐
           ├──▶ Shared Evaluation ▶── Coordinated Adaptation
Agent B ───┘            ▲                    │
                        └────────────────────┘

// Central coordinator manages all agent 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) {
    // Aggregate feedback across agents
    const aggregate = await this.aggregateFeedback(feedback);
    
    // Identify system-level patterns
    const patterns = await this.identifyPatterns(aggregate);
    
    // Determine coordinated adaptations
    const adaptations = await this.planAdaptations(patterns);
    
    // Distribute adaptations to agents
    for (const [agentId, adaptation] of adaptations) {
      await this.sendAdaptation(agentId, adaptation);
    }
    
    // Log coordination decisions
    await this.logCoordination({ aggregate, patterns, adaptations });
  }
  
  async identifyPatterns(aggregate) {
    // Detect when multiple agents struggle with similar tasks
    const commonIssues = aggregate.filter(a => 
      a.frequency > 1 && a.affectedAgents.length > 1
    );
    
    // Identify resource conflicts
    const conflicts = detectConflicts(aggregate);
    
    // Find optimization opportunities
    const optimizations = findOptimizations(aggregate);
    
    return { commonIssues, conflicts, optimizations };
  }
}

// Agents negotiate adaptations peer-to-peer
async function negotiateAdaptation(agentId, proposedChange) {
  // Query other agents for impact assessment
  const impacts = await Promise.all(
    peerAgents.map(peer => 
      assessImpact(peer, proposedChange)
    )
  );
  
  // If conflicts detected, negotiate compromise
  const conflicts = impacts.filter(i => i.conflict);
  if (conflicts.length > 0) {
    const compromise = await generateCompromise(proposedChange, conflicts);
    return { approved: true, adjustment: compromise };
  }
  
  // No conflicts, proceed with original
  return { approved: true, adjustment: proposedChange };
}

// Multi-level coordination
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 bubbles up, adaptations cascade down
async function hierarchicalCoordination(feedback, level) {
  const config = coordinationHierarchy[level];
  
  // Process at current level
  const adaptations = await processAtLevel(feedback, config);
  
  // Bubble up if significant
  if (adaptations.significance > threshold && level < maxLevel) {
    await hierarchicalCoordination(adaptations, level + 1);
  }
  
  // Cascade down approved adaptations
  for (const agent of config.agents) {
    await applyAdaptation(agent, adaptations);
  }
}

const conflictResolutionStrategies = {
  PRIORITY: (conflicts) => {
    // Higher priority agent wins
    return conflicts.sort((a, b) => b.priority - a.priority)[0];
  },
  
  MERGE: (conflicts) => {
    // Attempt to merge adaptations
    return attemptMerge(conflicts);
  },
  
  COMPROMISE: (conflicts) => {
    // Find middle ground
    return findCompromise(conflicts);
  },
  
  EXPERIMENT: (conflicts) => {
    // Run A/B test
    return scheduleExperiment(conflicts);
  },
  
  ESCALATE: (conflicts) => {
    // Human decision required
    return escalateToHuman(conflicts);
  }
};

Ticket received → AI generates response → Send to customer → 
Collect satisfaction → If low, analyze → Update response strategy → 
Apply to future tickets

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) => {
    // Identify common failure patterns
    const patterns = analyzePatterns(lowPerformanceInstances);
    
    // Update knowledge base gaps
    if (patterns.knowledgeGaps) {
      await queueKnowledgeUpdates(patterns.knowledgeGaps);
    }
    
    // Refine tone if complaints about communication
    if (patterns.toneIssues) {
      await updateToneGuidelines(patterns.toneIssues);
    }
    
    // Adjust escalation thresholds
    if (patterns.underEscalation) {
      await lowerEscalationThreshold();
    }
  }
};

Lead enters pipeline → AI qualifies → Personalized outreach → 
Track engagement → Measure conversion → Refine qualification criteria

const salesLoop = {
  // Delayed 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) => {
    // Update qualification model
    const newCriteria = await retrainQualificationModel(results);
    await deployQualificationModel(newCriteria);
    
    // Optimize outreach sequences
    const sequences = await optimizeSequences(results);
    await updateOutreachTemplates(sequences);
    
    // Adjust lead scoring
    await updateLeadScoringWeights(results);
  }
};

Generate content draft → Human/editor review → Publish → 
Track engagement → Analyze performance → Refine generation strategy

const contentLoop = {
  // Human-in-the-loop for quality
  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) => {
    // Identify high-performing content patterns
    const winners = performanceData.filter(p => p.conversion > threshold);
    const patterns = extractPatterns(winners);
    
    // Update content generation guidelines
    await updateContentGuidelines(patterns);
    
    // Adjust topic selection
    await updateTopicModel(patterns.topics);
    
    // Refine tone and style
    await updateStyleGuide(patterns.style);
  }
};

Developer requests code → AI generates → Developer uses → 
Track acceptance/rejection → Measure code quality → Update generation patterns

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) => {
    // Update coding patterns
    const patterns = await analyzeCodePatterns(evaluations);
    await updateCodingGuidelines(patterns);
    
    // Learn project-specific conventions
    const conventions = await extractConventions(evaluations);
    await updateProjectProfile(conventions);
    
    // Adjust for different task types
    await updateTaskTypeStrategies(evaluations);
  }
};

const governanceFramework = {
  // Approval workflows for adaptations
  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 capabilities
  rollback: {
    automaticTriggers: [
      "error_rate_increase > 50%",
      "satisfaction_decrease > 20%",
      "security_alert"
    ],
    maxRollbackTime: "24h",
    preserveState: true
  }
};

async function proposeAdaptation(proposal) {
  // Security scan
  const securityScan = await scanForSecurityIssues(proposal);
  if (securityScan.issues.length > 0) {
    return { approved: false, reason: "security_concerns" };
  }
  
  // Policy compliance check
  const compliance = await checkPolicyCompliance(proposal);
  if (!compliance.compliant) {
    return { approved: false, reason: "policy_violation", details: compliance.violations };
  }
  
  // Determine approval path
  const path = determineApprovalPath(proposal);
  
  if (path === "automatic") {
    // Deploy to canary
    await deployCanary(proposal);
    await scheduleEvaluation(proposal.id, "1h");
    return { approved: true, deployment: "canary" };
  }
  
  // Queue for manual review
  await queueForReview(proposal);
  return { approved: false, status: "pending_review" };
}

async function checkForBias(feedbackData) {
  // Check for demographic disparities
  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);
    
    // Apply correction
    await applyBiasCorrection(disparities);
    
    // Require human review before further adaptations
    await pauseAutomaticAdaptations();
  }
}

// Comprehensive audit logging
async function logAdaptationEvent(event) {
  const auditRecord = {
    timestamp: Date.now(),
    eventId: generateId(),
    eventType: event.type,
    
    // Change details
    change: {
      before: event.previousState,
      after: event.newState,
      diff: calculateDiff(event.previousState, event.newState)
    },
    
    // Decision rationale
    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);
}

// Run new adaptations alongside existing ones
async function shadowTest(adaptation) {
  // Process same input with both old and new
  const oldResult = await executeWithConfig(currentConfig, input);
  const newResult = await executeWithConfig(adaptation, input);
  
  // Compare outcomes
  const comparison = await compareResults(oldResult, newResult);
  
  // Log for analysis
  await logShadowTest({
    adaptation: adaptation.id,
    input: input.id,
    oldResult,
    newResult,
    comparison
  });
  
  // Only surface significant differences
  if (comparison.significantDifference) {
    await flagForReview({ adaptation, input, comparison });
  }
}

async function abTestAdaptation(adaptation) {
  // Split traffic
  const assignment = Math.random() < 0.5 ? "control" : "treatment";
  
  if (assignment === "treatment") {
    await applyAdaptation(adaptation);
  }
  
  // Track performance for both groups
  const performance = await trackPerformance({
    adaptation: adaptation.id,
    assignment,
    duration: "7d"
  });
  
  // Statistical significance test
  const significance = await calculateSignificance(performance);
  
  if (significance.pValue < 0.05 && performance.treatment > performance.control) {
    await fullDeployment(adaptation);
  } else {
    await rollback(adaptation);
  }
}