Build an AI Agent Error Triage Pipeline with n8n, Gemini & Slack

┌─────────────────────────────────────────────────────────────┐
│              n8n AI Agent Triage Workflow                    │
│                                                             │
│  [Webhook: POST /agent-error-triage]                        │
│       ↓                                                     │
│  Accepts: Sentry native payload OR { message: "..." }       │
│       ↓                                                     │
│  [Extract & Dedup Code Node]                                │
│       → Normalize payload (title, culprit, stack_trace)     │
│       → Build fingerprint (hash of identifying fields)      │
│       → Check 30-min in-memory suppression window           │
│       ↓              ↓                                      │
│  [isDuplicate=true]  [isDuplicate=false]                    │
│       ↓                    ↓                                │
│  [Skip No-Op]    [Classify with Gemini]                     │
│                       ↓                                     │
│              Structured Output Parser                        │
│              → { category, confidence, severity,            │
│                  summary, reasoning }                        │
│                       ↓                                     │
│              [Build Triage Report Code Node]                │
│              → Map category → fix playbook                  │
│              → Assemble Slack message                       │
│                       ↓                                     │
│              [Post Triage Report: Slack Node]               │
│              → #agent-alerts channel                        │
└─────────────────────────────────────────────────────────────┘

{
  "data": {
    "event": {
      "title": "ToolCallError: Timeout on /api/crm",
      "culprit": "agent.tool_executor.call_external",
      "exception": {
        "values": [{ "stacktrace": { "frames": [...] } }]
      }
    }
  }
}

{
  "message": "Agent failed: context limit exceeded after 47 tool calls"
}

// Code Node — Extract & Dedup
const input = $input.first().json;

// Handle both Sentry and generic payloads
let title, culprit, stackTrace;

if (input.data?.event) {
  // Sentry native format
  const event = input.data.event;
  title = event.title || 'Unknown Error';
  culprit = event.culprit || '';
  const frames = event.exception?.values?.[0]?.stacktrace?.frames || [];
  stackTrace = frames.map(f => `${f.filename}:${f.lineno} in ${f.function}`).join('\n');
} else {
  // Generic format
  title = input.message || 'Unknown Error';
  culprit = input.culprit || '';
  stackTrace = input.stack_trace || '';
}

// Build fingerprint — hash of identifying fields (not timestamps/IDs)
const fingerprintSource = `${title}::${culprit}::${stackTrace.substring(0, 200)}`;
const fingerprint = fingerprintSource.split('').reduce((hash, char) => {
  return ((hash << 5) - hash) + char.charCodeAt(0);
}, 0).toString(36);

// Check 30-minute suppression window using n8n static data
const staticData = $getWorkflowStaticData('global');
const seen = staticData.seenFingerprints || {};
const now = Date.now();
const windowMs = 30 * 60 * 1000; // 30 minutes

// Clean expired entries
Object.keys(seen).forEach(fp => {
  if (now - seen[fp] > windowMs) delete seen[fp];
});

const isDuplicate = !!seen[fingerprint];

if (!isDuplicate) {
  seen[fingerprint] = now;
}

staticData.seenFingerprints = seen;

return [{
  json: { title, culprit, stackTrace, fingerprint, isDuplicate }
}];

isDuplicate == true  → Skip (No-Op node, logs fingerprint)
isDuplicate == false → Continue to classification

You are an AI agent error classifier. Classify the error into exactly one of these categories:

1. tool_call_failure — A call to an external API, database, function, or tool failed outright. Look for timeout errors, HTTP 4xx/5xx codes, connection refused, or authentication failures in tool calls.

2. context_window_exhaustion — The model's context limit was reached. Look for "context length exceeded", "max tokens", or errors after long chains of tool calls with no summarisation.

3. state_corruption — The agent's internal memory or task state is in an unexpected condition. Look for key errors on expected state fields, type mismatches in state objects, or missing required state values.

4. retry_loop — The agent is stuck repeating the same failed action without progress. Look for repeated identical tool calls, loop detection errors, or max retry exceeded messages.

5. uncertain — The error doesn't clearly fit any category above. Use this when evidence is ambiguous or the error message lacks enough context to classify confidently.

Rules:
- Choose uncertain rather than force a bad fit
- Base classification only on evidence in the error, not assumptions
- Confidence should reflect actual evidence strength, not optimism

