Inspiration

Subscription fatigue is quietly draining our bank accounts, but the real problem isn't just forgetting to click "cancel." It’s navigating the dark patterns of subscription management: hidden early termination fees, complex contract policies, and the fear of losing critical data. We realized that existing AI financial tools just give passive advice. We wanted to build an autonomous agent that not only provides portfolio-wide optimization and live internet research, but also gives users the power to execute savings instantly. That is how SubPilot AI was born.

What it does

SubPilot AI is a full-stack, AI-agentic application that autonomously researches and manages financial subscriptions:

  • Live RAG & Web Research: Instead of relying on outdated training data, the AI uses LangChain and the Tavily Search API to scrape real-time merchant cancellation policies and early termination fees directly from the live internet.
  • Proactive Portfolio Optimization: If a user asks how to save money during a budget crunch, the AI evaluates their entire active subscription portfolio, protects critical services like Health Insurance, and highlights non-essentials.
  • Dynamic 1-Click Execution: Rather than vague advice, it structures responses into interactive cards with pros, cons, and dynamic 1-click execution buttons for each recommended cancellation.
  • Enterprise Guardrails: A custom Python GuardrailService intercepts every AI decision to block out-of-context prompts, enforce financial safety rules, and mandate Human-in-the-Loop (HITL) authorization before mutating data.
  • Seamless Execution: Once authorized, the backend authenticates and executes cancellations or downgrades directly via the PayPal Subscriptions API.

How we built it

We designed SubPilot AI with a highly scalable, modern enterprise architecture:

  • Frontend: Next.js and Tailwind CSS, utilizing a clean design system inspired by fintech dashboards to deliver a responsive, intuitive UI with a locked chat layout.
  • Backend: An asynchronous Python FastAPI application handling business logic, API validation via Pydantic schemas, and middleware CORS configurations.
  • AI Orchestration: LangChain paired with Groq’s high-throughput LPU inference engine. We used strict JsonOutputParser schemas to force the LLM to return deterministic, machine-readable decision trees and recommended cancellation actions.
  • Retrieval Infrastructure: Integrated the Tavily Search API to bypass web scraping bottlenecks and bot blockers, ensuring reliable real-time policy retrieval.
  • Payment Integration: Directly integrated the official PayPal Sandbox API (/v1/billing/subscriptions) to simulate verified, real-world financial mutations with independent loading states.

Challenges we ran into

Bridging the gap between unpredictable AI models and strict financial APIs was incredibly difficult. Early on, we hit severe web scraping blocks and bot protections when trying to fetch merchant policies inside standard environments. We solved this by integrating the Tavily Search API, which is purpose-built for reliable agentic web retrieval.

On the AI side, local and legacy models were too slow and frequently broke JSON formatting rules, causing frontend parsing crashes. Moving to Groq solved our speed constraints, while LangChain's Pydantic validation enforced strict type safety. Finally, updating our frontend execution logic to handle multiple independent 1-click cancel buttons simultaneously required carefully refactoring our React message state tracking.

Accomplishments that we're proud of

We are incredibly proud of building a complete, end-to-end execution loop that goes far beyond a standard chat interface. We successfully implemented a live RAG pipeline that retrieves real internet data, engineered a multi-layered Python guardrail system, and built an interactive UI that turns general AI financial advice into actionable, multi-target 1-click buttons. The application looks and functions like a true production-grade fintech product.

What we learned

We learned that AI safety and grounding cannot be an afterthought in FinTech. Relying on prompt engineering alone is never enough to prevent hallucinations or accidental data mutations. True safety requires a multi-layered architecture where the LLM is treated as an untrusted input source, and an authoritative Python backend with strict schemas and guardrails maintains absolute control over state changes.

What's next for SubPilot AI

Our roadmap includes integrating Plaid to auto-detect subscriptions directly from live bank statements, implementing caching layers to optimize Tavily search queries, and building out an immutable, compliance-ready audit history tab for all autonomous financial actions.

Built With

Share this project:

Updates

Submission history