When Berkeley's systems fail students, Jugaad gives them the workaround.

Jugaad is a voice-powered AI platform that crowdsources and delivers the creative hacks, loopholes, and workarounds that Berkeley students use to survive broken systems — and makes them available to every student, not just the ones with the right connections.

Built at UC Berkeley AI Hackathon 2026 by team Jugaad · Track: Ddoski's World (Social Impact) · $5,000 Grand Prize

Berkeley's institutional systems — financial aid, housing, mental health, enrollment, food access — are broken, overwhelmed, or inaccessible. Solutions DO exist: clever workarounds, stacking strategies, and loopholes that students discover through experience. But this "jugaad knowledge" only circulates inside privileged social networks: Greek life, legacy families, established friend groups.

First-gen students, transfer students, international students, and low-income students are systematically excluded from this tribal knowledge. The information asymmetry is the real inequity.

Food Insecurity

• 39% of undergrads and 23% of grad students experience food insecurity
• Roughly 17,000 Berkeley students don't have reliable access to food
• CalFresh eligibility changed April 1, 2026 for non-citizen groups
• The Basic Needs Food Pantry is in the lower level of MLK Student Union — the hackathon venue

Housing Insecurity

• 3,300+ students lack stable housing
• 2,400 face both food and housing insecurity simultaneously
• Berkeley has the highest student housing costs of any UC campus

Mental Health

• 61% of undergrads say depression and stress is an obstacle to academic success
• Tang Center / CAPS has weeks-long wait times for counseling appointments

Financial Aid Chaos

• FAFSA processing paused after April 21, 2026 due to One Big Beautiful Bill Act system updates
• Grad PLUS loans eliminated effective July 1, 2026
• Parent PLUS loans capped at $20K/year, $65K aggregate

Academic Crisis

• 35.3% of CS 10 students received F's in Spring 2026 (up from under 10% historically)
• EECS graduating class dropping from 1,029 to ~350
• Student Advisory Council explicitly listed "challenging to find campus resources" as a top issue

Jugaad works in three steps:

1. Listen — Speak or type your problem. Deepgram captures your voice, Claude understands the context, and a Coordinator Agent routes your request to the right specialists.
2. Match — Five specialized agents run in parallel, each searching their domain — food, safety, financial aid, wellness, and academics — drawing from a live Redis knowledge graph and Browserbase web agents browsing Berkeley sites in real time.
3. Act — A personalized dashboard surfaces your specific "hack stack": not just what resources exist, but how to stack them, what exemptions you qualify for, and pre-filled applications ready to submit.

The key differentiator: Jugaad doesn't just INFORM ("here's the food pantry"). It SOLVES ("here's how to stack CalFresh + food pantry + event food + Market Match to eat well on near-zero budget, and here's your auto-filled CalFresh application").

Owner: Person 1 (AI / Claude Lead)

A Claude-powered conversational agent that replaces a cold form. It asks 6–8 natural questions — delivered via voice through Deepgram — to build a complete student profile in under 5 minutes. This profile powers every personalized recommendation downstream.

Collects:

• UC campus and enrollment status (full-time, part-time, grad, undergrad)
• EFC / SAI from financial aid letter
• Housing situation — on-campus, off-campus, or unstably housed
• Meal plan status — active, expired, or none
• Citizenship/residency status — determines CalFresh, DACA, and undocumented-specific eligibility
• Current aid received (Pell, Cal Grant, loans)
• Number of dependents

How it works:

User speaks or types → Deepgram STT transcribes → Claude asks follow-up questions
→ Profile JSON built → Saved to Redis (session) + Supabase (persistent)
→ Profile broadcast to all agents via Coordinator

Tech: Claude claude-sonnet-4-6, Deepgram STT, FastAPI, Redis, Supabase

Owner: Person 4 (Frontend Lead) + Person 2 (Fetch.ai Lead)

After intake, the dashboard shows only the resources this specific student qualifies for — not a generic directory. Powered by five specialist agents running in parallel, with results drawn from the Redis knowledge graph and live Browserbase web searches. Ranked by deadline urgency, match confidence, and dollar value.

Each resource card includes:

• Resource name and organization
• One-sentence match explanation (why this student qualifies)
• Dollar value or benefit description
• Deadline badge — red if under 7 days, amber if under 30
• Effort level — "5 min online form" vs "appointment required"
• "Apply Now" CTA that generates pre-filled content from the student's profile

Categories covered:

How it works:

