AscendFi

Built-in Capital One educational hub surfacing banking tools and resources for users.
AI-powered spending dashboard with live risk alerts, account overview, and category breakdown.

Inspiration

Financial stress is one of the most pervasive yet quietly ignored crises affecting everyday people. Millions struggle with overdraft risks, mounting debt, and no clear roadmap out — not because they lack discipline, but because they lack the right tools. Traditional budgeting apps tell you what happened; we wanted to build something that tells you what's about to happen and actively helps you fix it. The idea of an autonomous, AI-driven financial co-pilot — one that thinks ahead, spots risk before it hits, and builds a personalized recovery plan — is what inspired AscendFi.

What it does

AscendFi is a full-stack AI personal finance platform organized around three core dashboards:

Checking & Spending — AI-generated risk chips (overdraft probability, missed payment likelihood, credit behavior shifts), a spending breakdown donut chart, behavioral insight panels, and a debt paydown trajectory sparkline.
Debt & Investments — An interactive debt payoff accelerator comparing avalanche vs. snowball strategies, plus a live stock watchlist with real-time price charts.
Autonomous Finance — An AI-built behavioral spending profile, personalized next-step recommendations, paycheck split planner, emergency fund tracker, and sinking fund goals.

At the heart of the platform is ARIA — our streaming AI financial advisor accessible via the Chat page — powered by a Python multi-agent system that orchestrates specialized agents for risk prediction, debt optimization, behavioral analysis, and investment guidance.

How we built it

AscendFi runs as a three-tier system:

Frontend — Built with Nuxt 4, Vue 3, and Tailwind CSS. Interactive charts use Chart.js and lightweight-charts v5. The UI communicates with both the Node backend and the Python agent directly.

Node.js Backend — An Express server handling authentication sessions via Supabase and acting as a secure proxy between the frontend and the Python agent.

Python Multi-Agent FastAPI Server — The core AI engine. A supervisor agent routes incoming queries to four specialized sub-agents:

Agent	Responsibility
Risk Agent	Predicts overdraft, missed payment, and credit shift probability
Debt Agent	Optimizes payoff strategy using avalanche/snowball models
Behaviour Agent	Analyzes spending patterns and builds a user profile
Investment Agent	Surfaces watchlist insights and market data

Each agent is powered by Anthropic Claude, with OpenAI GPT and Google Gemini available as configurable alternatives. ARIA streams responses to the frontend in real time via Server-Sent Events (SSE).

ML prediction models (CatBoost, XGBoost) are layered into the risk and debt tools. Market data is sourced live from stooq.com — no API key required. User auth and persistent data are handled by Supabase (Postgres + Auth).

The risk score for a user is calculated as a weighted composite:

$$R = w_1 \cdot P(\text{overdraft}) + w_2 \cdot P(\text{missed payment}) + w_3 \cdot \Delta C$$

where $\Delta C$ is the credit utilization shift over a rolling 30-day window and $w_1, w_2, w_3$ are agent-calibrated weights.

Debt payoff trajectories under the avalanche method minimize total interest paid by targeting the highest APR balance first:

$$T_{\text{avalanche}} = \sum_{i=1}^{n} \frac{B_i}{P_i - r_i \cdot B_i}$$

where $B_i$ is the balance, $P_i$ the monthly payment, and $r_i$ the monthly interest rate for debt $i$.

Challenges we ran into

Three-server orchestration — Keeping the Nuxt frontend, Node backend, and Python FastAPI agent in sync during development — especially clean startup, teardown, and hot-reload — required building a custom launcher script (start-dev.sh) and a full CI pipeline on GitHub Actions.
Real-time streaming — Wiring SSE from the Python agent through the Node proxy to the Vue frontend without breaking buffering or losing chunks took significant debugging.
Cross-platform ML dependencies — CatBoost and XGBoost require C++ build tools on Windows. Getting CI to pass cleanly across Ubuntu, macOS, and Windows environments was a real fight.
UI polish under time pressure — Building three data-rich dashboard tabs with responsive charts, live data, and a coherent design language in a hackathon window was the hardest design constraint we faced.

Accomplishments that we're proud of

A fully functional multi-agent AI system where Claude orchestrates specialized financial sub-agents — not just a single prompt call.

A production-grade CI pipeline that validates all three services (Python, Node, Nuxt) in parallel on every push.
A one-command launcher (./start-dev.sh) that installs, builds, and starts the entire stack simultaneously.
ARIA's streaming chat experience — responses feel instant and conversational, not like waiting on a batch API.
A demo mode (NUXT_PUBLIC_USE_DUMMY_DATA=true) that lets anyone explore the full UI without needing API keys or a database.

What we learned

How to architect and coordinate a multi-agent AI system where a supervisor delegates to domain-specific agents rather than relying on a single monolithic prompt.

The nuances of Server-Sent Events for real-time AI streaming through a multi-layer backend.
How ML models like CatBoost and XGBoost can be integrated as financial prediction tools alongside large language models — each doing what it does best.
How much design and UX decisions matter when the data is financial — trust and clarity are non-negotiable when someone is looking at their debt or risk score.