DEV Community: Tanmaya sree Chirra

Why We Built Foresight: Stopping AI from Committing Commercial Suicide

Tanmaya sree Chirra — Mon, 28 Sep 2026 17:32:24 +0000

If you give an LLM access to a sales inbox, it will eventually agree to an impossible contract.

Last week, we tested what happens when a prospect sends an aggressive negotiation email: "Can you give us 40% off and get us live into production in two weeks?" A standard prompt-chained LLM happily replied that it could make that work if the customer signed by Friday. In the real world, sending that email would have triggered a contractual disaster: our engineering team requires at least 21 days for secure VPC peering, our finance team caps rep discounts at 15%, and our security lead had already barred all production data ingestion until an overdue compliance audit was reviewed.

Stateless LLMs fail at enterprise sales because they suffer from acute context amnesia. They treat each incoming message as an isolated conversational turn, completely blind to the commitments, constraints, and politics established over months of prior calls.

To fix this, we built Foresight, an enterprise deal intelligence engine that uses Hindsight to maintain an active, self-updating memory bank of the entire customer relationship. Instead of simply generating agreeable text, Foresight intercepts incoming demands, checks them against historical commitments and company policies, detects multi-variable collisions, and dynamically updates its strategy when real-world facts change.

Here is how we designed the system, the architectural trade-offs we encountered, and why agent memory must act as a computational governor rather than a simple passive search index.

The System Architecture: How Foresight Fits Together

Enterprise sales deals are not linear chats; they are multi-month distributed state machines. A single deal involves half a dozen stakeholders with competing agendas:

The Champion wants roadmap features delivered yesterday.
The Technical Evaluator cares about latency, architecture, and deployment constraints.
The Security Gatekeeper (CISO) cares about compliance, data residency, and audit certifications.
The Economic Buyer (CFO) enforces budget ceilings and hates multi-year lock-in.
Procurement plays hardball on discounts and payment terms.

To model this reality without building a bloated microservice architecture, we designed Foresight around three distinct layers:

┌─────────────────────────────────────────────────────────────┐
│ 1. Historical Interaction Ingestion (Hindsight Memory Bank)  │
│    Ingests call transcripts, emails, and commitments into   │
│    a dedicated deal memory bank via retain().               │
└──────────────────────────────┬──────────────────────────────┘
                               │
                               ▼
┌─────────────────────────────────────────────────────────────┐
│ 2. The Collision Engine                                      │
│    Cross-checks incoming demands against:                   │
│    • Active commitments & fulfillment status in memory       │
│    • Static company baseline policies (SLAs, margins)       │
│    Categorizes conflicts into Security, Timeline, and Price.│
└──────────────────────────────┬──────────────────────────────┘
                               │
                               ▼
┌─────────────────────────────────────────────────────────────┐
│ 3. The Dynamic Reflection & Strategy Loop                   │
│    When real-world state changes occur (e.g. SOC-2 sent),   │
│    memory mutates live, re-evaluating advice from           │
│    defensive blocker to offensive closing plan.             │
└─────────────────────────────────────────────────────────────┘

Rather than feeding an entire 8-week call history into a prompt window—which burns tokens, degrades reasoning attention, and costs a fortune—we use Vectorize agent memory to maintain persistent structured entities: stakeholders, explicit objections, competitor mentions, and an auditable commitment ledger.

Core Technical Story: Moving from Naive RAG to Collision Detection

Most developers building sales tooling reach immediately for naive Retrieval-Augmented Generation (RAG): embed previous call summaries in a vector database, perform cosine similarity search on the incoming prompt, and feed the top-k chunks into the context window.

During our early testing, naive RAG broke down completely. Consider this incoming request from the customer's procurement lead:

"Can you give us 40% off and get us live into production in two weeks?"

If you run a standard vector search against the past 8 weeks of call notes, your embedding model will retrieve chunks containing words like "discount", "pricing", and "timeline".

What does it miss? Call #2 from 31 days prior.

In Call #2, the customer's CISO (Nadia Chen) stated:

"No production data can touch your platform without our security team reviewing your audited SOC-2 Type II report."

Semantically, "SOC-2 Type II audit" has almost zero cosine similarity to "40% discount". A traditional RAG pipeline ignores it. Yet operationally, that single security mandate is a hard fatal blocker: agreeing to a two-week deployment is contractually impossible because the security team hasn't even begun reviewing the compliance report.

