New customer signup → Validate email → Create CRM record → Send welcome email → Add to onboarding sequence

[2026-03-05T14:23:01] Step 1: Received webhook from payment processor
[2026-03-05T14:23:01] Step 2: Validated payment amount: $299.00
[2026-03-05T14:23:02] Step 3: Created invoice record
[2026-03-05T14:23:02] Step 4: Sent confirmation email

// Error handling in n8n
if (apiResponse.status !== 200) {
  if (apiResponse.status === 429) {
    // Rate limited — wait and retry
    await sleep(60000);
    return retry();
  }
  if (apiResponse.status === 401) {
    // Authentication failed — alert admin
    await notifyAdmin("API key expired");
    return pause();
  }
}

- If customer tier = enterprise AND contract value > $50k AND previous interactions > 3 AND sentiment = positive...
- Else if customer tier = enterprise AND contract value > $25k AND previous interactions > 5...
- Else if customer tier = mid-market AND...

"Prioritize this lead based on historical conversion patterns"

// Agent analyzes customer email
const analysis = await agent.analyze({
  content: email.body,
  task: "Determine: Is this a complaint, request for refund, technical issue, or sales inquiry?"
});

// Route based on intent
switch (analysis.intent) {
  case "complaint": return escalateToManager(email);
  case "refund": return processRefund(email);
  case "technical": return createTicket(email);
  case "sales": return assignToSales(email);
}

Customer: "I'm not happy with my subscription and want to downgrade"

Agent reasoning:
1. Customer sentiment = negative
2. Account value = $2,400 ARR
3. Downgrade risk = high (negative sentiment + downgrade request)
4. Action: Escalate to retention specialist with context
5. Temporary: Pause automated downgrade for 24 hours

// Agent chooses tools based on situation
const plan = await agent.plan({
  goal: "Help customer with account issue",
  context: customerData,
  availableTools: ["lookupAccount", "processRefund", "scheduleCall", "lookupKnowledgeBase"]
});

// Agent might use:
// - lookupKnowledgeBase (if issue is common)
// - scheduleCall (if account is high-value)
// - processRefund (if explicitly requested)

Input → LLM → Output → LLM → Output → Final result

Input → Classify → Route to specialist → Return result

Input → [LLM-1, LLM-2, LLM-3] → Vote → Final result

Orchestrator → Plan → [Worker-1, Worker-2, Worker-3] → Synthesize

Generate → Evaluate → If not good enough, revise → Repeat

// Before: Hardcoded categorization
const category = input.productType === "electronics" ? "tech" : "general";

// After: AI-enhanced
const category = await llm.classify({
  content: input.productDescription,
  categories: ["tech", "home", "clothing", "food", "other"]
});

if (isStandardCase(data)) {
  return workflow.process(data);
} else {
  return agent.escalate(data, {
    reason: "Non-standard case requiring judgment"
  });
}

const agent = new Agent({
  instructions: "Process customer refunds",
  tools: [calculateRefund, checkPolicy, sendNotification],
  guardrails: [
    { // Can't exceed $1000 without approval
      condition: (refund) => refund.amount > 1000,
      action: "requestHumanApproval"
    },
    { // Must have receipt
      condition: (refund) => !refund.hasReceipt,
      action: "requestReceipt"
    }
  ]
});

// n8n workflow with agent components

// Step 1: Receive ticket
const ticket = $input.first().json;

// Step 2: Use AI to classify urgency
const urgency = await $http.request({
  method: 'POST',
  url: 'https://api.openai.com/v1/chat/completions',
  body: {
    model: 'gpt-4',
    messages: [{
      role: 'system',
      content: 'Classify support ticket urgency: low, medium, high, critical'
    }, {
      role: 'user',
      content: ticket.description
    }]
  }
});

// Step 3: Route based on urgency
if (urgency.data.choices[0].message.content === 'critical') {
  return [{ json: { route: 'immediate-human' } }];
} else if (['high', 'medium'].includes(urgency)) {
  return [{ json: { route: 'ai-agent' } }];
} else {
  return [{ json: { route: 'kb-auto-response' } }];
}

// Use agent to extract data, workflow to validate

// Agent extracts information from messy input
const extracted = await agent.extract({
  input: messyCustomerData,
  fields: ["name", "email", "company", "phone", "address"]
});

// Workflow validates extracted data
const validations = [
  validateEmail(extracted.email),
  validatePhone(extracted.phone),
  validateCompanyExists(extracted.company)
];

if (validations.every(v => v.valid)) {
  await createCustomerRecord(extracted);
} else {
  await queueForManualReview(extracted, validations);
}

// Test cases for agents
describe("Support Agent", () => {
  it("should escalate critical security issues", async () => {
    const result = await agent.process({
      message: "I think someone unauthorized accessed my account"
    });
    expect(result.route).toBe("security-team");
    expect(result.priority).toBe("critical");
  });

  it("should handle refunds under policy", async () => {
    const result = await agent.process({
      message: "I want a refund for my purchase from 2 days ago",
      orderValue: 50
    });
    expect(result.action).toBe("approve-refund");
  });
});