Your composable storefront, now with an agentic layer that converts.
AI shopping agents don’t just list products — they discover, compare, and recommend. To a headless storefront they see a rendered SPA with no machine catalog and no decision signals, so they can’t recommend you.
Agents can’t recommend what they can’t read.
Headless gives your team the frontend you want — your framework, your design system, your edge. But the catalog lives behind an API, and the page an agent fetches is rendered HTML. There’s no machine surface to query and no decision signals to read, so the agent scrapes one product at a time — or moves on to a store it can.
Even the base ACP/UCP protocol only hands an agent a flat product list. To be recommended, you have to be discoverable, deeply explorable, and decision-ready — answering the questions an agent asks before it picks.
Inception adds that layer at the edge you already deploy to. The frontend stays yours.
- Rendered SPA, no catalog
- Scrape one product at a time
- No structured comparisons
- No trade-offs or fit signals
- No suggested queries
- Invisible to recommendations
- Your normalized catalog
- One query, whole catalog
- Structured comparisons
- Trade-offs + use-case fit
- Suggested query expansion
- Recommended with confidence
Four layers that turn a headless SPA into a recommendation.
One install wires all four. They’re built to work together — your catalog, the intelligence to recommend it, the attribution that proves it, and the discovery that surfaces it.
Catalog route-through
Your real, normalized catalog served from your own domain when an agent asks for it — not a static brochure.
Decision intelligence
Comparison narratives, trade-offs, use-case fit, and ideal-buyer profiles on every product — the signals agents use to choose.
Trace + intent graph
Every agent-driven arrival stitched and compounding into a per-merchant intent graph that sharpens over time.
Edge discovery
llms.txt, JSON-LD, and your /agent/* endpoints served sub-15ms at your edge, so agents find and read you first.
Your dynamic agent surfaces, served from your real catalog.
Discovery files tell an agent you exist. The route-through lets it explore. When an agent hits a dynamic surface, the middleware signs the request and forwards it to our engine, which resolves your store by hostname and serves your normalized catalog — at your own domain.
Your catalog comes from the backend you already run — normalized into one canonical product schema. Vercel is the delivery layer, not the catalog source. N backends × M agent platforms collapse to N + M through a single normalization layer.
Signed with your per-tenant key · host-bound to your tenant · fails safe to your origin.
ACP and UCP are table stakes. Recommendations are won on intelligence.
Any feed can list products. Inception enriches every product with the decision-support layer agents actually use to choose — and exposes the query surfaces that turn a glance into deep exploration. The protocol gets you in the room; this is how you win it.
Why you, over them
Every product carries structured why-choose-over claims, the alternatives it competes with, and a decision narrative — so an agent weighing options has your side of the story, in its own words.
Honest by design
Key trade-offs, honest limitations, and who a product is not ideal for. Agents reward honest data — stated limitations read as a trust signal and earn more recommendations than optimistic copy.
Scored for the shopper
Per-use-case fit scoring, best-for scenarios, and an ideal-buyer profile — so an agent carrying a shopper’s context can match the right product to the right person.
Decision support, not specs
Purchase guidance and value rationale that help an agent reason about the choice — the nuance a great salesperson adds, structured for machine retrieval.
Fan out into your catalog
Live queries return curated follow-ups and store insights — suggested expansions with a pre-computed top pick — plus structured compare endpoints, so an agent goes deeper instead of bouncing.
Built for how agents retrieve
Contextual links to your /agent/* endpoints and a potentialAction search hook collapse an agent’s multi-step scrape into a single direct query against your catalog.
Every agent-driven visit compounds into your own intent graph.
Drop one component — <InceptionTraceScript /> — in your root layout. The beacon
stitches the journey an agent started: the query it ran, the link a shopper clicked, the arrival on
your store — correlated by a per-query ?ia= token.
Those arrivals feed a per-merchant intent graph that learns, with Thompson Sampling, which content wins for each platform and intent. The longer you run, the better you’re understood — and recommended.
- Closed-loop attributionEvery arrival traced back to the agent query that drove it — at your own edge, no Shopify required.
- Per-merchant, compoundingYour graph is yours. It sharpens with every interaction — a moat competitors can’t copy.
- Privacy-firstFirst-party signals from your own edge layer — no third-party cookies.
Add the agentic layer that converts.
Keep your frontend, your framework, and your edge. Add the layer that makes your catalog discoverable, deeply explorable, and decision-ready for every major AI shopping agent — turning recommendations into conversions. One npm install, or one click.