Projects

TripGen proved the multi-agent travel-planning concept on the web, but a real travel app needs to work in someone's pocket on a plane, send notifications, accept App Store payments, and integrate with the AI tools people already use. A web-only product also can't be invoked from inside Claude or ChatGPT, where many users now do their planning. The challenge was to take an agentic backend designed for a web UI and rebuild the surrounding product as a native, offline-first mobile app plus an MCP integration — without losing the conversational, streamed, multi-agent experience that made TripGen work.

Rewrote the frontend as an Expo / React Native app with an offline-first architecture: every mutation goes through a local MMKV-backed queue that reconciles on reconnection, so the app feels instant and survives flaky travel networks. Re-architected the backend around the OpenAI Agents SDK as 5 orchestrators coordinating 10+ specialized agents on Gemini 3.1 Flash with an OpenAI fallback, with proper tool calling, handoffs, and Langfuse-traced spans. Engineered cost in from day one — multi-layer caching, token-budgeted MCP responses, deterministic day-splitting, and a 4-stage photo lookup keep generation cheap at scale. Added real-time SSE streaming so users see the itinerary build progressively rather than waiting for a single blocking response. Stood up an OAuth-secured MCP server (Clerk) on top of the same agent stack, exposing two tools and two single-file UI bundles so Claude and ChatGPT can render rich, interactive trip widgets without iframe gymnastics. Layered in a 23-dim ML personalization model, a credit-based freemium economy with RevenueCat, V2 delta mutations for efficient edits, and collaboration via signed invite links. Shipped iOS to the App Store and Android to Google Play through EAS Build / EAS Submit, alongside the Next.js web build.

Three-tier system on a shared FastAPI/GCP backend. (1) Clients — Expo SDK 55 / React Native 0.83 mobile (iOS on the App Store, Android on Google Play) with Expo Router, React Query + MMKV for cached and offline state, an SSE parser for streamed itineraries, react-native-maps with native Google / Apple Maps; a parallel Next.js web build; Clerk for auth; RevenueCat for subscriptions; EAS for iOS / Android builds. (2) Backend — FastAPI on Google Cloud Run (Docker, uv-managed Python 3.12), 24 routers, 5 orchestrators coordinating 10+ specialized agents through the OpenAI Agents SDK with tool calling and handoffs on Gemini 3.1 Flash with OpenAI fallback, a 23-dim cosine-similarity recommender, credit-aware rate limiting in MongoDB, 15-second SSE keepalives for long generation streams, and a V2 delta-mutation editor for atomic trip edits. Cost controls — multi-layer caching, token-budgeted MCP responses, deterministic day-splitting, 4-stage photo lookup — run across the pipeline. (3) MCP server — FastMCP-mounted on the same backend, OAuth-secured through Clerk, exposing two tools (explore_destination, build_itinerary) plus two single-file Vite + React + MapLibre GL UI bundles (~340 KB gzipped each) that MCP hosts can render in-line. MongoDB Atlas is the primary store. Langfuse, Sentry, and PostHog instrument every layer.

Live as a solo-built cross-platform suite with ~500 monthly users: iOS on the App Store, Android on Google Play, and the web build — all on a shared FastAPI/GCP backend with SSE sync. Generates streamed multi-day itineraries with bookable Viator tours, Ticketmaster events, weather, maps, and per-activity deep context. Offline-first sync lets users edit without connectivity. OAuth-secured MCP tools let Claude and ChatGPT plan trips directly without leaving the chat. Cost controls (caching, token-budgeted MCP responses, deterministic day-splitting, 4-stage photo lookup) keep per-trip economics tight. Production observability — Langfuse for every LLM call, Sentry across web / mobile / backend / MCP, PostHog product analytics — keeps the agent pipeline debuggable end-to-end.

Researchers and developers studying multi-agent systems lacked a unified platform to compare different agent architectures (rule-based, RL, LLM) under controlled game-theoretic conditions. Existing tools were either too academic (no visualization) or too narrow (single agent type).

Built an event-driven simulation engine in Python with a plugin architecture allowing any agent type to be registered. Added real-time WebSocket streaming so simulations can be watched live. Created a React frontend with D3.js for interactive visualization of agent behaviors, payoffs, and strategy evolution across runs.

Event-driven simulation engine with a Python backend serving WebSocket connections for real-time streaming. React frontend with D3.js visualizations renders live agent interactions and analytics dashboards. Plugin architecture allows custom agent types (rule-based, RL, LLM) with a unified interface across 5+ LLM providers. Simulation state is managed server-side with event sourcing for replay capability.

Published as open-source on PyPI with 15+ built-in game scenarios. Supports OpenAI, Anthropic, Gemini, DeepSeek, and Ollama as LLM backends. Used for research comparisons and educational demonstrations of game theory concepts.

