🏆 Winner — Hack Canada 2026

Transit Planner is an AI-powered urban transit planning tool that simulates a city council deliberation to design, debate, and approve new transit routes. Built for Toronto, it combines multi-agent AI, real-time geospatial visualization, and voice narration to make transit planning accessible, transparent, and engaging.

A structured 6-round deliberation where specialized AI agents debate a proposed transit route — each with distinct values, priorities, and personalities:

Each round streams in real-time. Routes update live on the map as agents propose alternatives.

• Draw custom routes or boundaries directly on the map
• Select neighborhoods and existing TTC stations as context
• See population density, traffic levels, and employment overlays
• View generated routes rendered in real-time as the council deliberates

Animated Three.js globe with orbiting transit lines and trains, giving the app a cinematic entry point.

ElevenLabs text-to-speech narrates key quotes from each agent, with distinct voice IDs per character.

All council sessions are persisted and replayable — review past deliberations and route outcomes.

Frontend

• Next.js 15 (App Router, React 19)
• TypeScript
• Mapbox GL + MapboxDraw — interactive map and route drawing
• Three.js + React Three Fiber — 3D globe visualization
• Tailwind CSS 4
• tRPC + React Query — type-safe API layer

Backend

• FastAPI (Python) — core AI orchestration engine
• Backboard.io — LLM API wrapper with thread-based conversations
• Anthropic Claude (Haiku 4.5 + Sonnet 4.5)
• ElevenLabs — text-to-speech per agent voice
• PostgreSQL + PostGIS — geospatial transit data
• Supabase — hosted database
• Go — routing management API

Infrastructure

• Monorepo with npm workspaces
• Docker
• GitHub Actions (CI/CD)

transit-planner/

├── web/ # Next.js frontend │ └── src/app/ │ ├── page.tsx # Landing page (3D globe) │ ├── map/page.tsx # Main planning interface │ └── api/ │ ├── council/ # Proxies to Python AI backend (SSE) │ ├── tts/ # ElevenLabs text-to-speech │ ├── traffic/ # Traffic data │ └── population/ # Population density data │ ├── python_server/ # FastAPI — AI council engine │ └── api/ │ ├── council.py # 6-round multi-agent orchestration

│ ├── backboard.py # LLM API wrapper (Claude via Backboard.io)

│ └── data_tools.py # PostGIS queries, neighborhood GeoJSON

│ ├── go_server/ # Routing management API

├── express_server/ # Express backend (optional services)

├── web_db/ # Prisma schema

└── python_utils/ # Shared DB models (SQLAlchemy + PostGIS)

Data flow:

1. User selects neighborhoods/stations and submits a planning request
2. Next.js /api/council proxies the request to the Python FastAPI backend
3. Python fetches relevant transit data from PostgreSQL/PostGIS
4. The council orchestrator opens 6 sequential LLM threads via Backboard.io
5. Each agent streams their response back via Server-Sent Events
6. Frontend parses SSE events, updates the chat panel and map in real-time
7. Final approved route is rendered on the Mapbox map

# Install all dependencies (root + web workspace)
npm install

# Install Python dependencies
cd python_server && pip install -r requirements.txt

# Copy and fill in environment variables
cp .env.example .env

Frontend:

cd web && npm run dev

Python backend:

./python_server/run.sh

Or directly:

.venv/bin/uvicorn python_server.api.main:app --host 0.0.0.0 --port 8000 --reload --reload-dir python_server --reload-dir python_utils

Requires: Node.js 20+, Python 3.11+, PostgreSQL with PostGIS.

web/.env.local (Next.js frontend)

python_server/.env (FastAPI backend)

JPW Brand New Subway

Built At Hack Canada 2026 — Top 10 Google - Build with AI Track

MIT