BAZaar

Path: products/bazaar/

BAZaar (stylized BAZaar, /\ˈbəˌzär/) is the RAGBAZ marketplace concept — a draft specification for a platform where RAGBAZ and its tenants publish, trade, deploy, document, and teach software. The name collapses BAZaar from Bazaar + Articulate + Zone + Application + Archive + Research, reflecting the six provenance categories of the platform.

This document is a draft spec — it defines the aspirational surface before any implementation.

Concept

BAZaar is a storefront that is also a workshop. Every listing is:

a shop item — purchasable, licensable, or free
a deployment target — one-click deploy to a tenant's infrastructure
a documentation site — versioned manuals, API references, technical guides
a notebook — interactive Jupyter/observable-style specimens that the buyer can fork, run, and modify

The platform is itself a tenant of the RAGBAZ control plane — every BAZaar deployment is a WordPress multisite backed by the Articulate universe, with listing data managed via MCP subgraph.

Shop Elements

Product Card

Every listing surfaces as a product card with tier toggle (free / paid / subscription), provenance badge, format chips, specimen preview placeholder, and Deploy/Fork actions.

MATCHES Simulation Engine
bazaarbinarynotebook
$49.00
Tier
▣ specimen preview · binary · bazaar

Mailguard Policy Pack
articulatesourcedoc
$29.00
Tier
▣ specimen preview · source · articulate

The tier selector switches between free (green), paid one-time (orange), and subscription (blue) pricing. The price badge updates in real time.

Cart & Checkout

A four-step browse → cart → checkout → confirmation flow simulating the BAZaar purchase experience.

Available Listings
MATCHES Simulation Enginebazaar
Free
Mailguard Policy Packarticulate
$29
Glither Ruleset Compilerresearch
$49

The checkout step integrates with the RAGBAZ control plane for Stripe payment processing, with tier selection affecting final price calculation. Confirmation displays an order summary with per-item provenance tracking.

Order Timeline

After purchase, the order timeline visualizes the six stages from placement to URL delivery, with actor labels and elapsed time.

Order Timeline
Buyer places ordertenant
T+0s
BAZaar validates paymentcontrol-plane◀
T+2s
Specimens compilingbuilder
T+8s
Deploying to tenantprovision
T+15s
Health check passmonitor
T+25s
URL returnedgateway
T+30s

Taxonomy

Provenance

Format

SLUG

bazaar/notebook/bazaar-notebook-demo-01

bazaarnotebook

Every listing in BAZaar is tagged with exactly one provenance category and one or more format tags. The table below maps the metadata model:

Field	Type	Example
`slug`	`string`	`matches-sim-engine`
`title`	`string`	`MATCHES Simulation Engine`
`provenance`	enum	`bazaar`
`formats`	`string[]`	`["binary", "notebook", "doc"]`
`tier`	enum	`free` / `paid` / `subscription`
`price`	`number`	`0` or `29.00`
`tenant`	`string`	`ragbaz` or custom slug
`specimens`	`Specimen[]`	interactive notebooks
`deploy`	`DeployTarget`	helm / docker / wp / wasm

Specimens

The core innovation of BAZaar is the specimen — a runnable, forkable interactive document that serves simultaneously as demo, manual, test, and tutorial. Every listing carries at least one specimen.

The specimen runtime is a sandboxed WebAssembly environment with bindings to the RAGBAZ MCP gateway. Each specimen:

renders in the browser via an MDX-embedded iframe or web component
can invoke the listing's own API (if any)
can be forked into a tenant's own workspace
reports telemetry (run count, fork count, average duration)

Example: MATCHES Simulation

An interactive specimen that runs a headless MATCHES simulation and plots the pose graph of two actors over 240 ticks.

import matches

sim = matches.Simulation(actors=2, ticks=240)
result = sim.run()
result.plot_pose_graph()

Specimen format

