PLUTUS

Inspiration

The spark for PLUTUS came from a deeply human problem the moment someone receives a devastating medical bill and realizes their entire financial life is about to collapse around it. We kept asking: why does this always come as a surprise?

The data is staggering. 68% of personal bankruptcies in the US are linked to medical debt. Yet healthcare apps, banking apps, and insurance portals all operate in complete isolation none of them talk to each other, and none of them warn you in advance. A person can be simultaneously at risk from a health condition, an insurance gap, a debt spiral, and a fraud attempt and no single system sees all four at once.

We were inspired by the way air traffic control works multiple data streams unified into one intelligent system that prevents disasters before they happen. We asked: what if we could build that for personal finance and health? What if AI could see the full picture and act as your personal crisis prevention co-pilot? That question became PLUTUS.

What it does

PLUTUS is an autonomous multi-agent AI ecosystem that predicts and prevents personal financial and healthcare crises before they occur.

Users securely upload their medical records, financial statements, insurance documents, and transaction history. PLUTUS then deploys four specialized AI agents that run in parallel:

Health Agent — Analyzes blood reports and medical records to flag conditions that could escalate into expensive emergencies
Finance Agent — Scans spending patterns, income, and liabilities to detect debt trajectories and savings risk
Insurance Agent — Identifies coverage gaps, exclusions, and scenarios where the user is underinsured without knowing it
Fraud Agent — Detects anomalous transactions, recurring unauthorized charges, and identity theft signals in real time

All four agents feed into a Unified Risk Engine that calculates a composite Crisis Probability Index (CPI) — a single score from 0 to 100 showing how close the user is to a crisis. The platform then generates a fully personalized Prevention Plan with prioritized action items, 90-day risk projections, and real-time alerts.

The experience is wrapped in a premium dashboard with dark and light themes, an AI chatbot advisor, and a full onboarding flow that personalizes every insight to the user's financial goals, health profile, location, and risk preferences.

How we built it

We built PLUTUS as a full-stack application over 48 hours using the following architecture:

Frontend — Next.js 14 with the App Router, styled with Tailwind CSS and shadcn/ui components. Framer Motion handles all animations including the CPI gauge, chart draw-on animations, and theme transitions. Recharts powers the risk trend and breakdown visualizations. The theme system uses CSS variables and next-themes for SSR-safe dark/light switching with the user's accent color persisted in localStorage.

Backend — FastAPI (Python) serves as the API layer with JWT authentication and AES-256 encryption for all document handling. All four AI agents run concurrently via asyncio.gather(), cutting analysis time to that of the slowest single agent rather than the sum of all four.

AI Layer — Each agent is built with CrewAI, giving each one a distinct role, goal, and backstory that shapes how it reasons over documents. GPT-4o handles complex medical and financial language understanding. The agents return structured JSON that feeds directly into the Risk Engine's weighted scoring formula.

Risk Engine — A Python scoring module that applies domain weights (Finance 35%, Health 30%, Insurance 20%, Fraud 15%) to produce the CPI, categorize risk levels, and identify the primary risk domain driving the user's score.

Data Layer — Supabase handles PostgreSQL storage for user profiles, onboarding data, agent outputs, and alert history. Qdrant vector database stores document embeddings for semantic search and cross-document context retrieval. All documents are stored encrypted at rest.

Infrastructure — Docker Compose orchestrates all services locally. The full stack can be spun up with a single docker-compose up command.

Challenges we ran into

Getting four AI agents to share context without conflicts was the hardest technical challenge. Early versions had agents producing contradictory risk assessments because they had no awareness of each other's findings. We solved this by designing a two-pass architecture — agents first analyze independently, then a synthesis pass gives each agent visibility into the other three's high-severity findings before the Risk Engine scores.

Structured output reliability from LLMs was a constant battle. Agents would occasionally return narrative prose instead of clean JSON, breaking the downstream scoring pipeline. We implemented a robust fallback parser with retry logic and output validation using Pydantic models that enforced schema compliance before any score was accepted.

Theming without flash was a surprisingly deep frontend problem. Implementing SSR-safe dark/light mode in Next.js without a flash of unstyled content required careful use of next-themes, CSS variable injection at the document root, and suppressing hydration warnings in specific components. Getting every chart, glassmorphism card, and animation to respond correctly to both themes added significant CSS complexity.

Document parsing across formats — users upload PDFs, images, CSVs, and Excel files with wildly inconsistent structure. Building a preprocessing pipeline that could extract meaningful text from a blood report PDF, a bank statement CSV, and a photo of an insurance card required chaining multiple extraction strategies.

Personalization at depth — making the AI chatbot responses feel genuinely personal (referencing the user's name, city, health conditions, financial goal, and actual scores) without it feeling like a mail-merge required careful prompt engineering and a context-injection system that assembles a user profile summary and injects it into every agent prompt.

Accomplishments that we're proud of

Built a working multi-agent AI pipeline in 48 hours where four specialized agents run concurrently and feed into a unified scoring engine — not just a prototype, but actual working code
The Crisis Probability Index — distilling health, financial, insurance, and fraud risk into one actionable number that a non-technical user immediately understands
An award-worthy UI with a full dark/light theme system, animated gauges, chart draw-on effects, and glassmorphism cards that holds up to professional product standards
A personalized AI chatbot that references the user's actual onboarding data — their city, health conditions, financial goals, and live scores — in every response
The 5-step onboarding flow that collects a rich user profile (financial, health, preferences) and uses it to make every single insight in the dashboard feel specific to that person
Security-first architecture — JWT auth, AES-256 document encryption, and encrypted-at-rest storage from day one, not bolted on afterward
One-command deployment — the entire stack runs with docker-compose up --build which meant we spent zero time on deployment issues during the hackathon

What we learned

AI agents need personas, not just instructions. Giving each CrewAI agent a detailed backstory ("You are a former cybercrime investigator at a major bank's fraud division") produced dramatically more specific, useful, and correctly-formatted outputs than generic task descriptions. The persona shapes how the model reasons, not just what it says.

Design systems pay off fast. Spending the first two hours defining CSS variables, color tokens, and a component library felt slow. But by hour 12, building new pages was effortless because every element automatically adapted to both themes and followed consistent spacing and typography rules.

Concurrent AI is a superpower. Running all four agents with asyncio.gather() instead of sequentially reduced analysis time by roughly 65%. For a user-facing product, that difference between 8 seconds and 24 seconds is the difference between feeling like magic and feeling broken.

User context transforms AI output quality. The single biggest improvement to chatbot response quality came not from prompt engineering tricks but from injecting a rich user profile into every prompt — name, location, income bracket, health conditions, financial goal, current scores. The model had something real to reason about.

Scope ruthlessly, polish obsessively. We cut several planned features (real-time bank API integration, wearable data, blockchain audit trail) to focus on making the core loop — upload → analyze → score → plan — feel genuinely polished. A tight, well-executed core beats a sprawling prototype every time.

What's next for PLUTUS

v2.0 — Real Data Integrations (6 months) Connect directly to bank APIs (Plaid), wearable devices (Apple Health, Fitbit), and insurance provider portals via open APIs. This eliminates manual document uploads and enables truly real-time risk monitoring — your CPI updates every time a transaction posts or a new health reading comes in.

Mobile App (6 months) A React Native app with push notifications, biometric authentication, and a widget showing your live CPI on your home screen. The fraud agent runs locally on-device for instant transaction alerts.

PLUTUS Enterprise (12 months) A B2B product for HR teams and employee wellness programs. Companies get an anonymized aggregate risk dashboard across their workforce — identifying departments at high financial stress risk before it affects productivity or retention. Individual employee data stays private.

Insurance & Healthcare Partnerships (12 months) Work directly with insurance companies to surface PLUTUS risk assessments during underwriting, potentially lowering premiums for users who actively manage their risk score. Partner with preventive healthcare providers to offer discounted screenings to high health-risk users.

PLUTUS Global (24 months) Multi-country compliance support, localized financial regulations (RBI guidelines for India, FCA for UK, CFPB for US), multilingual AI agents, and currency-aware financial modeling. The goal is making PLUTUS useful for the 3 billion people worldwide without access to integrated financial health guidance.

Population-Level Intelligence Anonymized, aggregated crisis data across the PLUTUS user base to build predictive models for regional financial health trends — giving researchers, policymakers, and public health officials early warning of emerging economic stress patterns before they become crises.