To solve this, we abandoned simple semantic retrieval and built a deterministic Multi-Constraint Collision Engine.

Instead of asking the LLM "How should I answer this email?", the system evaluates the request against three discrete constraint checks:

🔴 Security Gate: Are there unfulfilled compliance commitments or unresolved access blockers?
🟠 Timeline Feasibility: Does the requested go-live date violate engineering lead times (4–6 weeks standard) or crash into documented customer code freezes?
🟡 Commercial Alignment: Does the requested discount violate delegation-of-authority limits, ignore established budget caps, or fail to account for competitor bids?

Code-Backed Implementation: How We Integrated Hindsight

Let's look at how this is implemented in our codebase.

1. Ingesting Deal History with `retain()`

In memory.py, we initialize the deal bank and index every conversation, stakeholder sensitivity, and commitment into Hindsight:

class DealMemoryBank:
    def __init__(self, deal_path: str = ACME_DEAL_PATH, kb_path: str = COMPANY_KB_PATH):
        self.deal_data = self._load_json(deal_path)
        self.company_kb = self._load_json(kb_path)
        self.commitments = self.deal_data.get("commitments", [])
        self.interactions = self.deal_data.get("interactions", [])

        # Initialize Hindsight client
        self.hindsight_client = None
        self._init_hindsight()

    def retain(self, content: str, category: str, metadata: Optional[Dict[str, Any]] = None):
        """Retains an observation, commitment, or interaction into deal memory."""
        if self.hindsight_client:
            self.hindsight_client.retain(
                bank_id="acme-deal",
                text=content,
                context=category
            )

Each interaction is tagged with its chronological context. Crucially, promises made by sales reps are extracted into structured Commitments with an explicit initial state: "Overdue" or "Pending", accompanied by the audit note: "No fulfilment recorded".

2. Multi-Constraint Collision Evaluation

In collision_detector.py, the engine intercepts the customer's request and cross-references active commitments and baseline company rules:

def check_collisions(self, customer_request: str, deal_context: Dict[str, Any]) -> Dict[str, Any]:
    commitments = deal_context.get("commitments", [])
    kb_deploy = self.company_kb.get("deployment_rules", {})
    kb_pricing = self.company_kb.get("pricing_and_discount_rules", {})

    # Check 1: Security Gate (SOC-2 Type II Report)
    soc2_comm = next((c for c in commitments if c.get("id") == "COMM-02"), None)
    is_soc2_completed = soc2_comm and soc2_comm.get("status") == "Completed"

    collisions = []

    if not is_soc2_completed:
        collisions.append({
            "severity": "RED",
            "badge": "🔴 Security Blocker",
            "title": "Unfulfilled SOC-2 Mandate for Production Access",
            "description": "Nadia Chen (CISO) explicitly mandated that NO production data can touch Veridian without reviewed SOC-2 Type II audit report.",
            "evidence": [
                "Call #2 (31 days ago): Nadia stated 'No production data can touch your platform without our security team reviewing your audited SOC-2 Type II report.'",
                "Commitment COMM-02: 'SOC-2 Type II Audit Report Delivery' is currently OVERDUE (31 days elapsed)."
            ],
            "impact": "CRITICAL: Promising deployment before SOC-2 sign-off triggers an immediate security veto."
        })
    else:
        collisions.append({
            "severity": "GREEN",
            "badge": "✅ Security Cleared",
            "title": "SOC-2 Type II Report Delivered",
            "description": "Security gate unlocked for staging and production onboarding."
        })

    # Check 2: Timeline Feasibility
    if any(k in customer_request.lower() for k in ["two weeks", "2 weeks", "14 days"]):
        collisions.append({
            "severity": "ORANGE",
            "badge": "🟠 Timeline Conflict",
            "title": "Unrealistic 2-Week Deployment Request vs. 4-6 Week Baseline",
            "description": "Veridian standard onboarding takes 4 to 6 weeks. No 2-week promise was ever recorded.",
            "evidence": [
                "Call #3: SA confirmed standard deployment is 4 to 6 weeks due to VPC peering.",
                "Call #9: Marcus confirmed ACME has an annual production freeze starting October 15."
            ],
            "impact": "HIGH: Agreeing creates catastrophic delivery failure and SLA breach risk."
        })

    return {"collisions": collisions}

