MirrorLoop 🪞🔁

Tagline

The "Invisible" Customer Feedback Agent — Turning raw venting into structured, actionable engineering tickets in real-time.

Inspiration 💡

Have you ever filled out a customer feedback survey and thought, "This is going to disappear into a void"? We have. And we've also been on the other side — product teams drowning in unstructured complaints, trying to manually triage what's urgent, what's a bug, and what's just noise.

The problem is twofold:

Customers hate surveys. They're long, generic, and feel like busywork.
Teams hate unstructured feedback. A wall of text doesn't tell you what to build or who should own it.

We asked ourselves: What if feedback could be invisible? What if customers could just vent naturally, and AI would handle the rest — extracting insights, generating follow-up questions, and creating ready-to-ship tickets?

That's MirrorLoop. It's not a survey platform. It's an Agentic Customer Feedback System that turns chaos into clarity.

What It Does 🚀

MirrorLoop is a multi-modal AI feedback pipeline that analyzes customer complaints in real-time and autonomously generates:

1️⃣ Structured Analysis

Issue Type: Bug, UX, Service, Delivery, Pricing, etc.
Emotion Detection: Neutral → Annoyed → Frustrated → Angry
Severity Score: 1-5 scale based on content + typing speed (WPM)
Evidence Extraction: Direct quotes from the complaint
Follow-up Recommendation: Whether a survey is needed

2️⃣ Dynamic "Pulse Checks"

Instead of generic surveys, MirrorLoop generates context-specific micro-surveys tailored to each complaint:

Delivery complaint? → "Rate the driver" + "Rate food temperature" + "Rate app speed"
App crash? → "Did this block your task?" + "Rate app stability" + "Rate error messaging"
All questions use emoji scales (1-5) to reduce friction and survey fatigue

3️⃣ Autonomous Triage & Ticketing

MirrorLoop creates a sprint-ready backlog with:

Role Assignment: Product Manager, Software Engineer, or Field Operations
Priority Calculation: P0-P3 based on severity, emotion, and impact
Acceptance Criteria: 2-bullet "Definition of Done" for each ticket
Smart Routing: App bugs → SWE, logistics issues → Field Ops, UX friction → PM

4️⃣ SurveyMonkey Integration (Optional)

Auto-creates live surveys with the generated Pulse Check questions
Submits votes via API and retrieves real-time responses
Works in demo mode without SurveyMonkey (shows questions but disables voting)

How We Built It 🛠️

Tech Stack

Frontend: React + TypeScript + Vite
Styling: Custom CSS with Glassmorphism (dark mode, gradients, micro-animations)
Backend: Python + FastAPI
AI/LLM: OpenAI GPT-4o-mini + LangChain (structured outputs)
Integrations: SurveyMonkey API, Sentry (error tracking)

Architecture

MirrorLoop uses a 3-stage AI pipeline powered by LangChain:

Stage 1: Structured Feedback Extraction

async def generate_structured_feedback(inp: ComplaintInput) -> StructuredFeedback:
    # Analyzes complaint text + WPM + metadata
    # Returns: issue_type, emotion, severity, summary, evidence_quotes

Input: Raw complaint + typing speed (WPM) + journey stage + channel
Output: Structured JSON with issue type, emotion, severity, summary, and evidence quotes
Key Innovation: Uses WPM as a secondary signal (high WPM = anger/urgency, low WPM = hesitation/sadness)

Stage 2: Dynamic Pulse Check Generation

async def generate_followup_survey(structured: StructuredFeedback) -> FollowupSurveyDraft:
    # Creates 3 context-specific questions (all scale 1-5)
    # Example: Delivery issue → "Rate driver", "Rate food temp", "Rate app speed"

Input: Structured feedback from Stage 1
Output: 3 tailored questions (all emoji-scale 1-5 type)
Key Innovation: Questions are hyper-contextual (no generic "How was your experience?")

Stage 3: Action Plan & Ticket Generation

async def generate_action_plan(structured, survey) -> ActionPlan:
    # Creates up to 3 JIRA-ready tickets with role, priority, acceptance criteria

Input: Structured feedback + survey draft
Output: Top theme, recommended action, owner, impact/effort scores, and 1-3 tickets
Key Innovation: Intelligent role assignment (e.g., app bugs → SWE, in-store issues → Field Ops)

Frontend Highlights

Glassmorphic UI: Frosted glass cards, subtle animations, dark mode with vibrant gradients
Real-time Typing Speed Tracking: Measures WPM as users type (used for urgency detection)
Interactive Pulse Checks: Emoji-based voting (😡 Critical, 😐 Neutral, 😃 Good)
Tabbed Results Panel: Structured feedback, Pulse Checks, Survey Answers, Action Plan, Raw JSON
Graceful Degradation: Falls back to mock data if backend is unavailable

Challenges We Ran Into 😅

1️⃣ Getting LLMs to Follow Strict Output Schemas

Problem: GPT-4 would sometimes return single_choice questions when we explicitly asked for scale_1_5 only.
Solution: Used LangChain's with_structured_output() with Pydantic models + added explicit rules in the system prompt: "2. ALL questions must be type 'scale_1_5'." "3. DO NOT use text or single_choice questions."

2️⃣ Pulse Checks Not Rendering

Problem: Pulse checks were only displayed when SurveyMonkey integration was fully configured (conditional on surveymonkey?.weblink_url).
Solution: Decoupled the rendering logic — pulse checks always display, but voting buttons are conditionally shown based on SurveyMonkey status.

