Inspiration
Cognizant AI Lab's videos of the worldwide agentic web prototype showed us an idea we hadn't seen working anywhere else: websites that carry their own agents, publish them as plain JSON, and let other sites' agents talk to them right in the visitor's browser.
The new standards behind it made that concrete:
- The Minimum Viable Specification for a Worldwide Agentic Web (MVP Profile 0.2). A site publishes an
agent-manifest.json, describes its agents as data rather than code, runs them in the browser, and lets the visitor choose the model. - Neuro SAN agent networks and the nsDeploy reference runtime, which show how a multi-agent graph can move between sites.
- Bring-your-own-model options that only recently became practical in a browser: Mozilla Otari as one OpenAI-compatible gateway for many providers, and Chrome's built-in Gemini Nano.
We wanted to test the idea on something people actually buy, compare and argue about: price. A custom scale diorama is a good case. Every order is unique, it has to be designed before it can be priced, and different makers will build and price the same request differently. So we built a small marketplace of websites that have never met, and let their agents compete for the order.
What it does
Open Agentic Procurement: Dioramas is three independent agentic websites: one buyer and two competing makers.
- OpenAgentic Procurement Hub (the buyer). You type a commission in plain language, for example "a 1:35 WWII desert trench diorama, 40x40cm, with a resin river and LED explosions, budget $450".
intake_agentturns it into a structured request for quote (RFQ).discovery_agentreads each supplier's publicagent-manifest.jsonand shortlists every studio that publishesdiorama.quoteand builds the requested scale.negotiator_agentcollects the competing quotes, waits for your choice, and counter-offers within your budget.
- Two diorama studios, each with its own agents, prices and style:
- Miniature Worlds: fast and premium, with a 12% maximum discount.
- Frostbite Miniatures: dense natural detail, lower labour rates and longer lead times, with an 8% maximum discount.
- In each studio,
diorama_designerturns the RFQ into a live 3D scene in Three.js (terrain, trenches, ruins, trees, a resin river, flickering LEDs), all procedural geometry.diorama_estimatorprices it from materials and labour hours, applies scale rules, and negotiates.workshop_operatorupdates the 3D preview and the commission board.
One request, two 3D blueprints, your choice:
- The hub sends the same RFQ to both studios at once. Both designs render side by side, live, in the hub's split view, and the same brief comes back as two visibly different dioramas.
- The hub shows the quotes next to each other with badges such as Lowest price, Fastest and Over budget by $50. In the demo, Miniature Worlds quotes $500 in 7 days and Frostbite quotes $450 in 12 days.
- You click Choose this quote, or Let the agent pick (within budget first, then cheapest, then fastest).
- The hub negotiates only with the studio you chose. For Miniature Worlds: $500 → you offer $430 → studio $465 → your $450 is accepted. Frostbite is already within budget, so that deal closes at once.
- Comparison quotes write nothing. Only the studio you choose puts the order on its board.
You stay in control:
- Nothing is written without your approval. Every write pauses on an "Approve Action?" card that shows the exact payload, the price, the target site and the other quotes you compared. That covers placing the order on the hub and locking a build slot on the chosen studio.
- Rules are enforced in code, not left to the model. The hub never accepts or orders above your budget. Each studio never goes below its own discount floor.
- You choose the model on each site:
- Mozilla Otari with your own key (global or EU region, plus a list of the models your organization can use)
- Gemini Nano on your device
- Hybrid (Nano first, Otari as fallback)
- Demo Mode, which needs no key, so anyone can try it
- You can watch everything. A live execution stream shows every agent handoff across all three sites, labelled by shop, plus every manifest fetch and the provider, time and tokens of every model call. A Manifest Inspector shows each site's published agents and checks them against the spec.
How we built it
- No backend, no build step, no dependencies. All three sites are plain HTML, CSS and ES modules. An 83-line Node dev server serves them on three ports with CORS. The live version runs on GitHub Pages.
- Agents are data. Each site's network file holds every agent's instructions and output schema, and the runtime loads it through the site's
agent-manifest.json. - A second shop is a profile, not a fork. Frostbite runs the same studio code as Miniature Worlds. Its folder holds only what makes it a different business: a
shop.jsonwith prices, lead times, discount floor and design style, its own manifest and agent network, and a colour theme. - The model proposes, the code decides. Every model output is validated against its schema, then normalized: scenes are clamped inside the base, unknown structure types dropped, missing features restored. Business policy runs in plain functions that are unit-tested on their own.
- Cross-site protocol. The sites talk over
window.postMessage:OAW_RPC_REQUEST/OAW_RPC_RESPONSEfor callsOAW_RPC_EVENTso the hub can show each studio's agents working in real time- origin and window checks on both sides, and consent for unknown callers
- one live frame and one RPC connection per supplier, so several shops can share a host
- One shared runtime for all sites, with these providers:
- Mozilla Otari: OpenAI-compatible
chat/completions, JSON mode, model discovery via/models - Gemini Nano: Chrome Prompt API with
responseConstraint - Hybrid and Demo
- Mozilla Otari: OpenAI-compatible
- Every site exposes
window.OpenAgenticWeb(manifest,run,callTool,getState; the hub addschooseQuote), so other pages, extensions or agents can drive them. - Tested in a real browser. Headless Chrome runs the full commission across all three sites, compares both quotes, makes the choice and clicks every approval, locally and on the live site. Mocked Otari errors, a Gemini Nano that never answers, a model that returns empty JSON and a slow CDN all have their own tests.
Challenges we ran into
- Small models don't follow orders. Gemini Nano sometimes ignored the JSON format, and some Chrome builds rejected structured output with
kErrorUnknown. On slower machines it could take longer than 30 seconds to write a full 3D scene. We added a JSON extractor, one retry, a time limit that can't hang, and a fallback that skips Nano for a few minutes after it fails. - Models hand back nonsense, and politely. In one test the model left out the counter-offer price, the code read that as
0, and the hub offered $1. The studio's floor rule caught it, but that run is why the hub has its own policy layer now. - Two shops, one address. On GitHub Pages every site shares one origin, so connections and saved data keyed by origin collided between the two studios. We now key every frame, RPC connection, board and settings store by supplier, and check which window each reply came from.
- A studio that was too slow to answer. Each studio waited for Three.js to download before it answered the hub, so on a slow connection one shop could miss the quote. The 3D viewer now loads in the background: the studio quotes at once and draws the model when Three.js arrives.
- Pricing that made a fair demo. Frostbite's first price list made its 8% floor sit above a typical budget, so choosing it always ended in "no deal". We recalibrated both shops so each has a real trade-off: cheaper but slower, or faster but over budget and open to negotiation.
- Real-world gateway errors. Otari keys belong to a region (a 421 means "use the EU endpoint"), and an organization may not have credentials for every provider (424). The site now switches region automatically, but only between Otari's own hosts, and lists the models the key can actually run.
- Invisible characters. A pasted key containing an invisible character broke
fetchwith an unhelpful error. We now strip those and name any character that can't be sent. - Static hosting surprises. GitHub Pages caches files for 10 minutes, so visitors kept running old code after a fix. Every file URL now carries a content hash, and the build ID shows in the stream.
Accomplishments that we're proud of
- A working agent marketplace. Three websites that have never met discover each other, design two competing products in 3D, let a human compare and choose, negotiate and confirm an order, all from published JSON with no server.
- Side-by-side 3D feedback. The same request becomes two different dioramas you can orbit and compare before you spend anything.
- Human approval and human choice are built into the protocol. You pick the supplier, and writes are approved on the site that owns them, even when another site requests them.
- The model can't break the rules. Budgets, discount floors and scale limits are enforced in code. Whenever the model's proposal gets overruled, the stream says so.
- Adding a shop is cheap. A new storefront is a profile, a manifest and a theme on top of the same open runtime.
- It works for everyone:
- with your own Mozilla Otari key
- fully on-device with Gemini Nano
- with no key at all in Demo Mode
What we learned
- Publishing agents as data changes the conversation between sites. Once a site's capabilities are a JSON file, discovery is just a
fetch, comparing suppliers is just asking each one, and checking a site against the spec is a set of yes/no questions. - Competition makes agents more useful. One supplier's quote is a number. Two quotes with two 3D blueprints give the buyer a real decision, and give the negotiator something to work with.
- Treat model output as a proposal, never a decision. Schemas, normalization and policy functions made the agents dependable, and they work the same with Otari, Nano or Demo Mode.
- Bring-your-own-model is a UX problem as much as an API problem. Regions, provider credentials, model lists, pasted keys and slow local models all need clear messages and sensible defaults.
- Consent and approval should belong to whoever owns the data. The hub can ask a studio to lock a slot, but only that studio's owner can approve it.
What's next for Open Agentic Procurement: Dioramas
- An open supplier network. Let any studio join by publishing a manifest, and let the hub find them through a public registry instead of a fixed list.
- Negotiate with every shop. Run counter-offers with all shortlisted studios in parallel and bring back the best final offers.
- Truly separate hosting. Put each site on its own domain, so the live demo is cross-origin like the local one.
- Shared, persistent boards. Swap the studios' local board stores for Firebase, so orders survive across devices and studio staff can work the queue together.
- Richer 3D. Add more structure types, editable blueprints the buyer can tweak before ordering, and a snapshot of the approved scene saved with the order.
- Trust and payments. Signed manifests, supplier reputation, and deposits or escrow on confirmation.
- Wider interoperability. MCP tools and A2A agent cards, so any agentic site can buy from or sell through the market.