Return ONLY valid JSON:
{
  "category": "tool_call_failure|context_window_exhaustion|state_corruption|retry_loop|uncertain",
  "confidence": 0.0-1.0,
  "severity": "low|medium|high|critical",
  "summary": "One sentence plain-language description of what happened",
  "reasoning": "Why you chose this category based on specific evidence in the error"
}

// Code Node — Build Triage Report
const { category, confidence, severity, summary, reasoning } = $input.first().json;
const { title, culprit, stackTrace } = $('Extract & Dedup').first().json;

const playbooks = {
  tool_call_failure: [
    '1. Check external service status page for outages',
    '2. Review tool call logs for HTTP status codes and timeouts',
    '3. Verify API credentials and rate limit headers',
    '4. Add retry with exponential backoff if not already present'
  ],
  context_window_exhaustion: [
    '1. Add conversation summarisation step before context limit is reached',
    '2. Review tool call chain length — reduce unnecessary calls',
    '3. Implement sliding window for conversation history',
    '4. Consider chunking long tool outputs before adding to context'
  ],
  state_corruption: [
    '1. Add state validation checks at each agent step',
    '2. Review state schema for missing required fields',
    '3. Check for race conditions in concurrent agent runs',
    '4. Add state recovery logic or restart from last valid checkpoint'
  ],
  retry_loop: [
    '1. Implement loop detection — track repeated tool call signatures',
    '2. Set max retry limit with circuit breaker',
    '3. Add fallback action when retry limit is reached',
    '4. Review condition for loop exit — is the success criteria reachable?'
  ],
  uncertain: [
    '1. Review full stack trace manually — insufficient context for classification',
    '2. Improve agent error logging to include more diagnostic detail',
    '3. Check recent deployments for changes that could explain the failure',
    '4. Escalate to senior engineer if pattern recurs'
  ]
};

const severityEmoji = {
  critical: '🔴',
  high: '🟠',
  medium: '🟡',
  low: '🟢'
};

const confidenceBar = confidence >= 0.8 ? 'High' : confidence >= 0.5 ? 'Medium' : 'Low';
const playbook = playbooks[category] || playbooks.uncertain;

// Build Slack Block Kit message
const blocks = [
  {
    type: 'header',
    text: {
      type: 'plain_text',
      text: `${severityEmoji[severity] || '⚪'} AI Agent Error Triage Report`
    }
  },
  {
    type: 'section',
    fields: [
      { type: 'mrkdwn', text: `*Category:*\n${category.replace(/_/g, ' ').toUpperCase()}` },
      { type: 'mrkdwn', text: `*Severity:*\n${severity.toUpperCase()}` },
      { type: 'mrkdwn', text: `*Confidence:*\n${confidenceBar} (${(confidence * 100).toFixed(0)}%)` },
      { type: 'mrkdwn', text: `*Culprit:*\n${culprit || 'Unknown'}` }
    ]
  },
  {
    type: 'section',
    text: { type: 'mrkdwn', text: `*Error:*\n${title}` }
  },
  {
    type: 'section',
    text: { type: 'mrkdwn', text: `*Summary:*\n${summary}` }
  },
  {
    type: 'section',
    text: { type: 'mrkdwn', text: `*AI Reasoning:*\n${reasoning}` }
  },
  {
    type: 'section',
    text: {
      type: 'mrkdwn',
      text: `*Suggested Fix Steps:*\n${playbook.join('\n')}`
    }
  },
  { type: 'divider' }
];

return [{ json: { blocks, category, severity, confidence } }];

// Error branch — uncertain fallback
const errorContext = {
  timestamp: new Date().toISOString(),
  stage: $input.first().json.failedNode || 'classification',
  rawError: $input.first().json.error?.message || 'Unknown',
  originalTitle: $('Extract & Dedup').first().json?.title || 'Unknown'
};

// Override with uncertain classification
return [{
  json: {
    category: 'uncertain',
    confidence: 0,
    severity: 'medium',
    summary: 'Classification failed — manual review required',
    reasoning: `Workflow error at ${errorContext.stage}: ${errorContext.rawError}`,
    ...errorContext
  }
}];

const windowMs = 30 * 60 * 1000; // Adjust this value

[Build Triage Report]
       ↓
[IF severity == critical]
       ↓
[Send approval email: Proceed / Escalate]
       ↓
[n8n Wait Node]
       ↓
[Webhook: receives decision]
       ↓
[Route to downstream automation]

[Post to Slack]
       ↓
[Jira: Create Issue] OR [Linear: Create Issue]
Fields: title=error title, label=category, priority=severity