AI Agent for Benefits Enrollment: Social Services Application Assistance

The Benefits Enrollment Gap

Social services programs — food assistance, housing vouchers, childcare subsidies, Medicaid, utility assistance — exist to help people in need. But the enrollment process itself can be a barrier. Applicants face multi-page forms with legal jargon, confusing eligibility rules that vary by household composition, lengthy document requirements, and long wait times for status updates. Studies consistently show that eligible citizens often do not apply because the process is too complex or intimidating.

An AI agent can bridge this gap by acting as a patient, knowledgeable guide that speaks plain language, checks eligibility before the applicant invests time in a full application, walks them through each form field, tells them exactly which documents to gather, and provides real-time status on submitted applications.

Modeling Eligibility Rules

Benefits programs have specific eligibility criteria based on income, household size, age, disability status, and other factors. These rules must be encoded as deterministic logic — not left to LLM interpretation.

from dataclasses import dataclass, field
from enum import Enum


class BenefitProgram(Enum):
    SNAP = "snap"                    # Food assistance
    MEDICAID = "medicaid"            # Health coverage
    HOUSING_VOUCHER = "housing"      # Section 8
    CHILDCARE = "childcare"          # Childcare subsidy
    LIHEAP = "liheap"               # Utility assistance
    WIC = "wic"                      # Women/Infants/Children


@dataclass
class HouseholdInfo:
    household_size: int
    monthly_income: float
    has_children_under_5: bool = False
    has_children_under_18: bool = False
    has_elderly_member: bool = False
    has_disabled_member: bool = False
    is_pregnant: bool = False
    is_citizen_or_eligible_noncitizen: bool = True
    current_benefits: list[str] = field(default_factory=list)


# Federal Poverty Level thresholds (2026, monthly, by household size)
FPL_MONTHLY = {
    1: 1_255, 2: 1_703, 3: 2_150, 4: 2_598,
    5: 3_045, 6: 3_493, 7: 3_940, 8: 4_388,
}


def get_fpl(household_size: int) -> float:
    """Get monthly Federal Poverty Level for household size."""
    if household_size <= 8:
        return FPL_MONTHLY[household_size]
    # Each additional person adds ~$448/month
    return FPL_MONTHLY[8] + (household_size - 8) * 448


@dataclass
class EligibilityRule:
    program: BenefitProgram
    income_limit_fpl_pct: float  # e.g., 1.30 = 130% FPL
    additional_checks: list[str] = field(default_factory=list)
    required_documents: list[str] = field(default_factory=list)


ELIGIBILITY_RULES: dict[BenefitProgram, EligibilityRule] = {
    BenefitProgram.SNAP: EligibilityRule(
        program=BenefitProgram.SNAP,
        income_limit_fpl_pct=1.30,
        additional_checks=["citizenship_or_eligible_noncitizen"],
        required_documents=[
            "Photo ID", "Proof of income (pay stubs, 30 days)",
            "Proof of address", "Social Security numbers for all members",
            "Bank statements (last 30 days)",
        ],
    ),
    BenefitProgram.MEDICAID: EligibilityRule(
        program=BenefitProgram.MEDICAID,
        income_limit_fpl_pct=1.38,
        additional_checks=["citizenship_or_eligible_noncitizen"],
        required_documents=[
            "Photo ID", "Proof of income", "Proof of address",
            "Social Security numbers", "Immigration documents (if applicable)",
        ],
    ),
    BenefitProgram.WIC: EligibilityRule(
        program=BenefitProgram.WIC,
        income_limit_fpl_pct=1.85,
        additional_checks=[
            "has_children_under_5_or_pregnant",
            "citizenship_or_eligible_noncitizen",
        ],
        required_documents=[
            "Photo ID", "Proof of income", "Proof of address",
            "Child's birth certificate or proof of pregnancy",
            "Immunization records",
        ],
    ),
    BenefitProgram.LIHEAP: EligibilityRule(
        program=BenefitProgram.LIHEAP,
        income_limit_fpl_pct=1.50,
        additional_checks=[],
        required_documents=[
            "Photo ID", "Proof of income", "Most recent utility bill",
            "Social Security numbers", "Proof of address",
        ],
    ),
}

The Eligibility Screening Engine

The screening engine runs deterministic checks against the eligibility rules. This is not something we delegate to the LLM — getting eligibility wrong could mean a family misses benefits they deserve or wastes time applying for programs they cannot receive.

@dataclass
class EligibilityResult:
    program: BenefitProgram
    eligible: bool
    reason: str
    income_limit: float
    applicant_income: float
    required_documents: list[str]
    estimated_benefit: float | None = None