Profile broadcast to Coordinator Agent
→ Coordinator routes to 5 specialist agents
→ Agents query Redis knowledge graph + Browserbase live search
→ Results merged, ranked, and rendered as personalized "hack stacks"

Tech: Next.js, Tailwind CSS, FastAPI, Redis, Browserbase, Fetch.ai uAgents

Owner: Person 1 (AI / Claude Lead)

The core value proposition. For each problem domain, Claude doesn't return a single resource — it returns a complete stacking strategy of 3–6 complementary resources that compound together. These hacks are drawn from the crowdsourced knowledge graph and personalized to the student's exact situation.

Example hack stacks by domain:

Food Insecurity Hack Stack:

• CalFresh ($292/month) + food pantry (weekly, MLK lower level) + Grab N Go recovered meals (free, daily) + club events with free catering (several/week) + Berkeley Student Food Collective (sliding-scale) + Market Match at Saturday farmers market (doubles first $10 CalFresh spend)
• Most students know 1–2 of these. Jugaad gives you all 6 and helps you access each one.

Housing Hack Stack:

• BSC co-op (30–50% cheaper than dorms, rolling admissions, most students never hear about it) + summer sublet conversion strategy + rent control rights (apartments pre-1980 have annual caps) + lease red-flag scanner (upload lease, AI flags predatory clauses)

Financial Aid Hack Stack:

• Special Circumstances Appeal (recalculates aid based on current income — can add thousands) + emergency short-term loan bridge (covers FAFSA delay) + micro-scholarship scan (hundreds of $500–$2,000 awards with few applicants) + fee payment plan (spreads tuition across semester)

Mental Health Hack Stack:

• Let's Talk drop-in (no appointment, no paperwork, multiple campus locations) + SHIP therapist bypass (off-campus providers with same-week availability, no referral) + urgent appointment pathway at CAPS (same-day if you communicate urgency) + 24/7 counseling line: 855-817-5667

How it works:

User describes problem
→ Claude classifies domain + urgency
→ Redis vector search retrieves relevant hacks
→ Claude assembles personalized stack based on student profile
→ Ranked by impact + effort + deadline

Tech: Claude claude-sonnet-4-6, Redis vector search, FastAPI

Owner: Person 2 (Fetch.ai + Band Lead)

Five specialized agents registered on Agentverse, coordinated by a Jugaad Coordinator Agent via the Fetch.ai mailbox protocol. Agents also share context through Band rooms, enabling cross-domain intelligence: if the financial aid agent detects aid loss, the food agent proactively surfaces CalFresh hacks.

The agents:

Cross-domain intelligence (Band):

Financial aid loss detected
→ Food Agent proactively surfaces CalFresh + food pantry hacks
→ Wellness Agent flags mental health resources for financial stress
→ Academic Agent checks for registration holds tied to outstanding balance

Demo flow:

User: "I need help paying for food."
→ Coordinator receives message via Fetch.ai mailbox
→ Routes to: Food Agent + Financial Aid Agent (parallel)
→ Both query Redis knowledge graph + Browserbase live search
→ Band room shares context: Financial Agent finding aid triggers Food Agent supplement
→ Returns: Complete personalized food survival plan

Tech: Fetch.ai uAgents SDK, Agentverse, Band platform, Python asyncio

All agents have real addresses on Agentverse, verifiable by judges during demo.

Owner: Person 4 (Frontend Lead)

Voice is the primary interface, not a bolt-on. Many students in crisis are multitasking, visually impaired, or in situations where typing is impractical. Deepgram STT captures voice input; Deepgram TTS delivers responses back as natural speech. The entire intake-to-dashboard flow works hands-free.

Components:

Demo flow:

User presses mic button
Speaks: "I can't afford food this week."
→ Deepgram STT transcribes in real time
→ Agents activate (visible in activity feed)
→ Resource dashboard populates
→ Deepgram TTS: "You likely qualify for CalFresh. I've pre-filled your application. The food pantry one floor below us is open Friday at 2pm..."

Tech: Deepgram STT + TTS SDK, Next.js, React

Owner: Person 3 (Data Lead)

The intelligence and memory backbone. Redis stores student sessions so they never re-answer the same questions. A vector-indexed knowledge graph encodes all jugaad hacks, eligibility rules, and resource relationships — enabling semantic search so Claude finds the right hack even when the user's phrasing doesn't match keywords.

Components:

Knowledge graph seeded with (from Section 5 hacks):

