What Building SupportMind Taught Us About AI Agents

samalakavya115-kavi — Mon, 28 Sep 2026 23:36:55 +0000

Hackathons have a way of turning simple ideas into surprisingly interesting engineering problems.

Our starting idea sounded straightforward:

Build an AI customer-support agent that remembers customers.

Then we started asking questions.

What exactly should it remember?

How does it retrieve the right memory?

How do we prevent customer histories from mixing?

What happens when there is no memory?

How do we show that memory actually improved the response?

Those questions shaped SupportMind, our hackathon project.

I'm Samala Kavya, and here are some of the most useful things we learned while building it.

Lesson 1: An LLM and an agent aren't the same thing

An LLM can generate a response.

But an application around the LLM can decide what information it sees, what tools it can use, what it stores, and what happens after it responds.

For SupportMind, the language model handles the conversation while our application manages customer-specific memory.

That separation helped us think about the system more clearly.

Lesson 2: More context isn't always the goal

Our first instinct could have been to keep sending the entire customer conversation history to the model.

That works for small demonstrations.

But imagine a customer with hundreds of interactions.

Most of those conversations may have nothing to do with today's problem.

Instead, SupportMind recalls relevant memories based on the current message.

The goal becomes:

Give the model useful context, not simply more context.

Lesson 3: Identity matters

Long-term memory becomes dangerous if memories aren't separated correctly.

If Priya's WiFi history appears in Ramesh's support conversation, the feature becomes a problem instead of a solution.

So our architecture uses a customer identifier as the memory-bank identifier.

hindsight.recall(
bank_id=customer_id,
query=message
)

That simple design choice is fundamental to the prototype.

Lesson 4: Test zero memory first

We naturally wanted to demonstrate returning customers because that is where the project looks impressive.

But every returning customer was once a new customer.

So the empty-memory state matters.

If nothing relevant is recalled, SupportMind tells the model that this is a new customer with no previous history.

The agent can then respond normally instead of pretending to know something it doesn't.

Lesson 5: Make AI behavior observable

One feature we particularly liked was displaying recalled memories beside the conversation.

Suppose the assistant says:

“The firmware update that solved your previous problem may be relevant again.”

The interface can show the previous memory responsible for that context.

This made development and testing easier because we could inspect what information was being passed to the model.

Lesson 6: Summaries can be more useful than raw history

Long-term memory is useful, but a support representative may not want to inspect every individual memory.

That led us to the customer briefing feature.

Using reflection, SupportMind can transform previous interactions into a short summary containing important issues and successful fixes.

This gave us two ways of using memory:

Recall helps answer the current question.

Reflect helps understand the customer more broadly.

Our prototype stack

We kept the architecture relatively simple.

Flask handles the web application and API routes.

Hindsight handles customer memory.

Groq with gpt-oss-120b generates support responses.

The frontend demonstrates customer selection, chat, recalled memories, comparison, and customer briefings.

The result isn't a full customer-support platform.

It is a focused prototype designed to answer one question:

What changes when an AI support agent can remember?

Current limitations

There are several things we intentionally left outside the hackathon prototype.

The customers and tickets are sample data.

The assistant provides advice but cannot access real customer accounts.

It cannot directly issue refunds, modify subscriptions, or perform account actions.

Those limitations also point toward the next stage of the project.

A more complete system could combine memory with authenticated customer accounts, ticket-management systems, CRM data, and carefully permissioned actions.

Final takeaway

Before this project, it was easy to think of AI improvement mainly in terms of choosing a better model.

SupportMind showed us another possibility.

Sometimes the model already knows how to answer the question.

What it lacks is the right information from the past.

Our experiment was about giving that past back to the agent.

Don't make the customer start over. Remember, recall, and continue.

DEV Community: samalakavya115-kavi

What Building SupportMind Taught Us About AI Agents