Notice the evidence array. Every single collision badge is tied directly to a specific historical call, speaker, and timestamp. In enterprise environments, human operators do not trust an AI that asserts "This is risky". They trust an AI that shows the exact receipt from Call #2.

3. Dynamic Memory Reflection

The most important capability of Hindsight agent memory is that memory is mutable. It updates when real-world actions occur.

When the sales rep finally emails the compliance package to the prospect's security team, they click "Mark SOC-2 Sent to Nadia" in the UI. Here is what happens under the hood:

def update_commitment_status(self, deal_context: Dict[str, Any], commitment_id: str, new_status: str, notes: str) -> bool:
    commitments = deal_context.get("commitments", [])
    for comm in commitments:
        if comm.get("id") == commitment_id:
            comm["status"] = new_status
            comm["status_notes"] = notes
            comm["last_updated"] = datetime.now().isoformat()

            # Retain this critical state change into Hindsight memory
            reflection_text = (
                f"COMMITMENT STATE CHANGE: '{comm['title']}' for recipient '{comm['recipient']}' "
                f"changed to [{new_status}]. Note: {notes}"
            )
            self.hindsight_client.retain(
                bank_id="acme-deal",
                text=reflection_text,
                context="commitment_update"
            )
            return True
    return False

When this state mutation is saved, the Collision Engine immediately recalculates. The 🔴 Security Blocker dissolves into a ✅ Security Cleared notification, and the downstream response generation pivots automatically.

Results and Behavior: The Live Interaction

To verify the system, we ran our benchmark enterprise deal: ACME Corp (an 8-week history comprising 9 calls, 5 stakeholders, a \$72k quote, and an active competing bid from NimbusAI at \$48k).

Interaction 1: Before Memory Reflection (Defensive Triage)

When the aggressive request ("40% off + 2-week deploy") arrives:

Foresight output:
- 🔴 Security Blocker: Missing SOC-2 Report (Overdue by 31 days).
- 🟠 Timeline Conflict: 2 weeks requested vs. 4–6 week standard.
- 🟡 Commercial Alignment: 40% discount (\$43,200) violates margin policy and is unnecessarily low given Linda's \$50k budget ceiling.
Strategic Advice Generated:
- "⛔ DO NOT agree to deployment dates or price concessions yet. Your immediate priority is delivering the SOC-2 report to Nadia Chen."

Interaction 2: After Memory Reflection (Offensive Negotiation)

The rep clicks "Mark SOC-2 Sent to Nadia". Hindsight records the reflection. The collision check re-runs automatically:

Foresight output:
- ✅ Security Cleared: SOC-2 delivered; security gate unlocked.
- 🟠 Timeline Conflict: Adjusted to offer a phased 3-week express onboarding with dedicated solution architects.
- 🟡 Commercial Alignment: Counter-offers at \$49,000 ARR.
Strategic Advice Generated:
- "🎯 PROCEED WITH COMMERCIAL NEGOTIATION. Target price: \$49,000 (respects Linda's \$50k budget ceiling and beats NimbusAI's \$48k offer) with an agreement to sign before the October 15 code freeze."

The draft customer reply updates instantly, switching from a defensive delay to a confident commercial closing pitch.

Lessons Learned

Building Foresight surfaced several non-obvious engineering realities about memory-augmented agents:

1. Negative Grounding Prevents Hallucinated Certainty

When tracking commitments, never let your agent declare: "The report was never sent." If an interaction happened outside the recorded system, that absolute claim destroys user trust. Instead, our ledger outputs: "No fulfilment recorded". That subtle wording change reflects epistemic humility: the agent only claims knowledge of recorded events.

2. Decouple Static Policy from Dynamic Memory

Early on, we tried storing company policies (like minimum deployment timelines and discount delegation matrices) inside the same memory bank as call transcripts. The LLM regularly confused company rules with customer statements. Separating static company ground truth (company_kb.json) from dynamic deal memories (acme_deal.json) eliminated cross-contamination completely.

3. Multi-Variable Constraints Beat Pure Probabilistic Generation

