DEV Community: Deepak Paswan

How I Built a Sales Agent That Actually Remembers Your Prospects

Deepak Paswan — Sat, 04 Jul 2026 12:40:41 +0000

Copy this entire block and paste it into Dev.to:

Every sales tool I've used has the same problem: it forgets everything the moment you close the tab.

Your CRM has notes, sure. But your AI assistant? Blank slate every single conversation. Ask it about a prospect you've been working for three months and it treats them like a stranger.

I built something different. A sales agent that remembers every objection, every discussion, every commitment — across sessions, across restarts, across days.

What It Does

Deal Intelligence Agent is a sales assistant built on three layers:

Hindsight for persistent memory across sessions
cascadeflow for intelligent model routing and cost control
FastAPI + React for the backend and UI

A sales rep opens a prospect, has a conversation, ends the session. Next day, different server instance, they ask "what objections has Acme raised?" — the agent recalls exactly what was discussed, including specific dollar amounts and concerns raised days ago.

The Memory Problem

Most AI agents store conversation history in memory. That works fine until the server restarts, the session ends, or you switch devices. Then everything is gone.

Hindsight solves this with a persistent memory bank per entity. Each prospect gets their own bank:

def _bank_id(self, prospect_id: str) -> str:
    return f"prospect-{prospect_id}"

Every exchange gets retained after each turn:

client.retain(
    bank_id=bank_id,
    content=f"[{role.upper()}] [{timestamp}] {content}"
)

Before each response, the agent recalls relevant context:

results_raw = client.recall(bank_id=bank_id, query=query)
if hasattr(results_raw, 'results') and results_raw.results:
    memories = [r.text for r in results_raw.results[:max_results]]

Key lesson: Hindsight returns a RecallResult object, not a list or dict. I spent two hours debugging because my parser was doing isinstance(results, list) checks that always failed silently. Always print the raw response shape before writing your parser.

The Before and After

Session 1 — no prior context:

Rep: "They objected to the $50K price"
Agent: "I don't have prior context on this prospect.
        Can you tell me more about their concerns?"

memory_source: none
memories_recalled: 0

Session 2 — after server restart, completely new session:

Rep: "What objections has Acme raised?"
Agent: "Acme raised a price objection of $50,000 in
        our last discussion..."

memory_source: hindsight
memories_recalled: 5

That delta — generic to specific — is the entire value proposition. Without Hindsight's agent memory, session 2 is identical to session 1. With it, the agent compounds knowledge over time.

Intelligent Routing With cascadeflow

Running every query through a 70B model is expensive and unnecessary.

cascadeflow handles routing automatically:

route_result = await self.router.route_query(
    messages=messages,
    complexity_hint=self._estimate_complexity(message),
)

Simple queries → llama-3.1-8b-instant at $0.00005 per call
Complex analysis → llama-3.3-70b-versatile at $0.00032 per call

Every decision is logged — model selected, cost, complexity, reasoning. Most sales conversations are simple status checks. Only strategic analysis needs the expensive model. Across 100 queries the cost difference is significant.

Session Summaries via Hindsight reflect()

After each conversation, the agent synthesizes everything:

result = client.reflect(
    bank_id=bank_id,
    query="Summarize key points, objections raised, "
          "deal stage, and recommended next action."
)

Output is a structured summary — discussion points, prospect sentiment, objections, and a specific next action. This becomes the handoff document between sessions.

Three Things I'd Do Differently

Test your recall parser against the actual response object on day one. Don't assume the shape. Print the raw response first.
Add a health check endpoint. I had Hindsight silently falling back to local memory for hours without knowing. A simple retain-then-recall test at startup would have caught this immediately.
Classify intent instead of counting words. My complexity heuristic uses word count. Classifying the request type — question vs analysis vs drafting — is more reliable.

What's Next

The current version handles single-rep conversations. The obvious next step is multi-rep shared memory — where a prospect's history is visible across the entire sales team.

Code: github.com/dpkpaswan/deal-intelligence-agent
Hindsight docs: hindsight.vectorize.io
cascadeflow docs: docs.cascadeflow.ai

From Abandoned Prototype to AI-Powered Google Form Platform

Deepak Paswan — Thu, 28 May 2026 06:05:13 +0000

I Revived My AI-Powered Google Form Generator Using GitHub Copilot

This is a submission for the GitHub Finish-Up-A-Thon Challenge

What I Built

