The events of this week's Google I/O 2026 conference, held on May 19-20, 2026, confirmed a shift we at nolimeo have been pointing to for a long time. The launch of the Gemini 3.5 model family, the rollout of 24/7 Information Agents, and the broader deployment of Generative UI directly inside search are changing how customers discover products, compare offers, and make buying decisions.
For the e-commerce sector, whether you run a mass-market B2C store or a large B2B platform, this is not just another marketing headline. It is a technological shift. Google is moving toward a world where users click fewer blue links and expect ready-made comparisons, recommendations, and answers. Autonomous agents now sit between the customer and your e-shop. They scan websites, read inventory data, and assemble interactive mini-apps directly inside search.
If your e-shop still runs on an old, slow PHP monolith or a bloated WordPress stack where price and availability data are pulled from an unstructured DOM tree, you are becoming harder to read for AI search. An autonomous agent will not patiently wait for slow-loading, render-blocking JavaScript. It needs fast responses, structured APIs, and semantically clean data.
1. Google I/O 2026 and the Agent Era: What Actually Changed?
At Google I/O 2026, Google introduced a new generation of AI models led by Gemini 3.5 Flash. It is a model designed for fast agentic workflows that need low latency, lower processing costs, and reliable access to external tools.
Higher speed and lower latency allow Google to develop two major concepts:
A. 24/7 Information Agents
Instead of one-off query processing, Google is deploying agents that run asynchronously in the background. These agents monitor the web, analyze catalog changes, and continuously synthesize updates. When a customer searches for a specific product, the agent may already have a current view of the market.
B. Generative UI
Search is shifting from a text interface to a dynamic interface generator. If a consumer searches for a specific OLED TV with delivery within 24 hours, or a B2B buyer looks for industrial bearings, Gemini 3.5 Flash can use the Antigravity developer platform to do more than show links. It can generate an interactive comparison widget, a table of specs, and availability directly inside search. This is where agents decide which e-shops stay in the comparison and which ones get left out.
[ Traditional SEO ]: User ──► Clicks blue links ──► Inspects slow HTML
[ Modern AEO ]: Information Agent (Gemini 3.5 Flash) ──► API / JSON-LD ──► Generative UI
This shift means a move from classic SEO to AEO (Agent Engine Optimization). In addition to humans, agents are becoming a new audience that can decide whether your offer reaches the person at all.
2. Why Traditional Monoliths Do Not Work for AI Agents
To understand why old IT systems fail in this era, we need to look at how Gemini 3.5 Flash analyzes the web. When an agent enters a page:
- It sends an HTTP request and waits for Time to First Byte (TTFB).
- It downloads the HTML document and parses the DOM tree to extract data.
- It executes client-side JavaScript to render dynamic pricing and stock state.
In a typical monolith, such as older PHP e-shops built on WooCommerce or standard template-based platforms, this process is effectively unusable for agents. The monolith generates HTML synchronously on the server while running dozens of unoptimized SQL queries against the relational database. TTFB often slips into multi-second territory. Add render-blocking JavaScript from marketing plugins and an unstructured DOM with thousands of unnecessary tags, and the agent will mark the site as unreadable or too slow.
If your prices, discounts, or availability are loaded asynchronously through fetch calls after the page is rendered, the AI bot does not need to wait for complex JavaScript events. It will just download an empty template without prices. For the agent, that product has low informational value, which means it is less likely to appear in the generative UI comparison.
3. The Pressure Point: AI Scraper Traffic
With the arrival of 24/7 information agents from Google, OpenAI, and Perplexity comes a new kind of network load. These bots will not visit your site once a week like an old Googlebot. They will query it much more often so generative UI can display fresh pricing and stock data.
If your infrastructure is built on a direct frontend -> relational database connection, a heavy scan from agents can exhaust memory and database connections (Connection Pool Exhaustion). Every page render triggered by an agent runs expensive SQL calculations. In a monolithic infrastructure, for example on AWS RDS, unnecessary scaling caused by bots can create meaningful additional monthly costs.
How we solve it at nolimeo: ISR and distributed edge caching
To reduce the risk of outages, we build an architecture that separates the database core from outside queries:
- Next.js Incremental Static Regeneration (ISR): We do not generate product pages on every request. They are generated in the background once and stored as static HTML with JSON-LD structure on an Edge CDN, such as Cloudflare or Vercel.
- Redis and a semantic Meilisearch layer: If an agent needs data through an API, it queries an optimized in-memory cache or a search engine with very fast response times when the index is designed correctly. The database (PostgreSQL or Supabase) stays protected from unnecessary load.
- Asynchronous cache invalidation (Revalidation): When prices or stock levels change in the enterprise ERP, the ERP sends a webhook to our Node.js middleware. The middleware then regenerates only the affected product pages in the background. The agent receives fresh data from cache without loading the primary SQL database.
4. Architecture for AEO: Next.js Server Components and Medusa.js
The future of both B2C and B2B e-commerce lies in headless architecture. The visual layer, built on Next.js, communicates with a backend such as Medusa.js, Directus, or Supabase through optimized APIs.
With React Server Components (RSC) in Next.js, we can load data from the backend directly on the server, generate clean, semantic HTML with integrated JSON-LD data, and send it to the agent without unnecessary client-side JavaScript. The result is lower TTFB, easier parsing, and better readability for AI bots.
Code Example: Next.js App Router in Practice
Long code is harder to read, so we split it into two smaller parts.
This is how we prepare clean meta tags for traditional SEO:
// src/app/products/[slug]/page.tsx (Part 1 - SEO and metadata)
import { notFound } from "next/navigation";
import { getProductByHandle } from "@/services/medusa-api";
import { stripHtmlTags } from "@/utils/string"; // Helper for cleaning HTML
import { Metadata } from "next";
interface ProductPageProps {
params: { slug: string };
}
// Dynamic metadata generation for classic search engines and AI
export async function generateMetadata({ params }: ProductPageProps): Promise<Metadata> {
const product = await getProductByHandle(params.slug);
if (!product) return {};
return {
title: `${product.title} | Custom E-commerce`,
// Remove HTML tags from the description for clean SEO and AEO output
description: product.description ? stripHtmlTags(product.description) : `Buy ${product.title} at the best price.`,
robots: "index, follow",
};
}
This is the core layer for AI agents (JSON-LD and Server Component):
// src/app/products/[slug]/page.tsx (Part 2 - JSON-LD and UI)
// React Server Component: rendered only on the server with zero client-side JS
export default async function ProductPage({ params }: ProductPageProps) {
// 1. Fetch data from the headless backend (safe integration)
const product = await getProductByHandle(params.slug);
if (!product) {
return notFound();
}
// 2. Define structured data (JSON-LD) for Google Information Agents
const jsonLd = {
"@context": "https://schema.org",
"@type": "Product",
"name": product.title,
"image": product.images?.[0]?.url || "/assets/img/placeholder.jpg",
// For AI agents too, we need semantically clean text without HTML
"description": product.description ? stripHtmlTags(product.description) : "",
"sku": product.variants?.[0]?.sku || "",
"mpn": product.variants?.[0]?.barcode || "",
"brand": {
"@type": "Brand",
"name": product.metadata?.brand || "Unknown"
},
"offers": {
"@type": "AggregateOffer",
"priceCurrency": "EUR",
"lowPrice": product.calculated_min_price, // Dynamically calculated price
"highPrice": product.calculated_max_price,
"offerCount": product.variants?.length || 1,
"availability": product.variants?.some(v => v.inventory_quantity > 0)
? "https://schema.org/InStock"
: "https://schema.org/OutOfStock"
}
};
return (
<main className="max-w-7xl mx-auto px-4 py-12 sm:px-6 lg:px-8">
{/* 3. Inject semantic JSON-LD data directly into the HTML head */}
<script
type="application/ld+json"
dangerouslySetInnerHTML={{ __html: JSON.stringify(jsonLd) }}
/>
{/* Visual layer optimized for human buyers */}
<div className="lg:grid lg:grid-cols-2 lg:gap-x-8 lg:items-start">
<div className="product-gallery">
{/* Next.js optimized Image component */}
</div>
<div className="mt-10 px-4 sm:px-0 sm:mt-16 lg:mt-0">
<h1 className="text-3xl font-extrabold tracking-tight text-gray-900">{product.title}</h1>
<div className="mt-3">
<h2 className="sr-only">Product information</h2>
<p className="text-3xl text-gray-900 font-semibold">
{product.calculated_min_price} € <span className="text-sm font-normal text-gray-500">incl. VAT</span>
</p>
</div>
<div className="mt-6">
<h3 className="sr-only">Description</h3>
{/* Visual HTML description from CMS for human buyers */}
<div
className="text-base text-gray-700 prose"
dangerouslySetInnerHTML={{ __html: product.description }}
/>
</div>
{/* Client component with interactive cart logic */}
<div className="mt-8">
{/* AddToCartButton component */}
</div>
</div>
</div>
</main>
);
}
With this implementation, Google agents get a clean structure from the application/ld+json tag without having to infer meaning from complex navigation or client-side JavaScript. That increases the chance that the product is understood correctly, indexed, and used in AI-generated answers.
5. Your E-shop as an API: The Shift to Composable Commerce
Adapting to artificial intelligence is not a marketing question. It is about protecting your revenue and infrastructure. The idea that you can survive the AI era with a slow monolithic system is dangerous. If your site does not provide clean data and a fast API layer to agents, you risk gradually losing visibility in Google's new search model.
The move to headless and composable architecture is becoming a more important technical direction for mid-sized and large e-commerce companies. At nolimeo, we design and implement stable, type-safe systems with fast response times that are ready for the era of the agentic web.
Not sure whether your current e-shop or portal can be read correctly by AI agents, or whether your infrastructure can handle the new wave of scrapers? Contact us and we’ll review your data, performance, API layer, and the right architecture for agentic search.