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
Log in with your GitHub account.
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