I revived and completed my unfinished project: AI-Powered Google Form Generator — a full-stack web application that creates real Google Forms from natural language prompts using Google Gemini AI.

The original idea started as a small experiment:

“Can AI automatically generate a complete Google Form from a simple text description?”

Initially, the project only supported basic prompt-to-form generation. It worked as a proof of concept, but the user experience was incomplete, the backend structure was messy, and several important features were missing. Eventually, I stopped working on it.

For the GitHub Finish-Up-A-Thon Challenge, I decided to revisit the project and properly finish it by transforming it from a simple AI demo into a more complete workflow platform.

The application now supports:

🔐 Google OAuth authentication
🧠 AI-powered form generation using Google Gemini
📄 PDF and DOCX document-to-form generation
🖼️ Image-to-form generation
✏️ Editable generated questions
📊 Form analytics dashboard
📂 User form management dashboard
📝 Pre-built form templates
🛡️ Secure token handling and validation
🐳 Docker-based deployment support

Tech Stack

Frontend

React 18
Vite
TailwindCSS
Redux Toolkit
Framer Motion
Recharts + D3.js

Backend

Node.js
Express.js
Google Gemini API
Google Forms API
Supabase PostgreSQL
Zod validation
JWT Authentication

GitHub Repository

https://github.com/dpkpaswan/AI-powered-Google-Form-Generator

Demo

🎥 Video Walkthrough

https://youtu.be/b_d_2QhdoRU

Application Workflow

Sign in using Google OAuth
Enter a natural language prompt
AI generates structured form questions
Edit or improve generated questions
Publish directly to Google Forms
Manage forms and view analytics

Example Prompt

“Create a college symposium registration form with participant details, department selection, workshop preferences, and feedback questions.”

Screenshots

Repository

https://github.com/dpkpaswan/AI-powered-Google-Form-Generator

The Comeback Story

When I first started this project, it was mainly a proof of concept focused on AI-generated forms.

The original version had multiple issues:

Weak UI and UX
No form management system
No analytics support
Limited backend structure
Minimal validation
No document parsing
No templates
No deployment setup
Difficult-to-maintain codebase

Over time, I kept adding ideas without properly finishing the core workflow. The project slowly became harder to maintain and eventually got abandoned.

For this challenge, I focused less on adding random new features and more on improving usability, architecture, reliability, and overall product quality.

Major improvements I made during the revival process:

Rebuilt the backend using controllers/services architecture
Added secure Google OAuth integration
Integrated Supabase for persistent storage
Added PDF and DOCX parsing support
Added image-based form generation
Added editable forms workflow
Built analytics dashboards using charts
Improved validation and error handling
Added reusable templates
Added Docker deployment support
Improved overall frontend design and responsiveness

One important lesson from this process was:

Finishing and polishing a project is much harder than starting one.

The biggest improvements were not flashy AI features — they were stability, usability, and better system structure.

My Experience with GitHub Copilot

GitHub Copilot helped me significantly during the rebuilding and cleanup process.

I mainly used Copilot for:

Refactoring backend services
Creating API boilerplate
Improving Express routes and middleware
Writing reusable utility functions
Generating validation schemas
Improving React component structure
Debugging async logic
Speeding up repetitive frontend tasks
Improving documentation

One of the most useful parts was backend refactoring. The earlier version had tightly coupled logic, and Copilot helped accelerate the process of separating business logic into cleaner service layers.

I also used Copilot while improving UI components and simplifying repetitive coding tasks during frontend cleanup.

Instead of treating Copilot as a replacement for development, I used it as a productivity tool to speed up implementation and refactoring while still making the technical decisions manually.

Challenges Faced

Some of the biggest technical challenges were:

Managing Google OAuth token handling securely
Integrating the Google Forms API reliably
Structuring AI-generated question formats consistently
Parsing uploaded documents correctly
Maintaining clean architecture while expanding features
Handling async workflows between AI generation and Google APIs

I also realized that overengineering can easily destroy project momentum. At one point, I was adding too many ideas without stabilizing the core product experience.

This challenge helped me focus on actually finishing the application.

Final Thoughts

This challenge pushed me to revisit an abandoned project and finally complete it properly.

The biggest takeaway for me was:

A polished and usable product matters more than endlessly adding features.

There are still future improvements I want to make, but this challenge helped me transform an unfinished prototype into a much more stable and production-ready application.

Thanks for reading!
This is a submission for the GitHub Finish-Up-A-Thon Challenge