Rove

Rove turns open-web shopping into a shared workspace where people and browser agents research, refine, and save real retailer finds together.

Comment

Inspiration

Shopping across the open web is fragmented. Products live across dozens of retailer tabs, useful recommendations disappear inside chat transcripts, and the human often cannot refine an agent’s work without starting over.

That inspired Rove: a shared fashion research workspace where a person and a browser agent work on the same shopping mission. The agent handles open-web research while the human stays in control of preferences, budgets, product review, selective replacement, and the final cart.

What it does

Rove turns a natural shopping request—such as “Find three shirts, three pants, sneakers, and a fragrance for four days in Cancún under C$450”—into a structured research mission.

The browser agent can:

  • Read the user-approved style profile.
  • Translate the request into quantities, categories, occasions, and budgets.
  • Claim prioritized retailer research targets.
  • Browse live retailer pages.
  • Progressively publish grounded products with direct images and canonical links.
  • Enrich products with availability, pricing, materials, and variants.
  • Report research progress and unresolved needs.
  • Add exact products to the shared cart.

At the same time, the human can:

  • Watch products arrive progressively.
  • Filter and compare recommendations.
  • Inspect retailer provenance.
  • Accept the complete edit or replace only selected items.
  • Request completely fresh research without duplicate links.
  • Save completed prompts and accepted products locally.
  • Manage a cross-retailer cart called “Your Thread.”

Rove keeps completed missions separate from the current mission, so previous research remains useful without confusing the active task.

How we built it

Rove is a client-only application built with Nuxt 4, Vue 3, strict TypeScript, Tailwind CSS, and the imperative WebMCP API.

It registers 17 tools through document.modelContext, covering profile setup, mission planning, retailer scheduling, candidate publication, product enrichment, recommendation review, research history, and cart management.

The most important architectural decision was giving the interface and WebMCP tools the same typed domain action layer. Agent actions do not update a separate hidden system: they produce the same visible state changes as human actions.

A deterministic research scheduler ranks retailer targets based on:

  • Requested categories and quantities.
  • Remaining unmet needs.
  • Style and occasion relevance.
  • Department compatibility.
  • Per-item and overall budgets.
  • Retailer capabilities.
  • Scarce categories such as fragrance.

Published candidates pass through validation for retailer domains, canonical product URLs, mission identity, budgets, duplicate history, and required imagery. Recommendation order combines relevance, budget fit, profile alignment, availability, freshness, and retailer diversity.

The application uses browser-local persistence and requires no backend, database, account, API key, embedded chatbot, or OpenAI API call. It is deployed as a static Netlify application and remains usable when WebMCP is unavailable.

Challenges we ran into

The hardest challenge was making agent research behave like a reliable product workflow instead of an open-ended chat.

Retailer information is inconsistent. Some products have sizes and colours, while fragrances and accessories may have neither. We had to introduce category-aware variant handling so a perfume could not accidentally inherit an invalid clothing colour or size.

Selective replacement was another difficult problem. When the user rejected one product, the system initially risked replacing or hiding accepted products. We redesigned the review workflow so accepted products remain visible and only explicitly rejected items become new research targets.

We also had to solve duplicate prevention across repeated missions. Rove now retains previously surfaced and accepted product links so “research again” can use past preferences as context without relisting the same products.

Product imagery created additional complexity because retailer image URLs vary and can fail after publication. We added direct-image validation, visible fallbacks, and consistent image framing so missing or differently sized assets do not break the interface.

Finally, we had to balance a sophisticated agent workflow with a simple human experience. Mission state, research queues, replacement context, saved history, and the cart all needed to remain understandable without exposing internal orchestration details.

Accomplishments that we're proud of

We are especially proud that Rove feels like a complete fashion product rather than a WebMCP demonstration screen.

Key accomplishments include:

  • Seventeen working WebMCP tools with closed schemas and clear annotations.
  • One shared action boundary for human and agent operations.
  • Progressive multi-retailer research with visible state changes.
  • Quantity-aware and budget-aware mission fulfilment.
  • Selective product replacement without disturbing accepted items.
  • Fresh research that avoids previously listed links.
  • Category-aware cart variants for clothing, fragrance, and accessories.
  • Saved missions with locally preserved prompts and accepted edits.
  • A polished, responsive, accessible Rove interface.
  • A deterministic test suite with 68 passing tests, strict type checking, and verified production builds.

What we learned

We learned that useful agent experiences depend more on state design and tool contracts than on one large prompt.

Small, purpose-built tools with explicit schemas gave the browser agent clearer responsibilities and made failures easier to understand. A persisted state machine also made the collaboration resilient: the agent could report what it had completed, what remained unresolved, and what it should do next.

We also learned that human control must be visible. Users need to see what the agent changed, preserve decisions they already approved, and request corrections without restarting the entire workflow.

Most importantly, WebMCP works best when it is integrated into the product’s real domain model. The tools should not sit beside the application—they should operate the application.

What's next for Rove

Next, we want to expand Rove with:

  • More retailer adapters and stronger regional availability support.
  • Better price and inventory freshness indicators.
  • Optional, privacy-conscious cross-device synchronization.
  • Visual style references and wardrobe-aware recommendations.
  • Stronger accessibility and mobile interaction testing.
  • User-controlled retailer preferences and sustainability signals.
  • Cleaner retailer checkout handoffs while keeping purchasing on official retailer sites.
  • Evaluations that measure duplicate rate, budget adherence, research completion, and recommendation acceptance.

Our long-term vision is for Rove to become the open-web workspace where people and agents build confident shopping decisions together.

Built With

Share this project:

Updates

Submission history