I Built an AI Sales Agent That Learns From Every Deal — Here's How

The problem nobody captures
Every experienced sales rep is a walking memory bank. They remember that the CFO at one account kills anything over $100K without board sign-off. They remember that a particular buyer cares more about integration depth than price. They remember the compliance question that surfaced three calls ago and quietly became a deal-breaker.
That knowledge lives in one person's head. When they're out sick, switch territories, or leave the company, it disappears — and the next rep starts from zero. This is the institutional-knowledge problem, and it costs sales teams real revenue every quarter.
What I built
SalesIQ is an AI sales intelligence engine that treats memory as the product, not a feature. Instead of a chat history, it maintains a structured, evolving understanding of each buyer that any rep can pick up and run with. You can try it here: [your demo url].
How the memory works
Most "AI with memory" is just retrieval — a lookup table dressed up as intelligence. SalesIQ organizes what it knows into three distinct layers, which is what makes it feel like it understands a deal rather than just recalling facts:

World Facts are the static parameters: the buyer's role, company size, budget constraints, and legal or procurement rules. This is the foundation — without it, the agent restarts every session.
Experiences are episodic — what happened in each call, which objections came up, what excited the buyer, what was committed to. This is the evidence base.
Mental Models are the highest-value layer: synthesized beliefs like "this buyer decides on integration depth, not price." They're generated from patterns across multiple experiences and updated as new evidence arrives.

The Gemini API does the synthesis and tagging work — turning raw negotiation logs into clean, categorized memory entries and surfacing the heuristics that become Mental Models.
The before/after that matters
Ask a generic AI assistant about a specific deal and it tells you, honestly, that it knows nothing. Ask SalesIQ about the same buyer after a full account history is loaded and it answers with specifics: the budget cap, who has to approve the deal, the objection most likely to come up next, and why. Same question, completely different answer — that gap is the entire point.
Making memory visible
The single most important UI decision was the Memory Inspector — a live sidebar that shows everything the agent knows about the active buyer, split across the three memory tabs. Reps can read it, edit it, and delete entries (with a safety confirmation, because deleting a deal assertion shouldn't be a one-tap mistake). Memory that you can't see and can't correct isn't trustworthy. Making it inspectable is what turns a black box into a tool a rep will actually rely on.
I also added Focus Rooms — switching the active account instantly re-anchors the whole dashboard and memory ledger to that buyer, so a rep juggling several deals never mixes up context.
The stack

Frontend: React (TypeScript), Vite, TailwindCSS, Framer Motion
Backend: Node.js API layer with a simulated data store
Auth & data: Firebase Authentication and Firestore, with offline/mock fallback for demos
AI: Gemini API for summarization, tagging, and synthesis

What I learned
The difference between memory-as-lookup and memory-as-belief is enormous. Storing transcripts is easy. The hard and interesting part is synthesizing scattered experiences into a belief the agent can act on — and then showing the rep that belief so they can trust or correct it. The visible, editable memory layer did more for the product's credibility than any amount of model tuning.
Try it

Demo: [your demo url]
Code: https://github.com/YashAsija/SalesIQ

If you've felt the institutional-knowledge problem on your own team, I'd genuinely like to hear how you've handled it.