Inspiration
Over 500 million Indians are eligible for government welfare schemes they never claim — not because they don't want help, but because the system is fragmented, bureaucratic, and built around forms that assume a literacy and digital fluency many people don't have.
We grounded our thinking in one person: Ramesh, a 42-year-old daily-wage laborer in Uttar Pradesh earning ₹8,000/month, living in a kutcha house with his wife and three children, two of them in government school. Ramesh has likely been eligible for housing assistance for years — he just never knew which scheme, what the income threshold was, or what documents to bring. When he visits a block office to ask, he loses a full day's wages, only to be turned away for a missing document nobody told him about.
We didn't want to build another government scheme directory. India already has dozens. What's missing isn't information — it's interpretation, trust, and a clear next step.
What it does
YojanaPath asks a user 13 simple, guided questions — in Hindi or English — about their age, income, housing, land, and family situation. It then checks their answers against 8 major central government schemes (PM-KISAN, Ayushman Bharat, PDS, MGNREGA, PMAY-G, NSP Scholarships, PMJJBY, and PMSBY) and shows a visible reasoning chain: exactly which fact about the user's life matched which government rule, with a confidence score — never a flat guarantee.
Beyond eligibility, YojanaPath:
- Generates a consolidated, deduplicated document checklist for every matched scheme
- Calculates a combined benefit summary — total annual cash, one-time grants, and recurring in-kind support — so the user sees the real value of acting, not just a list
- Routes the user to their nearest Common Service Centre (CSC) with a pre-written handoff summary for the local VLE operator
- Includes a misinformation fact-checker — users can paste a rumor they heard (e.g. "PM-KISAN band ho gaya hai") and the system verifies it against real scheme data, correcting false claims with the actual numbers instead of letting misinformation spread unchecked
How we built it
The backend is a Python FastAPI service. Eligibility rules for all 8 schemes are codified as structured YAML files — income thresholds, exclusions, required documents, and CSC routing instructions — so the reasoning engine is grounded in verifiable facts, not the LLM's own assumptions.
We use the Groq API (llama-3.1-8b-instant) for four coordinated agents:
- Eligibility Agent — classifies the user against each scheme's rules and generates the visible reasoning chain
- Document Agent — generates the deduplicated document checklist
- Handoff Agent — writes the plain-language CSC handoff summary
- Fact-Check Agent — verifies user-submitted claims against the same YAML knowledge base
Every agent is strictly prompted to reason only from the injected YAML context — never from general training knowledge — and to use probabilistic framing ("likely qualifies") rather than definitive claims. A deterministic local fallback exists for every agent in case the API is unavailable, so the system degrades gracefully instead of failing silently.
The frontend is built in React with a conversational chat interface, a color-coded reasoning chain table, an animated confidence meter, and a combined benefit summary banner.
Challenges we ran into
Grounding vs. hallucination. Early on, the LLM occasionally produced vague or overly cautious explanations when a user's claim partially matched a scheme's actual benefit. We added a deterministic override layer that pulls the exact value from the YAML knowledge base whenever there's a numeric mismatch, so explanations always cite the real figure instead of a generic "partially supported" response.
Merge conflicts across a 3-person team working under deadline pressure, including a moment where one teammate pushed to a different default branch than the rest of the team — we had to carefully reconcile both branches' work (including bug fixes to our API integration) without losing either side's contributions.
Balancing realism with build-time constraints. India's welfare system has dozens of state-specific variations. We scoped our knowledge base to 8 major central schemes with nationally consistent rules, while designing the YAML structure so state-specific rules (like Kerala's color-coded ration cards) could be added without changing the reasoning engine itself.
Accomplishments that we're proud of
- A genuinely visible reasoning chain — not a black-box chatbot answer, but a transparent table showing exactly why a user does or doesn't qualify for each scheme
- A misinformation fact-checker that uses the same grounded knowledge base to correct false claims, addressing a real and underserved problem in rural India
- Built-in Responsible AI safeguards from day one: probabilistic framing, confidence scoring tied to data completeness, a persistent disclaimer, and a hard human-in-the-loop handoff for final verification
- In-memory-only data processing, aligned with India's Digital Personal Data Protection Act (2023)
What we learned
We learned that the hardest part of building "trustworthy AI" isn't the model — it's the discipline of constraining it. Every design decision, from YAML grounding to probabilistic language to the CSC handoff, exists because we kept asking: what happens to a real person if this is wrong?
What's next for YojanaPath
- Integrate real Common Service Centre location data so the handoff is GPS-specific, not just district-level
- Expand the knowledge base to include state-specific scheme variations
- Add voice input for users who are more comfortable speaking than typing
- Partner with an actual CSC network or NGO for a pilot deployment
Log in or sign up for Devpost to join the conversation.