Build for what the visitor came to do

Every visitor arrives with something they’re trying to do. A website does its best to guess what that is, and calls the result “personalization.” In practice, that has usually meant putting someone in an audience based on stale data, then showing them the experience built for that audience. Perhaps “personalization” was always the wrong word, and “audience-ation” is closer to the truth.

To be fair, there was a good reason for it. Reading intent and building for it, one visitor at a time, was expensive. So teams made a handful of decisions up front, grouped users into audiences and debated what might convert each one. Then you’d design three versions of an experience, test them, and repeat, on and on. The more advanced teams used propensity or next-best-action models, which pick much better, but they can still only see the features someone defined in advance and predict the outcomes someone chose in advance.

What’s changed is that reading intent and building for it are both getting cheap. Agents can now read what a visitor is doing in the moment and build a page around it while they’re still on the site, out of components your team has approved. Along the way they take over much of the manual work: the rules, the segments and the predefined variants. People have started calling this generative UI.

Others see the same shift

Last week I was lucky enough to be in San Francisco to see Guillermo Rauch, Vercel’s CEO, put the prediction plainly on stage at ShipSF: “Interfaces will be generated just for you for the task you need to complete and then disappear.” That’s the point. The interface fits the task in front of you, not the segment you were put in. He also named a problem that still needs solving. Software that generates its own UI still needs to know whether what it made was a better experience, and the only place that answer lives is what he called production context.

The building blocks for generative UI are already here. Vercel’s open source json-render and Google’s A2UI let an agent build an interface out of components your team has approved. On understanding user intent, recently released decision models are opening up new possibilities. TypeSafe launched Jev in September, a model that answers a typed question about a user fast enough to sit inside a page. Within weeks OpenAI put a Decisions API into limited preview and Databricks added ai_decide. Aside note - I’m starting to think “decision” is the wrong word for these models - but that’s a post for another time.

Cloudflare is working toward the same thing. A few days ago, Brayden Wilmoth described two of its models, one that chooses the best component for the screen and one that fills in its content, and wrote that “none of that happens without an amazing context layer to glue it all together.”

What nobody has shown yet is the full system, one that reads behavior, understands the user’s intent, composes the page and reliably gets better in production.

Building an audience of one

Personalization has always worked on audiences. An agent can work on an audience of one, meaning this visitor in this visit.

I want to walk through an example from retail, though the same idea applies well beyond it. A B2B company can tailor its interface to a customer, because it knows who they are and what they need to do next. A media company can compose a more engaging experience based entirely on how the reader is interacting.

Here’s how it could work for a running shoe shopper, in a scenario I’ve been in a number of times.

Read the intent

Picture a visitor who has come back to a website to replace a pair of running shoes they have worn through. Today the site’s rules might put them in a “runners” audience based on their previous purchase, and “personalize” some content around that label.

What changes now is that an agent can read the visit itself. In this session the visitor has gone back and forth between a cushioned daily trainer and a lighter racing shoe three times, and read the reviews about how each one holds up on long runs. The agent can work out that they’re unsure which shoe suits the way they run, not that the price is too high. What makes this possible now is that System One decision models, like Jev, have brought the cost and latency of a model call down far enough to classify a visitor’s intent while they browse.

Previously, capturing that intent meant encoding it in advance, as a set of rules or as features engineered for a model. Someone had to think of every intent a visitor might have, and with all the possible combinations that was usually far too complex.

Shape the experience

This is the generative UI part. Today you might design a handful of variants for an experiment, one for each segment. With an agent, this is something it can build on its own. Knowing this visitor is unsure which shoe suits them, it can show a page that puts the two shoes side by side with cushioning, weight and what each is built for up top, and pulls in reviews from runners who use them for long distances. It’s all built from components your team approved, within your brand rules. Nobody designed that exact page in advance.

Decide whether to step in

A typical rule fires a discount for everyone who leaves a cart. Here the running site’s team has approved three options instead: a free exchange, a discount or nothing. Experiments show which one works for visitors with each intent. Over time they might show that for visitors unsure which shoe to pick, the free exchange helps and the discount mostly gives money away. So this visitor sees the free exchange.

