Stefan Hamann Shopware Founder and CEO · Building Agentic Commerce where machines buy and merchants win
30 April 2026
Some time ago I wrote here that AI is eating e-commerce for breakfast that funnels are collapsing into a half-second LLM thought-chain, that Visa just handed autonomous agents a tokenised Black Card, and that the SERP is becoming yesterday's Yellow Pages. The piece landed harder than I expected, and the question I kept getting back from operators, founders, and engineers was the same one: okay, but what does the storefront on the other side actually look like?
So I closed that laptop, opened a different one, and built it.
This article is the prototype I want to talk about. A working storefront where there is no template, no page, no component library. Every pixel a customer sees is rendered live by a video model around them. Shopware still owns every Euro. Everything between the pixel and the cart is the new frontend — and I am genuinely convinced it's about to look completely different from what almost any of us ship today.
The page is dying. The cart isn't. The interesting work is everything in between.
1. The thesis: the frontend becomes a thin business + design opinion layer on top of an agentic substrate.
Here is the version of the argument I keep telling my own teams:
For the last twenty years the frontend was the product. We picked frameworks, built component libraries, argued about routing, hand-tuned design tokens, A/B-tested CTAs. The frontend was a thick layer of code that turned data into pages.
In the next five years, that frontend stops being most of that. The agent renders. The model paints. The human steers. The merchant supplies brand opinion and business rules. What's left of "the frontend" is a thin policy layer — what to show, who to show it to, what the brand allows, what the cart actually says — sitting on top of a generative substrate that does the rendering and, increasingly, the transacting.
It is not zero work. It is different work. Operators stop shipping templates and start shipping:
- Brand opinion — the rules the model is allowed to render under (palette, tone, motion language, what is forbidden).
- Business logic — pricing tiers, product availability, eligibility, cart, fulfilment.
- Intent routing — what the customer typed, dragged, or whispered, and which generative world they should land in.
That's the new frontend. The pixels are the agent's problem.
I built this prototype because I needed to know, end-to-end, what that actually looks and feels like for a customer — not as a slide, not as a manifesto, but as something you can click and break.
The page is dying. The world is being rendered. The new frontend is the rules in between.
2. What "fully generative" looks like when you actually ship it.
The prototype is called the LTX-Native Flipbook. LTX 2.3 — a real-time generative rendering engine for cinematic storefront experiences — generates the atmosphere…
- LTX 2.3 generates the atmosphere: pages, paper, light, motion, camera moves, transitions, breathing product loops, golden hour rakes across walnut wood. Anything you'd describe as feeling.
- Shopware generates the truth: product names, prices, inventory, line items, cart, checkout. Anything you'd describe as fact.
Two pipelines. One pixel surface. They meet inside a tiny compositor that paints Shopware's facts onto LTX's surfaces at frame time.
That sounds like an architectural footnote. It is, structurally, the only contract under which a generative frontend can ever be allowed to talk to a customer. The model is never told what a price is, so it physically cannot make one up. That isn't paranoia, that is the only deal a CFO, a regulator, or an auditor will ever sign off on.
The interesting consequence: the further I pushed the atmosphere side, the safer the truth side became. They are inversely coupled, not competing. The story can scream as long as the cart whispers the same number every time.
Two pipelines. One pixel surface. The model never sees a price.
3. The Director: an agent that ships pages, not prose.
Sitting between the customer and the two pipelines is the part of the prototype that does the agentic work. I call it the Flipbook Director.
It does not write product copy. It does not narrate. It does not invent recommendations. It plans pages and routes facts. That is all.
When you submit an intent, the director:
- Picks a page sequence — cover, category spread, product detail, bundle, cart preview.
- Assigns each page a mood key (warm / neutral / minimal × room type) and seeds an LTX render.
- Asks Shopware for a product set that matches your budget and category.
- Generates a slot graph per page — geometry, fact bindings, hotspots — and dispatches Sharp texture renders in parallel.
- Pre-warms the next two pages speculatively, in the background, before you've even tapped the first hotspot.
By the time you finish reading the cover, the next page is already warm. By the time you tap a product card, the detail world is already rendered. By the time you hit "Add to cart", Shopware has been pre-warmed with the line item.
The director is the most "agent-y" part of the system, but its surface area is deliberately tiny. It interprets fuzzy intent and ranks atmosphere and that's the only thing only an LLM can do here. Everything else is deterministic, typed, inspectable, and re-runnable.
This is, I am now convinced, the actual shape of agents inside frontend code. Not chatty. Narrow. Plan-emitting. Auditable.
I'm not generating copy. I'm generating camera moves and routing facts.
4. Personalisation is the only thing the customer can still hand-craft. So I made it the entire UI.
This is, for me, the single most important section of this article. It is also the section I rebuilt the most times.
In a templated storefront, the customer "personalises" by clicking filters, sorting, comparing, and reading specs. In a generative storefront, all of that is the agent's job. The customer is not optimising anymore. The customer is steering.
So the entire interactive surface I designed is two things: a theme entry (one tap to land in a generative world) and a tiny personalisation panel with three knobs:
- Light mood — cool / neutral / warm (re-renders the LTX backdrop and the colour grade).
- Style density — minimal / balanced / maximal (changes which products the director picks).
- Maximum budget — a slider in Euros (changes which products are available at all).
Drag the budget slider three times in the demo and you watch the storefront reshape itself in real time:
- €400 → Plywood Cafe Chair, €180. Honest, structural, daylight studio still.
- €800 → Wishbone Oak Chair, €490. Cane seat, warm afternoon light.
- €1,500 → Boucle Lounge Armchair, €1,290. Tufted cushion, cinematic stage light.
Three completely different chairs. Three completely different prices. The atmosphere around them shifts to match the budget tier. The card layout, the spread composition, the cart preview — all of it re-plans live. The customer hasn't filtered anything. They have just expressed more of who they are, and the agent has re-rendered the world to fit.
This, I believe, is what personalisation is going to feel like in five years. Not a million toggles. Two or three big steering wheels, with the agent doing all the work in between.
The closer I look at the data on how humans actually browse premium goods in the physical world, the more obvious it becomes that we have been forcing customers to operate online stores like spreadsheets. The generative substrate finally gives us a way to put them back in the chair, hand them the wheel, and let the world arrange itself around them.
The customer doesn't filter anymore. They steer. The agent does the rest.
5. Experience first. Specs second. The human came back.
Once you take the customer out of the optimisation seat, something genuinely surprising happens to the experience: there is less to do, and more to feel.
On a detail page in the prototype, the product photo breathes. Light shifts across glass. Dust motes drift past a brass lamp. Ceramic catches a slow rake of golden hour. None of this is video stock — these are short image-conditioned LTX loops keyed off the actual Shopware product photo, classified by archetype (lamp, vase, mug, shelving, diffuser, …) and prompted with motion that suits that kind of object.
The product information sits on the page as a single calm plaque. One brand line. One product name. One price. One Add to Cart. That's the entire UI. Nothing flashes. Nothing competes. The world around the product is doing the storytelling.
The thing this taught me — and I cannot overstate how much this was the headline learning of the entire build — is that when the atmosphere layer is generated, you do not need to add more features. You need to remove almost all of them. A generated world cannot survive next to a chrome-y comparison widget and a sticky upsell banner. The whole point is that the customer is in the world, not managing it.
This is the part I am most excited about for human commerce. I argued it in my last piece: bots buy facts, humans buy stories. A generative frontend is the first storefront medium where you can actually deliver a story at scale, in real time, around a real catalogue. That changes what an "experience-led" store can be.
When you generate the atmosphere, you have to remove the chrome. Otherwise the customer is back to managing instead of feeling.
6. Knowing what not to generate — and where the merchant rules layer lives.
A confession in the middle of the optimism: the hardest part of building a generative storefront is not the prompts. It's the negative prompts.
For furniture (chairs, sofas, tables), even at image_strength = 0.95, LTX would happily invent a second cushion or curl an armrest in a way that breaks silhouette. So the prototype hard-skips LTX for any chair: the product photo holds still, the world around it animates, and the customer never gets a "model thinks this chair has two right-angle pillows" moment.
That rule lives in the new frontend. Not in the model. Not in the catalogue. In the brand-and-business policy layer between them.
This is, in my view, what merchants will actually configure in the post-frontend era. Not React components. Not CSS. They will configure things like:
- "Never let the model touch the silhouette of these product categories."
- "This brand allows warm and neutral moods only — never cool."
- "Below this budget tier, only show products from these suppliers."
- "Never composite text that wasn't generated deterministically from a snapshot."
Those are the storefront. Everything else is rendered on the fly. The rules are short, declarative, auditable, and that is the artifact a brand owns. Not a Figma file. Not a design system. A small, sharp policy.
The brand of tomorrow isn't a design system. It's a list of negative prompts.
7. The substrate has to be inspectable. Otherwise nobody ships it.
There is a live debug panel built into the prototype that you can toggle on top of any page. It shows the current page kind, the mood key, the seed, the entire render queue (next + speculative pages, their statuses, their hashes), every slot's geometry and fact bindings, and the Shopware product IDs in play, stamped with the snapshot revision.
This is not a developer toy. It is, for me, the most important product part of the prototype.
A merchant cannot trust a generative storefront they cannot crack open. A regulator cannot certify one. An auditor cannot reconcile one. Even an agent on the buying side has to be able to ask the storefront: "prove to me this price came from your catalogue and not from the model."
So the substrate has to be transparently inspectable from day one. Every price has a Shopware fingerprint. Every pixel has a render budget. Every product has a hashed snapshot. The director's plan is dumpable as JSON. The slot graph is dumpable as JSON. If the model ever started drifting, the panel tells you in real time which atom went off-script.
This is non-negotiable for any generative storefront that makes it to production. Trust is the feature. Inspectability is how you ship it.
Every price has a Shopware fingerprint. Every pixel has a render budget.
8. What I think this means for the next five years.
The honest version of my prediction:
- The frontend stops being mostly code. It becomes mostly opinion. Brand rules, business policies, intent routing, taste. Smaller teams. Higher leverage. Less Figma, more forbidden tokens.
- Templates die for experience-led commerce. They survive a long time for commodity SKUs and B2B re-orders, because there is no upside to generating a world around a printer toner cartridge. But for anything aspirational — fashion, home, food, travel, hobby, configurable B2B — the page becomes a generated world. There is just no way to compete with a model that can render anything for anyone in a couple of seconds.
- Personalisation collapses to two or three big steering wheels. Customers stop filtering. They steer. Mood. Budget. Density. Maybe one or two domain-specific dials. The agent re-renders the world. This is, frankly, much closer to how humans actually shop in physical luxury than to how we have been making them shop online.
- The cart never moves. This is the boring, beautiful part. Whatever else changes, the deterministic transaction layer — Shopware, in our case, but the shape is the same everywhere — stays exactly where it is. It is the truth side of the architecture. It is the part the CFO trusts. It is the only reason any of the rest of this is allowed to ship.
- The "frontend developer" role changes shape, not direction. The taste, the typography, the rhythm, the negative space, the brand opinion — all of that gets more important, not less. The skill shifts from translating taste into HTML to translating taste into policy that an agent will faithfully render.
What this prototype is not: a merchant-ready product. It is nowhere near that. GPU economics, latency at retail scale, content rights for product motion loops, accessibility on a generative canvas — every one of those is its own multi-quarter problem.
But it proves the substrate. And right now that is the only thing worth proving.
Build the storefront before the agent buys yours.
The take-away
In May I argued that automation pays the bills and experience earns the applause. The honest follow-up a year later is this: the storefront that delivers both is no longer a stack of templates. It's a generative world rendered around a deterministic cart, governed by a small layer of brand and business opinion, and steered by the customer instead of optimised by them.
That's what this prototype is. An open architecture. A working demo with real LTX 2.3 renders, a real Shopware cart, three actual chairs at three actual price points, and a personalisation panel that re-plans the world live. A negative-prompt list as long as the prompt list. And one rule pinned above the workstation:
The model never sees a price. The customer never sees a template.
If you are working on agentic commerce, on the merchant side, the model side, the payments side, the discovery side, the design-systems side — I would love to compare notes. There is a lot of architecture left to design before any of this is shippable, and the only way it ships well is if storefront people, model people, brand people, and commerce people stop talking past each other.
Stay sharp, keep generating.
— Stefan 🧑🚀🛒
#shopware #ecommerce #agenticcommerce #generativeai #ltx #ltxvideo #ai #commerce #b2c #b2b #aibuying #storefront #composablecommerce #personalization #experiencedesign #postfrontend
