DEV Community: Lalit

ScopeGuard 🛡️ — Catch Freelance Scope Creep Early with Local Open-Weight AI

Lalit — Sat, 17 Oct 2026 07:09:24 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

Freelance software engineers, UI/UX designers, and consultants constantly face one silent income-killer: scope creep.

Scope creep rarely arrives as an aggressive demand. It almost always arrives as an innocent-sounding message:

"Can you also connect Stripe checkout?"

"Can we just add an admin dashboard for managing orders?"

"While you're in there, could we set up customer accounts?"

Freelancers often struggle to push back due to people-pleasing tendencies, imposter syndrome, ambiguous contract wording, or simply the emotional exhaustion of drafting polite boundary emails. Unbilled scope creep routinely eats 15% to 30% of an independent creator's annual earnings.

ScopeGuard is a local-first AI assistant designed to solve this exact problem. It compares client messages directly against signed agreements or Statements of Work (SOWs) to:

Pinpoint Scope Boundaries: Identifies which requests are included, which are potentially_out_of_scope, and which are uncertain (ambiguous clauses).
Provide Evidence-Backed Citations: Extracts verbatim excerpts from both the client's request and the original contract agreement with confidence scores.
Draft 3 Tailored Client Pushback Replies:
- 🤝 Friendly & Collaborative: Enthusiastically suggests proposing the extra features as a Phase 2 add-on.
- 📋 Professional & Firm: Standard corporate change-order phrasing referencing signed project milestones.
- ⚡ Short & Direct: Quick 2-paragraph response for fast communications.
Anti-Hallucination Safety: Never invents fake hourly rates or delivery dates—uses structured placeholders like [estimated additional cost] and [timeline impact] for the freelancer to customize.

Who Would Pay For This?

Solo software developers, freelance designers, copywriters, and boutique agency owners. For a freelancer charging $75–$150/hr, catching just one unbilled scope creep request (e.g., adding an admin dashboard or authentication flow) easily saves $1,500 to $3,000+ of unpaid labor. A tool that provides contract-grounded pushback and polite email drafts pays for itself on day one.

Demo

🌐 Live Web Application & Interactive Playground: https://lalit-oli-mohan-479.github.io/ScopeGuard/

(You can test all 3 interactive scenarios—Website Developer Scope Creep, Vague Consulting Agreement, and Legitimate Clarification—directly in your browser with zero installation needed, or run inference locally on your own machine via Ollama!)

📥 Export Reports: The app includes a 1-click Download Markdown Audit Report button to save documented evidence for client change orders or contract dispute records.

Code

ScopeGuard is 100% open-source under the MIT License:

lalit-oli-mohan-479 / ScopeGuard

ScopeGuard 🛡️

AI-Powered Freelance Scope Creep Detector
Built for the Hacktoberfest 2026 Open-Source AI Challenge (Week 2: Side Hustle)

"Protect your time, catch scope creep early, and handle difficult client conversations professionally."

🌐 Live Web Application & Interactive Demo: https://lalit-oli-mohan-479.github.io/ScopeGuard/
(Experience the interactive scope analysis, reply drafts, and report generator directly in your browser without local setup!)

The Problem ScopeGuard Solves

Freelance software engineers, UI/UX designers, copywriters, and consultants frequently encounter scope creep—the gradual expansion of project requirements without corresponding adjustments to budget, timeline, or contractual terms.

Scope creep rarely arrives as an aggressive demand. It almost always sneaks in as innocent requests:

"Could you also connect Stripe checkout?"
"Can we just add an admin dashboard for orders?"
"While you're in there, could we set up customer accounts?"

Freelancers often struggle to navigate these conversations:

People-Pleasing & Imposter Syndrome: Independent creators fear that flagging extra work will damage client…

View on GitHub

GitHub Repository: https://github.com/lalit-oli-mohan-479/ScopeGuard

Tech Stack:

Local AI Engine: Ollama running open-weight Qwen 2.5 3B Instruct (also compatible with Llama 3.2 3B and Qwen 2.5 7B)
Backend API: FastAPI (Python 3.10+), Pydantic v2, Uvicorn
Frontend UI: React 19, TypeScript, Tailwind CSS, Lucide Icons, Vite
Test Suite: Pytest (13 backend unit tests) & Vitest (3 frontend component tests)

How I Built It

ScopeGuard is architected strictly around open-weight models and local inference:

PlantGuard AI: Open-Source Plant Disease Detection That Gets You Outside to Touch Grass 🌿

Lalit — Sat, 10 Oct 2026 08:31:41 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass.

🌿 PlantGuard AI: Open-Source Plant Disease Detection & Garden Care Companion

GitHub Repository: PlantGuard AI on GitHub

Live Demo: Try PlantGuard AI

What I Built

🌿 The Vision: Reconnecting Digital Minds with Living Earth

In an age where developers and tech workers spend 8 to 10 hours a day glued to glowing screens, our connection with the physical, living world can easily deteriorate. When a beloved balcony tomato plant develops yellow halos or an apple tree shows olive-green spots, our modern reflex is to grab a phone, search endlessly, and sink deeper into screen fatigue.

Existing commercial plant identification apps can make this experience even more frustrating:

Aggressive Subscription Walls: Essential plant health screening may be locked behind recurring subscriptions.
Privacy Concerns: Personal garden photos, images of living spaces, and location data may be uploaded to remote servers.
Passive Screen Traps: Users can get stuck scrolling through diagnosis pages, forum discussions, and pesticide advertisements instead of stepping outside to inspect their plants.

PlantGuard AI was built to offer a different approach.

Created for the Hacktoberfest Open-Source AI Challenge Week 1: “Touch Grass,” PlantGuard AI is an open-source plant disease screening tool and garden care companion designed to run locally.

It uses open-weight computer vision not to keep you glued to your screen, but to help you step away from your desk, get some sunlight, and reconnect with your garden.

🌱 Explore the project: GitHub Repository

👥 Who Is It For?

Urban and Balcony Gardeners: Apartment dwellers growing herbs, cherry tomatoes, and peppers in containers who need help identifying potential plant health problems.
Backyard Homesteaders and Community Growers: Gardeners managing vegetable patches and fruit trees who want accessible crop screening without recurring subscription fees.
Beginner Plant Parents: Enthusiasts looking for practical, cautious care guidance without unnecessary pressure to use synthetic chemicals.
Open-Source and Privacy Advocates: Users who want plant image analysis and garden records to remain on their own devices when using the local application.

✨ Core Features Breakdown

1. 🔬 Open-Weight AI Screening (38 Classes Across 14 Crops)

PlantGuard AI uses a MobileNetV2 architecture fine-tuned on the PlantVillage dataset to identify visual patterns associated with plant diseases and healthy leaves.

Lightweight Model (~8.9 MB weights): Designed for CPU inference without requiring a dedicated GPU.
Validation Accuracy: Reports 95.41% accuracy across 38 classes in the project's validation benchmark.
Supported Crops:
- Fruits and Orchards: Apple, Blueberry, Cherry, Grape, Orange, Peach, Raspberry, Strawberry.
- Vegetables and Field Crops: Bell Pepper, Potato, Tomato, Squash, Corn (Maize), Soybean.

These results represent the project's reported benchmark performance, not a guarantee of accuracy for every real-world garden condition.

2. 📊 Transparent Statistical Confidence and Low-Confidence Warnings

PlantGuard AI treats AI predictions as probabilistic screening aids, not definitive diagnoses.

Clearly labels prediction scores as Model Statistical Confidence.
Displays the top five alternative predictions with percentage bars.
Triggers a low-confidence warning when the top prediction falls below 60%.
Encourages users to consider environmental stress, lighting conditions, and unsupported plant species before taking action.

3. 🩺 Transparent, Practical Gardening Guidance

Each of the 38 classes includes a human-reviewed care profile designed to help users understand symptoms and choose sensible next steps.

Profiles include:

Symptom Manifestations: Visual descriptions of lesions, pustules, chlorosis, and stippling.
Immediate Practical Actions: Cleaning pruning tools, removing severely affected foliage when appropriate, and adjusting watering practices.
Preventative Cultural Practices: Mulching, drip irrigation, improving airflow, and crop rotation where applicable.

Recommendations are intended as general gardening guidance. Treatments should be selected according to the plant, likely cause, and local growing conditions.

4. 🌱 Dedicated “Touch Grass Mode”

This is the heart of PlantGuard AI.

Instead of ending with an AI prediction, the application gives users a customized checklist that encourages them to inspect their plants outdoors.