• All food insecurity hack stacks (CalFresh exemptions, stacking strategies, surplus network)
• All housing hacks (BSC co-op, rent control, lease scanner, summer sublet conversion)
• All mental health hacks (Let's Talk schedule, SHIP provider bypass, urgent appointment pathway)
• All financial aid hacks (Special Circumstances appeal, micro-scholarships, emergency loans)
• All safety hacks (walking buddy algorithm, safe routes, SafeWalk request flow)
• All academic hacks (enrollment strategies, BerkeleyTime patterns, study group matching)

Tech: Redis Cloud, Redis vector search, Python embeddings

Owner: Person 3 (Data Lead)

Four web-browsing agents that crawl Berkeley websites in real time, ensuring resource data is always current — not stale from a seed database. Live results are visible in the UI during demo.

Agents:

Demo moment:

User: "Find me scholarships I can apply for this week."
→ Browserbase searches Berkeley financial aid pages live
→ Returns: Current opportunities with real deadlines
→ Results cached in Redis for next similar query

Tech: Browserbase SDK, Stagehand, Python, FastAPI

Owner: Person 1 (AI / Claude Lead)

Students miss aid because they didn't know about a deadline, not because they chose not to apply. Proactive alerts fire at 30 days, 7 days, and 48 hours before each relevant deadline — based on the student's profile and the resources they've been matched with.

Tracks:

• FAFSA priority deadlines per campus
• Special Circumstances appeal windows
• CalFresh recertification deadlines (every 6–12 months)
• Scholarship deadlines matched to student profile
• Emergency grant application windows (quarterly)
• Fee deferral request windows (per semester)

Alert channels:

• In-app notification with one-click "start application"
• Email digest (weekly upcoming deadlines)
• SMS via Twilio for students who check email infrequently

Tech: Supabase scheduled functions, Resend (email), Twilio (SMS)

See Feature 1 above — this is the same agent, preserved from original spec.

Owner: Person 4 (Frontend Lead)

A live crowdsourced visualization of student struggles across campus. Students anonymously report what they're struggling with; Jugaad aggregates into a real-time crisis dashboard. Useful for individual students navigating the city — and as an advocacy data tool for student government and administrators.

What it shows:

• Food insecurity density by neighborhood
• Safety incident clusters by time of day
• Financial aid anxiety spikes (e.g., post-FAFSA pause)
• Mental health demand vs. CAPS capacity
• Resource gaps — areas with problems but no nearby resources

Tech: Next.js, Recharts or D3.js, Supabase real-time, Mapbox

Owner: Person 4 (Multi-Agent + Reliability Lead)

In a platform that students depend on for critical information — food access, housing, financial aid — hallucinations and errors are unacceptable. Every Claude call is instrumented through Arize for trace monitoring. Sentry is integrated from the first commit for error monitoring and crash reporting.

Arize:

• Every Claude API call logged with input, output, and agent context
• Traces show full agent reasoning chains
• Used during the hackathon to identify and fix prompt issues in real time
• Demo moment: show Arize dashboard with traces proving output quality improved

Sentry:

• Error monitoring across all agents and API calls
• Performance monitoring for voice pipeline latency
• Crash reporting with full context

Tech: Arize SDK, Sentry SDK, FastAPI middleware

┌────────────────────────────────────────────────────────────────┐
│                    VOICE + CHAT INTERFACE                       │
│              Deepgram STT/TTS + Next.js UI                      │
│                                                                 │
│  ┌────────────┐   ┌──────────────────┐   ┌───────────────────┐  │
│  │  Voice     │   │  Agent Activity  │   │  Berkeley         │  │
│  │  Chat      │   │  Feed            │   │  Problem Map      │  │
│  │  Panel     │   │                  │   │  Dashboard        │  │
│  └────────────┘   └──────────────────┘   └───────────────────┘  │
└───────────────────────────┬────────────────────────────────────┘
                            │
               ┌────────────▼────────────┐
               │      ORCHESTRATOR        │
               │      Claude API          │
               │  classify → route →      │
               │  select jugaads →        │
               │  generate hack stack     │
               └────────────┬────────────┘
                            │
        ┌──────────┬─────────┼──────────┬──────────┐
        │          │         │          │          │
   ┌────▼───┐ ┌────▼───┐ ┌───▼────┐ ┌───▼────┐ ┌──▼──────┐
   │  FOOD  │ │ SAFETY │ │  AID   │ │WELLNESS│ │ ACADEMIC│
   │ AGENT  │ │ AGENT  │ │ AGENT  │ │ AGENT  │ │  AGENT  │
   └────┬───┘ └────┬───┘ └───┬────┘ └───┬────┘ └──┬──────┘
        └──────────┴─────────┼──────────┴──────────┘
                             │ Fetch.ai Agentverse + Band rooms
              ┌──────────────▼──────────────────┐
              │           SHARED SERVICES         │
              │                                   │
              │  Redis:                            │
              │    Jugaad Knowledge Graph          │
              │    Vector search (RAG)             │
              │    Semantic caching                │
              │    Student session memory          │
              │    Food surplus real-time DB       │
              │    Walking buddy queue             │
              │                                   │
              │  Browserbase: Live Berkeley crawl  │
              │  Arize: LLM observability traces   │
              │  Sentry: Error monitoring          │
              └───────────────────────────────────┘

Each person owns one vertical end-to-end. All four tracks must be demo-ready independently, then integrated in the final hour.

Goal: Win Anthropic + Best Golden Bear Hack

Setup:

• Install Anthropic SDK (pip install anthropic)
• Test Claude claude-sonnet-4-6 API connection
• Design system prompt architecture (master prompt + domain-specific sub-prompts)
• Set up Arize instrumentation on all Claude calls

Build:

Features to own:

Deliverables:

• Intake interview working end-to-end (voice in → profile built)
• All domain hack selection logic returning personalized results
• "Apply Now" generates real pre-filled content from student profile
• Arize traces on every Claude call, dashboard accessible during demo

Sponsor targets: Anthropic · Best Golden Bear Hack · Ddoski's World Grand Prize

Goal: Win Fetch.ai + Band

Setup:

• Attend Fetch.ai workshop at hackathon
• Install Fetch.ai uAgents SDK (pip install uagents)
• Create Agentverse account at agentverse.ai
• Register all agents and make them discoverable
• Set up Band account and create shared agent rooms

Agents to build:

Band integration:

• Create shared Band rooms for agent coordination
• Implement cross-domain triggers: financial stress → food hacks proactively surfaced
• Academic struggle → wellness agent offers mental health resources
• Minimum: 3 agents sharing context through Band during demo

Deliverables:

• All 6 agents registered with real addresses on Agentverse
• Agent-to-agent communication via Fetch.ai mailbox protocol working
• Coordinator correctly routes to relevant agents based on user problem
• Band rooms active with at least 3 agents sharing context
• Demo showing agents collaborating on one query — Agentverse dashboard visible

Sponsor targets: Fetch.ai · Band · Most Technical Hack

Goal: Win Browserbase + Redis

Setup:

• Spin up Redis Cloud instance (free tier)
• Set up Browserbase account and test a scrape
• Design knowledge graph schema (hack types, resource types, eligibility rules, relationships)

Redis — build:

Browserbase agents — build:

Knowledge base to populate (from the hack stacks in this doc):

• All food insecurity hacks (CalFresh exemptions, stacking strategy, surplus network)
• All housing hacks (BSC co-op, rent control, lease scanner, sublet conversion)
• All financial aid hacks (Special Circumstances, micro-scholarships, emergency loans)
• All mental health hacks (Let's Talk, SHIP bypass, urgent CAPS, 24/7 line)
• All safety hacks (walking buddy, safe routes, SafeWalk)
• All academic hacks (enrollment strategy, BerkeleyTime, study groups)

Deliverables:

• Redis connected with user profiles persisting across sessions
• Knowledge graph with 30+ hacks indexed as vector embeddings
• At least 2 Browserbase agents returning live Berkeley results during demo
• Semantic cache demonstrably reducing latency on repeated queries

Sponsor targets: Browserbase · Redis · Most Technical Hack

Goal: Win Deepgram + Best UI/UX

Setup:

• Initialize Next.js 14 project with Tailwind CSS
• Set up Deepgram account and test STT + TTS
• Set up Sentry SDK from first commit (required for Sentry prize)
• Create Vercel project for instant deploys

Pages to build:

Deepgram — build:

Visual components:

Sentry integration:

• Sentry SDK in from first commit
• Error boundaries on all major components
• Performance monitoring on voice pipeline latency

Demo day extras:

• Devpost screenshots — every major screen captured before 11am Sunday
• Demo video — 90-second screen recording of full voice flow
• Pitch slides — 5 slides: problem, solution, demo, tech, impact
• Own the live demo at judging — practice 5+ times before 1pm

Deliverables:

• All 5 pages built and navigable
• Voice flow working end-to-end: speak → agents activate → spoken response
• Agent activity feed updating in real time during a query
• App deployed to Vercel with shareable URL before 11am Sunday

Sponsor targets: Deepgram · Best UI/UX · Hacker's Choice · Sentry

Estimated total prize value: $15,000+ cash/credits + hardware

"39% of Berkeley undergrads are food insecure. That's 17,000 students. Three thousand three hundred don't have stable housing. FAFSA processing is literally paused right now. And the food pantry that serves these students? It's one floor below us in this building.

Resources exist. But they're scattered, confusing, and the hacks that actually work — the stacking strategies, the loopholes, the workarounds — only travel through word of mouth. If you have the right friends, you know them. If you don't, you don't.

Jugaad is a Hindi word for the creative hack you use when the system doesn't work for you. We built Jugaad to make sure every student gets the hack — not just the connected ones."

[Press mic button, speak live] "Hey Jugaad — I'm a sophomore, I can barely afford groceries, and I didn't think I qualified for any help."

[Screen: Claude processing → Food Agent + Financial Aid Agent activating → Browserbase browsing basicneeds.berkeley.edu → Redis pulling CalFresh stacking hacks]

[Deepgram TTS response] "Actually, you likely qualify for CalFresh — $292 a month for groceries. Since you're enrolled at least half-time and your income is under the threshold, you meet the student exemption. I've pre-filled your CalFresh application. Meanwhile, the food pantry in the lower level of MLK has the shortest lines Friday afternoons. This week there are 4 campus events with free catering. And if you use CalFresh at the Saturday farmers market, Market Match doubles your first $10. Stack all of these and you'll eat well."

[Point downstairs] "That food pantry is literally one floor below us right now."

[Speak live] "I need to walk from Main Stacks to Unit 2 and it's late."

[Safety Agent activates → walking buddy algorithm runs → route analyzer runs]

"Two other students are leaving Stacks in the next 8 minutes heading to Southside. Group formed. I'm also suggesting the Oxford Street route — 3 minutes longer, better lighting, zero incidents this month."

[Show dashboard] "This is the Berkeley Problem Map. Students report what they're struggling with anonymously, and Jugaad aggregates it in real time. Right now you can see food insecurity concentrated south of campus, safety concerns peaking after 10pm on Telegraph, and financial aid anxiety spiking across all demographics since the FAFSA pause. This isn't just a tool for individuals — it's data for systemic change."

"Jugaad doesn't just tell students about resources. It gives them the hack. It auto-fills their CalFresh application. It matches them with a walking buddy. It finds the therapist with an opening this week. It stacks every resource into a personalized survival strategy.

17,000 students can't afford food. We're not going to solve that with a chatbot. We're going to solve it with jugaad."

# Clone the repo
git clone https://github.com/nergisRahimzade/jugaad.git
cd jugaad

# Backend
cd backend
pip install -r requirements.txt
uvicorn main:app --reload

# Frontend
cd frontend
npm install
npm run dev

Environment variables required:

ANTHROPIC_API_KEY=
DEEPGRAM_API_KEY=
REDIS_URL=
BROWSERBASE_API_KEY=
FETCH_AI_AGENT_KEY=
BAND_API_KEY=
ARIZE_API_KEY=
SENTRY_DSN=
SUPABASE_URL=
SUPABASE_ANON_KEY=
TWILIO_ACCOUNT_SID=
TWILIO_AUTH_TOKEN=
RESEND_API_KEY=

• Check-in: 9am Saturday, second floor entrance from Sproul Plaza
• Opening Ceremony: 10am, Wheeler Auditorium
• Devpost draft: Must be up by midnight Saturday
• Devpost final: Submit by 11am Sunday, edits until 12pm
• Judging: 1pm–3pm Sunday — all team members at table
• Top 10 notification: ~3:15pm Sunday via phone call
• Closing Ceremony: 4pm Sunday, Wheeler Auditorium

Emergency info: Urgent emergency: 911 · Nearest hospital: Alta Bates Summit, 2001 Dwight Way · Hackathon help: #0-ask-directors on Slack · 24/7 director desk: 2nd floor across from Goldie's

Jugaad (जुगाड़): a Hindi word for a flexible, frugal, improvised solution born in communities that had to survive despite broken systems. At Berkeley, 17,000 students need jugaad.

Built at UC Berkeley AI Hackathon 2026 · Ddoski's World track · live.hackberkeley.org

The Berkeley Student Advisory Council for Financial Aid explicitly recommended an AI chatbot for campus systems. Jugaad is what they asked for — built in 24 hours, by students who understand the problem from the inside.

700,000+ UC students enrolled system-wide. 230,000+ experiencing food or housing insecurity. Every university has this problem. Berkeley is where we start.