A returning customer is not a stranger

The shape of it

Want to build a support agent that already knows who is writing? Here is how

How you build it

Six steps, and the last one is the part you skip

1. 1
   Wire up the agent itself. You already have Claude Code or Cursor, so spin up the bot in whatever you use for helpdesk and chat: a Zendesk or Intercom integration, a custom widget, a Slack or WhatsApp bridge. This part is the easy part and you can do it today.
2. 2
   Identify the customer before the first reply. When a message comes in, take the email or customer ID and look up everything you already know about that person: open tickets, past issues, the channel they wrote from last time, their plan, their mood on the last contact. This is one read call, and it has to be fast or the chat feels laggy.
3. 3
   Feed that context into the prompt. Open the conversation already informed. Instead of "Hi, how can I help you today," the agent can say "Hi Marco, is this still about the failed export from Tuesday?" That single line is the whole difference between a bot people tolerate and one they trust.
4. 4
   Let the agent write down what it learns. The customer mentions they are on the new billing plan, that they prefer email over phone, that the bug only happens on Safari. The agent saves those as facts the moment they come up, so the next agent or the next session starts from there.
5. 5
   Handle the truth changing over time. Yesterday the ticket was open, today it is resolved. Yesterday they were a trial user, today they pay. Memory cannot just pile up old notes, it has to know what is true right now and resolve the contradiction when "use my work email" becomes "actually use my personal one," keeping a trail of when it changed in case billing asks later.
6. 6
   Skip the hard part. A bi-temporal, graph-backed agentic memory that recognises a returning customer, tracks issue history, knows the preferred channel, handles facts that change, and resolves contradictions, all answered in under fifty milliseconds. With Korely you skip building that infrastructure yourself. You call add to save what the agent learns and search to recall it. It starts at nineteen euro a month and it saves you weeks of building plus the ongoing cost of running it.

How Korely fits

The memory layer that makes a support agent feel like it remembers people

Show me the code

Save on close, read on open

# ── On ticket close ────────────────────────────────────────────
from korely_memory import Korely

korely = Korely(api_key="kor_live_...")

korely.add(
    f"Ticket #{ticket.id}: customer reported CSV export failing on "
    f"order {ticket.order_id}. Resolution: fixed, marked resolved "
    f"2026-03-04. Prefers email over chat.",
    agent_id=f"brand-{brand_id}",
    metadata={"customer_id": hash(customer.email)},
)

# ── On ticket open: search before the agent greets ─────────────
history = korely.search(
    f"history customer {customer.email}",
    agent_id=f"brand-{brand_id}",
)

if history:
    greeting = build_warm_greeting(history)   # "Hi again, the Friday export is sorted..."
else:
    greeting = build_first_time_greeting()

The same memory is reachable from any agent, Zendesk, Intercom, Slack, WhatsApp, or a plain HTTP client. Scope memories with different agent_id values to keep each brand customer history separate and auditable.

Frequently asked

Support memory, common questions