🧤 The 2-Inch Soil Finger Test: Check soil moisture below the surface before deciding whether to water.
🔍 Underside Leaf Examination: Inspect leaves in natural light for fungal signs, pest activity, and beneficial insects.
💨 Canopy Airflow Check: Look for overcrowding and improve air circulation where appropriate.
✂️ Sanitized Pruning: Remove affected foliage when appropriate and clean pruning tools between plants.

Interactive Milestone Rewards: After completing the outdoor inspection, users can click “Mark Outdoor Inspection Complete” to record their garden visit and celebrate time spent caring for living plants.

The goal is simple: use AI as a bridge to real-world action, not as another reason to stay indoors.

5. 📖 Local SQLite Plant Care Journal

The desktop application stores scan history, prediction confidence, personal notes, and outdoor follow-up statuses in a local SQLite database:

data/journal.db

Features include:

Reviewing historical observations and plant health progression.
Tracking follow-up statuses such as Pending Outdoor Check, Grass Touched: Inspected Outdoors, and Recovering.
Keeping garden notes and records locally when using the desktop application.

Privacy by design: The local desktop workflow is designed to keep plant photos, notes, and inference on the user's machine rather than uploading them to third-party servers.

The browser-based showcase uses browser localStorage for its client-side journal, which is separate from the desktop application's SQLite database.

🚀 Demo and Source Code

Experience PlantGuard AI in two ways.

1. 🌐 Live Web Showcase

Try it here: Open the Interactive GitHub Pages Demo

You can explore the interactive showcase from a phone, tablet, or desktop browser.

What you can do:

Instant Sample Testing: Explore sample profiles for:
- 🍅 Healthy Tomato Leaf
- 🥀 Tomato Early Blight
- 🍏 Apple Scab
Drag-and-Drop Image Ingestion: Upload a JPG or PNG leaf image to explore the demo's image-analysis interface.
Interactive Touch Grass Checklist: Check off real-world gardening tasks and track your progress.
Client-Side Plant Journal: Add, view, and manage observation logs stored in browser localStorage.
One-Click Code Snippets: Copy commands for running the Python application locally.

Note: The browser showcase and the full local desktop application are separate experiences. Check the repository documentation for the implementation details and capabilities of each.

2. 💻 Full Local Desktop Dashboard (Gradio + PyTorch)

Run the Python application locally to explore the complete desktop workflow.

Prerequisites

Python 3.10, 3.11, 3.12, or 3.13
Git

Quickstart Commands

# 1. Clone the repository
git clone https://github.com/lalit-oli-mohan-479/PlantGuard-AI---Open-Source-Plant-Disease-Detector.git

# 2. Enter the project directory
cd PlantGuard-AI---Open-Source-Plant-Disease-Detector

# 3. Install dependencies
pip install -r requirements.txt

# 4. Launch the local application
python app.py

Get the code: View the PlantGuard AI GitHub Repository

🌍 Why PlantGuard AI Matters

PlantGuard AI is built around a simple idea: technology should help us engage more meaningfully with the world around us.

By combining accessible computer vision, transparent prediction confidence, local data storage, and practical gardening checklists, the project aims to make plant health screening more approachable while encouraging users to spend less time scrolling and more time caring for their plants.

It is not about replacing hands-on gardening expertise. It is about using AI to help people ask better questions, inspect their plants more carefully, and take informed next steps.

🤝 Explore, Use, and Contribute

PlantGuard AI is an open-source project, and contributions are welcome.

🌱 GitHub: Star the repository, explore the code, or contribute

🌐 Live Demo: Try PlantGuard AI

Built for Hacktoberfest. Inspired by nature. Designed to bring people back to their gardens.

Touch grass. Inspect a leaf. Let AI help you take the next step. 🌿

🎯 Focus Mitra -> Gentle, Privacy-First AI Study Companion

Lalit — Sun, 04 Oct 2026 17:26:14 +0000

What I Built

I built Focus Mitra for my close friend who has been preparing for competitive exams and technical interviews while battling severe study paralysis and ADHD.
Whenever he sits down with massive syllabi or dense topics—like Compiler Design, Operating Systems, or Data Structures—he often hits an invisible wall of executive dysfunction. Traditional productivity apps made things worse: cold timers, flashing red streak alerts, and rigid checklists only amplified anxiety.
In Sanskrit and Hindi, Mitra means Friend.
Focus Mitra reimagines productivity through empathetic, companion-based guidance:

Smart Task Decomposition: Enter any overwhelming topic (e.g., "Understand LR Parsing" or "Prepare for Operating Systems Finals"), and the AI deconstructs it into bite-sized, 10–25 minute micro-steps with calm tips and time estimates.
Empathetic Companion Chat: An AI study companion you can talk to when you feel stuck, confused, or unmotivated—offering quick concept clarifications and gentle reassurance without judgment.
Adaptive Pomodoro Cycles: Low-pressure focus sessions with calming, restorative breaks.
Procedural Ambient Soundscapes: Generative audio synthesized in real time via the browser's Web Audio API—binaural focus waves, rain, cozy cafe, forest rustle, and lo-fi hum—requiring zero external streaming, MP3 downloads, or subscriptions.

5. Private Progress Tracking: Mindful streak counters and reflections that praise consistency over perfection, stored entirely on your device.

Demo

🌐 Live Web Application: https://lalit-oli-mohan-479.github.io/Focus_Mitra/
💻 Source Code: https://github.com/lalit-oli-mohan-479/Focus_Mitra ### How to Try It:
Open the Live Demo.
Local AI: If you have Ollama running locally (llama3.2 or mistral), the app connects automatically.
Cloud AI: If testing on mobile or a laptop without Ollama, click ⚙️ Settings in the top-right corner, enter your free Google Gemini API Key, and test the full AI decomposer and companion chat immediately.

4. Try breaking down a complex topic or turn on the ambient binaural soundscape!

Code

lalit-oli-mohan-479 / Focus_Mitra

🎯 Focus Mitra

A gentle, privacy-first AI study companion for students and creators who struggle with focus, overwhelm, and study burnout.

Built with ❤️ for a friend who battles ADHD, procrastination, and anxiety when starting large study sessions.

🌟 Why "Focus Mitra"?

In Sanskrit and Hindi, Mitra (मित्र) means Friend.

Traditional productivity tools are often cold, rigid, and guilt-inducing with red streaks and harsh alarms. Focus Mitra reimagines study productivity through empathetic, companion-based guidance:

It breaks terrifying, complex topics into bite-sized, digestible micro-steps.
It provides warm, calm encouragement instead of judgment.
It combines adaptive Pomodoro cycles with a generative ambient soundscape and thoughtful check-ins.

🧠 Open-Source AI at the Core

Focus Mitra is built around open-source AI principles:

100% Local & Private: Connects directly to Ollama running local open-weight models (llama3.2, mistral, deepseek-r1, phi3). Your personal study thoughts, struggles, and notes never leave…

View on GitHub

- GitHub Repository: https://github.com/lalit-oli-mohan-479/Focus_Mitra

How I Built It

Focus Mitra is engineered with open-source AI, lightweight web standards, and privacy at its foundation:

1. Local Open-Source AI Engine (Ollama)

Direct integration with Ollama REST API running open-weight models such as Llama 3.2, Mistral, or DeepSeek-R1.
Model-agnostic design: Users can switch models on the fly depending on their hardware.
Custom system prompting tailored for calm, gentle peer encouragement rather than robotic instruction. ### 2. Cloud Fallback (Gemini API)
To ensure my friend could still use Focus Mitra on his lightweight travel laptop without a dedicated GPU, I built a smart dual-backend system that seamlessly falls back to Google's Gemini API with client-side API key storage (localStorage). ### 3. Procedural Audio Engine (Web Audio API)
Rather than streaming large audio files over the internet, ambient sounds (binaural beats, pink/white rain noise, cafe hum) are synthesized procedurally in real-time in the browser using Web Audio API oscillators and gain nodes. ### 4. Glassmorphism Design System

- Built with semantic HTML5 and vanilla modern CSS (custom tokens, flexbox/grid, and micro-interactions) to keep the app blazing fast, lightweight, and calming to look at.

Why Does Open Innovation Matter?

When you are struggling with focus or mental fatigue, your study notes, frustrations, and thoughts are deeply personal. Using closed, centralized AI services often means:

Your candid study struggles and notes get logged onto corporate cloud servers.
You are gated behind $20/month subscription paywalls that students cannot afford.
You are dead in the water the moment Wi-Fi cuts out in a library or train. Open innovation changes everything:
Zero Data Leakage (100% Private): Running open-weight models locally on Ollama ensures personal notes and reflections never leave your machine.
Offline Reliability: Works in rural areas, flights, or distraction-free offline study retreats with no internet connection.
Accessible to Every Student: High-performance open models like Llama 3.2 3B run comfortably on standard consumer laptops at zero cost.
User Agency: The user owns their AI companion—free to fine-tune prompts, adjust system temperatures, and switch backends whenever they choose. --- ## My Agent Session

