My Sales Agent Kept Forgetting Deals, So I Gave It Memory

Namratha VT Namratha — Wed, 12 Aug 2026 13:12:30 +0000

So I Gave It Memory
I spent the first two weeks solving the wrong problem. I kept tuning prompts, stuffing more context into every call summary, trying to make one message smarter. The agent wasn't dumb, though. It was amnesiac. Every time a rep opened a new call, it started from a blank page — no memory of the objection raised three weeks ago, no memory of last Tuesday's pricing conversation, no memory of which stakeholder actually controls budget.
That's the real problem in enterprise sales: the story of a deal doesn't live in any single email or call. It's scattered across a CRM record, a stack of meeting notes, a Slack thread, and whatever a rep happens to remember on a good day. I built a Deal Intelligence Agent to stop reconstructing that story from scratch every time — and to actually get sharper about a deal the longer it stays open.
What it does
The agent sits alongside a sales rep for the life of a deal. It watches the inputs a rep already generates — CRM updates, email threads, call notes — and turns them into a running memory of that deal: who the stakeholders are, what they care about, which objections have already come up, what's been promised, and what's changed since last time.

When a rep is about to walk into a meeting, they don't ask the agent to summarize a transcript. They ask it what it knows about this deal — and it answers with the accumulated context of every interaction that came before, not just the most recent one.
The core problem: agents don't remember, they infer
Most agent demos look impressive because they're solving a single-turn problem: read this email, answer this question, draft this reply. Deal cycles aren't single-turn. A real enterprise deal runs for months, involves five or six people on the buyer's side, and accumulates dozens of small facts that only matter in combination — the CFO mentioned a hard budget freeze in March, the champion admitted in June that the freeze softened, and by September the same "we don't have budget" objection means something completely different than it did in the spring.
An LLM with a big context window doesn't fix this. Feeding an agent the entire deal history on every call is expensive, slow, and mostly noise — the agent has to re-derive what matters every single time instead of already knowing it. What I actually needed was a memory layer that could retain individual facts as they happened and recall only the ones relevant to the current moment, the way Hindsight's approach to agent memory is designed to work.
That's the decision that mattered more than any prompt tweak: give the agent a memory it writes to continuously and reads from selectively, instead of asking one giant context window to do both jobs at once.
How the pieces fit together
Every time something happens on a deal — a call ends, an email comes in, a CRM field changes — the agent retains it as a discrete memory tied to that deal:
python
from hindsight import HindsightClient

memory = HindsightClient(agent_id="deal-intelligence-agent")

memory.retain(
deal_id=deal.id,
content=(
"Call with Priya (VP Finance): raised concern about "
"annual commitment, wants month-to-month pilot first."
),
metadata={"stage": deal.stage, "type": "objection", "contact": "priya"},
)
When the rep is prepping for the next call, the agent doesn't replay the whole history — it recalls the slice that's actually relevant to what's coming up:
python
context = memory.recall(
deal_id=deal.id,

query="pricing objections and commitment terms discussed so far",
)
That distinction — retain everything cheaply, recall selectively and expensively — is the whole trick. It's also the piece I underestimated going in. I assumed the hard part would be the reasoning layer that decides what to do with deal context. It turned out the hard part was deciding what to retain in the first place, and at what granularity, so recall later actually returns something useful instead of a wall of loosely related notes.
Once recall returns the right slice of history, the reasoning step is comparatively simple — it's mostly asking the model to weigh what it now knows against the current situation and suggest a next move:
python
recommendation = agent.recommend_next_action(
deal=deal,
recalled_context=context,
current_situation="Rep has a renewal call scheduled in 2 days",
)
What this actually looks like in use
The clearest before/after isn't a benchmark, it's a specific kind of moment reps run into constantly: the recurring objection that resurfaces months apart, phrased differently each time.
Without memory, that objection reads as brand new every time it comes up, and the agent (or the rep) responds as if it's the first time. With retain/recall in place, the agent can surface something like: this budget concern echoes what the CFO raised back in March — that time, the pilot-first approach is what unstuck it. That single connection is the difference between an agent that transcribes conversations and one that actually understands a deal.

I don't want to overstate this with numbers I haven't rigorously measured — the honest version is that memory changes the kind of help the agent can give, not just the speed of it. A rep can ask "has this come up before?" and get a real answer instead of "I don't have that context."
Lessons learned
Retention granularity matters more than reasoning sophistication. A fancier prompt on top of poorly-retained memories is still going to recall the wrong things. I got more value from getting the retain step right than from any amount of prompt engineering downstream.
Recall needs a specific question, not a vague one. "Tell me about this deal" produces mush. "What pricing objections has this stakeholder raised" produces something a rep can act on. The quality of recall is bottlenecked by the quality of the query, not just the memory store.
Memory changes what "context" means for an agent. I stopped thinking about context windows and started thinking about what's worth remembering permanently versus what's disposable after one turn. That's a genuinely different design problem than prompt engineering.
The agent gets better the longer a deal runs, not worse. Most agents degrade as conversations get longer because everything competes for space in one context window. This one gets more useful over time because retained memory compounds instead of getting truncated.
Read the actual retain/recall docs before you assume you know the API. I burned an afternoon guessing at parameter names before checking Hindsight's documentation directly — worth doing first, not last.
Where this goes next
The version of this I want to build next pushes further into deal risk, not just deal history — using the same retained memory to flag when a deal's pattern looks like ones that stalled or died before, instead of only answering direct questions about the past. The scaffolding for that is already in the Hindsight GitHub repo if you want to see how retain and recall are actually implemented under the hood.
If you're building anything that has to reason about a relationship — a deal, a support ticket, a long-running project — the lesson generalizes past sales: the bottleneck usually isn't the model. It's whether the thing your agent is reasoning about is remembered anywhere at all.

DEV Community: Namratha VT Namratha

My Sales Agent Kept Forgetting Deals, So I Gave It Memory