Side∞Quest

placeholder text

Comment

🎮 Side∞Quest

💡 Inspiration

As college students, we’ve found ourselves in the exact same dilemma countless times: a surprise gap between classes, a canceled lecture, or an open Friday afternoon with friends. Everyone wants to hang out, but decision paralysis immediately kicks in. We scroll through maps, debate where to eat, second-guess parking, and by the time anyone agrees on a plan, half our free time is already gone.

We wanted to eliminate that friction and help people sidequestmax. Life shouldn’t just be about grinding the "main quest" (school, work, exams). Side quests—spontaneous late-night taco runs, finding an obscure retro arcade, or checking out a tucked-away botanical garden—are the memories you actually remember. We built Side Quest to turn any slice of free time, any budget, and any neighborhood into an instant, curated micro-adventure with zero planning overhead.

⚙️ How We Built It

Side Quest merges autonomous AI agents with an immersive RPG-style experience, targeting both the Fetch.ai / ASI:One challenge and the Applied Intelligence track.

                    ┌────────────────────────────────────────────────────────┐
                    │               DUAL-FRONTEND ECOSYSTEM                  │
                    │                                                        │
                    │  [Paper Interface (Web)]     [ASI:One Chat (asi1.ai)]  │
                    │   Guided 6-step UI wizard      Free-form natural lang  │
                    │   (REST /api/quest JSON)       (ACP v0.3.0 /submit)    │
                    └───────────────┬────────────────────────┬───────────────┘
                                    │                        │
                                    ▼                        ▼
                    ┌────────────────────────────────────────────────────────┐
                    │       adapters.py (Unified Dual-Gateway Layer)         │
                    │         Normalized into Canonical QuestConstraints    │
                    └────────────────────────┬───────────────────────────────┘
                                             │
                                             ▼
                    ┌────────────────────────────────────────────────────────┐
                    │     Quest Orchestrator Bureau (@quest-orchestrator)    │
                    │                                                        │
                    │   ┌────────────────────────────────────────────────┐   │
                    │   │ Scout Ensemble (POI Discovery & Grounding)     │   │
                    │   │  ├── Culture Scout   ├── Dining Scout          │   │
                    │   │  └── Trails Scout    └── Google Places + Gemini│   │
                    │   └───────────────────────┬────────────────────────┘   │
                    │                           │                            │
                    │   ┌───────────────────────┴────────────────────────┐   │
                    │   │ Transit Agent (Multi-Modal Routing & Fares)    │   │
                    │   └───────────────────────┬────────────────────────┘   │
                    │                           │                            │
                    │   ┌───────────────────────┴────────────────────────┐   │
                    │   │ Budget & Meal Agent (Slack & Dining Injector)  │   │
                    │   └────────────────────────────────────────────────┘   │
                    └────────────────────────────────────────────────────────┘

1. Dual-Frontend Experience: Paper Interface vs. ASI:One

To make Side Quest accessible to everyone, we engineered two distinct frontend systems sharing a single, unified multi-agent backend via adapters.py:

Dimension 📄 Paper Interface ("Side Quest Board") 💬 ASI:One Interface (asi1.ai)
Primary Interaction Guided & Structured: One-question-per-screen visual wizard eliminating decision friction. Free-Form & Conversational: Open natural-language chat where you talk directly to the agent.
Input Modality 6-step interactive UI controls (vibe tiles, dual-clock time sliders, budget range sliders, GPS/map radius). Conversational text prompts ("I have 2.5 hours and \$30 starting from Westwood, looking for modern art and boba").
Protocol / Transport Direct REST JSON contract (POST /api/quest / POST /api/quest/plan) conforming to types/quest.ts. Fetch.ai Agent Chat Protocol (ACP v0.3.0) over webhook endpoints (POST /submit).
Output Presentation Multi-tab interactive quest cards, Leaflet / OpenStreetMap visual route geometry, and stop timeline cards. Formatted Markdown RPG Sidequest Log in chat + structured ACP interactive card payload.
Best For... Users who want a fast, visual, click-through mobile/desktop app without typing prompts. Users inside the Fetch.ai/ASI ecosystem who want conversational fluidity and instant agent-to-agent chat.