You should not rely on an LLM's next-token prediction to decide whether a discount is legally permissible. Use deterministic code or structured Pydantic schemas to validate hard boundaries (budgets, compliance rules, timeline baselines), and let the LLM handle the natural language synthesis within those validated bounds.

Conclusion

Stateless chatbots treat conversations as ephemeral noise. But in high-stakes enterprise workflows, conversation history is a web of promises, liabilities, and leverage.

By integrating Hindsight into our deal intelligence architecture, we gave our agent the ability to remember what was promised, flag dangerous collisions, and dynamically adapt its strategy when real-world milestones are reached. That is the difference between an AI that makes reckless promises and one you can actually trust with your business.

Explore the full implementation on GitHub.

Finding Exoplanets in Noisy Data with Machine Learning

Tanmaya sree Chirra — Mon, 14 Sep 2026 18:00:31 +0000

We Built an AI to Hunt Earth-Like Planets — Here's How

Finding planets around other stars is hard. Kepler gives us raw light curves — brightness measurements over time — and buried inside that noisy data are tiny dips caused by planets
crossing their star. We built Astrobit 1.0 to find them automatically.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

The Problem

Kepler's Simple Aperture Photometry (SAP) flux is messy. Instrumental systematics, cosmic rays, and quarter-boundary artifacts all look like signals. A naive threshold approach
misses real planets and flags false positives constantly.

Architecture

Raw SAP Flux
↓
[Cleaner] — mask bad cadences + sigma-clip outliers
↓
[Detrender] — per-quarter Savitzky-Golay filter
↓
[BLS Search] — 50k coarse grid → fine refinement → alias check
↓
[Feature Extractor] — SDE, depth, SNR, odd/even, secondary eclipse
↓
[Random Forest Classifier] — trained on 269 labelled stars
↓
[Platt Scaler] — calibrates scores to probabilities
↓
[Vetter] — secondary eclipse, odd/even, recurrence, systematics
↓
Ranked Candidates → submission.csv

Each stage is independent and cacheable — BLS results are cached to CSV so you can interrupt and resume without recomputing.

What We Built

Cleaning — mask bad cadences, sigma-clip outliers from raw SAP flux
Detrending — per-quarter Savitzky-Golay filter. Recovers ~90% of true transit depth vs ~33% with a running median, and avoids edge artifacts at Kepler's quarterly roll boundaries
BLS Period Search — 50k log-spaced coarse grid + 600-point fine refinement around each peak. Alias checking at 0.5x, 1x, 2x, 3x catches period harmonics. ~100x cheaper than full- resolution search
Feature Extraction — SDE, transit depth, SNR, odd/even depth ratio, secondary eclipse depth
Random Forest Classifier — trained on 269 labelled stars, replaces brittle single-SDE-threshold with a multi-feature decision boundary
Platt Scaling — calibrates raw model scores to actual probabilities on the dev set
Vetting — secondary eclipse check, odd/even depth consistency, per-quarter recurrence, known systematic period filtering

Results

Stage	Impact
SG detrending vs running median	~90% vs ~33% transit depth recovery
Coarse-to-fine BLS	~100x faster than full-resolution search
Alias checking	Catches period harmonics at 0.5x–3x
RF classifier vs SDE threshold	Multi-feature boundary, fewer false positives
Platt scaling	Calibrated confidence scores on dev set
Vetting layer	Filters secondary eclipses, systematics, odd/even inconsistencies

Lessons Learned

• Detrending matters more than the classifier. A bad detrend corrupts every downstream feature. We spent more time on the SG filter than the ML model — worth it.
• Cache everything. BLS on a full Kepler star takes time. Caching to CSV saved us hours during iteration.
• Single thresholds break. SDE alone is a terrible classifier. The moment we switched to a multi-feature Random Forest, false positive rate dropped significantly.
• Calibration is underrated. Raw model scores are not probabilities. Platt scaling on the dev set made our confidence scores actually trustworthy for ranking candidates.
• Vetting is not optional. The classifier catches most false positives, but secondary eclipse checks and odd/even consistency are cheap and eliminate a whole class of eclipsing
binary contamination.

Stack

Python · scikit-learn · lightkurve · scipy · numpy

Repo

🔗 github.com/25wh1a6678-art/Astrobit_1.0

From Zero to Hindi Voice Agent in 10 Days: Schemes, Memory, and Outbound Calls"

