The year is computed from a seed — calendar physics, seasonal curves, a Black Friday — and written onto the store through real APIs, 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.
Measured year loading.
Proven against real Shopify. For the current 43/55 covered Admin GraphQL checks, every call Meguro accepts behaves like real Shopify — same errors, same status codes — without the rate limits — and your test-store results carry that proof.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.
| 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 rehearse a year of commerce. Your practice store runs without you. See exactly what your app or agent changes.
RL agents ace their own simulator. Run the same seed with and without your agent — ship the measured delta, not a vibe.
Order bursts, webhook swarms, inventory swings — find what breaks before customers do.
Trends, slumps, reorder points — features that need history finally have some.
Screenshots, App Store listings, and sales demos stop looking like a ghost town.
Below is one of those years. Scroll through it.
Six products, one seed, and the first backdated order written through Shopify's own import path — the mechanism analytics trust.
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.
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.
The biggest day of the synthetic year, placed exactly where the declared calendar puts it. See how your app behaves through this scenario's November before a release reaches a merchant.
Real stores exhale in January. So does this one — post-promo dip, slower weeks, the unglamorous data that makes forecasts honest.
The tank sells out. A restock lands. Every webhook arrives once, in order — and Meguro checked, because activity without verification is just noise.
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.
Type anything — your store, your dog, a commit hash. A year is computed from it while you watch, by the same seeded engine that drives real runs. Retype the same seed: the identical year, to the order.
Store profile, your own catalog, demand knobs, elasticity bands, the promo calendar.
Aged history, a Black Friday stress run, a stockout drill, a January slump.
It settles only the randomness you left free — so it can never surprise you twice.
You trained it in your own simulator, and it got good — at your simulator. A Meguro world is real Shopify under computed time: real APIs, demand that answers price and availability, a calendar with a Black Friday in it. Integration is one line: point your agent's store URL at a Meguro world. It speaks Shopify; the world answers in Shopify. No SDK, no shim, not a single line of Meguro-specific code. Below: two recorded runs in stocked worlds — a year, replayed in twenty seconds.
This is the catch. The agent looks fine but costs about $110k/year vs doing nothing. Meguro shows that before your customers pay for it.
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.
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.
Nobody knows a market's true elasticity — so we never pretend to. The physics are declared bands, the verdict spans all of them: "wins in 9 of 10 plausible worlds" is a result; "won once" is a story.
Pass or fail, with 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.
Our returns agent lived a full year — measured calls loading — in under 25 minutes. One call at a time, no rate limits. Recreating that year on a real dev store means ~50–70,000 API calls against the throttle — a hard 2-hour floor, realistically a day — and real time never passes: no webhooks, no seasons. Run it on every commit; run seed ensembles over lunch. Practice records the calls; the Exam reports where their real-Shopify replay is exact, normalized, rejected, or unsupported. We publish the measured boundary.
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.
Not a dashboard to interpret — an itemized record of what your agent did to the store, and what the store did back. The samples above produced these receipts.
A test-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.
One shell script, zero SDK dependencies: gate.sh runs your app or 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. Run the same probe set across store templates for a matrix, then export a public-safe bundle for the release thread or keep the full evidence private.
Practice helps you test. The Gate decides whether you ship.
Three ways in, none of them involve our code in your repo:
The dashboard. Worlds, runs, verdicts, ledgers — watch a year being born from a browser tab.
Swaps one URL. It keeps speaking Shopify; the world answers in Shopify. It never learns Meguro exists — and it cannot burn the store down. Unsafe writes are blocked and named; nothing changes outside a run. Agents are operating real stores now. Practice is cheaper than a postmortem.
Meguro speaks MCP. Claude Code, Cursor, your CI agent — they drive worlds conversationally, no install beyond a registration line.
One click at app.meguro.io. Ready in seconds — stocked, priced, already trading.
Paste three values your agent already expects. Meguro confirms each one before anything can change.
Run it, then read the receipt — every call, every change, anything blocked.
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.
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.
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, with the supported and unsupported boundary published in full.
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.
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.
Seeders and clones provide useful state at one moment. Meguro adds declared time, repeatable scenarios, receipts, and release gates so software can rehearse a sequence of commerce events.
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.
Meguro has a free Developer tier — one practice store, full-truth receipts, no card. Builder is $199/month (or $1,990/year) with a 14-day free trial, no card required. A Team plan is coming. See exact limits and billing behavior.
seed "meguro-demo-v2" │ engine computes each day — calendar physics, demand, elasticity ▼ base ledger the whole year as data — every order and webhook, before any store exists ├─► materialized on a real dev store real Shopify writes, paced at platform caps │ ├─► fires real webhooks ─────────► your app │ └─► streams world state ────────► your agent's endpoint │ └─ actions return → executed → attributed in the ledger └─► forked into virtual stores instant, unlimited, free — same data, no real store, no caps
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.
Generated, not recorded. There is no library of canned histories. Every run computes its year from a seed, order by order, and writes it through the platform's front door — so the store, its webhooks, and its analytics respond 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 dates are genuinely backdated through Shopify's import mechanism. What the platform can't date, we label. What cleanup can't undo, we say. The report never claims more than the ledger can prove.
And the other direction: AI shopping agents already browse stores through Shopify's MCP surface — Meguro drives that surface too, with synthetic agent traffic and an agent-legibility report. Is your catalog even visible to them? Ours wasn't, until we checked.
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.
