🏆 Start Here: Register & Get Aura Credits: Aura Agent Hackathon

[kitushenoy (Kirthi Shanbhag)]

LifeGraph: AI Social Resource Navigator

Neo4j Aura Agent Hackathon 2026 - Final Submission

---

PROBLEM STATEMENT

Millions of people qualify for life-changing assistance but never receive it.

Consider a foster youth aging out of care at 18. She qualifies for 20+ programs that could transform her life:

• Extended Foster Care (housing + support)
• Job Corps (training + $500/month stipend)
• CalFresh (food assistance)
• Medi-Cal (healthcare)
• Housing Vouchers (independent housing)
• And 15+ more programs

But she discovers maybe two.

Why? It's a Graph Problem, Not a Search Problem

Social services are fundamentally interconnected—but presented as isolated silos:

• Fragmentation: 50+ agencies manage these programs

• Opacity: Eligibility rules are buried in government documents

• Hidden Dependencies: She doesn't know that Program A unlocks Program B, which unlocks Program C

• Missing Context: Traditional search returns: "You might qualify for CalFresh, Job Corps, and housing" — no sequence, no why, no what comes next

The Result: Missed opportunities, prolonged poverty, and human potential left unrealized.

LifeGraph solves this by treating social services as what they really are: an interconnected graph of programs, eligibility, and outcomes.

---

VISION

Every person facing a life transition deserves a clear, intelligent path to stability.

Instead of searching blindly through disconnected programs, users see:

• What they qualify for (based on their situation)

• The best sequence to apply (programs unlock each other)

• Where to go (real organizations with contact info)

• What it leads to (concrete outcomes: employment, housing, stability)

Graph reasoning makes this possible.

---

SOLUTION: LifeGraph

A Neo4j knowledge graph of social programs + three specialized AI agents that reason through relationships to guide users to stability.

How It Works

Traditional Search:

"What programs can I get?"
→ Search engine returns list
→ User is overwhelmed
→ User gives up

LifeGraph (Graph-Powered):

"I'm 19, aging out of foster care in Alameda. What's my path?"

↓ GRAPH REASONS:

Extended Foster Care (YOU TRIGGER)
  ↓ UNLOCKS
Transportation Assistance
  ↓ MAKES ACCESSIBLE  
Job Corps Oakland (location, contact, benefits)
  ↓ LEADS TO
Stable employment → Housing secured

Result: Clear 6-month pathway from aging out to financial stability

The difference: Graph reasoning reveals dependencies, sequences, and outcomes that search engines cannot discover.

---

WHY GRAPHS ARE NECESSARY FOR THIS PROBLEM

Graph Structure Solves What Relational Databases Cannot

Traditional Database Approach (Relational):

SELECT programs WHERE user_age < 21 AND location = 'Alameda'
→ Returns isolated list: [Extended Foster Care, CalFresh, Job Corps]
→ No understanding of how they connect
→ User still doesn't know the sequence or dependencies

Graph Approach:

MATCH (user:LifeEvent)-[:TRIGGERS]->(p:Program)-[:UNLOCKS]->(p2:Program)-[:LEADS_TO]->(outcome:Outcome)
WHERE user.event = 'AGED_OUT_OF_FOSTER_CARE' AND p.location = 'Alameda'
→ Returns complete journeys
→ Shows implicit dependencies
→ Reveals hidden programs user didn't know existed
→ Explains the "why" and "what comes next"

The Key Insight: Dependencies ARE the Intelligence

In relational databases, relationships are metadata ("this program ID links to this rule ID").

In a knowledge graph, relationships are the intelligence itself:

• Extended_Foster_Care -[:UNLOCKS]-> Transportation_Assistance (hidden program revealed)
• AGED_OUT_OF_FOSTER_CARE -[:TRIGGERS]-> Extended_Foster_Care (entry point identified)
• Job_Corps -[:LEADS_TO]-> EMPLOYED (outcome clarity)

Only a graph can efficiently traverse and reason through these chains.

---

KNOWLEDGE GRAPH STRUCTURE

Graph Statistics

• Total Nodes: 127

• Total Relationships: 246

