How Relay Uses Memory to Stop Repeating Failed Support Steps

Zoha Fatima — Tue, 29 Sep 2026 05:35:14 +0000

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.

Conversational memory

Customer said Wi-Fi disconnects.
Agent suggested restarting router.
Customer said it worked temporarily.

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.

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 prob

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.»

DEV Community: Zoha Fatima

How Relay Uses Memory to Stop Repeating Failed Support Steps