Client Brain: An AI Memory Agent That Learns From Client Decisions

Battina Durga Malleshwari — Tue, 29 Sep 2026 02:43:49 +0000

Introduction

Freelancers often work with multiple clients at the same time. Important information is spread across calls, chats, project discussions, price negotiations, deadlines, and changing requirements.

The problem is not simply remembering what a client said.

The real problem is remembering what was finally decided.

A client might initially say:

“My budget is around ₹40,000.”

Later, after negotiation:

“Okay, ₹50,000 works. Let's proceed.”

If that conversation happens weeks ago, the freelancer needs the AI to understand that ₹50,000 is the final agreed price, not ₹40,000.

This is the problem we wanted to solve with Client Brain.

Client Brain is an AI memory agent designed for freelancers. It understands client conversations, identifies important decisions, stores them using Hindsight, recalls them later, detects when those decisions change, and helps the freelancer take the appropriate action.

The Hindsight hackathon specifically focuses on building AI agents that learn using memory, with emphasis on a clear learning curve and memory being central to the product.

The Problem

A normal AI assistant can answer questions about the current conversation.

But a freelancer needs something more:

“What did we actually agree on last time?”

Consider a typical client relationship.

First conversation

The client says:

Project: WordPress website
Initial budget: ₹40,000
Deadline: October 15

After negotiation:

Final agreed price: ₹50,000
Status: Accepted

A few days later, the client comes back and says that the project budget needs to change.

Without reliable memory, an AI assistant could confuse:

Initial budget → ₹40,000

with:

Final agreement → ₹50,000

That can lead to incorrect decisions.

Client Brain is designed around this exact problem.

Our Solution

Client Brain follows a simple loop:

Conversation
↓
Understand
↓
Remember
↓
Recall
↓
Detect Change
↓
Take Action

Instead of treating every conversation as an isolated interaction, Client Brain builds a memory of the client's decisions.

The important idea is:

Client Brain doesn't just remember conversations. It remembers decisions.

What Makes Client Brain Different?

The central concept is Decision Memory.

When a client conversation contains negotiation, Client Brain distinguishes between:

what was initially discussed,
what was negotiated,
and what was finally agreed.

For example:

Information Value
Project WordPress Website
Original Budget ₹40,000
Final Agreed Price ₹50,000
Deadline October 15
Status Accepted
Communication Preference Short WhatsApp messages

The final agreement becomes the important long-term memory.

How Hindsight Is Used

Hindsight is the memory layer of Client Brain.

The hackathon requires teams to use Hindsight Cloud or OSS as part of the project.

Client Brain uses Hindsight to retain important client information and recall it when the client returns.

The process is:

Client Conversation
↓
AI understands conversation
↓
Important decision extracted
↓
Hindsight stores memory
↓
Client returns later
↓
Previous memory recalled
↓
New conversation compared
↓
Changes detected

This makes memory a core part of the product rather than an additional feature.

Example: Rahul's Conversation

Let's take a simple example.

Conversation 1

Rahul says:

“I need a WordPress website. My budget is around ₹40,000.”

The freelancer responds:

“The minimum price is ₹50,000.”

Rahul agrees:

“Okay, ₹50,000 works. Let's proceed. I need it by October 15.”

Client Brain extracts:

Client: Rahul Sharma
Project: WordPress Website

Original Budget: ₹40,000
Final Agreed Price: ₹50,000
Deadline: October 15
Status: Accepted

This information is stored in Hindsight.

When the Client Returns

Later, Rahul contacts the freelancer again.

Client Brain recalls the previous decision.

It knows that the original budget was ₹40,000, but the final agreed price was ₹50,000.

Now suppose the freelancer says:

“Rahul, I want to change the project budget from ₹40,000 to ₹60,000.”

Client Brain identifies the new amount and understands that the agreement has changed.

The new memory becomes:

Previous Final Price: ₹50,000
New Final Price: ₹60,000

Change detected:
₹50,000 → ₹60,000

This creates a history of the client's decisions rather than simply storing disconnected conversations.

Verified Memory

One important idea behind Client Brain is Verified Memory.

Not every statement made during a conversation should automatically become a permanent decision.

For example:

“Maybe we can do it for ₹45,000.”

This is different from:

“Okay, ₹50,000 works. Let's proceed.”

The first statement is a discussion.

The second is an agreement.

Client Brain is designed to focus on the information that represents an actual decision or commitment.

This helps prevent temporary negotiation statements from being treated as final agreements.

Detecting Changes

Client relationships evolve.

A project can change its:

budget,
deadline,
scope,
technology,
status,
or other important requirements.

Client Brain compares new information with previous memory.

For example:

OLD MEMORY
Final Price: ₹50,000

↓

NEW CONVERSATION

Final Price: ₹60,000

↓

CHANGE DETECTED

₹50,000 → ₹60,000

The system can then update the memory and surface the change to the freelancer.

This creates an evolving memory of the client.

From Memory to Action

Remembering information is useful.

But the goal of Client Brain is to make that memory actionable.

The product therefore follows:

Remember
↓
Compare
↓
Detect
↓
Suggest Action

For example, when a previously agreed price changes, Client Brain can highlight the change so the freelancer knows that an important project decision has been updated.

This is particularly useful when a freelancer is managing multiple clients and projects simultaneously.

Product Experience

Client Brain is designed around a focused workflow.

Client Conversation

The freelancer communicates with the client.

AI Understanding

The AI analyzes the conversation and identifies important information.

Memory

Important decisions are stored using Hindsight.

