Project Info

MyAutoBenefits

Inspiration

Public benefits can be life-changing, but the path to getting them is still a maze. Families are expected to know which programs exist, understand eligibility rules, gather the right documents, re-enter the same information across multiple portals, and then wait through county or agency review. A missed program or missing proof document can mean leaving food, health coverage, phone discounts, or energy assistance on the table. We wanted to build an AI project that was useful in a high-stakes real-world setting, not just another chatbot. The core idea behind MyAutoBenefits is simple: people should be able to enter their situation once, see the benefits they may qualify for, understand why, and get safe help completing applications.

What it does

MyAutoBenefits is an AI-powered benefits navigator and application assistant. A user enters one household profile: location, household size, income, expenses, current benefits, immigration/citizenship status, and immediate needs. The app then checks that profile against program rules and surfaces benefits such as CalFresh, WIC, Medi-Cal, LIHEAP energy assistance, California LifeLine, and CalWORKs. For each program, MyAutoBenefits shows: whether the user likely qualifies or may qualify estimated monthly or yearly value when we can estimate it safely expected application time official application links and eligibility links a document checklist so users know what proof to prepare plain-language explanations of the matched rules For the end-to-end demo, CalFresh and WIC are agent-ready. Claude drafts user-specific application answers, and a Browserbase cloud browser agent opens a safe routed portal, fills out the application, submits the demo flow, captures confirmation proof, and saves the application status so judges can return to the proof later. Other benefits are still surfaced with official next steps even when auto-apply is not available yet.

How we built it

We built the frontend in React, Vite, and Material UI, with a paper-doodle inspired visual direction to make a stressful benefits workflow feel more approachable. The intake flow is modeled after real benefits screeners: it collects household members, income sources, expenses, health coverage, existing benefits, and urgent needs. The backend is a Flask/Python API. It runs deterministic eligibility checks for the programs we support, persists profiles, uploaded documents, and application confirmations in SQLite, and exposes routes for eligibility, document management, Claude-drafted answers, and browser-agent status. We used Anthropic Claude for the parts where natural language helps most: friendly explanations, summaries, and draft answers that the user can review. We intentionally did not let the model be the sole source of truth for eligibility. The core eligibility matching is rule-based, and the app links back to official program sources. We used Browserbase with Playwright to run the application-agent demo in a real cloud browser session. The agent fills a routed benefits portal flow, captures screenshots and confirmation evidence, and returns a live session/proof view. This let us demonstrate the hard part of the product: moving from "you might qualify" to "your application packet is ready."

Challenges we ran into

The hardest challenge was balancing ambition with safety. Public benefits are high-stakes: a wrong eligibility answer can waste someone's time or discourage them from applying, and a wrong form submission could create real harm. We had to design MyAutoBenefits around trust instead of pure automation. That meant keeping eligibility logic grounded in deterministic rules, showing official links, making the application flow reviewable, and using a safe routed portal for the live demo rather than silently submitting real government forms. Browser automation was also challenging. Form-filling agents are powerful, but real portals are brittle and vary across counties and programs. We scoped the end-to-end demo to CalFresh and WIC while still showing other benefits as reviewable next steps. Finally, we had to make the UI dense enough to be useful without overwhelming users. The app needs to show value, eligibility, documents, application time, official links, and agent status in a way that judges can understand quickly.

Accomplishments we're proud of

We are proud that MyAutoBenefits is more than a benefits chatbot. It has a real intake flow, rule-based program matching, estimated value, document checklists, official links, AI-generated explanations, draft application answers, and a live Browserbase agent flow for CalFresh and WIC. We are also proud of the trust and safety details: the app does not ask Claude to invent eligibility, it avoids unnecessary sensitive data in model calls, it gives users review points, and it saves browser-agent proof so the result is auditable. The most exciting part is that the demo shows a full loop: enter your situation once, discover benefits, prepare documents, draft application answers, run an agent, and come back to a verified submission record.

What we learned