📄 The Paper Interface: Minimal Dark-Mode Wizard

  • Built with Next.js App Router, TypeScript, Tailwind CSS, and Leaflet / OpenStreetMap.
  • Designed around a rapid, low-friction 6-step guided wizard:
    1. Vibe Selector (VibeOptions): Quick-tap tiles for Food, Outdoors, Arts, Nightlife, Games / Arcade, or Surprise Me.
    2. Clock Window (ClockWindow): Visual departure & hard return cutoff picker calculating exact time budgets ($\Delta T$).
    3. Budget Range (BigRange): Smooth slider with typed precision, including $\$0$ / free adventure mode.
    4. Starting Location (LocationInput): One-click browser geolocation (navigator.geolocation) or quick neighborhood selection.
    5. Distance Boundary (DistancePicker / RadiusMap): Real-time interactive Leaflet circle showing maximum exploration radius.
    6. Party Stepper (PartyStepper): Group size configuration with RPG party banter.
  • Results Quest Board: Renders 3 simultaneously curated, ranked quests (Primary Recommended, Active Exploratory, Scenic Leisure) complete with live Leaflet route mapping, walking/transit connectors, rating stars, and verified place review summaries.

💬 The ASI:One Interface: Conversational Natural Language

  • Registered on the Agentverse Almanac under the handle @quest-orchestrator.
  • Powered by our regex and heuristic NLP extraction engine (planner.py & adapters.py), which parses unstructured text into hard constraints:
    • Extracts duration windows ("2 hours", "until 6pm"), budget ceilings ("\$35", "cheap", "free"), neighborhoods, and vibe intent.
  • Streams back an immersive RPG "Sidequest Log" in Markdown:
    • Quest Rank Classification (Rank C Micro-Patrol $\to$ Rank S Epic Campaign).
    • Resource Feasibility Tables showing utilized vs. slack time and spent vs. remaining funds.
    • Fast-Travel Timelines with ingress/egress transit legs, dwell times, and tactical buffs (e.g., +20 Cultural Wisdom, +15 Sugar Rush).
    • Dispatches non-blocking ChatAcknowledgement and ACP-compliant interactive card JSON objects.

2. Autonomous Multi-Agent Bureau (Fetch.ai uagents)

Rather than relying on a single, monolithic LLM prompt that hallucinates routes or miscalculates travel times, we implemented a distributed Fetch.ai uagents.Bureau communicating over the Agent Chat Protocol (ACP v0.3.0):

  • Quest Orchestrator (agent.py): The primary coordinator registered on Agentverse. It operates as a dual gateway (REST + ACP), translates inputs into canonical QuestConstraints, dispatches sub-tasks across the Bureau, and compiles the final itinerary.
  • Specialized Scout Ensemble (scout_agent.py): A coordinated network of domain-specialized discovery agents:
    • Culture Scout (culture_scout.py): Evaluates museums, galleries, historic sites, and admission costs.
    • Dining Scout (dining_scout.py): Curates neighborhood food gems, cafes, ramen bars, and dessert stops.
    • Trails Scout (trails_scout.py): Identifies parks, coastal walks, botanical gardens, and scenic viewpoints.
  • Transit & Mobility Agent (transit_agent.py): Calculates multi-modal travel buffers (driving, walking, rideshare, public transit), estimated fares, and round-trip ingress/egress timings.
  • Budget & Meal Agent (budget_agent.py): Evaluates fiscal and temporal headroom to opportunistically inject culinary pitstops (sit-down meals, boba, matcha, food trucks) when slack time permits.

3. Dual-Engine Intelligence: Live Google Places API & Gemini AI Summaries

