A support conversation can contain a surprising amount of useful information.
The customer explains a problem. The agent suggests a solution. The customer tries it. Maybe it works. Maybe it fails. Maybe it works temporarily.
But if the next interaction starts without that information, the agent is effectively starting over.
While building Relay, we focused on one question: What if a support agent could remember the outcome of previous troubleshooting attempts and use those outcomes in future conversations?
That became the central role of memory in Relay.
The difference between remembering a conversation and remembering a case
Consider a simple support problem.
A customer says:
“My Wi-Fi keeps disconnecting.”
The agent suggests restarting the router.
The customer tries it and replies:
“It works, but only for a little while.”
There are two ways an AI system could remember this interaction.
The first is conversational memory:
Customer said Wi-Fi disconnects.
Agent suggested restarting router.
Customer said it worked temporarily.
The second is case memory:
Problem:
Wi-Fi disconnecting
Attempt:
Restart router
Result:
Temporary improvement
The second representation is much more useful for troubleshooting.
It captures not only what was said, but what was tried and what happened afterward.
That is what Relay is designed around.
Why repeating solutions is a real problem
Troubleshooting usually follows a process of elimination.
You try one thing.
If it doesn't work, you try something else.
If it works temporarily, that is also important information.
Eventually, you narrow down the possible causes.
An AI support agent without persistent memory can lose that progress between interactions.
The customer may return later and receive the same suggestion they already tried.
From the system's perspective, that suggestion may look reasonable.
From the customer's perspective, it is wasted time.
Relay attempts to preserve that troubleshooting progress.
How Hindsight fits into Relay
We use Hindsight as the memory layer behind Relay.
Hindsight GitHub
The basic idea is:
Support interaction
↓
Retain
↓
Persistent memory
↓
Recall
↓
Relevant previous cases
↓
Reason
↓
Next support action
This makes memory part of the decision-making process rather than simply an archive.
When a new support request arrives, Relay can retrieve information that is relevant to the current problem.
The agent can then use that information when deciding what to do next.
The interesting part: remembering failure
One of the most useful ideas in Relay is that failed or incomplete attempts are still worth remembering.
Imagine this sequence:
Router restart
→ Temporary improvement
Network reset
→ No improvement
Driver update
→ Problem solved
A simple chatbot might focus primarily on the successful answer.
Relay needs to remember the entire sequence.
Why?
Because if the problem happens again, the previous failures help narrow the search.
The agent shouldn't blindly return to the beginning.
It already has evidence.
A later conversation changes the behavior
Now imagine the customer returns several days later.
They describe the same Wi-Fi problem.
Relay recalls the previous case.
Instead of immediately recommending the router restart again, it can recognize:
Router restart
→ Already attempted
→ Only temporary
Driver update
→ Previously resolved the issue
That memory changes the next interaction.
This is the behavior we wanted to demonstrate with Hindsight.
The important result isn't simply that Relay can retrieve an old message.
It's that retrieved memory changes what the agent does.
Building a learning loop
We designed Relay around a simple feedback loop.
Receive problem
↓
Recall relevant history
↓
Choose troubleshooting action
↓
Get outcome
↓
Store outcome
↓
Use it in future interactions Every completed troubleshooting step can add another piece of information to the case.
Over multiple interactions, the agent can therefore build a more useful history.
This also gives the system a natural way to distinguish between different outcomes:
FAILED
TEMPORARY
SUCCESSFUL
ESCALATED
The exact outcome matters because each one should influence future decisions differently.
Escalation should also use memory
Not every support problem should be solved by an AI agent.
Sometimes the useful troubleshooting options have already been exhausted.
That's where Relay's escalation behavior comes in.
Suppose the customer has already tried several relevant solutions and the problem continues.
Instead of endlessly producing more generic suggestions, Relay can recognize that continued troubleshooting may not be useful and recommend involving a technician.
The important part is that the decision is informed by the case history.
And the escalation itself can become part of the remembered case.
That creates a complete support history:
Problem
↓
Attempt 1 → temporary
↓
Attempt 2 → failed
↓
Attempt 3 → failed
↓
Escalation → technician
A future support interaction now has access to that context.
Why this makes memory central to the product
It would be easy to add memory to a chatbot and call it a memory-powered application.
But that doesn't necessarily make memory useful.
For Relay, we wanted memory to affect the actual workflow. Without memory:
Customer → Problem → Generic troubleshooting
With memory:
Customer
↓
Problem
↓
Previous case history
↓
Previous attempts + outcomes
↓
More informed troubleshooting
That difference is the reason Hindsight is central to Relay.
What I learned
Memory is only useful when it changes behavior
The most important question isn't:
“Can the agent remember?”
It is:
“What does the agent do differently because it remembers?”
For Relay, the answer is troubleshooting. Failed solutions shouldn't disappear
A failed attempt is still useful because it tells the agent what not to repeat.
Outcomes matter
The same action can have different results.
“Restart router” followed by “problem solved” is different from “restart router” followed by “temporary improvement.”
The outcome changes the meaning of the memory.
Good support is cumulative
A customer shouldn't have to rebuild the same troubleshooting history every time they return.
A useful support agent should be able to build on previous interactions.
The idea behind Relay
Relay isn't trying to remember every sentence a customer has ever written.
It is trying to remember what happened during the case.
What was the problem?
What did we try?
What happened?
What worked?
What didn't?
And when the customer returns, what can we do differently because we already know those answers?
That's the role of memory in Relay.
The goal isn't simply for an AI agent to remember the conversation.
The goal is for it to remember what happened—and use that experience the next time.