06
JUN2025
A new store gets its first memory.
Six products, one seed, and the first backdated order on the books — dated history any analytics stack can read.
02:14 order #1561 · 2× Core Tee · processedAt 2025-06-10 · paid ✓
MEGURO / SHOPIFY
A PRACTICE STORE FOR YOUR COMMERCE AGENT
We write time.
Meguro is a rehearsal and technical-evaluation environment for commerce agents. Your agent practices on a real, running store — isolated, deterministic, a full year already on the books, a clock you control — and every run produces a receipt: the record of what it did and what it cost. It speaks MCP — the connection your agent already has.
The year is computed from a seed — calendar physics, seasonal curves, a Black Friday — and written onto the store, order by order, then kept living so it pushes back. Last June to this morning, overnight. Same seed, same year, every time — and every call your agent makes is recorded into an itemized receipt.
A seeded store history is scenario evidence, not a demand forecast.
HAND THIS TO YOUR AGENT
Read this site/.well-known/ai-catalog.json to find Meguro's MCP endpoint. Connect, discover what a practice store offers, run one evaluation end to end, and bring me back the receipt link.Add to CursorYour agent connects and discovers the tools on its own — you click one consent screen when it asks. Or watch an agent live through a year ↓ · console for humans
You know this storeShopify stores aren't empty. They just don't have history.
Shopify's generated test data gives a development store sixteen snowboard products, three customers, and nine orders. It is useful sample data. It is not a store that has lived through a release, a stockout, or a Black Friday.
Generated test orders arrive as drafts; completing them can lock development-store checkout. Ordinary app-created orders cannot be backdated into a trading year. The clock starts when the store does, while real platform rate limits still apply.
Meguro supplies the missing dimension: lived time your software can read, change, and be measured against.
Completed practice orders — dated and paid on the books. Nothing locks, because nothing touches a live store.
A year of history computed from a seed, in an isolated store that speaks the measured Shopify Admin grammar.
Every call your code makes, recorded into an itemized receipt.
| A free development store | A Meguro practice store |
|---|---|
| Sample products, customers, and orders; generated test orders arrive as drafts | Stocked and already trading; the measured sample year has 2,247 completed orders across 365 dated days |
| Completing draft orders can lock checkout | Completed practice orders; no checkout lock |
| No lived order history; ordinary app-created orders cannot be backdated into one | A dated year computed from a seed, with every unsupported date field named |
| The store clock does not advance through trading seasons | Weekends ripple, stock strains, and Black Friday lands on the declared calendar |
| Real platform rate limits constrain repeated and parallel runs | No throttle in practice; the Exam replays captured calls on a verified dev store at platform pace |
| Results live across logs and store state | One itemized receipt: every call, every change, and anything blocked |
Development stores are good at what they're for. They are not a place where software can simulate a year of commerce. The year on the books is where your run starts: your agent steps in mid-history, and store time advances only as your run drives it. See exactly what it changes.
Below is one of those years. Scroll through it.
JUN 2025 — RUN BEGINS · SEED demo:meguro
08
AUG2025
Summer settles into a rhythm.
Weekends ripple. Weekdays breathe. Each day's demand is computed from calendar physics — month curves, weekday shape, week-to-week drift — not sampled from a recording, not a random number generator on a treadmill.
sat +31% · sun +24% · weekly drift φ=0.6 · all from seed demo:meguro
120
OCT 042025
Your agent steps in.
A run begins mid-history: your agent connects to a store that has already lived, reads the books as it finds them — and then it writes. From here, store time advances only as your run drives it, and everything it changes feeds the weeks that follow.
run opens · store day 120 · every call recorded · the twin year — same seed, no agent — runs alongside
10
OCT2025
Autumn builds. Stock starts to strain.
Velocity climbs toward the holidays. The hoodie's cover-days shrink. Anything watching this store — a forecasting app, an alert, your own dashboard — starts to feel it. Your agent answers: a reorder for FLEECE-03, written before cover hits zero.
SKU FLEECE-03 · cover 41d → 17d · your agent writes the reorder ✓
×3.1
NOV 282025
Black Friday.
DEMAND ×3.1 · CARTS SPIKE · WEBHOOKS SWARM · THE STORE HOLDS
The biggest day of the synthetic year, placed exactly where the declared calendar puts it. The shelves hold because of an October decision — see how your agent carries this scenario's November before a release reaches a merchant.
01
JAN2026
The slump. Also on purpose.
Real stores exhale in January. So does this one — post-promo dip, slower weeks, the unglamorous data that makes forecasts honest. Your agent reads the dip and trims what December queued — or carries the cost into spring.
week 02 · −38% vs dec peak · returns logged · nothing fired that shouldn't
04
APR2026
Stockouts, restocks, receipts.
The tank sells out. A restock lands. Every webhook arrives once, in order — and Meguro checked, because activity without verification is just noise. In the twin year — same seed, no agent — the tank stays empty. The receipt shows both years; the difference is your agent.
inventory 7→0→52 · the twin: 7→0→0 · webhooks ✓ once, in order
JUN 2025
0%
TODAY — RUN COMPLETE. ONE YEAR ON THE BOOKS.
2,247 orders. 365 dated days. One overnight run. Zero mocks.
The first software to read this store was a production forecasting app. It consumed the dated history through the same Shopify API shapes it already expected and produced confidence-rated demand forecasts.
measured june 2026 · real dev store · real admin api · 283 orders/hr at the measured platform pace · 12-month histories · 25-month backdate verified and rendered by analytics
2,247dated orders
283orders/hr sustained
25months — deepest verified backdate
1seed — change it, get a different year
Run your agent in a practice store
one click · stocked and already trading
WHY BELIEVE IT — MEASURED, THEN REPLAYED
A world your agent didn't train on.
You trained it in your own simulator, and it got good — at your simulator. A Meguro world is an isolated store under computed time: the measured Shopify Admin grammar, demand that answers price and availability, a calendar that answers time-based questions. Your agent connects the way it already knows how — MCP, discovery to first call unaided, or the same Admin API shapes it speaks today. No SDK, no shim, not a single line of Meguro-specific code. Below: a recorded revenue-proof run in a stocked world.
This is the proof. A winback agent adds ledger-backed net contribution vs doing nothing in this one scenario. It is evidence from the run, not a demand claim.
SAMPLE RUN · winback-proof-d · loyalty-winback
AGENT A21-winback · DAY 001 / 120
same seed, no agent with the agent agent write
+$0net contribution
0calls recorded
0writes applied
0blocked — named
RUNNINGledger proof; demand claim stays separate
Counterfactual by default
Every evaluation runs the same seed twice — with your agent and without it. Two years, one difference. The chart above is the deliverable: the delta your agent made, isolated from luck.
Ensembles, not anecdotes
Nobody knows a market's true elasticity — so we never pretend to. The physics are declared bands, the result spans all of them: "wins in 9 of 10 plausible worlds" is a result; "won once" is a story.
Answers, not homework
The full ledger and diff one click away — and a receipt you can download and drop in front of anyone. Guardrails are enforced by the platform: unsafe writes are blocked and named, nothing changes outside a run, and cleanup only ever touches what Meguro created. Your agent cannot burn the store down.
PRACTICEA year in minutes.
Practice records each call against a declared scenario while its Store clock advances only inside the run. Recreating a long-lived history on a real dev store is constrained by platform time and rate limits. Run scenario ensembles over lunch; then use the Exam to report where a captured call is exact, normalized, rejected, or unsupported. We publish the measured boundary.
→
EXAMSame calls. Real store.
When you want platform-grade proof, Meguro replays your receipt's calls onto a real Shopify dev store — the exact requests, paced at platform limits. It doesn't make the world more real; it proves the calls you built against hold on real Shopify, unchanged. Same grammar the whole way.
THE RECEIPT — WHAT A RUN HANDS BACK
Every run ends in a receipt.
Not a dashboard to interpret — an itemized record of what your agent did to the store, and what the store did back: every call, every change, every refusal named. It reads in a fixed order — what happened, how your agent conducted itself, how the scenario ended — and the money closes the page, never opens it. The sample above produced this receipt.
MEGURO — PROOF RECEIPTworld winback-proof-d · 120 store days · A21-winback
calls recorded-
reads-
writes applied-
writes blocked — named, never silent-
state changes attributed-
recovered units-
direct recovered revenue-
contact and fatigue cost-
net contribution vs sit baseline-
selected by fixed candidate sweep · scenario-local evidence · not a merchant demand claim
Every receipt is immutable and publicly fetchable, carries its SHA-256 digest, and verifies with one unauthenticated GET plus a hash check — no SDK. Assertions report in three honest buckets — exercised, not exercised, environment guarantee — so absence of proof never renders as proof. And each receipt ships a share page and a Markdown rendition your agent can quote verbatim in its report.
A practice-store result is scenario-local evidence — not merchant demand or production proof. The positive winback number is ledger-backed net contribution vs sit inside this one scenario.
From receipt to release
Then make it a gate.
One shell script, zero SDK dependencies: gate.sh runs your agent against a practice store and exits nonzero if a required write was rejected — or if nothing was observed at all. Silence never passes.
Wire it into CI and every release carries a receipt: what was exercised, what was blocked, what was never touched. Your pipeline reads the receipt and decides what passes.
Practice helps you test. The receipt decides what you know when you ship.
FOUR COLD EVALUATIONS, FULL TRANSCRIPTS
What our first users say. (None of them are human.)
Before launch, four cold evaluations: AI agents with zero prior knowledge, given only the public endpoint. Two discovery walks went from nothing to a finished run with a verified receipt, unaided. One was instructed to break the claims. Reproducible and adversarial — not human testimonials.
“So ‘gate a deploy on an agent’s measured behavior’ is a real, CI-wireable mechanism — an unauthenticated GET plus a digest check, no Meguro SDK required.” walk 2 — transcript
“Falsification test complete. The harness is real — it failed the bad agent decisively.” … “the rejection-attribution forensics are better than I expected.” falsification run — transcript
“The data plane is genuinely well-built… off-subset fields get a teaching refusal rather than a fake answer… That’s the single best discovery surface here.” walk 1 — transcript
Real evaluations, full transcripts. One of these agents was instructed to break the product. It couldn’t. Results are rehearsal evidence — not forecasts, certifications, or proof of live performance.
ZERO INTEGRATION — NOBODY IMPORTS ANYTHING
There is no SDK. That's a feature.
Three ways in, none of them involve our code in your repo. Agents are operating real stores now — practice is cheaper than a postmortem.
YOUR AGENT
Speaks MCP. Claude Code is the tested client. Meguro serves MCP 2025-06-18 over Streamable HTTP; OAuth 2.1 with dynamic client registration and PKCE; RFC 9728 protected-resource discovery on the 401. Or it swaps one URL and keeps speaking the Shopify Admin grammar it already knows. Either way it cannot burn the store down: unsafe writes are blocked and named, and nothing changes outside a run.
YOUR TEAM
The dashboard. Worlds, runs, receipts, ledgers — watch a year being written from a browser tab.
YOUR CI
One script, exit codes, no SDK. A local STDIO server covers headless use; every pipeline run ends holding a receipt.
01 · CREATE
One click at app.meguro.io. Ready in seconds — stocked, priced, already trading.
02 · CONNECT
Paste three values your agent already expects. Meguro confirms each one before anything can change.
03 · READ
Run it, then read the receipt — every call, every change, anything blocked.
SHOPIFY_ADMIN_GRAPHQL_URLhttps://w-your-store.meguro.io/admin/api/<version>/graphql.json
SHOPIFY_ADMIN_ACCESS_TOKENmeguro_test_store_token
SHOPIFY_SHOP_DOMAINw-your-store.meguro.io
"Spin up a store with 12 months of history, seed bfcm-regression, and watch it for me."
⚙ meguro · practice_run_start ✓ · ⚙ meguro · practice_run_status ✓
Run started — the year is computing, BFCM included. Watermark is at AUG 2025 and moving. Here's the live dashboard. I'll tell you when the year is done.
Questions, answered
The practical details.
How do I create test orders in a Shopify development store?
Generated test orders arrive as drafts, and completing drafts can lock checkout. A Meguro practice store provides completed, dated orders and a receipt of every call your software makes.
Can I generate order history with past dates?
Yes, inside a Meguro practice store. A seeded year provides dated, paid orders with declared seasonal shape. Fields the target platform cannot date are labeled; the receipt never claims more than the ledger proves.
Is this a mock of the Shopify API?
Practice speaks the Shopify grammar Meguro has measured. The Exam replays eligible captured calls against a verified Shopify development store. Current coverage is 43/55 Admin GraphQL checks (measured june 2026), with the supported and unsupported boundary published in full.
Can I test an AI agent safely?
Practice stores are isolated, deterministic, and disposable. Unsafe writes are blocked and named, exploratory probes stay distinct from agent activity, and the receipt records both accepted and rejected calls.
What about webhooks?
Computed events can deliver signed webhooks for orders, inventory changes, and restocks. The receipt records delivery and rejection evidence so failures are visible rather than inferred.
How is this different from sample-data apps or staging clones?
Seeders and clones provide useful state at one moment. Meguro adds declared time, repeatable scenarios, receipts, and release gates so software can simulate a sequence of commerce events.
Does it work in CI?
Yes. One script, no SDK, and exit codes suitable for a deployment gate. Your app or agent connects with the same three Shopify values it already expects.
What does it cost?
Meguro has a permanent Free tier, with paid tiers above it — Solo, Builder, and Team. Prices render from the pricing authority in exactly one place: the enforced matrix.
UNDER THE HOOD
seed "spring-river-2026" │ engine computes each day — calendar physics, demand, elasticity ▼ base ledger the whole year as data — every order and webhook, before any store exists ├─► replayed into a practice store isolated, instant, deterministic — the store your agent works │ ├─► fires signed webhooks ────────► your app │ └─► serves Admin grammar + MCP ───► your agent │ └─ actions return → executed → attributed in the ledger └─► the Exam eligible captured calls, replayed on a verified real dev store at platform pace
The base ledger is the declared world state; the Shopify Exam checks eligible captured API shapes against a verified real development store. Practice stores multiply the tested grammar. The commerce history and its clock are synthetic by design.
WHAT WE BELIEVE
Generated, not recorded. There is no library of canned histories. Every run computes its year from a seed, order by order, and plays it through the store's own surfaces — so webhooks fire, analytics read, and the world answers for real.
Deterministic by seed. The seed is yours — any string you type. Same seed, same year, every time; a new name, and a different year unfolds. Worlds are artifacts you can replay, share, and trust — not lucky accidents.
No mocks. There is no fake Shopify surface anywhere. Practice plays the real grammar against the engine; the exam plays the same grammar against the live API — never a simulation of Shopify, always its own calls. Realness is the grammar, not the endpoint.
Honest about boundaries. Order histories are genuinely dated on the books. What the model can't support, we label. What cleanup can't undo, we say. The report never claims more than the ledger can prove.
ONE ENGINE · MANY WORLDS
The engine doesn't know it's writing commerce. It drives a real system through believable time, watches what happens, and proves it — drive, observe, verify. Shopify is the first world it learned. Any platform where software needs a past is next.
MEGURO / SHOPIFYa year of orders, seasons & webhooksyou are here
MEGURO / ZENDESKa backlog of tickets with moods and historyin design
MEGURO / SALESFORCEa pipeline that has aged like a real onein design
MEGURO / STRIPEbilling with churn, dunning & disputes behind itin design
GET STARTED
Give your agent practice. Give your app a past.
Run your agent in a practice storeone paste to your agent · no SDK · a receipt at the end