Behind the build: Valtech Concierge

We wanted to find out what it actually takes to build on top of them. So, we created a fictional luxury luggage brand, complete with product catalogue, collections, color variants and pricing in Shopify, then built a fully working concierge agent on top of it. The brand isn't real. The architecture, the engineering challenges and the solutions are. 

This is what we learned. 

The problem we were solving 

Luxury luggage is a considered purchase. Customers don't browse a grid and add to cart. They need advice: Will this fit JetBlue's cabin limits? Is it durable enough for three months in Southeast Asia? What's the difference between the hard-shell and the nylon? Would my wife prefer the Maple or the Forest Green? 

In a physical store, a great associate handles all of this. Online, you get filters and FAQ pages. The gap between those two experiences is where conversion dies. 

We set out to close that gap with an AI concierge that behaves like the best person on the shop floor, one that's available around the clock across every digital channel.   

The technology stack 

The agent is built on three layers that each do what they're best at: 

• Gemini Enterprise for CX (GECX) provides the conversational intelligence. The GECX agent handles multimodal understanding (text, voice, image inputs) and delivers the natural, reasoning-driven dialogue that makes the experience feel consultative rather than transactional. The agent understands that "my daughter is heading to Southeast Asia for a gap year" implies budget airlines, tropical humidity, theft risk and extreme durability requirements without the customer saying any of those words. 

• Shopify is the commerce backbone. Product catalogue, pricing, variant availability, inventory, customer profiles and checkout all live in Shopify. The agent queries the Storefront MCP endpoint in real time for every product recommendation, which means prices are always current, stock levels are always accurate, and the AI never invents a product that doesn't exist.  

• Google Cloud provides the infrastructure. The agent runs on Cloud Run with WebSocket connections for real-time streaming. The deterministic orchestration layer (the Python code that validates data, manages conversation state, and enforces the sales process) runs within GECX without adding latency. 

Where UCP fits 

The Universal Commerce Protocol solves the last-mile problem: getting from "I'll take it" to a completed transaction without ejecting the customer from the conversation. 

UCP defines how the agent discovers product capabilities, negotiates checkout options and hands off to Shopify's payment infrastructure, all within the conversational interface. The customer doesn't get redirected to a separate checkout page. The merchant doesn't lose control of their checkout customizations, payment routing or fraud rules. 

For Shopify merchants, this is significant. UCP means the agent can complete a purchase using the merchant's existing Shopify checkout, with all the payment methods, promotions and post-purchase flows they've already configured. The agent is a new surface for existing commerce infrastructure, not a parallel system that needs its own integration. 

For Google Cloud, UCP turns GECX from a conversational platform into a transactional one. The GECX Agent can reason about products. UCP lets it close the deal. 

What we built that isn't out of the box  

GECX provides the managed agent runtime. Shopify provides the commerce APIs. But the gap between "a conversational AI that can search products" and "a sales associate that guides a customer from need to purchase" is where the real engineering lives. 

Here's what we had to build on top of the platform: 

Headless GECX implementation

GECX provides a pre-built web widget for chat and voice. For our fictitious luxury luggage brand, we needed full control over the user experience, so the out-of-the-box web widget wasn’t enough. 

We used GECX’s API deployment mode to go headless. The GECX platform exposes a bidirectional streaming session (BidiRunSession) that our middleware connects to. The frontend is entirely custom: a React application that communicates with a FastAPI middleware layer on Cloud Run over WebSockets. 

The middleware handles the two-hop connection (frontend to middleware, middleware to GECX), manages session lifecycle, and translates between the frontend's event model and GECX's streaming protocol. 

This gives us two things the pre-built front ends can't provide:

• Rich product cards, comparison views and variant switchers that render inline alongside the conversation, driven by structured payloads from the callback layer rather than text the AI generates

• Complete control over the visual experience: the brand's typography, color palette, interaction patterns and mobile responsiveness

A session state machine 

We built a structured data model (needs, constraints, context, recommendations, reactions, outcomes) that captures the full shape of the conversation and is injected back into the agent's context on every turn.

One customer can have multiple needs (a carry-on for themselves, a checked bag as a gift), each tracked independently with its own constraints, product recommendations and purchase status. 

Deterministic conversation orchestration 

After every interaction, Python code evaluates the evidence and sets a readiness mode: discover (ask questions), recommend (show products), trial close (test purchase intent) or close (confirm and stop selling).

This prevents the two most common failures in AI-assisted selling: asking too many questions before showing a product and continuing to sell after the customer already said yes. 

Hallucination prevention 

Every product recommendation is validated before the customer sees it. The AI picks a product by code. Every detail (name, price, images, stock, variants) is looked up from Shopify, not generated by the AI.

A validation layer intercepts every tool call and blocks any request that references a product, variant or need that doesn't exist in the session. Tool errors are invisible to the customer. The AI silently retries with corrected values.  

Intelligent search cycle management 

When no products match the customer's requirements, the agent systematically relaxes constraints through a deterministic cycle: drop nice-to-have features first, then widen the budget slightly, then demote the least critical must-have.

Dealbreakers are never relaxed. After each relaxation, the agent is transparent with the customer about the trade-off. Three retries maximum, then an honest acknowledgment. This is entirely code-driven. The AI doesn't decide which constraints to drop. 

Variant matching and visual product cards 

When a customer says, "something green," the agent stores the raw preference and maps it to catalogue color names at recommendation time. The product card that renders in the front end shows the correct variant image, not the default hero shot in a color the customer didn't ask for. Variant switches (e.g., "show me the lilac one") update the card in place without a new search. 

Architecture principles  

Three principles governed every decision: 

• The AI owns conversation. Python owns state. The AI understands natural language, composes responses and makes associative leaps. Python validates data, manages session state, enforces the sales process and prevents hallucination. Neither could do this alone. 

• The merchant's data is the source of truth. Every product detail comes from Shopify. Every checkout flows through Shopify. The agent is a new interface for existing commerce infrastructure. It doesn't create a parallel data layer. 

• Transparency over optimization. When the agent can't find a perfect match, it tells the customer what it compromised and asks if it matters. When a product is above budget, it says so. When all options are exhausted, it admits it.    

Schedule a walkthrough 

We built this as a fully functional proof of concept against a purpose-built Shopify store with collections, product categories and variant-level inventory. Everything the agent does, from consultative discovery to checkout, runs against live Shopify data. 

The demo covers: multi-need discovery, constraint-aware product search, color preference matching, objection handling with constraint updates, empty-result relaxation, product comparison, variant switching and the cart to checkout flow. 

Book a demo