After that decision has been made, the agent has a part to play. It can decide what that free exchange looks like to this visitor. Rather than choosing from predefined variants, it can write the message around the visitor’s intent.

Two page wireframes side by side. Today: a hero banner reading “New season for runners,” written for the “runners” segment, a standard product grid, and a popup offering a discount that fires when the visitor leaves the cart. With an agent: a heading the agent wrote for this visit, “Daily trainer or racing shoe?”, the two shoes the visitor has been comparing side by side with cushioning, weight and what each is built for, reviews from runners who use them for long distances, and a note that says “Not sure? Swap for the other one, free,” which experimentation chose and the agent worded. Every part is built from components the team approved.

I do want to make one thing clear - agents probably shouldn’t be making persuasive decisions that cost margin, at least for now. A discount that goes to someone who was buying anyway is revenue given away, and agents aren’t yet reliable with numbers or at spotting trends across thousands of visits.

Closing the loop

One problem that needs solving is the one Rauch named at ShipSF. When the page is generated for each visitor, you can’t run simple A/B tests. In practice, you need to measure the system as a whole instead. Split visitors between the system and your existing static experience, record the intent behind each visitor, what they saw and what they did next. Then measure whether they reached their goal for that intent. For our runner, the question is “did they buy and keep the shoes,” rather than only “did they buy.”

For offers, experiments should keep showing which response works for which kind of visitor, based on their intent. For the page itself, every page is different, so you learn from its parts instead. Record what the agent built, such as which components it used and in what order, alongside the intent it read.

A separate agent can then read the results and propose changes to how it builds and what it offers, and a person signs off on them.

Diagram in two panels. Today, decided before the visitor arrives: past behavior from last month feeds segments such as “runners,” then rules or a model that pick from a fixed list, then variants A, B and C designed in advance, then an A/B test of which variant won. Your team sets up the segments, rules and variants. With agents, decided during the visit: this visit, comparing a daily trainer with a racing shoe, feeds an agent that reads the intent, “unsure which shoe suits them.” To help the visitor, the agent composes the page from a component catalog your team approved, with a side-by-side comparison and reviews from long-distance runners. For an offer with a cost, an experiment chooses between a free exchange, a discount or nothing, and the agent writes the offer for this visitor from the same catalog. Both make a page for one visitor from approved components. Results are measured against the default experience by whether visitors reached their goal. Experiments measure which offer works, an agent reviews the results and proposes new responses and ways to build, and your team approves each change before it goes live.

What still needs to be solved

Personalization has always had its fair share of challenges, and it rarely stalled for lack of ideas. It usually stalls on data, and agents don’t change that.

Agents remove the cost of writing rules and variants. They don’t remove the need to know what a visitor is doing. An agent decides only as well as the context it’s given: who this visitor is, what they’re doing right now in the current visit, what they did in previous visits, their purchase history, their loyalty tier and much more. If that data is slow or patchy, you’ll get an agent that makes confident guesses about intent. Machine learning has had the same problem for years, with data scientists spending months cleaning data so their models can make sensible predictions. This is the part we’re focused on at Signals.

What’s next

I expect this to be a long journey we’re all about to start. The first agents will feed user intent into existing personalization tools. Next, agents will start to compose and create experiences, before making their way into low-risk decisions. As we build trust in the agents and build measurement frameworks, agents will take on more of the page. Along the way, the work of a personalization team changes. Less of it goes into writing rules and designing variants, and more into the component catalog, the brand rules and the decisions about what an agent is allowed to change.

Snowplow Signals collects what each visitor is doing and serves it as real-time customer context to whatever makes the decision, whether that’s a System One model, an agent or the personalization tools you already run. Our upcoming agentic attributes go a step further and detect a visitor’s intent as they browse, with more in the works.

If you’re building generative UI experiences, or the technology that makes them possible, please reach out. I’d love to discuss it.

James Borlase

Head of Signals, Snowplow

Runs Snowplow Signals, from the product to go-to-market. Previously at Google.