Built with the assistance of an agentic pair-programming workflow in Google Antigravity, iterating from problem discovery through generative audio synthesis, local Ollama integration, UI refinement, and automated GitHub Pages deployment.

Building Jan Dhan Seva: A Multi-Agent Voice AI Assistant for Financial Literacy in India 🇮🇳

Lalit — Sat, 15 Aug 2026 04:35:08 +0000

Building Jan Dhan Seva: A Multi-Agent Voice AI Assistant for Financial Literacy in India 🇮🇳

#10DaysOfAIVoiceAgents Challenge — VoiceForBharat Edition by Murf AI

Powered by Murf Falcon TTS, LiveKit Agents SDK, Deepgram STT, Google Gemini LLM, Next.js 15, and SQLite.

📌 1. The Problem & The Audience

In India, hundreds of millions of citizens are entering the formal banking system through national financial inclusion initiatives like the Pradhan Mantri Jan Dhan Yojana (PMJDY). However, a major barrier remains: financial literacy and language accessibility.

Navigating complex banking terminology, understanding government scheme eligibility, calculating fixed deposit (FD) returns, or avoiding cyber fraud can be daunting—especially for first-time banking users who prefer communicating in their native language over text or voice.

To solve this, I built Jan Dhan Seva (Aarav Voice Agent)—an interactive, register-aware, multilingual AI voice assistant designed to deliver accessible financial guidance in Hindi (Devanagari) and English.

🏗️ 2. How the System Works

The system operates on an ultra-low latency (<480ms voice turn) streaming loop using WebRTC transport.

sequenceDiagram
    autonumber
    actor Caller as 👤 Caller (Browser/SIP)
    participant LK as ⚡ LiveKit WebRTC
    participant STT as 🎙️ Deepgram STT
    participant LLM as 🧠 Gemini 3.5 LLM
    participant TTS as 🔊 Murf Falcon TTS
    participant DB as 💾 SQLite & UI Cards

    Caller->>LK: Speaks Audio Chunk
    LK->>STT: Audio Stream
    STT-->>LLM: Real-Time Text Transcript
    LLM->>DB: Execute Tool (e.g. FD Calc / Handoff)
    DB-->>LK: Push Floating UI Card
    LLM->>TTS: Streamed Response Text
    TTS-->>LK: High-Quality Audio Stream (Samar/Pooja/Nikhil/Palak)
    LK-->>Caller: Plays Audio Response (<480ms Latency)

Core Architecture Components:

Streaming Speech-to-Text (STT): Deepgram nova-3 for real-time multilingual speech recognition (Hindi + English).
Brain / Reasoning Engine (LLM): Google gemini-3.5-flash-lite for intent classification, strict language mirroring, and tool calling.
Text-to-Speech (TTS): Murf Falcon — ultra-fast streaming Indian voice models with dynamic voice profile switching (Samar, Pooja, Nikhil, Palak).
Real-Time Transport & State: LiveKit Agents SDK with WebRTC audio streaming, Voice Activity Detection (Silero VAD), and data channels.
Persistence & Telephony: SQLite (data.db) for profile memory, outbound call logs, escalation tickets, and session analytics.

🌟 3. Most Important Features Built

1. Multi-Agent Mesh Architecture & Dynamic Murf Falcon Voice Handoffs 🔄

Instead of relying on a single monolith agent, Jan Dhan Seva implements a 4-agent specialist mesh featuring:

Aarav (Main Guide) — Murf Voice: Samar
Kavya (Schemes Specialist) — Murf Voice: Pooja
Vikram (Fraud Specialist) — Murf Voice: Nikhil
Kirti (FD Calculator Specialist) — Murf Voice: Palak

When a user switches topics, the active agent executes a handoff tool that atomically updates the session's underlying Murf TTS voice profile in real-time without dropping the WebRTC audio connection:

# Code Snippet: Sub-second atomic voice engine transition inside AgentSession
async def _switch_agent(self, specialist: BaseAgent, active_agent_title: str) -> str:
    # 1. Update TTS engine to specialist's assigned Murf voice model
    self.ctx.session._tts = specialist.tts
    # 2. Switch agent persona and instructions
    self.ctx.session.update_agent(specialist)
    # 3. Trigger immediate proactive speech generation
    asyncio.create_task(self.ctx.session.generate_reply())
    return f"Transferred call to {active_agent_title}."