• Average Density: 2.5 relationships/node (vs. typical 0.8-1.2)

• Multi-hop Paths: 100+ unique 3-4 hop sequences

  

Type	Count	Examples
Benefit (Programs)	45+	CalFresh, Extended Foster Care, Job Corps, Housing Vouchers, Medi-Cal
Organization	35+	First Place for Youth, Job Corps Oakland, Alameda Workforce Development, YouthBuilt Collective
LifeEvent	12	AGED_OUT_OF_FOSTER_CARE, LOST_JOB, HAD_CHILD, HOMELESSNESS_RISK, DOMESTIC_VIOLENCE
EligibilityRule	20+	Age limits, income caps (<$1,500/month), residency (Bay Area), work requirements
Document	15+	Birth Certificate, ID Card, Proof of Income, Foster Care Documentation
Outcome	10	HOUSING_SECURED, EMPLOYED, FINANCIAL_STABILITY, HEALTHCARE_ACCESS, EDUCATION_COMPLETED

Relationship Types (7 Core Types)

LifeEvent -[:TRIGGERS]-> Benefit
  ↳ When this life event occurs, this program becomes available
  ↳ Example: AGED_OUT_OF_FOSTER_CARE -[:TRIGGERS]-> Extended_Foster_Care
  ↳ Agent use: "Here are programs you can access right now"

Benefit -[:UNLOCKS]-> Benefit
  ↳ Qualifying for one program automatically makes you eligible for another
  ↳ Example: Extended_Foster_Care -[:UNLOCKS]-> Transportation_Assistance
  ↳ Agent use: "This program unlocks three others"

Benefit -[:REQUIRES]-> Document
  ↳ You need this document to apply
  ↳ Example: Foster_Youth_Housing -[:REQUIRES]-> Foster_Care_Documentation
  ↳ Agent use: "Here's what paperwork to gather"

Benefit -[:HAS_RULE]-> EligibilityRule
  ↳ You must meet this condition to qualify
  ↳ Example: CalFresh -[:HAS_RULE]-> (income < $1,500/month)
  ↳ Agent use: "You qualify because your income is under $1,500"

Benefit -[:LEADS_TO]-> Outcome
  ↳ Successfully completing this program leads to this outcome
  ↳ Example: Job_Corps -[:LEADS_TO]-> EMPLOYED
  ↳ Agent use: "This leads to stable employment"

Organization -[:SERVES]-> LifeEvent
  ↳ This organization specializes in helping people in this situation
  ↳ Example: First_Place_for_Youth -[:SERVES]-> AGED_OUT_OF_FOSTER_CARE
  ↳ Agent use: "Organization X helps foster youth"

Organization -[:PROVIDES]-> Benefit
  ↳ This organization delivers this program
  ↳ Example: Job_Corps_Oakland -[:PROVIDES]-> Job_Corps
  ↳ Agent use: "Here's where to go and how to contact them"

Complete Graph Schema

Graph Schema - Complete Node and Relationship Network

Graph Design Principles:

1. Benefit is the Hub

   • All relationships flow through programs because they're:

     • Triggered by life events (entry point)

     • Unlocking other programs (sequencing)

     • Requiring documents and rules (eligibility)

     • Leading to outcomes (impact)

2. TRIGGERS + UNLOCKS Create Pathways

    LifeEvent -[:TRIGGERS]-> Program1 -[:UNLOCKS]-> Program2 -[:LEADS_TO]-> Outcome
    = Complete journey from situation to stability
   

3. Organization Layer Bridges Graph to Reality

   • SERVES and PROVIDES relationships ensure:

     • Finding the right organization for user's situation

     • Getting actual contact info and location

     • Moving from "what to apply" to "where to go"

---

THREE SPECIALIZED AURA AGENTS

Agent 1: Eligibility Navigator

Problem it solves: "What programs can I actually qualify for?"

User Example:

"I'm 19, aging out of foster care in Alameda. What programs can I access?"

Agent Response:

• Lists all programs triggered by user's life event
• Applies eligibility rules (age, income, residency)
• Shows required documents
• Explains why user qualifies
• Returns actionable next steps

