The support desk that remembers.

Seven nodes, left to right. #

A ticket arrives, past tickets are looked up, an AI model classifies it, a repeat score is computed, and the ticket is routed or answered with a drafted reply.

The whole workflow saves as one JSON file you can keep in git, and every run's inputs and outputs can be inspected in the execution log.

{
  "type": "object",
  "required": ["category", "severity"],
  "properties": {
    "category": { "enum": ["hardware", "software", "network", "logistics", "other"] },
    "severity": { "enum": ["low", "medium", "high"] },
    "device":   { "type": "string" },
    "likely_fix": { "type": "string" }
  }
}

// Same device + category at this location in the last 90 days
const t = $('AI Agent').first().json.output;
const cutoff = Date.now() - 90 * 864e5;
const repeats = $('Past tickets').all()
  .map(i => i.json)
  .filter(p => p.category === t.category && p.device === t.device
            && new Date(p.opened_at).getTime() >= cutoff).length;
return [{ json: { ...t, repeats, escalate: t.severity === 'high' || repeats >= 3 } }];

Node 5 then only has to check one boolean, escalate. That's the point to make out loud: the model never decides who gets paged.

Click through the workflow. A simulated n8n editor you can run in this page. #

Pick one of the five scripted calls, press Execute workflow, and watch the ticket move node by node. Click any node to open it and see what went in, what the node is set to, and what came out. Run a few, then open the Executions tab, which is where you'd go on stage to show that nothing is magic.

One command the morning of the session. Have Claude Code build this kit for you. #

The goal: the presenter types one command and everything is ready. Ask Claude Code to build it in a folder such as ~/n8n-demo/ and keep it in git.

# n8n Community Edition for the demo laptop. Pin the version you rehearsed on.
services:
  n8n:
    image: docker.n8n.io/n8nio/n8n:2.45.7
    ports:
      - "5678:5678"
    environment:
      - GENERIC_TIMEZONE=America/New_York
      - TZ=America/New_York
      - N8N_ENCRYPTION_KEY=${N8N_ENCRYPTION_KEY}   # keep it in .env, out of git
    volumes:
      - n8n_data:/home/node/.n8n
    restart: unless-stopped
volumes:
  n8n_data:

#!/usr/bin/env bash
# Usage: ./fire.sh 1   (sends call 1 of 5 to the running workflow)
set -euo pipefail
TEXT=$(sed -n "${1}p" calls.txt)
curl -s -X POST http://localhost:5678/webhook/ticket \
  -H 'Content-Type: application/json' \
  -d "$(jq -n --arg t "$TEXT" '{store: "9001", text: $t}')" | jq .

The five scripted calls

All synthetic. Store numbers like 9001 are made up; write tickets that look like the ones your desk actually gets.

1. "Store 9001: the left window LED is flickering again"Fifth repeat → escalated, flagged "recurring, consider replacement."
2. "Smart shopper screen image upside down after reboot"New issue, medium severity → automatic reply with the known fix.
3. "Demo tablet stuck in a kiosk login loop"Routed to the mobile device management queue.
4. "Got a replacement TV but nobody scheduled the install"Not a device fault → routed to logistics, with a polite reply.
5. A messy, all-caps, two-issue rantShows the model splitting it into two categories. It gets a laugh and makes the point.

The same workflow in LangGraph. Five nodes and one conditional edge. #

If someone asks "why not just write it?", show them. This follows LangChain's current docs (with_structured_output, StateGraph, add_conditional_edges). It was run on langchain 1.4.7 and langgraph 1.2.18 with a stubbed model and routed correctly: one past match went to a drafted reply, three matches escalated.

# pip install langchain langgraph langchain-openai   (any tool-calling chat model works)
from typing import Literal
from typing_extensions import TypedDict
from pydantic import BaseModel
from langchain.chat_models import init_chat_model
from langgraph.graph import StateGraph, START, END

class Triage(BaseModel):
    category: Literal["hardware", "software", "network", "logistics", "other"]
    severity: Literal["low", "medium", "high"]

class State(TypedDict, total=False):
    ticket: str
    past: list[str]
    triage: Triage
    repeat_score: float
    reply: str

llm = init_chat_model("openai:gpt-5.5")          # swap in any provider:model string
classifier = llm.with_structured_output(Triage)  # returns a validated Triage object

def lookup(s: State):   return {"past": search_past_tickets(s["ticket"])}  # your DB / vector search
def classify(s: State): return {"triage": classifier.invoke(f"Classify this ticket:\n{s['ticket']}")}
def score(s: State):    return {"repeat_score": min(1.0, len(s["past"]) / 3)}
def draft(s: State):    return {"reply": llm.invoke(f"Draft a reply to:\n{s['ticket']}\nSimilar: {s['past']}").content}
def escalate(s: State): return {"reply": "ESCALATED to on-call"}

def route(s: State) -> str:
    return "escalate" if s["triage"].severity == "high" or s["repeat_score"] >= 0.67 else "draft"

g = StateGraph(State)
for name, fn in [("lookup", lookup), ("classify", classify), ("score", score), ("draft", draft), ("escalate", escalate)]:
    g.add_node(name, fn)
g.add_edge(START, "lookup"); g.add_edge("lookup", "classify"); g.add_edge("classify", "score")
g.add_conditional_edges("score", route, ["draft", "escalate"])
g.add_edge("draft", END); g.add_edge("escalate", END)
app = g.compile()
# app.invoke({"ticket": "The window display is flickering again"})

search_past_tickets is a placeholder for your own database or vector search.

n8n or LangChain, side by side

Risks and controls. For the stage, and for the week after. #

Questions to be ready for. #