I build intelligence
from complexity

Planning a trip means juggling flights, hotels, restaurants, activities, and logistics across 10+ tabs. Users spend hours comparing options, and the result is still a messy spreadsheet. Travel agents are expensive. Existing AI tools give generic suggestions with no real booking capability.

I designed a LangGraph state machine with 14 nodes and 9 specialized agents. The routing agent classifies intent. Context analysis extracts constraints (budget, dates, preferences). Search planning parallelizes queries across providers. A scoring agent ranks results, then a critic-debate loop between two agents challenges weak picks before they reach the user.

The key insight was the critic-debate pattern — instead of trusting a single ranking pass, two agents argue about each recommendation. This caught edge cases that a linear pipeline would miss.

14 nodes orchestrating 9 agents with sub-second routing decisions. Weaviate vector store handles thousands of travel entities with semantic retrieval. The system is still in active development with a paying client.

Solo architect and builder. Designed the agent topology from scratch, built the FastAPI backend, configured the Weaviate vector store, and built the Next.js frontend.

A single round of qualitative user research costs $5–15K, takes 2–4 weeks, and most product teams skip it entirely because of that. The ones who do it get 6–8 interviews and call it a day. The insights decay before they're even acted on.

Multi-agent orchestration where one agent conducts the interview — adapting questions in real-time based on responses — while another synthesizes insights with Big Five and Enneagram psychometric profiling. The interview agent doesn't follow a rigid script; it probes deeper when it detects surface-level answers and pivots when a new theme emerges.

I integrated Beyond Presence for avatar-based conversations (people open up more to a face than a chatbox) and Phoenix observability to trace every LLM decision for quality control.

90% cost reduction compared to traditional interviews. Minutes instead of weeks for synthesized insights. Scalable concurrent interview capacity — run 50 interviews simultaneously, something no human team can do.

Product lead and builder at ProductLoop. Designed the research methodology, built the agent pipeline, integrated real-time voice, and made the product decisions around when AI should probe deeper vs. move on.

Most personas in product teams are fiction. Someone interviewed 5 users a year ago, wrote up "Marketing Mary" and "Developer Dave," and the team has been building for them ever since. The segments don't reflect real behavior, and feature decisions based on them are essentially guesswork.

Two-phase system. First, ML clustering on actual behavioral data (usage patterns, engagement signals, conversion paths) to generate data-backed segments. Second, 6 LangGraph agents that take these validated personas and stress-test feature ideas against them: "Would this segment use this feature? What would break?"

The agents argue with each other — one advocates for the feature, another plays devil's advocate, a third evaluates from a business viability angle.

Working MVP tested on real product data. Personas you can actually trust because they're derived from behavior, not interviews. Feature validation that catches blind spots before engineering starts building.

Concept to MVP, solo. Designed the validation framework, built the ML pipeline, the 6-agent system, and the Streamlit interface.

Political researchers need to understand how different voter segments think and react. Traditional polling is slow and expensive. Focus groups are hard to organize and biased by group dynamics. There's no quick way to pressure-test campaign messaging against realistic voter archetypes.

The client had the AI backend — 12 functionally representative synthetic voter personas. My job: two interaction modes. First, one-on-one chats where a researcher talks directly to a single persona. Second, multi-persona focus groups where several synthetic voters discuss a topic together — showing group dynamics that make focus groups valuable in the first place.

Personas react to each other's arguments, agree, disagree, shift positions. The researcher can observe, interject, redirect the discussion, or let it run.

Shipped and used during the German federal election cycle. Live at wahllabor.ai with paying users. Won the BVM Innovation Prize 2025 — recognized for combining AI with qualitative research traditions. Up to 100 synthetic in-depth interviews per hour.

Frontend and chat interface — both the 1-on-1 conversation mode and the multi-persona focus group experience. The client owned the AI/persona backend — I owned the user-facing experience.

Elder care is reactive. Problems surface only after a crisis. Caregivers are overwhelmed, disconnected from day-to-day reality. Elderly users often can't or won't type — they need voice, and the system needs to understand not just what they say but how they feel.

The core interaction is voice-first through ElevenLabs integration. The dialogue agent runs a Listener → Emotion → Planner → Coach pipeline. The Emotion stage classifies emotional content before any response is planned — the system doesn't just hear "I'm fine," it detects when "I'm fine" means the opposite.

A mind-behavior engine tracks emotional, cognitive, social, and routine patterns over time — longitudinal trends, not just snapshots. A caregiver gets alerted not because someone had one bad day, but because the system detected a three-week downward trend.

