User feedback synthesizer

I Built a Customer Support Agent That Remembers What Users Said

Most customer-support agents are good at answering the message in front of them. The harder problem starts when the same customer comes back a week later and the agent has no idea what happened before.

I wanted to build a support agent where previous conversations are not just stored as chat history, but become useful context for the next interaction. The key piece of that architecture is persistent agent memory with Hindsight.

The problem with stateless customer support agents

A conventional LLM-based support flow is straightforward:

Customer

↓

Support UI

↓

LLM

↓

Response

For a single conversation, this works reasonably well.

The problem appears across conversations.

Imagine a customer says:

“My order arrived damaged. I already contacted support yesterday and was told that a replacement would be shipped.”

If the customer returns later and asks:

“What’s happening with my replacement?”

A stateless agent has to rely on whatever information happens to be inside the current context window.

That creates several problems:

I approached the problem differently: make important customer interactions persistent memories and retrieve them when they become relevant.

That is where Hindsight fits into the architecture.

The architecture

The customer support system separates the user-facing application, agent reasoning and persistent memory.

                Customer
                   │
                   ▼
          Support Chat Interface
                   │
                   ▼
             Support Agent
                   │
         ┌─────────┴─────────┐
         │                   │
         ▼                   ▼
   Current Context       Hindsight Memory
         │                   │
         │             ┌─────┴─────┐
         │             │           │
         │          Retain       Recall
         │             │           │
         └─────────────┴───────────┘
                   │
                   ▼
             Final Response

The important change is that Hindsight is not treated as another prompt template.

It becomes the memory layer between conversations.

Hindsight provides three core operations: retain, recall and reflect. Retain processes information into structured memories, recall searches those memories, and reflect can synthesize a response from relevant memories.

What I actually want the agent to remember

I quickly found that remembering everything is not the same as having useful memory.

For customer support, useful memories can include:

For example:

Customer: Priya

Issue:

Laptop battery drains quickly.

Previous troubleshooting:

Power settings were reset.

Support outcome:

Customer was asked to monitor battery performance

for two days.

Follow-up:

Customer returned because the issue continued.

The next time Priya contacts the system, the agent does not need to start from zero.

It can retrieve the relevant history and continue from there.

Retaining a conversation

The basic memory loop is simple.

When an interaction contains information worth keeping, it is retained in the customer’s memory bank.

A simplified integration looks like this:

def remember_conversation(customer_id, conversation):

hindsight.retain(

    bank_id=customer_id,

    content=conversation,

    context="customer support conversation"

)

The important part is that I don’t need to manually convert every sentence into a database record.

Hindsight processes retained content and extracts structured memories, entities and relationships that can later be retrieved.

That is a useful distinction from simply dumping transcripts into a vector database.

The memory layer can preserve facts and relationships rather than treating the entire conversation as one giant text blob.

Recalling the right context

When a customer sends a new message, the agent can first search memory for relevant information.

def get_customer_context(customer_id, query):

memories = hindsight.recall(

    bank_id=customer_id,

    query=query

)

return memories

For example, the current message might be:

"Is my replacement ready?"

A keyword search alone might not be enough.

The relevant previous memory could contain:

Customer reported a damaged product.

Support approved a replacement.

Customer was told the replacement would be dispatched.

Hindsight’s recall process combines multiple retrieval approaches, including semantic, keyword, graph and temporal retrieval.

That matters in support because customers rarely repeat the exact wording they used previously.

Memory becomes part of the agent’s context

The final step is combining the current request with the retrieved memories.

Conceptually:

memories = get_customer_context(

customer_id,

user_message

)

prompt = f"""

You are a customer support agent.

Relevant customer history:

{memories}

Current customer message:

{user_message}

Respond clearly and avoid asking for information

that is already available in the customer history.

"""

response = llm.generate(prompt)

This creates a different interaction model.

Instead of:

Message → LLM → Answer

the flow becomes:

Message

↓

Recall relevant memories

↓

Combine memory + current request

↓

LLM

↓

Context-aware answer

That small architectural change is where most of the value comes from.

Before and after

Consider a customer who previously reported the same issue.

Without persistent memory

Customer:

My payment failed again.

Agent:

I’m sorry you’re experiencing this. Could you provide your order number and explain when the payment failed?

The customer has already explained the problem in a previous conversation.

Now they have to do it again.

With persistent memory

The agent retrieves the previous support interaction.

It can respond along the lines of:

I remember that you previously had a payment failure while using your saved card. Since the issue has happened again, let’s check the transaction status and work through the next step.

The difference is not that the model suddenly became more intelligent.