How it works:

1. Matches (user_event:LifeEvent) -[:TRIGGERS]-> (program:Benefit)
2. Filters by (program) -[:HAS_RULE]-> (rule) where rule applies to user
3. Collects (program) -[:REQUIRES]-> (document)
4. Returns: Programs + Rules + Documents + Explanation

---

Agent 2: Pathway Advisor

Problem it solves: "What's my path to stability? What's the sequence?"

User Example:

"I'm 19 in Alameda, aging out of foster care. I need housing and a job. 
Show me the best pathway to stability."

Agent Response:

• Builds step-by-step sequences showing program dependencies
• Explains why each step unlocks the next
• Shows timeline to outcomes (employment, housing, stability)
• Reasons through multi-hop relationships

How it works:

1. Starts with (user_event:LifeEvent) -[:TRIGGERS]-> (p1:Program)
2. Follows (p1) -[:UNLOCKS]-> (p2) -[:UNLOCKS]-> (p3)
3. Traces (p_final) -[:LEADS_TO]-> (outcome:Outcome)
4. Orders programs logically
5. Returns: Step-by-step plan with "why" explanations

Example Journey:

Step 1: Extended Foster Care
  Why: You aged out of foster care + age < 21 ✓

Step 2: Transportation Assistance (UNLOCKED by Step 1)
  Why: Extended Foster Care automatically includes this
  Impact: Makes Job Corps accessible

Step 3: Job Corps Oakland
  Where: 1801 Embarcadero, Oakland
  Contact: (510) 622-4600
  Benefits: Free training + $500/month stipend
  Why Matters: Transportation enables you to attend

Step 4: Employment (LEADS TO from Job Corps)
  Outcome: Stable monthly income
  Timeline: 6-month training program

Step 5: Independent Housing
  Why Possible: Income from employment enables housing
  Outcome: Financial stability achieved

---

Agent 3: Resource Locator

Problem it solves: "Where can I actually find help?"

User Example:

"Where can I find job training in Alameda County?"

Agent Response:

• Finds organizations that SERVE user's situation
• Lists organizations that PROVIDE relevant programs
• Returns real contact info, locations, eligibility
• Connects programs to real-world access points

How it works:

1. Identifies (user_event:LifeEvent)
2. Finds (org:Organization) -[:SERVES]-> (user_event)
3. Also finds (org) -[:PROVIDES]-> (program)
4. Returns: Organization details + Services + Contact + Eligibility

Real Results:

Job Corps Oakland
├─ What: Federal job training & education
├─ Where: Oakland, Alameda County
├─ Contact: (510) 622-4600
├─ Eligibility: Ages 16-24, no income limits
└─ Serves: Individuals seeking employment

Alameda Workforce Development
├─ What: Career services & job training
├─ Where: Alameda, Alameda County
├─ Contact: (510) 832-3500
├─ Eligibility: Free for eligible residents
└─ Serves: Job seekers & displaced workers

YouthBuilt Collective
├─ What: Construction & green jobs training
├─ Where: Alameda County
├─ Contact: (510) 567-9000
├─ Eligibility: Ages 16-29
└─ Serves: Young adults seeking career training

---

DATA SOURCES

All data is publicly available from official government and nonprofit sources:

Layer 1: Government Programs & Benefits