Critical personal information is trapped in physical cards, photo galleries and email attachments. Every form, bank visit or immigration desk means hunting for one number. Existing apps are digital filing cabinets that store the photo, not the information.

Split the AI work into stages instead of one generic prompt: a cheap classification call routes each document to a type-specific extraction prompt with expected fields and format hints, and a deterministic validator catches errors before the user sees them, retrying once with the error as context. Graceful degradation at every stage — per-image fallback classification, model escalation, and repair of malformed groupings — keeps the pipeline reliable on messy real-world photos.

Expo / React Native iOS app (Expo Router, Zustand with MMKV persistence, expo-sqlite FTS5 search) plus a hosted Vite + React web vault, both on a shared FastAPI backend on GCP with Clerk JWT auth and MongoDB Atlas. The extraction pipeline is a 4-stage batch processor with per-group parallelism: preprocess → multi-document classification in one Gemini call (which also groups front/back and multi-page scans) → type-specific extraction prompts → deterministic validation with error-aware retry. Gemini Flash-Lite handles classification and first-pass extraction; failed validations escalate to Gemini Flash. Tesseract OCR runs concurrently to power full-text search. Pydantic schemas enforce structured outputs end to end.

Working iOS beta and web vault: documents are scanned, grouped, extracted and validated in seconds, auto-categorised, searchable, and scheduled for expiry reminders. Sensitive document types stay on-device by design.

Travel planning involves coordinating dozens of decisions across flights, accommodations, activities, dining, and logistics. Existing AI travel tools either produced generic suggestions or couldn't handle the complexity of multi-day, multi-city itineraries with real constraints like budgets and preferences.

Designed a multi-agent system where specialized agents each own a domain (flights, hotels, activities, dining). Agents run in parallel via async Python and coordinate through a central orchestrator. MCP tool integration enables agents to query real services. A conversational interface lets users iteratively refine the plan.

Multi-agent orchestration system where 10+ specialized agents run in parallel via async Python. FastAPI backend on GCP Cloud Run handles agent coordination and MCP tool integration for external service calls. React frontend provides conversational chat with streaming responses, interactive map rendering via Google Maps API, and itinerary visualization. Langfuse integration provides full observability into agent decisions and tool usage.

Generates complete day-by-day itineraries with activities, photos, maps, and budgets. Conversational refinement allows natural back-and-forth. Full agent observability through Langfuse traces every decision and tool call.

People relocating to a new city struggle to evaluate neighborhoods objectively. Information is scattered across forums, real estate sites, and local knowledge. There was no tool that scored neighborhoods across multiple lifestyle dimensions with a consistent methodology worldwide.

Built an AI scoring pipeline that aggregates data from multiple sources and applies weighted scoring across dimensions (safety, affordability, commute, lifestyle). Created interactive maps with filterable overlays so users can visually explore results. Added SEO-optimized city pages to capture organic search traffic from people researching relocations.

AI scoring pipeline that aggregates neighborhood data from multiple sources, processes it through weighted scoring models, and serves results via FastAPI. React frontend renders interactive maps with filterable overlays using Google Maps API. PostgreSQL stores neighborhood scores and metadata. SEO-optimized static pages are generated for 100+ cities with structured data markup. Langfuse provides observability into AI scoring decisions.

Covers 100+ cities worldwide with neighborhood-level scoring. Interactive maps allow filtering by any combination of lifestyle factors. SEO-optimized pages rank for neighborhood-related search queries. Supports both long-term and short-term rental perspectives.

Real estate investment decisions require complex financial analysis across multiple variables — mortgage terms, operating expenses, vacancy rates, appreciation, and tax implications. Investors were either relying on error-prone spreadsheets or paying for overpriced tools that didn't support international markets or short-term rental scenarios.

Built a suite of 6 interconnected financial tools that share property parameters: ROI calculator, mortgage calculator, rent vs buy analyzer, scenario modeler, market explorer, and city comparison. Added localized market data for 30+ countries with auto-populated tax and mortgage rates. Interactive Leaflet maps and charts make data visually explorable. Included educational content so users understand the financial concepts behind the numbers.

Next.js application with server-side rendered pages for SEO performance across 30+ country market pages. Client-side financial calculation engine handles mortgage amortization schedules, ROI projections, rent vs buy modeling, and scenario stress-testing without server round-trips. Interactive Leaflet maps with bubble overlays for market visualization. Responsive React frontend with charts for cash flow, equity buildup, principal vs interest splits, and net wealth projections. Country-specific tax rates and mortgage rates auto-populate from a built-in dataset. Dark mode support with persistent localStorage preferences.

Covers 30+ real estate markets worldwide with localized tax and mortgage rates. Provides instant ROI calculations with break-even timelines, mortgage amortization schedules, rent vs buy projections, and side-by-side city comparisons. Supports both long-term and short-term (Airbnb) rental analysis. Free and accessible to all investors regardless of experience level.