I Built Customer Support That Remembers with Hindsight
The first time a customer contacts support, an AI agent can usually handle the conversation. The interesting problem starts when that same customer comes back later and the agent has forgotten everything.
I built MEMORA to solve that problem.
MEMORA is a persistent-memory customer support agent that uses Hindsight to retain useful information from previous conversations, recall relevant memories later, and use that context when responding to the customer.
The goal was simple: a returning customer should not have to explain the same problem twice.
The Problem With Starting From Zero
A typical support conversation looks something like this:
Customer: My payment failed while upgrading to Pro. I'm using Android.
The agent can respond with troubleshooting steps. That part isn't particularly difficult.
But imagine the customer returns later and says:
I'm having the payment problem again.
Without persistent memory, the agent has very little context. It needs to ask the customer what happened, what device they used, what they tried, and whether anything worked previously.
From the customer's perspective, this feels repetitive.
I wanted MEMORA to behave differently.
If the previous conversation established that the customer was using Android and that completing checkout through the website worked, the next conversation should be able to use that information.
That became the core design principle:
A support agent should remember useful experiences, not just the current conversation.
Where Hindsight Fits
I used Hindsight as the memory layer behind MEMORA.
The architecture is intentionally small:
Customer
↓
Current conversation
↓
Hindsight Recall
↓
MEMORA Support Agent
↓
Personalized response
↓
Hindsight Retain
↓
Future conversations
There are two important operations in this loop.
Recall retrieves relevant information from previous interactions.
Retain stores useful information from the current interaction so it can become part of the agent's future context.
This is different from simply putting the entire conversation into a prompt. The memory system gives the application a dedicated place to retain information that can be useful later.
For the project, I used the Hindsight JavaScript client:
const hindsight = new HindsightClient({
baseUrl: process.env.HINDSIGHT_API_URL,
apiKey: process.env.HINDSIGHT_API_KEY
});
The API credentials stay in environment variables rather than being committed to the repository.
The Recall Step
When a customer sends a message, MEMORA first asks Hindsight for relevant memories.
The important part of the implementation is small:
const memories = await hindsight.recall(
BANK_ID,
message,
{ limit: 5 }
);
The customer's current message becomes the query.
For example:
"I'm having the payment problem again."
can retrieve memories related to the customer's previous payment issue.
The application displays these recalled memories in the interface so the memory process is visible instead of being hidden behind the chatbot.
The UI shows:
Memory System: Hindsight
Memory Bank: memora-support
Memory recalled status
Relevant recall entries
This made debugging much easier because I could see whether the agent was actually retrieving useful information.
The Agent Response
After recalling context, MEMORA uses Hindsight's reasoning capability to generate the support response.
The application gives the agent a clear instruction:
const response = await hindsight.reflect(
BANK_ID,
`You are MEMORA, a helpful customer support agent.
Use the customer's previous interactions when relevant.
If a previous solution worked, mention it naturally.
Do not invent customer history that is not present in memory.
Current customer message:
${message}
Respond as a friendly, concise customer support agent.`
);
One rule here is particularly important:
Do not invent customer history that is not present in memory.
Persistent memory is only useful if the information retrieved from it can be trusted.
The goal isn't to make the agent pretend it knows everything about a customer. The goal is to use information that actually exists in its memory.
Retaining the New Interaction
After the response is generated, MEMORA stores the new interaction.
await hindsight.retain(
BANK_ID,
`Customer said: ${message}
MEMORA responded: ${response.text}`
);
Now the current interaction can become context for a future conversation.
That completes the loop:
Customer Message
↓
RECALL
↓
Agent Response
↓
RETAIN
↓
Future Interaction
↓
RECALL
This is what makes the system interesting to me.
MEMORA isn't simply producing isolated answers.
Each useful interaction can contribute to what the agent knows during later conversations.
For a deeper explanation of why persistent context matters for agents, the Vectorize guide to agent memory provides useful background.
Seeing the Memory in Action
I tested MEMORA with a simple customer-support scenario.
Interaction 1
The customer says:
"My payment failed while upgrading to Pro. I'm using Android."
MEMORA handles the payment issue and suggests completing checkout through the website.
The interaction is then retained by Hindsight.
Interaction 2
Later, the customer says:
"I'm having the payment problem again."
This time MEMORA doesn't have to treat the message as completely new.
It can recall the previous payment problem and the solution that was already suggested.
The response can therefore naturally reference the previous experience:
"I'm sorry you're running into that payment issue again. As we found earlier, completing checkout through our website is a reliable workaround for the issue on Android."
At the same time, the Hindsight Memory panel displays the relevant recalled information.
[ADD SCREENSHOT 2 HERE — MEMORA showing the repeated payment problem and recalled memories]
This is the difference I wanted to demonstrate.
Without persistent memory
Customer: I'm having the payment problem again.
Agent: Could you explain what payment problem
you're experiencing?
With persistent memory
Customer: I'm having the payment problem again.
MEMORA: You experienced a similar payment issue
previously. The website checkout workaround worked
before, so let's try that again.
The second response isn't useful because it is longer.
It's useful because the customer doesn't need to repeat information the system has already learned.
Why Not Just Send the Entire Chat History?
One obvious solution would be to continuously send previous conversations to the model.
That can work for small conversations, but it doesn't solve the broader memory problem very elegantly.
As interactions accumulate, the application needs a way to decide:
What information is worth remembering?
What previous information is relevant now?
What should be retrieved for this specific interaction?
How can useful experience persist beyond one conversation?
That's why I wanted memory to be its own layer.
Instead of thinking only about:
User → AI → Response
MEMORA works around a continuing loop:
┌───────────────┐
│ Customer │
└───────┬───────┘
↓
┌───────────────┐
│ MEMORA │
└───────┬───────┘
↓
┌───────────────┐
│ Hindsight │
│ Recall/Retain │
└───────┬───────┘
↓
┌───────────────┐
│ Response │
└───────┬───────┘
│
└────→ Future Conversation
[OPTIONAL: ADD ARCHITECTURE DIAGRAM HERE]
What I Learned Building MEMORA
Building MEMORA changed how I think about agent memory.
- Storing information isn't enough
A system can store thousands of conversations and still provide a poor experience.
Memory becomes valuable when previously stored information actually changes a future response in a useful way.
The real test isn't:
"Did we save the conversation?"
It's:
"Did remembering the conversation make the next interaction better?"
- Memory should be observable
Showing recalled memories in the MEMORA interface turned out to be extremely useful.
When testing the system, I can see what Hindsight retrieved instead of treating memory as a black box.
For developers building memory-based agents, I think this kind of visibility is extremely valuable.
- Agents shouldn't pretend to remember
Persistent memory can make an agent feel much more personal, but incorrect memory can also damage trust.
That's why I explicitly instruct MEMORA not to invent customer history.
The goal isn't to make the agent appear all-knowing.
The goal is to use real previous context when it is relevant.
- Start with one clear workflow
There are many possible applications for persistent agent memory.
Instead of trying to solve all of them, I focused on one:
customer support.
That made it much easier to answer an important question:
What should memory actually improve?
For MEMORA, the answer is straightforward:
Returning customers should receive better support because previous interactions aren't forgotten.
- The memory loop matters more than the chat interface
The chat interface is what users see.
But the part I find most interesting is happening behind it:
RECALL → RESPOND → RETAIN → RECALL
That's what allows previous interactions to influence future ones.
Where I Want to Take MEMORA Next
The payment scenario is a simple example, but the same architecture can extend to much richer support workflows.
A support agent could remember:
recurring customer issues,
device or environment information,
troubleshooting steps already attempted,
solutions that previously worked,
product preferences,
unresolved problems,
and relevant context from earlier support interactions.
There are also important engineering questions to explore further.
What information deserves long-term memory?
When should old information be ignored?
How should contradictory memories be handled?
How do you give users visibility and control over what an agent remembers?
Those problems become increasingly important as agents move from single conversations toward longer-running relationships with users.
Final Thought
The biggest lesson I took from building MEMORA is surprisingly simple:
The value of an AI agent isn't only in what it can answer right now. It's also in what it can remember for next time.
A customer shouldn't have to repeatedly explain the same problem.
A support agent should be able to learn from useful previous interactions and apply that experience when it becomes relevant again.
That's what I wanted MEMORA to demonstrate.
Using Hindsight gave me a practical way to build that persistent memory loop:
Recall what matters. Respond with context. Retain what may matter later.
And when the customer comes back, don't start from zero.
Top comments (0)