PropheSea

A personal AI trading guide that simplifies the complex world of predictive markets with top data-backed trades in a sleek, swipeable card experience.

Comment

PropheSea

A personal AI trading guide that simplifies the complex world of predictive markets with top data-backed trades in a sleek, swipeable card experience.

Built at HackPrinceton 2025

The Problem

Prediction markets are overwhelming to new traders. There's an overload of options and mountains of potentially relevant information from every source imaginable. Traditional trading dashboards force users into reactive decision-making, drowning them in data without guidance.

Our Solution

PropheSea transforms prediction market trading from information overload into an intuitive, personalized experience. Just as social media learns what you like, PropheSea shows you the best trading opportunities based on what you actually care about.

Key Features

  • Personalized Interest Selection: Choose up to three interests from diverse categories including Politics, Weather, Crypto, and Sports
  • Hybrid AI Analysis: Combines quantitative edge detection with sentiment analysis across multiple markets
  • Swipe-Based Trading: Top trades presented in an intuitive card format
  • Beginner-Friendly Reasoning: Complex financial analysis broken down into plain English
  • Real-Time Market Data: Live market odds and confidence scoring via volatility, volume, and momentum analysis

Architecture

Frontend

  • Framework: Next.js 14 (App Router)
  • Language: TypeScript
  • Styling: Tailwind CSS
  • UI Components: Radix UI + Custom components
  • Animations: Framer Motion

Backend & Infrastructure

  • API Server: FastAPI (Python)
  • Authentication: Supabase Auth
  • Database: PostgreSQL (via Supabase)

AI & Analytics Engine

  • Dedalus Labs: MCP server deployment
  • MCP: Tools for LLM to analyze Kalshi markets, perform analysis, and consult sources of truth

Quantitative Analysis

  • Market Confidence Scoring: Volatility, volume, and momentum indicators
  • Statistical Strategies:
    • Moving averages for trend detection
    • Statistical arbitrage identification
    • Custom technical indicators per domain (Weather, Politics, Economics)
  • Data Sources:
    • Weather: NOAA, Open-Meteo, Climatology data
    • Politics: Polling aggregators, 538 models
    • Economics: Federal Reserve data, economic indicators

Sentiment Analysis

  • LLM: xAI's Grok 4 model for real-time sentiment analysis via agentic search
  • X (Twitter) Integration: Real-time topic-relevant tweet analysis

Hybrid System

  • Two-Stage Pipeline:
    1. Fast statistical screening filters high-edge opportunities
    2. Grok sentiment analysis verifies filtered bets
  • Dynamic Weight Adjustment: Balances quantitative and semantic signals
  • Arbitrage Detection: Identifies mispriced markets across platforms

Getting Started

Prerequisites

# Node.js 18+ and Python 3.9+
node --version
python --version

# Environment variables required
SUPABASE_URL=your_supabase_url
SUPABASE_ANON_KEY=your_supabase_key
XAI_API_KEY=your_grok_api_key
KALSHI_API_KEY=your_kalshi_key

Installation

  1. Clone the repository

    git clone https://github.com/maalin2/hackprinceton.git
cd hackprinceton

  2. Install Python dependencies

    pip install -r requirements.txt
pip install -r api_requirements.txt

  3. Install frontend dependencies

    cd dashboard
npm install

  4. Set up environment variables

    # Create .env file in root directory
cp .env.example .env
# Add your API keys

Running the Application

Terminal 1: Start the FastAPI backend

python api_server.py --port 8000

Terminal 2: Start the Next.js frontend

cd dashboard
npm run dev

Open http://localhost:3000 in your browser.

Project Structure

hackprinceton/
├── dashboard/                 # Next.js frontend
│   ├── app/                  # App router pages
│   │   ├── dashboard/        # Main trading dashboard
│   │   ├── markets/          # Market browsing
│   │   ├── onboarding/       # User preference setup
│   │   └── saved/            # Saved picks
│   └── components/           # React components
│       ├── AgentFeed.tsx     # Card swipe interface
│       └── ui/               # Shared UI components
├── strategies/               # Quantitative trading strategies
│   ├── moving_average.py     # Trend detection
│   ├── statistical_arbitrage.py
│   └── kalshi_data.py        # Market data fetching
├── mcp_quantitative_agent/   # AI agent implementation
│   └── server.py             # Grok integration
├── api_server.py             # FastAPI backend
├── hybrid_analysis.py        # Combined quant + sentiment
├── weather_test.py           # Weather market analysis
├── politics_test.py          # Politics market analysis
└── economics_test.py         # Economics market analysis

Challenges We Overcame

  1. UX Complexity: Breaking down complex multi-factor trading decisions into an intuitive, beginner-friendly swipe interface
  2. Data Normalization: Sourcing and normalizing quantitative data to calculate accurate implied probabilities and identify arbitrage opportunities
  3. Domain-Specific Strategies: Implementing different technical indicators for different market types (weather vs. politics vs. economics)
  4. Signal Balance: Finding the optimal balance between sentiment and quantitative aspects for each trade recommendation
  5. Real-Time Performance: Managing latency challenges as market odds can shift extremely quickly

What We're Proud Of

  • Our swipe-based trading interface that makes complex decisions feel natural
  • Dynamic weight adjustment between quantitative and semantic signals
  • Successfully integrated diverse data sources and indicators
  • Building a production-quality, real-time agent

What We Learned

  • Integrating multiple systems (frontend, backend, AI, databases) is far more challenging than it appears
  • AI agents cannot be one-size-fits-all - context plays a major role when making predictions for prediction markets
  • In prediction markets, speed is everything. Odds can change in milliseconds, making performance optimization crucial
  • Breaking down AI reasoning into digestible explanations builds user confidence in automated recommendations

What's Next for PropheSea

Near-Term Goals

  • Multi-Platform Support: Integration with Polymarket, Manifold, and other prediction markets
  • WebSocket Implementation: Real-time bidirectional communication for instant trade execution
  • Mobile Apps: Native iOS and Android applications for on-the-go trading

Long-Term Vision

  • Advanced Analytics: Personal trading history, portfolio growth tracking, and risk optimization
  • Automated Trading: Risk-adjusted automatic trading using Kalshi's native API
  • Educational Mode: Tutorial system to teach users about prediction market mechanics
  • On-Chain Integration: Support for decentralized prediction markets, oracles as more sources of truth and arbitrage generation, and other blockchain-based platforms
  • Social Features: Follow successful traders, share picks, and collaborative analysis

Team (Discord)

  • Mohammed - @movisiting
  • Sugam - @pmiozmzoa
  • Anshul - @mrqwert.
  • Wing - @pencilknot

Acknowledgments

  • HackPrinceton for hosting an amazing hackathon
  • Kalshi for their prediction market API
  • xAI for Grok 4 model access
  • Dedalus Labs for agent infrastructure
  • All the open-source libraries that made this possible
Share this project:

Updates