def screen_eligibility(
    household: HouseholdInfo,
) -> list[EligibilityResult]:
    """Screen a household against all benefit programs."""
    results = []

    for program, rule in ELIGIBILITY_RULES.items():
        fpl = get_fpl(household.household_size)
        income_limit = fpl * rule.income_limit_fpl_pct
        income_eligible = household.monthly_income <= income_limit

        # Run additional checks
        additional_pass = True
        fail_reason = ""

        for check in rule.additional_checks:
            if check == "citizenship_or_eligible_noncitizen":
                if not household.is_citizen_or_eligible_noncitizen:
                    additional_pass = False
                    fail_reason = "Citizenship or eligible noncitizen status required"
            elif check == "has_children_under_5_or_pregnant":
                if not (household.has_children_under_5 or household.is_pregnant):
                    additional_pass = False
                    fail_reason = (
                        "Must have children under 5 or be pregnant"
                    )

        eligible = income_eligible and additional_pass

        if not eligible and not fail_reason:
            fail_reason = (
                f"Monthly income ${household.monthly_income:,.0f} exceeds "
                f"limit of ${income_limit:,.0f} "
                f"({rule.income_limit_fpl_pct:.0%} FPL)"
            )

        results.append(EligibilityResult(
            program=program,
            eligible=eligible,
            reason="Meets all eligibility criteria" if eligible else fail_reason,
            income_limit=income_limit,
            applicant_income=household.monthly_income,
            required_documents=rule.required_documents if eligible else [],
        ))

    return results

Conversational Intake Flow

The agent collects household information through a natural conversation rather than presenting a long form. It asks one or two questions at a time and validates responses before moving on.

from openai import OpenAI
import json

client = OpenAI()

INTAKE_PROMPT = """You are a social services benefits enrollment assistant.
Your job is to help citizens find out which benefits they may qualify for
and guide them through the application process.

Speak in plain, simple language. Many applicants are stressed or unfamiliar
with government terminology. Never use acronyms without explaining them.

To screen eligibility, you need to collect:
1. Household size (how many people live together and share meals)
2. Total monthly household income (all sources)
3. Whether there are children under 5
4. Whether there are children under 18
5. Whether any household member is elderly (60+) or disabled
6. Whether anyone in the household is pregnant

Ask these questions naturally, one or two at a time. After collecting all
information, use the screen_eligibility tool to check programs.

IMPORTANT: Never guarantee eligibility. Always say "you may qualify" or
"based on the information provided, you appear to meet the initial criteria."
Final determinations are made by caseworkers.
"""


def run_intake_conversation(user_message: str, history: list) -> str:
    """Process one turn of the intake conversation."""
    messages = [{"role": "system", "content": INTAKE_PROMPT}] + history
    messages.append({"role": "user", "content": user_message})

    response = client.chat.completions.create(
        model="gpt-4o",
        messages=messages,
        temperature=0.3,
    )

    return response.choices[0].message.content

Document Tracking and Status Updates

After screening, the agent helps applicants understand exactly what documents they need and tracks which ones have been submitted.

from datetime import datetime


@dataclass
class Application:
    id: str
    programs: list[BenefitProgram]
    household: HouseholdInfo
    submitted_at: datetime | None = None
    status: str = "in_progress"
    documents_submitted: list[str] = field(default_factory=list)
    documents_pending: list[str] = field(default_factory=list)
    caseworker: str | None = None
    interview_date: datetime | None = None


def get_document_status(app: Application) -> dict:
    """Generate a clear document status report for the applicant."""
    all_required = set()
    for program in app.programs:
        rule = ELIGIBILITY_RULES.get(program)
        if rule:
            all_required.update(rule.required_documents)

    submitted = set(app.documents_submitted)
    pending = all_required - submitted

    return {
        "application_id": app.id,
        "total_documents_required": len(all_required),
        "documents_received": sorted(submitted),
        "documents_still_needed": sorted(pending),
        "ready_to_submit": len(pending) == 0,
        "status": app.status,
        "next_step": (
            "All documents received. Your application is under review."
            if len(pending) == 0
            else f"Please provide: {', '.join(sorted(pending))}"
        ),
    }

FAQ

How does the agent handle applicants who are not comfortable sharing financial information with an AI?

The agent should always explain upfront that eligibility screening is a preliminary check and that applicants can choose to skip the AI screening and go directly to an in-person appointment with a caseworker. When applicants do share information, the agent makes clear that the data is used only for screening and is not stored beyond the session unless they choose to submit a formal application. Government agencies must follow strict data retention policies, and the agent's privacy disclosure should be reviewed by the agency's legal team.

What if the applicant's situation does not fit neatly into the eligibility rules?

Many real situations involve edge cases: fluctuating income from gig work, shared custody arrangements that affect household size, or pending disability determinations. When the agent detects ambiguity — income that varies month to month, household members who split time between addresses — it flags the application for caseworker review rather than making a determination. The agent tells the applicant: "Your situation has some details that a caseworker can best evaluate. I have noted the specifics so you will not need to repeat them."

Can the agent help with renewals and recertification, not just initial applications?

Yes. Most benefits programs require periodic recertification (typically every 6 or 12 months). The agent tracks recertification deadlines and proactively notifies beneficiaries when their renewal window opens. It pre-populates the renewal form with information from the original application, asks only about changes (income, household composition), and generates an updated document checklist that includes only newly required items such as current pay stubs.

---

#GovernmentAI #SocialServices #BenefitsEnrollment #Eligibility #PublicSector #AgenticAI #LearnAI #AIEngineering