To ground our agents in factual reality and eliminate dead ends:

  • Google Places API (New): Queries real-time geographical coordinates, price level estimates, operational status, and verified opening hours against the user's specific departure and return window.
  • Gemini Review Summaries & Editorial Consensus: Extracts Google’s AI-generated review summaries (reviewSummary / editorialSummary) and verified quotes to generate concise "waypoint intel"—giving users the true consensus on why a spot is worth the stop without wading through dozens of scattered reviews.
  • Anti-404 Link Verification Guardrail: An asynchronous pre-flight validator (is_link_live) validates destination URLs via HTTP HEAD/GET checks. If a venue website is blocked or returns a 404, it deterministically substitutes a live, verified Google Maps search coordinate query.

4. Mathematical Optimization Engine

Every generated side quest balances temporal constraints ($\Delta T$) and budget boundaries ($\Delta C$) through strict constraint validation:

$$\text{Total Time} = \sum_{i=1}^{n} T_{\text{dwell}}(i) + \sum_{i=1}^{n-1} T_{\text{transit}}(i \to i+1) + 2 \cdot T_{\text{transit}}(\text{base} \to 1) + T_{\text{slack}} \le \Delta T_{\text{window}}$$

$$\text{Total Cost} = \sum_{i=1}^{n} C_{\text{activity}}(i) + C_{\text{transit}} + C_{\text{dining}} \le \Delta C_{\text{budget}}$$

A bonus dining or snack checkpoint is opportunistically injected into the quest based on strict slack thresholds:

  • Sit-Down Meal Stop: $$T_{\text{slack}} \ge 45\text{ min} \quad \text{and} \quad C_{\text{remaining}} \ge \$15.00$$
  • Quick Supply Drop (Boba, Coffee, Pastry): $$T_{\text{slack}} \ge 20\text{ min} \quad \text{and} \quad C_{\text{remaining}} \ge \$4.50$$

🧗 Challenges We Faced

  • Bridging Guided Wizard UI with Conversational Agent Chat: Supporting both the visual Next.js Paper UI and the conversational ASI:One chat required building a bidirectional translation layer (adapters.py). This adapter normalizes disparate input shapes into unified internal datacontracts and synthesizes either strict typed JSON for React state or RPG Markdown for chat streams—guaranteeing 100% frontend compatibility without code regressions.
  • The "Closed Business" Trap & Live Place Data: Place metadata frequently suffers from outdated operating hours or defunct locations. We solved this by integrating Google Places API status filters, temporal bounds verification, and automated link liveness probing to reject closed venues before the agent completes synthesis.
  • Multi-Agent Asynchronous Choreography & Bureau Resilience: Coordinating four distributed agents over ACP v0.3.0 required handling state transitions (ChatMessage, ChatAcknowledgement) and non-blocking background task queuing. To protect against network drops or ledger lookups, we implemented smart local route resolvers and direct subagent fallbacks that guarantee real-time responses under 5 seconds.
  • DNS & Protocol Quirks in Python uagents: Standard ledger lookups can hang when local DNS resolvers throttle requests. We implemented automated monkeypatches (dns_resilience.py) and ASGI CORS wrappers to ensure smooth communication across localhost, ngrok tunnels, and browser origins.

🧠 What We Learned

  • Multi-Agent Specialization beats Monolithic LLMs: Decoupling tasks across a Bureau (Scout Ensemble for discovery, Transit for mobility, Budget for fiscal auditing, Orchestrator for synthesis) eliminated hallucinations and produced vastly superior route feasibility.
  • Dual-Gateway Architecture: How to build an AI application that simultaneously serves both conventional web applications (REST/JSON) and decentralized agent networks (Fetch.ai Agentverse / ACP) from a single shared core.
  • Deterministic Bounds Meet Generative Insights: Mathematical constraint checks ($\Delta T$, $\Delta C$) combined with Google & Gemini review synthesis yield grounded, dependable itineraries people can genuinely trust.

🔮 What's Next for Side Quest

  • Dynamic Mid-Quest Rerouting: Webhook alerts for live transit delays or sudden weather shifts that automatically branch the side quest mid-route.
  • Guild & Multiplayer Mode: Allowing friend groups to join a live room and vote on quest branching choices in real time right from their phones.

Built With

Share this project:

Updates

Submission history