2. Strict Language Mirroring & Financial Guardrails 🛡️

Script Consistency: Hindi input triggers pure Devanagari Hindi output. English input triggers pure English output.
Credential Protection: Intercepts requests for PINs, passwords, OTPs, or 16-digit card numbers with immediate security alerts.

3. Persistent Caller Profile Memory & Consent 💾

Integrates SQLite caller lookup (lookup_caller). Greets returning citizens by name, references their previous interaction date, and enforces explicit user consent before storing personal information.

4. Real-Time Tools & Floating UI Data Cards 📊

Bullion Rate Tool (get_gold_silver_price): Live 24K/22K Gold & Silver market rates via GoldAPI.io.
Government Schemes Database (lookup_govt_scheme): Curated eligibility criteria, document checklists, and benefits for major schemes (PMJDY, APY, PMSBY, PMJJBY, Sukanya Samriddhi, PM Kisan, PM Mudra).
FD Returns Calculator (calculate_fd_returns): Computes exact quarterly compounding returns based on current SBI rates (7.1% p.a.).

5. AI Guardrails & Non-Decision Boundaries 🚧

Implemented strict conversational boundaries preventing the agent from taking binding financial decisions. Scenarios like unauthorized transactions, account freezes, or KYC rejections trigger immediate red lines—redacting PII and generating emergency human escalation tickets.

6. Human Escalation Protocol & Support Portal 🚨

Generates unique reference IDs (e.g. ESC-72973) for cyber fraud disputes, redacts PII, saves tickets to SQLite, provides status lookups, and posts rich alerts to Discord support webhooks.

7. Glassmorphic Call Analytics Dashboard 📈

Features 5 live telemetry cards (Total Calls, Success Rate %, Avg Duration, Voice Turn Latency ~480ms), an SVG Donut Chart, failure category breakdowns, and 5-second polling via Next.js 15 REST endpoints (/api/analytics).

💡 4. Challenges & How I Overcame Them

Difficulty 1: Handoff Speech Transition Delay

Problem: When Aarav transferred a call to Kirti or Vikram, the system initially waited for the user to speak again before the specialist introduced themselves.
Solution: Implemented an asynchronous trigger asyncio.create_task(ctx.session.generate_reply()) inside _switch_agent. Now, the moment the TTS engine switches to Murf Palak or Nikhil, the specialist agent proactively greets the caller with zero delay.

Difficulty 2: Function Parameter Binding Mismatches

Problem: Tool execution for calculate_fd_returns failed under Gemini because RunContext injection caused signature mismatch errors.
Solution: Refactored tool signatures to isolate dynamic arguments and added safe_float type-coercion helpers to handle both string and numeric inputs cleanly.

🛠️ 5. How Readers Can Build and Run It

Follow these steps to get Jan Dhan Seva running locally:

1. Prerequisites

Python 3.10+ and uv
Node.js 18+ and pnpm
API Keys: Murf AI, LiveKit Cloud, Deepgram, and Google Gemini AI Studio.

2. Backend Setup

git clone https://github.com/lalit-oli-mohan-479/murf-livekit-starter-my.git
cd murf-livekit-starter-my/backend

# Create .env.local in backend directory (Never commit API keys!)
cp .env.example .env.local

# Install dependencies & run backend dev agent
uv sync
uv run python src/agent.py dev

3. Frontend Setup

cd ../frontend
pnpm install
pnpm dev

Open http://localhost:3000 in your browser, click "START TALKING", and converse with Aarav and his specialist team!

🔮 6. What I Would Improve Next

Regional Voice Support: Expanding Murf Falcon voice models to support Tamil, Telugu, Bengali, and Marathi.
Offline WhatsApp Receipts: Pushing scheme eligibility checklists and escalation reference IDs via WhatsApp Business API upon call disconnect.

🔗 Code & Resources

GitHub Repository: https://github.com/lalit-oli-mohan-479/murf-livekit-starter-my
Murf Falcon TTS API: Murf AI Documentation
LiveKit Agents Framework: LiveKit Docs

Built with ❤️ for #VoiceForBharat and the #10DaysOfAIVoiceAgents Challenge.