3️⃣ API Port Mismatch

Problem: Frontend was calling localhost:8001 but backend ran on localhost:8000.
Solution: Standardized to port 8000 and used a constant API_BASE to avoid hardcoded URLs.

4️⃣ Balancing Speed vs. Quality

Problem: Running 3 sequential LLM chains could take 5-10 seconds.
Solution:
- Used gpt-4o-mini instead of gpt-4 (10x faster, 90% quality)
- Added loading states and spinners to manage user expectations
- Optimized prompts to be concise (fewer tokens = faster responses)

5️⃣ Designing an "Invisible" UI

Problem: Surveys feel like work. How do we make feedback feel effortless?
Solution:
- Glassmorphism aesthetic (feels premium, not corporate)
- Emoji scales instead of numeric ratings (more human, less clinical)
- 3 questions max (10-second commitment)

Accomplishments That We're Proud Of 🏆

✅ Built a fully functional AI agent in 24 hours with 3 LLM chains, SurveyMonkey integration, and a polished UI
✅ Achieved true context-awareness — Pulse Checks adapt to the specific complaint (not generic templates)
✅ Intelligent role routing — Tickets are auto-assigned to PM, SWE, or Field Ops based on issue type
✅ Typing speed as a sentiment signal — Novel use of WPM to detect urgency/anger
✅ Glassmorphic UI — A design that feels premium and reduces survey fatigue
✅ Graceful degradation — Works in demo mode without SurveyMonkey (shows questions, disables voting)
✅ Real-world applicability — This could ship to production for e-commerce, delivery apps, SaaS tools, etc.

What We Learned 📚

Technical Learnings

LangChain's structured outputs are powerful but finicky — You need explicit Pydantic models + strict prompts to avoid hallucinations.
WPM is a surprisingly good sentiment signal — Fast typing often correlates with anger, slow typing with sadness/hesitation.
Glassmorphism is CSS-intensive — Layering backdrop-filter, gradients, and shadows requires careful tuning.
FastAPI + React is a dream stack — Type safety on both ends (Pydantic + TypeScript) catches bugs early.

Product Learnings

Customers don't hate feedback — they hate bad surveys — If you make it fast, contextual, and emoji-based, they'll engage.
Unstructured feedback is a goldmine — The real value isn't in the complaint itself, but in the AI's ability to extract structure, prioritize, and route.
"Invisible" UX is the future — The best tools don't feel like tools. MirrorLoop feels like venting to a friend who happens to create JIRA tickets.

Team Learnings

Divide and conquer works — One person on backend (LLM chains), one on frontend (UI/UX), one on integrations (SurveyMonkey), one on polish (animations, error handling).
Iterate fast, polish later — We shipped a working MVP in 12 hours, then spent the next 12 hours on UX, edge cases, and integrations.

What's Next for MirrorLoop 🔮

Short-Term (Next Sprint)

Multi-language support — Detect language and generate Pulse Checks in French, Spanish, Arabic, etc.
Sentiment trend dashboard — Aggregate feedback over time to spot patterns (e.g., "Checkout bugs spiked 40% this week").
Slack/Teams integration — Auto-post high-severity tickets to team channels.
Voice input — Let customers vent via voice (transcribe + analyze).

Medium-Term (Next Quarter)

Auto-close loop — When a ticket is resolved, auto-send a follow-up: "We fixed the bug you reported. Can you try again?"
A/B test Pulse Checks — Experiment with different question phrasings to maximize response rates.
Custom LLM fine-tuning — Train a domain-specific model on historical feedback for better accuracy.
Mobile app — Native iOS/Android apps with push notifications for urgent feedback.

Long-Term (Vision)

Predictive triage — Use historical data to predict which complaints will escalate (and proactively route them).
Auto-fix suggestions — For common bugs, generate code diffs or config changes (e.g., "Increase timeout from 5s to 10s").
Customer health scores — Track individual customers over time (e.g., "This user has filed 3 angry complaints in 2 weeks — reach out proactively").
White-label SaaS — Package MirrorLoop as a plug-and-play feedback platform for e-commerce, delivery, and SaaS companies.

Try It Out 🎮

Run Locally

Backend Setup

cd mirrorloop-backend
python -m venv venv
.\venv\Scripts\activate  # Windows
source venv/bin/activate  # Mac/Linux
pip install fastapi uvicorn pydantic pydantic-settings langchain langchain-openai httpx

Create .env file:

APP_ENV=dev
OPENAI_API_KEY=sk-your-key-here
# Optional:
# SURVEYMONKEY_ACCESS_TOKEN=your-token

Start server:

uvicorn main:app --reload

Backend runs at http://localhost:8000

Frontend Setup

cd mirrorloop-frontend
npm install
npm run dev

Frontend runs at http://localhost:5173

Team 👥

Built for UOttaHack 8 by:

Ajan Balaganesh
Danilo Bukvic
Aws Ali
Aydan Eng

Built With 🧰

React
TypeScript
Vite
Python
FastAPI
OpenAI GPT-4o-mini
LangChain
SurveyMonkey API
Pydantic
Custom CSS (Glassmorphism)
Sentry

License 📄

MIT License — Feel free to fork, modify, and use in your own projects!

Final Thoughts 💭

MirrorLoop isn't just a hackathon project — it's a vision for the future of customer feedback.

In a world where every company claims to be "customer-obsessed," most feedback systems are still stuck in the 2010s: long surveys, manual triage, and weeks-long response times.

We believe feedback should be: