Vitrine

Vitrine - a software marketplace where every product ships with a live, runnable preview, and where AI agents fill technical specs, verify quality, rank listings, advise on price, and guide buyers.

Comment

Inspiration

Today’s software marketplace is highly bifurcated. On one end, we have bloated SaaS platforms charging recurring fees for simple utilities. On the other end, we have fragmented GitHub repositories—millions of lines of open-source code gathering dust because they lack distribution, polished UI, or developer support.

We asked ourselves:

Why can't software be bought like editorial art? Why can't there be a boutique storefront for curated, production-ready, beautiful codebases?

This inspired Vitrine — a boutique marketplace for live, runnable software templates.

We wanted to build a platform that elevates code to craftsmanship. By combining rich web design with a fleet of autonomous AI agents, we created an environment where creators can present their codebases with the detail of an architectural spec sheet, while buyers can browse, test, and negotiate custom extensions with ease.

What It Does

Vitrine is a boutique gallery for high-quality software codebases. Instead of browsing simple README files, buyers see a comprehensive design and engineering specification.

Core Features

The Gallery

A premium storefront that dynamically sorts listings using the Vitrine Score, a multi-dimensional ranking algorithm balancing:

  • Visual craftsmanship
  • Repository completeness
  • Test coverage
  • Demo health
  • User engagement

AI Repo-Intake

Sellers paste a GitHub repository URL, and Vitrine automatically:

  1. Parses manifests and project metadata
  2. Detects frameworks, packages, and CI configurations
  3. Uses LLM enrichment to generate a structured specification sheet

Buyer Concierge

A conversational discovery interface powered by hybrid vector search:

  • pgvector in production
  • Optimized SQLite brute-force search in development

Buyers can search by:

  • Budget
  • Framework
  • Utility
  • Visual style
  • Technology stack

Interactive Negotiation (Buyer Representatives)

Buyers can dispatch autonomous AI agents to negotiate with sellers.

These agents operate using:

  • Budget constraints
  • Timeline goals
  • Historical transaction context
  • Product specification awareness

Feature Cost Estimator

Buyers describe a desired feature, and an estimator agent analyzes:

  • Programming languages
  • Database systems
  • Project architecture
  • Complexity estimates

The system then generates:

  • Recommended pricing
  • Milestone breakdowns
  • Delivery projections

Curator Moderation Console

An administrative suite for:

  • Human review workflows
  • Verification log screening
  • Copycat detection
  • Listing approval pipelines

How We Built It

Frontend

The frontend is a high-performance single-page application built using:

  • React
  • TypeScript
  • Vite

Design System

The visual system uses custom Vanilla CSS tokens to create a premium editorial aesthetic featuring:

  • Restrained typography
  • Dark mode transitions
  • Glassmorphism
  • Responsive card layouts

State Management

Global state synchronization is powered by:

  • Zustand

Backend

The backend consists of modular microservices implemented with:

  • FastAPI (Python 3.11)
  • SQLAlchemy 2.0
  • Aiosqlite

Database Architecture

  • SQLite in development
  • PostgreSQL migration path for production

Event Orchestration

Services communicate asynchronously using:

  • Redis Streams

AI Orchestrator

Vitrine uses a custom OpenAI tool-calling coordinator managing a fleet of seven autonomous agents.

Agent Fleet

Agent Responsibility
Repo-Intake Agent Repository structure analysis
Verification Agent License validation and preview checks
Curation Agent Visual scoring and ranking
Buyer Concierge Conversational discovery
Buyer Representative Autonomous negotiation
Feature Cost Estimator Quote generation
Pricing & Pitch Agent Seller pricing optimization

The Mathematics of Curation: The Vitrine Score

Rather than relying on chronological ordering, listings are ranked using the Vitrine Score.

Formula

$$ S_v = w_c \cdot C + w_u \cdot U + w_d \cdot D + w_r \cdot R + w_t \cdot T + w_e \cdot E $$

Where:

Variable Description
$C \in [0,100]$ Completeness index representing specification coverage
$U \in [0,100]$ UI Craft score generated via visual LLM analysis
$D \in [0,100]$ Demo health based on uptime and latency
$R \in [1,5]$ Bayesian review score
$T \in [0,1]$ Recency decay factor
$E \in [0,100]$ User engagement metrics

Bayesian Rating Rollup

To avoid low-volume review manipulation, ratings use Bayesian averaging:

$$ R = \frac{v \cdot r + m \cdot C_{\text{avg}}}{v + m} $$

Where:

  • $v$ = number of reviews
  • $r$ = average review score
  • $m = 10$ = prior weight
  • $C_{\text{avg}}$ = global average platform rating

Recency Decay

Repository freshness is modeled using exponential decay:

$$ T = e^{-\lambda t} $$

Where:

  • $t$ = elapsed days since the last update
  • $\lambda$ = decay coefficient

Challenges We Ran Into

Dynamic Multi-Turn Agent Tool-Calling

One of the largest challenges was building a secure framework where autonomous agents could:

  • Inspect database models
  • Compare pricing data
  • Generate negotiations
  • Write structured outputs safely

Solution

We implemented:

  • Strict Pydantic validation schemas
  • Restricted write operations
  • Controlled tool exposure boundaries

Context-Aware Bargaining

The Buyer Representative needed to:

  • Understand the buyer’s true maximum budget
  • Negotiate effectively
  • Avoid exposing internal constraints

Solution

We introduced:

  • Prompt guardrails
  • State verification loops
  • Counter-offer constraint systems

Synchronizing Mock and Live Modes

The frontend supports:

  • Fully client-side mock execution
  • Real-time backend synchronization

Reconciling both execution paths required a conditional API connector inside the Zustand store that switches seamlessly using:

VITE_USE_MOCKS

Accomplishments We’re Proud Of

High-Fidelity Aesthetics

We built a storefront experience that feels closer to a design publication than a traditional software marketplace.

Highlights include:

  • Inter & Outfit typography pairing
  • Glassmorphism interfaces
  • Editorial spacing systems
  • Seamless dark mode transitions

Robust Agent Fleet

A single repository link triggers an asynchronous orchestration pipeline involving:

  1. Repository inspection
  2. Stack detection
  3. Visual scoring
  4. Demo verification
  5. Score computation
  6. Final curation

Deterministic Embedding Fallback

We designed a custom hashing-based embedding fallback system allowing semantic search to function offline during development without requiring external API credentials.

What We Learned

Heuristics First, LLMs Last

LLMs are powerful but computationally expensive.

We significantly reduced inference costs by:

  1. Parsing structured manifests deterministically
  2. Using regex-based extraction first
  3. Passing only ambiguous or unstructured content to LLMs

Examples include:

  • package.json
  • pyproject.toml
  • CI configuration files

Zustand Is Powerful for Hybrid States

Separating networking logic from UI components dramatically simplified frontend architecture.

Transparent API fallback behavior inside Zustand actions allowed components to remain entirely presentation-focused.

What’s Next for Vitrine

Stripe Connect Integration

Direct seller payouts and marketplace revenue routing.

Live Sandbox Hosting

Secure WASM-based in-browser execution environments for live codebase testing before purchase.

it

Agent Screen to open The one line to say
Repo-Intake Sell → New Listing → paste repo "Detects the stack deterministically, then one LLM call fills the judgment fields — with confidence scores."
Pricing & Pitch Sell → "Help me price" "Anchors price on real comps, proposes tiers and copy — advisory, never auto-applied."
Verification Admin → verification queue "Pings the live demo, cross-checks claims, can flag but never hard-reject."
Curation & Ranking Product / Admin → Vitrine Score "Mostly deterministic signals + a once-cached vision score → the Vitrine Score."
Buyer Concierge Concierge panel "Plain English → filters → hybrid RAG search, streamed, grounded in real rows."
Buyer Representative Product → Ask AI to Bargain "Negotiates for the buyer, capped at their max budget, discloses it's an AI."
Feature Cost Estimator Product → custom feature "Reads the real tech spec, estimates hours + milestones, flags impossible asks."

GitHub Webhook Sync

Automatic re-indexing and score recalculation whenever repository updates are pushed.

This includes:

  • Test suite refreshes
  • Metadata synchronization
  • Demo validation
  • Vitrine Score recomputation

Built With

Share this project:

Updates