We learned that AI agents are most useful when they are paired with narrow, well-defined responsibility boundaries. A model is great at explaining rules and drafting text, but eligibility and submission need structure, citations, and human review. We also learned that benefits access is a UX problem as much as it is a technical problem. Showing "you may qualify" is not enough. People need to know how much it might help, how long it takes, what documents to bring, what official site to trust, and what happens next. Most importantly, we learned that in high-impact domains, the winning AI pattern is not maximum autonomy. It is grounded automation: rules first, AI assistance second, user control always.

What's next

Next, we want to expand beyond the CalFresh and WIC demo flows into a broader California benefits assistant that can support Medi-Cal, CalWORKs, LIHEAP, California LifeLine, housing assistance, and local nonprofit programs. We would also add multilingual intake, OCR for uploaded documents, stronger rule retrieval over official PDFs, county-specific eligibility differences, secure document storage, and partnerships with benefits navigators or legal aid groups. Longer term, MyAutoBenefits could become a trusted application layer between families and fragmented public benefits systems: one profile, many programs, transparent eligibility, and safe AI help with the paperwork.

Benefits Navigator

Benefits Navigator helps a low-income California household discover benefits, review what information will be reused, and auto-apply to the two programs we demo end-to-end: CalFresh and WIC.

The demo is intentionally safe. Browserbase opens realistic BenefitsCal and California WIC URLs, then Playwright routes those page loads to local high-fidelity mock portals. The agent creates/fills/reviews/submits inside the mock portals only, captures confirmation proof, and saves the verified application status to SQLite.

What Works

Rich household intake with saved profile data
Rule-based eligibility results for California benefit programs
CalFresh and WIC prioritized in demo mode
Other eligible/maybe benefits still surface with official next-step links, even when they do not have AI auto-apply
Impact summary showing programs found, estimated monthly value, and auto-apply time saved
Per-program document preflight checklists before auto-apply
Official apply/rules links and compact program branding on each benefit card
Claude-generated explanations/draft answers when ANTHROPIC_API_KEY exists
Browserbase live cloud browser for CalFresh and WIC auto-apply flows
Safe fallback animation when Browserbase credentials are missing
Submitted confirmations, Browserbase evidence, and portal screenshots saved back to the dashboard
Completed applications can be reopened from the dashboard with View agent proof

Stack

React + MUI, Flask, SQLite, Anthropic, Browserbase, Playwright.

Setup

From the repo root:

python3 -m venv venv
venv/bin/pip install -r backend/requirements.txt
cd frontend && npm install

Create backend/.env:

ANTHROPIC_API_KEY=
BROWSERBASE_API_KEY=
BROWSERBASE_PROJECT_ID=

Anthropic is optional. Browserbase is required for the live cloud-browser proof.

Run Locally

Backend:

PYTHONPATH=backend venv/bin/python backend/app.py

Frontend:

cd frontend
npm run dev -- --host 127.0.0.1

Open http://127.0.0.1:5173/ and use Load CalFresh + WIC demo profile.

Fast Checks

These do not need API keys:

PYTHONPATH=backend venv/bin/python -m unittest discover -s tests
venv/bin/python scripts/verify_agent_fallback.py
cd frontend && npm run lint && npm run build

With Flask and Vite running, and Browserbase configured:

venv/bin/python scripts/verify_demo.py

Expected:

Demo E2E passed
Screenshots: /tmp/benefits_frontend_e2e

Safety Boundary

This project does not submit real government applications. The cloud browser uses real-looking public URLs only as the navigation target; requests are intercepted and fulfilled with local static portal HTML.

Analysis

Compare with all teams

View

Metric

Figures cover GitHub contributors during the hackathon window. A co-authored commit counts in full for each author, so per-member totals add up to more than the whole-team figures.

Technology

Found in codeClaimed only

AnthropicIn code
CSSIn code
FlaskIn code
HTMLIn code
JavaScriptIn code
PythonIn code
ReactIn code
RedisClaimed

7 of 8 appear in the indexed code. 1 claimed on Devpost could not be matched to code, which may simply mean the tool leaves no trace in the repository.

AI coding agents

Claude CodeConfig · Commits

Detected from committed agent config files and commit authorship. Absence of a signal is not proof an agent was unused.

Codebase size

Source size

736 KB

Source files

107

Counts recognized source files only; vendored directories, binaries and lockfiles are excluded, so this is smaller than the repository on disk.