Tanmaya sree Chirra — Sat, 15 Aug 2026 18:37:54 +0000

Building Ashley: A Hindi Voice Agent for Rural Financial Access

The Problem and the Users

India has over 500 million Jan Dhan account holders — yet millions of first-time banking users in rural areas don't know what schemes they qualify for, how UPI works, or even how to
open a zero-balance account. They can't navigate government portals. They don't read English. And they're often afraid of being cheated.

A chatbot doesn't help them. A voice agent does.

Ashley is a Hindi/Hinglish voice agent built for exactly these users — someone who speaks to them like a helpful neighbour, in their own language, for free, 24/7. Built for the #
VoiceForBharat challenge under the Financial Services track.

What Ashley Does

• Speaks and understands Hindi and Hinglish
• Checks eligibility for 5 government schemes: Jan Dhan, PM Kisan, Mudra Yojana, PMJJBY, PMSBY
• Remembers returning users (with their consent)
• Escalates fraud cases to human agents with a reference ID
• Places outbound Twilio reminder calls for scheme deadlines
• Hands off to Priya, a specialist agent, for deep scheme queries
• Shows a live call analytics dashboard and escalations dashboard

How the System Works

Browser mic → Web Speech API (STT)
→ Flask /chat → LLM (OpenRouter) → Tool calls
→ Murf Falcon API (TTS) → Audio URL → Browser plays

The frontend handles speech recognition via the Web Speech API. The text goes to a Flask backend, which runs it through an LLM with tool-calling enabled. The LLM can call tools like
check_eligibility, save_user, create_escalation, or handoff_to_scheme_specialist. The response text is sent to Murf Falcon for TTS, and the audio URL is played back in the browser.

The Most Important Features

1. Indian Voice with Personality — Murf Falcon (hi-IN-shweta)

Ashley uses Murf Falcon GEN2 with the hi-IN-shweta voice — warm, natural, and unmistakably Indian. The system prompt enforces a strict personality: warm, unhurried, under 2 sentences
per response, mirrors the user's language exactly.

python
MURF_VOICE_ID = "hi-IN-shweta"

def murf_tts(text: str) -> str:
r = requests.post(
"https://api.murf.ai/v1/speech/generate",
headers={"api-key": MURF_API_KEY, "Content-Type": "application/json"},
json={"voiceId": MURF_VOICE_ID, "text": text, "format": "MP3", "modelVersion": "GEN2"},
)
r.raise_for_status()
return r.json()["audioFile"]

2. Safety Guardrails

Ashley will never ask for OTPs, PINs, or account numbers. If someone tries, she says exactly:
│ "Main aapka OTP ya PIN kabhi nahi maangunga. Koi bhi yeh maange toh fraud ho sakta hai — turant call kaatein."

3. Scheme Eligibility Tool

A local dataset of 5 schemes with eligibility rules. The LLM calls check_eligibility as soon as it has one relevant data point — age, farmer status, business ownership — without
waiting to collect everything first.

python
def check_eligibility(answers: dict) -> dict:
eligible = []
for name, scheme in SCHEMES.items():
try:
if scheme"rules":
eligible.append({
"scheme": name,
"description": scheme["description"],
"documents": scheme["documents"],
"apply_at": scheme["apply_at"],
})
except (TypeError, ValueError):
continue
return {"eligible_schemes": eligible, "data_as_of": "August 2025 (local dataset)"}

4. Consent-Gated Memory

Ashley asks before saving anything:
│ "Kya main yeh yaad rakh sakta hoon aapke liye?"

Only name, language preference, and scheme facts are stored — never account numbers or Aadhaar.

5. Human Escalation + Outbound Calls

Fraud reports and blocked account cases get escalated with a reference ID. Users can also request a Twilio outbound reminder call to their phone for scheme deadlines.

6. Specialist Handoff

When a user needs detailed scheme guidance, Ashley hands off to Priya — a specialist agent with a different system prompt — without making the user repeat themselves.

Challenges and How I Overcame Them

The Overlapping Audio Problem

The biggest bug: when a user typed a message before clicking "Start Call", two audio responses would play simultaneously — the greeting and the reply — completely overlapping.

Root cause: speakAgent() was creating a new Audio() object every time without stopping the previous one. Also, the chat input depended on an active voice session — if /start hadn't
been called, /chat had no session history and silently failed.