The difference is that the model has access to the right history at the right time.

Why I chose persistent agent memory

One of the biggest lessons from building this system was that conversation history and memory are different things.

A transcript answers:

“What was said?”

A useful memory system should help answer:

“What from the past matters to what is happening now?”

That distinction influenced how I designed the support agent.

Hindsight’s memory model is designed around extracting structured memories from retained information and making them available through recall and reflection.

It also supports timestamps and temporal grounding, which is particularly useful for support workflows where the sequence of events matters.

Monday:

Customer reported issue.

Tuesday:

Support requested additional information.

Wednesday:

Customer provided the information.

Thursday:

Replacement approved.

Friday:

Customer asks for an update.

The order matters.

A support agent shouldn’t treat these five events as unrelated pieces of text.

Memory should be selective

Another lesson was that persistent memory needs boundaries.

I don’t want the system to blindly remember every greeting or temporary piece of conversation.

Useful memory should be information that can help future interactions.

Useful:

"Customer prefers email communication."

Useful:

"Customer already completed troubleshooting step X."

Useful:

"Replacement was approved on September 20."

Less useful:

"Hello."

Less useful:

"Thanks."

Less useful:

"Okay, I'll check."

Hindsight supports a retain mission that can steer what the memory system should focus on during extraction.

For a customer-support memory bank, that means I can conceptually define a mission around issues, preferences, resolutions, commitments and customer context rather than treating every conversational sentence equally.

The support agent is more than a chatbot

Once memory is available, the system can support workflows beyond simple question answering.

Returning customers

The agent can retrieve relevant previous interactions instead of restarting the conversation.

Repeated issues

If the same customer repeatedly reports a problem, previous cases become useful context.

Follow-ups

The agent can use previous commitments and events when answering questions about ongoing cases.

Personalization

Stable customer preferences can influence future interactions.

Escalation

When a case needs a human agent, relevant history can be supplied instead of forcing the customer to repeat the entire story.

The important point is that these capabilities emerge from the same underlying memory mechanism.

What surprised me

The most interesting part wasn’t getting the first response to work.

That part is relatively easy.

The interesting part was thinking about what should happen after the conversation ends.

A normal chatbot treats the end of a conversation as the end of its useful context.

A memory-enabled agent treats the end of a conversation as another opportunity to learn something that may matter later.

That changes how I think about agent architecture.

The LLM is responsible for reasoning about the current request.

The memory layer is responsible for making previous experience available when it is relevant.

Those are different responsibilities, and keeping them separate makes the system easier to reason about.

Lessons I took away

Putting more conversation history into a prompt does not automatically create a good memory system.

The important question is which previous information is relevant now.

A support agent should not retain everything indiscriminately.

The memory system should have a clear purpose and useful retrieval boundaries.

A memory-enabled agent is only useful if it can retrieve the right information.

That makes recall strategy an important part of the application architecture rather than an implementation detail.

Customer support is inherently temporal.

Knowing what happened is useful.

Knowing what happened before what can be even more useful.

Adding persistent memory isn’t simply adding another service to the architecture.

It changes the interaction itself.

The customer no longer has to assume that every conversation begins from zero.

Building agents that remember

The customer support agent started with a simple goal: answer support questions.

The more interesting version is an agent that can maintain useful context across interactions without requiring the customer to repeat themselves.

That requires a memory layer designed specifically for agents.

For this project, I used Hindsight agent memory on GitHub for that layer. Its documentation covers the Hindsight memory API and retain/recall workflow, while Vectorize also provides a useful explanation of how agent memory works.

The architectural idea is simple:

                ┌─────────────────┐
                │    Customer     │
                └────────┬────────┘
                         │
                         ▼
                ┌─────────────────┐
                │ Support Agent   │
                └────────┬────────┘
                         │
             ┌───────────┴───────────┐
             │                       │
             ▼                       ▼
      Current Request        Hindsight Memory
                                     │
                              ┌──────┴──────┐
                              │             │
                           Retain         Recall
                              │             │
                              └──────┬──────┘
                                     │
                                     ▼
                              Relevant Context
                                     │
                                     ▼
                              Agent Response

The code required to connect an LLM to a support interface is not the hardest part.

The harder engineering problem is deciding what the agent should remember, when it should retrieve it, and how that memory should change its next action.

That’s the part I found most interesting about building a customer support agent with persistent memory.

source & further reading

dev.to — original article UI Architecture That AI Coding Agents Can Actually Use Zet: an open-source layer on Laya that knows when to ask a human Six Signatures, Zero Laws: What the White House Super Intelligence Accord Actually Requires