1. CA Open Data - CalHHS (https://data.ca.gov/)

   • CalFresh eligibility, WIC rules, Medi-Cal income limits, TANF/CalWORKs

2. CA Foster Care Indicators Dashboard (https://www.lab.data.ca.gov/)

   • Extended Foster Care age limits, youth transition programs, education support

3. California Department of Social Services (CDSS) (https://www.cdss.ca.gov/)

   • CalWORKs, TANF, welfare programs, emergency assistance

Layer 2: Community Resources & Organizations

4. 211.org Database - Alameda County (https://www.211.org/)

   • 50-80+ organizations, services, contact info, eligibility requirements

5. Alameda County Office of Education (https://www.acoe.org/)

   • Scholarships, youth programs, career pathways

6. California Foster Care Resources (https://www.fostercare.ca.gov/)

   • Foster youth-focused organizations, education benefits, transition resources

Data Characteristics

• No sensitive personal data — only public program information
• Official sources — government agencies and established nonprofits
• Current — 2024-2025 program documentation
• Regional focus — Bay Area/Alameda County with statewide programs
• Validated — cross-referenced across multiple official sources

---

HOW JUDGES CAN TEST

Option 1: Test in Aura Console (Live Agents)

Step 1: Access Agents

1. Open Neo4j Aura Console

2. Navigate to "Data Services → Agents"

3. Select the three LifeGraph agents

   

Step 2: Test Eligibility Navigator

Ask: "I'm 19, aging out of foster care in Alameda. What can I get?"

See:
- List of eligible programs
- Why user qualifies for each
- Required documents
- Next steps

Aura Agent UI

Step 3: Test Pathway Advisor

Ask: "Show me the path to stability. I need housing and a job."

See:
- Step-by-step sequence
- How programs unlock each other
- Why each step matters
- Outcomes (employment, housing, stability)

Step 4: Test Resource Locator

Ask: "Where's job training in Alameda County?"

See:
- Real organizations (Job Corps, Alameda Workforce, YouthBuilt)
- Contact info and locations
- What services they provide
- Eligibility requirements

Step 5: View Reasoning Traces

• Open agent reasoning panel
• See agents explicitly acknowledge graph structure
• Watch them traverse relationship chains
• See multi-hop pathways being constructed

Option 2: Test Web Application

go to git repo : GitHub - kirthistaank/LifeGraph · GitHub

Setup & Run (See README.md for detailed instructions):

1. Navigate to the LifeGraph project directory

2. Install dependencies: pip install -r requirements.txt

3. Configure environment variables (see STREAMLIT_SETUP_GUIDE.md):

   • ELIGIBILITY_AGENT_ENDPOINT

   • PATHWAY_AGENT_ENDPOINT

   • RESOURCE_AGENT_ENDPOINT

   • NEO4J_API_KEY

   • NEO4J_API_SECRET

4. Run the app: streamlit run streamlit_app.py

5. Open browser to http://localhost:8501

Interact with the Application:

1. Select an agent (Eligibility Navigator, Pathway Advisor, or Resource Locator) in the sidebar
2. Fill your profile (age, county, situation/goals) using the guided inputs
3. Review the auto-generated question pre-populated in the main prompt area
4. Ask your question - Edit the initial question or ask as-is
5. See real-time response with graph reasoning
6. Ask follow-up questions - The agent remembers your conversation context
7. View reasoning traces - Expand "View graph reasoning" to see how the agent traversed the knowledge graph

---

WHY NEO4J AURA MADE THIS SMOOTH

Challenge: Multi-Hop Reasoning at Scale

Without Neo4j Aura:

• SQL queries would require complex JOINs (5-7 tables minimum)
• Impossible to efficiently explore unknown paths ("find all programs that lead to employment")
• Poor performance with relationship traversal

With Neo4j Aura:

MATCH (event:LifeEvent)-[:TRIGGERS]->(p1:Program)
      -[:UNLOCKS]->(p2:Program)-[:LEADS_TO]->(outcome:Outcome)
WHERE event.name = 'AGED_OUT_OF_FOSTER_CARE' 
  AND p1.location = 'Alameda'
RETURN p1, p2, outcome

Result: Complex multi-hop reasoning in milliseconds.

Why Aura Specifically

1. Managed Infrastructure

   • No DevOps overhead

   • Automatic scaling

   • Built-in security and backups

2. Agents Integration

   • Neo4j Aura Agent framework is purpose-built for knowledge graphs

   • Agents can reason through relationships natively

   • Text2Cypher automatically converts questions to graph queries

3. Relationship Reasoning

   • Aura excels at what other databases struggle with: traversing relationships

   • Each relationship is indexed and optimized

   • Multi-hop queries scale linearly, not exponentially

4. Cost-Effective

   • Free tier sufficient for hackathon demo

   • ~$0.35/hour for external agent access (minimal)

   • No database redesign needed for scaling

---

WEB APP INTEGRATION: Easy + Elegant

Architecture: Graph + Agents + Streamlit

┌─────────────────────────────────────────┐
│         Streamlit Web App               │
│  ┌─────────────────────────────────────┤
│  │  Chat Interface                     │
│  │  - Select Agent                     │
│  │  - Fill Profile                     │
│  │  - Ask Question                     │
│  └─────────────────────────────────────┤
└────────────────┬────────────────────────┘
                 │
                 ↓ (REST API)
┌─────────────────────────────────────────┐
│    Neo4j Aura Agent (External)          │
│  ┌─────────────────────────────────────┤
│  │  Text2Cypher                        │
│  │  ↓ converts question to query       │
│  │  Cypher Template                    │
│  │  ↓ executes on graph                │
│  └─────────────────────────────────────┤
└────────────────┬────────────────────────┘
                 │
                 ↓
┌─────────────────────────────────────────┐
│    Neo4j Aura Database                  │
│  ┌─────────────────────────────────────┤
│  │  Knowledge Graph                    │
│  │  - 127 nodes (programs, orgs, etc)  │
│  │  - 246 relationships                │
│  │  - Multi-hop paths optimized        │
│  └─────────────────────────────────────┤
└─────────────────────────────────────────┘

Why Integration Was Seamless

1. REST API First

   • Aura agents expose REST endpoints

   • Streamlit just needs to POST questions

   • Get JSON responses back

2. Authentication Simple

   • Neo4j API credentials (not database credentials)

   • Standard OAuth token exchange

   • Works with any web framework

3. Stateless Design

   • Each question is independent

   • No session management needed

   • Agents handle all reasoning

4. Rapid Development

   • No custom agent logic needed

   • Aura agents work out-of-the-box

   • Focus on UX, not backend plumbing

Code Example: Calling Agent from Streamlit

def call_agent(agent_name: str, question: str) -> dict:
    """Call a Neo4j Aura Agent via REST API"""
    
    # Get bearer token (simple OAuth exchange)
    token = get_bearer_token(api_key, api_secret)
    
    # Call agent endpoint
    response = requests.post(
        agent_endpoint,
        headers={
            "Authorization": f"Bearer {token}",
            "Content-Type": "application/json"
        },
        json={"input": question},
        timeout=60
    )
    
    # Return parsed response
    return response.json()

That's it. No database connection, no query building, no response parsing.

---

---

WHAT DIFFERENTIATES LIFEGRAPH

vs. Traditional Benefits Directory

Traditional: Search → List of programs → User confused → User gives up
LifeGraph: Ask question → Get sequenced plan → User empowered → User acts

vs. Search Engine

Search: "What programs can I get?" → Irrelevant results
LifeGraph: Same question → Relationship reasoning → Relevant, sequenced, complete

vs. Linear Rule Engine

Rule Engine: "If age < 21 THEN extend foster care" (one condition)
LifeGraph: "Extend foster care TRIGGERS transportation assistance UNLOCKS job corps LEADS_TO employment"
         (complete chain, revealing hidden dependencies)

Unique Value Propositions

1. Dependency Navigation

   • First to focus on "what unlocks what"

   • Not just listing programs, but explaining sequences

2. Multi-Hop Reasoning

   • Connects 3-4 program hops in seconds

   • Reveals outcomes (housing, employment, stability)

3. Real Data, Real Impact

   • Based on actual CA social services

   • Real organizations, real phone numbers, real eligibility rules

4. Graph-Powered Intelligence

   • Only possible with Neo4j's relationship traversal

   • Can't be replicated with traditional databases or simple search

5. Transparency

   • Every recommendation includes reasoning

   • Users understand why they qualify

   • Builds trust

---

IMPACT

For Foster Youth

• Clear path from aging out → employment → independence

• Access to interconnected support system

• Transparent reasoning (understanding why programs matter)

For Government

• Reduced duplicated effort (agencies know who's applying where)

• Better outcomes tracking (see which programs lead to employment)

• Smarter resource allocation

---

LifeGraph: Because foster youth deserve a clear path to stability.

Built with Neo4j Aura. Powered by graph reasoning. Made for people.