Property	Required	Description
`id`	yes	UUID
`title`	yes	Human label
`language`	yes	`python` / `javascript` / `wasi` / `markdown`
`entry`	yes	Path to the main file
`files`	yes	File tree (zip or tar)
`runtime`	yes	WASI runtime version pin
`mcp_bindings`	no	Allowed MCP tools the specimen may call
`timeout_ms`	yes	Max execution wall time
`readme`	no	Rendered below the specimen pane

Deployment Targets

Every listing can declare one or more deployment targets. BAZaar generates the appropriate deployment artifact at purchase time.

Target	Format	Use case
`docker`	Compose file + `.env` template	Self-hosted services
`helm`	Chart tarball	Kubernetes deployments
`wp-plugin`	`.zip`	WordPress plugin install
`wp-theme`	`.zip`	WordPress theme install
`wasm`	`.wasm` binary	Edge / browser runtimes
`notebook`	`.ipynb` or `.md`	Interactive specimens only
`ragbaz-tenant`	MCP provisioning call	One-click deploy to tenant infra

The ragbaz-tenant target is the BAZaar-native deployment path. When a tenant purchases a listing with this target, the control plane:

provisions a subdomain on the tenant's WordPress network
deploys the listing as a WordPress plugin or standalone app
attaches the listing's specimens as pages
returns a URL

Deploy Pipeline

1Buyer clicks "Deploy"◀ active

2BAZaar resolves tenant + listing

3Control plane provisions subdomain

4Specimens attached as pages

5Deployment artifact generated

6URL returned to buyer

Marketplace Interface

The BAZaar storefront surfaces listings through three views:

Grid View

The default view — a responsive grid of listing cards. Each card shows:

title and provenance badge
price
thumbnail specimen (miniature interactive preview)
format icons

Detail View

Full listing page with:

hero specimen (full-size interactive demo)
versioned documentation
technical specs table
deployment target selector
pricing tier toggle
"Fork" and "Deploy" action buttons

Notebook View

Read-only or forkable view of the listing's specimens rendered as a Jupyter-style notebook with:

code cells (executable when forked)
markdown cells (documentation)
MCP tool call cells (live API interaction)
output cells (tables, plots, JSON)

Pricing Model

BAZaar supports three tier types:

Tier	Commission	Payout schedule
Free	0%	—
Paid (one-time)	15%	Net-30 after buyer confirmation
Subscription	10%	Monthly, net-15

Pricing is set by the listing author in their tenant dashboard. RAGBAZ-authored listings (provenance bazaar) follow RAGBAZ pricing.

Discovery & Search

Listings are indexed on:

title and description (full-text)
provenance and formats (faceted)
specimen MCP bindings (browse by API surface)
deployment targets (filter by deployment format)

The search endpoint is an MCP tool on the Articulate subgraph:

query BrowseBAZaar($filters: BAZaarFilters) {
  bazaar {
    listings(filters: $filters) {
      slug
      title
      provenance
      tier
      price
      specimens { count }
    }
  }
}

Draft Notes

This spec is aspirational. The following components are explicitly out of scope for an MVP:

On-platform payment processing (MVP uses Stripe via existing control-plane webhooks)
WASM specimen sandbox (MVP uses iframe with srcDoc sandbox only)
Tenant-to-tenant royalties
Specimen telemetry dashboard
Custom domain for listing documentation
Kubernetes Helm chart generation

In-scope for MVP:

Listing CRUD via MCP subgraph
Static specimen rendering (read-only)
One-click deploy via ragbaz-tenant target
Search and faceted browse
Pricing and Stripe checkout integration

Concept​

Shop Elements​

Product Card​

Cart & Checkout​

Order Timeline​

Taxonomy​

Specimens​

Specimen format​

Deployment Targets​

Marketplace Interface​

Grid View​

Detail View​

Notebook View​

Pricing Model​

Discovery & Search​

Draft Notes​