Fix: Made speakAgent() return a Promise and always call stopAudio() first. Created a single handleUserMessage(text, source) function that both voice and chat feed into. If no session
exists when a chat message arrives, it auto-starts one, awaits the greeting, then sends the message — in sequence, never in parallel.

javascript
function stopAudio() {
if (agentAudio) {
agentAudio.onended = null;
agentAudio.onerror = null;
agentAudio.pause();
agentAudio = null;
}
isSpeaking = false;
}

function speakAgent(reply, audioUrl) {
return new Promise((resolve) => {
stopAudio(); // always kill previous before starting new
// ...
});
}

Free LLM Rate Limits

OpenRouter's free tier has a 50 requests/day cap. Hit it mid-demo. Solution: keep a fallback model ready (nvidia/nemotron-3-super-120b-a12b:free) and consider adding $5 credits for
recording days.

How to Build and Run It

Components You Need

Component	What it does	Tool used
STT	Converts speech to text	Web Speech API (browser)
LLM	Understands and responds	OpenRouter
TTS	Converts text to speech	Murf Falcon API
Transport	Connects everything	Flask + fetch

Setup

bash
git clone https://github.com/your-username/ashley
cd ashley
python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt

API Keys

Create a .env file — never commit this:

MURF_API_KEY=your_key
OPENROUTER_API_KEY=your_key
TWILIO_ACCOUNT_SID=your_sid
TWILIO_AUTH_TOKEN=your_token
TWILIO_FROM_NUMBER=+1xxxxxxxxxx
PUBLIC_BASE_URL=https://your-ngrok-url.ngrok.io

Run

bash
python server.py

open http://localhost:5000

For outbound calls, run ngrok in a separate terminal:
bash
ngrok http 5000

Then update PUBLIC_BASE_URL in .env with the ngrok URL.

Test a Conversation

Open http://localhost:5000
Enter your name or phone number
Click "Baat Shuru Karein" or just type in the chat box
Ask: "Main kisan hoon, mujhe kya mil sakta hai?"
Ashley will ask your age and land size, then show eligible schemes

What I'd Improve Next

• Replace Web Speech API with Deepgram or AssemblyAI for better Hindi accuracy
• Add support for regional languages: Tamil, Bengali, Marathi
• Move from SQLite to PostgreSQL for production
• Add a proper job queue so outbound calls don't block the server
• Stream TTS audio instead of waiting for the full clip

Links

• 🔗 GitHub: https://github.com/25wh1a6678-art/voice_agent
• 📊 Analytics: http://localhost:5000/dashboard
• 🆘 Escalations: http://localhost:5000/escalations

DEV Community: Tanmaya sree Chirra

Why We Built Foresight: Stopping AI from Committing Commercial Suicide

The System Architecture: How Foresight Fits Together

Core Technical Story: Moving from Naive RAG to Collision Detection

Code-Backed Implementation: How We Integrated Hindsight

1. Ingesting Deal History with retain()

2. Multi-Constraint Collision Evaluation

3. Dynamic Memory Reflection

Results and Behavior: The Live Interaction

Interaction 1: Before Memory Reflection (Defensive Triage)

Interaction 2: After Memory Reflection (Offensive Negotiation)

Lessons Learned

1. Negative Grounding Prevents Hallucinated Certainty

2. Decouple Static Policy from Dynamic Memory

3. Multi-Variable Constraints Beat Pure Probabilistic Generation

Conclusion

Finding Exoplanets in Noisy Data with Machine Learning

From Zero to Hindi Voice Agent in 10 Days: Schemes, Memory, and Outbound Calls"

Building Ashley: A Hindi Voice Agent for Rural Financial Access

The Problem and the Users

What Ashley Does

How the System Works

The Most Important Features

1. Indian Voice with Personality — Murf Falcon (hi-IN-shweta)

2. Safety Guardrails

3. Scheme Eligibility Tool

4. Consent-Gated Memory

5. Human Escalation + Outbound Calls

6. Specialist Handoff

Challenges and How I Overcame Them

The Overlapping Audio Problem

Free LLM Rate Limits

How to Build and Run It

Components You Need

Setup

API Keys

Run

open http://localhost:5000

Test a Conversation

What I'd Improve Next

Links

1. Ingesting Deal History with `retain()`