Three agent layers: dialogue agent handles voice + emotion-aware responses. Coach agent generates personalized care plans. Safety agent evaluates incidents in real time and fires caregiver alerts. An event bus with persistent backlog ensures no signal is lost.

60 commits, working full-stack system with voice interface, emotion-aware dialogue, and caregiver alerting. Tested with real safety scenarios.

System architect. Designed the three-layer agent topology, the emotion recognition pipeline, and the event-driven architecture. Built the safety agent, memory management layer, and the developer playground frontend.

NYC's CitiBike system generates over a million trips per year, but there's no accessible way to explore what drives ridership. Weather impact, seasonal patterns, and station-level demand are invisible to city planners and operators.

Analysis of 1,051,000 trips across 365 days. Streamlit dashboard with 15+ chart types, 12+ interactive filters, weather correlation analysis, seasonal decomposition, and predictive demand forecasting. Kepler.gl for geospatial station mapping.

The non-obvious finding: temperature correlates with ridership at 0.768 — but the 56% variation based on weather conditions tells a more actionable story for operations planning than the raw correlation number.

Deployed at citibike2024.streamlit.app. 70% member vs. 30% casual split, station performance mapping, seasonal optimization strategies.

Solo. Full data pipeline — collection, cleaning, analysis, visualization, and deployment. 6 Jupyter notebooks for deep analysis, Streamlit app for interactive exploration.

Finance ops teams manually reconcile invoices, catch anomalies by scanning spreadsheets, and miss patterns because the volume is inhuman. Sending financial data to cloud AI services is a non-starter for most companies — compliance, security, trust.

Local-first architecture using Ollama for on-device inference and Cognee for knowledge graph construction. Four agents: Reconciliation Dashboard matches invoices and flags mismatches. Invoice Processing Agent normalizes vendor info and risk scores. Anomaly Detection prioritizes irregularities. Missing Invoice Flagging spots gaps by vendor and time period.

The design bet: a small local model on a well-structured knowledge graph outperforms a larger cloud model on raw text for domain-specific finance tasks.

Fully functional hackathon project. Zero data leaves the machine — model weights, graph DB, and vector store all run locally. Four distinct finance ops capabilities in a single Streamlit interface.

Co-creator with Anton Iemelianov. Built agent prompts and output parsing, integrated the Cognee knowledge graph, and made the product call to go local-first over cloud-first.

Retail promo planning runs on gut feel, spreadsheets, and last year's playbook. Marketing teams can't quickly model "what if we run 20% off for two weeks vs. buy-one-get-one for one week?" — they guess, launch, and hope.

Six specialized agents covering the full promo lifecycle: Promo Briefing transforms natural language into structured campaign specs. Data & Baseline Forecast builds projections from historical sales. Scenario Lab compares 2–3 approaches with KPI estimates. Optimization Engine balances sales, margin, and profitability. Creative Companion generates asset specs. Post-Mortem Analytics evaluates actual vs. projected.

The 14-hour constraint forced ruthless prioritization — every agent had to deliver real value, not just exist. Phoenix Arize tracing let us debug agent decisions in real time during the hackathon.

Working end-to-end system in 14 hours. Full campaign lifecycle from natural-language brief to performance analytics.

Co-creator with Anton Iemelianov. Designed the agent architecture, built the FastAPI backend, and made product decisions about which agents were essential vs. nice-to-have under extreme time pressure.

Web research disappears the moment you close a tab. Bookmarks are graveyards. When you actually need that article about distributed consensus you read three weeks ago, it's gone. Traditional search gets you new results, not your past research.

Multi-pass RAG reasoning with confidence scoring (70–95% range). Instead of one retrieval pass, the system iteratively refines its understanding — if confidence is below threshold, it re-queries with reformulated context. Unified vector search (Weaviate) + full-text search (Typesense) for semantic understanding and exact-match precision.

Added Apple OpenELM integration (8 local models, 6 specialized strategies) for privacy-focused local processing. The key design decision: making cloud AI optional — everything can run locally if your data is sensitive.

Open-source research copilot, MIT licensed. 46 commits, full microservices architecture. Glass morphism UI with drag-and-drop, real-time indexing, and Phoenix AI observability for monitoring LLM performance in production.

Full-stack, solo. System architecture, RAG pipeline design, React frontend, Weaviate + Typesense integration, local model support, deployment automation.