Recall

When the client returns, previous information can be retrieved.

Comparison

The new conversation is compared with previous memory.

Change Detection

Changes in important decisions are identified.

Action

The freelancer receives useful information about what changed.

Why Memory Is Central

The project could technically be built as a simple chatbot.

But that would miss the core problem.

The important question is not:

“Can AI understand this conversation?”

It is:

“Can AI remember what mattered from previous conversations and use that memory when the situation changes?”

That is why Hindsight is central to Client Brain.

The hackathon guidance specifically encourages teams to demonstrate how the agent improves through memory and to show a learning curve such as 1 vs 5 vs 20 interactions.

Client Brain follows that idea by making previous client decisions useful during future interactions.

Learning Over Time

Imagine a freelancer has worked with the same client for multiple conversations.

Interaction 1

Client discusses the project.

Client Brain learns:

Project = WordPress Website
Interaction 5

More decisions are made:

Budget
Deadline
Technology
Communication preference
Project status
Interaction 20

The system has a much richer understanding of the client:

Past decisions
Current agreements
Previous changes
Project history
Communication preferences

The value of the system increases because its memory becomes more useful over time.

Technology Stack

Client Brain uses:

React for the frontend
Node.js for the backend
Express for the API
Hindsight for long-term memory
Groq LLM for conversation understanding and analysis

The architecture is:

         Client Conversation
                 │
                 ▼
          React Frontend
                 │
                 ▼
          Express Backend
                 │
      ┌──────────┴──────────┐
      ▼                     ▼
   Groq LLM             Hindsight
      │                     │
      │              Long-term Memory
      │                     │
      └──────────┬──────────┘
                 ▼
          Decision Analysis
                 │
                 ▼
          Change Detection
                 │
                 ▼
             Freelancer

Building for a Real Business Problem

Client Brain focuses on a specific problem instead of trying to become a general-purpose AI assistant.

The target user is a freelancer who needs to manage ongoing client relationships.

The product focuses on:

client conversations,
decisions,
agreements,
memory,
changes,
and actionable information.

This matches the hackathon's emphasis on solving a real business problem with a focused scope and realistic data.

Demo

In our demo, we show a client conversation with Rahul.

First, Client Brain learns:

Original Budget: ₹40,000
Final Agreed Price: ₹50,000
Deadline: October 15

Then Rahul returns and the project price changes.

Client Brain:

recalls the previous information,
understands the new conversation,
detects the change,
identifies the new agreed price,
updates the memory,
and shows the freelancer what changed.

The demo is designed to make the memory loop visible:

FIRST CONVERSATION
↓
REMEMBER
↓
CLIENT RETURNS
↓
RECALL
↓
NEW DECISION
↓
COMPARE
↓
CHANGE DETECTED
↓
UPDATE MEMORY
What We Learned

Building Client Brain showed us that AI memory becomes much more useful when it is connected to decisions and actions.

A transcript by itself is not always useful.

A useful memory system should answer questions such as:

What did we agree on?
What was the original decision?
What changed?
What is the latest agreement?
What should the freelancer know now?

This is the direction we explored with Hindsight.

Future Improvements

Client Brain can be extended with:

automatic client relationship timelines,
stronger conflict resolution between memories,
approval workflows for important decisions,
deadline reminders,
follow-up suggestions,
richer project histories,
additional communication channels,
and more personalized actions based on long-term client behavior.

The goal would remain the same:

Help freelancers spend less time remembering what happened and more time acting on what matters.

Conclusion

Client Brain is an AI memory agent for freelancers that turns client conversations into useful, evolving decision memory.

Instead of simply remembering what a client said, it focuses on:

what was discussed → what was agreed → what changed → what matters now.

With Hindsight as its memory layer, Client Brain demonstrates how an AI agent can use information from previous interactions to make future interactions more useful.

The core idea is simple:

Conversation
↓
Understand
↓
Remember
↓
Recall
↓
Detect Change
↓
Action

Client Brain — AI that remembers what your clients decided, not just what they said.

Hackathon Links

GitHub:
https://github.com/durgamalleshwari00-coder/Client-Brain

Demo Video:
Add your YouTube Unlisted video URL here.

Live Demo:
Add your Vercel/Netlify URL here once deployment is working.

Built for: Hindsight Hackathon / Microsoft Hack with Hyderabad 3.0.

where i need to add this content

You should add that content to an online article, because your hackathon submission is asking for an Article Link.

Since I recommended Dev.to, here's exactly where to put it:

Step 1

Open:

DEV Community

Step 2

Step 3

Click Create Post.

You'll see a page with fields like:

Title

Put:

Client Brain: An AI Memory Agent That Learns From Client Decisions

Then you'll see the large article editor underneath.

Step 4

👉 Paste the entire article I gave you into that large editor.

You don't need to paste it into GitHub or your code.

Step 5

Add tags:

ai
agents
memory
hindsight
hackathon
Step 6

Click Publish.

Dev.to will create a page with a URL similar to:

https://dev.to/yourname/client-brain-an-ai-memory-agent-xxxxx
Step 7

Copy that URL.

Then your hackathon submission will have:

Submission field https://github.com/durgamalleshwari00-coder/Client-Brain
Demo Video https://youtu.be/eDzHKb-qyKs
Article Link Your Dev.to article URL
Live Demo client-brain-qi3dwgguv-durgamalleshwari00-coders-projects.vercel.app

DEV Community: Battina Durga Malleshwari

Client Brain: An AI Memory Agent That Learns From Client Decisions