Turning one-time buyers into repeat customers
Turning one-time buyers into repeat customers is one of the most valuable problems in retention — and this article is about how to actually do it with agents, not just talk about it. The first article in this series laid out the hidden millions sitting in your one-time buyer base.
The strategy was never the hard part. The hard part was always labour. Reactivating millions of one-time buyers, each at the right moment with the right message, needs more human hours than any team has.
So brands build one win-back campaign, send it to everyone, and accept the average. Below are the practical use cases that change that — real agents you can build, not a vision deck.
The campaign was always the bottleneck
Think about the one-to-two opportunity in practical terms. A QSR brand has two and a half million one-time buyers sitting in its database. Each one bought something different, at a different store, on a different day. The genuinely effective move is a tailored nudge for each of them, timed to when they’re likely to be hungry again.
No team on earth can hand-build that. So they don’t. They build a single “we miss you” blast, fire it at the whole cohort, and a fraction come back. The strategy was right. The execution model — the campaign as a unit of work — was the ceiling.
Agentic CRM removes the ceiling. You stop building campaigns and start configuring agents that run the lifecycle for you.
What the Braze Agent Console actually does
This isn’t a chatbot bolted onto the side of your stack. The Braze Agent Console lets you create and deploy AI agents directly inside the platform — within Canvas and Catalogs, where the work already happens. The agents handle real tasks: routing users through a journey based on behaviour and attributes, generating subject lines and in-product copy, enriching data, and selecting the right content for each person.
Braze frames the shift well: the point isn’t using AI to do more of the same, it’s using it to do more of the right things for each individual. That’s the difference between a faster campaign factory and an actual change in how the work gets done.
For a marketer, the unit of work moves from “this week’s send” to “the agent that handles this forever.”
A note on the use cases below. These are built for brainstorming, to show the shape of what’s possible and get teams thinking. They are not production-ready, and a real build may look completely different from what’s shown here. The localisation and translation example in particular needs proper guardrails designed up front: clear rules for what the agent can and can’t say, what’s on-brand, and what’s off-limits, so it can run on its own without going off-script. Treat these as a starting point for a conversation, not a finished design.
Use case one: the reactivation agent inside the Canvas
Instead of one win-back journey, you put an agent inside the Canvas. It reads each one-time buyer’s history, decides the right path and the right moment, and writes the message to match. The hunger clock from the last article — but decided per person, continuously, with nobody rebuilding the segment.
Here’s what that agent actually looks like when you spec it:
AGENT: One-to-Two Reactivation
Lives in: Braze Canvas (entry step)
Inputs (from the user profile):
- last_purchase_item → what they bought
- last_purchase_store → where they bought it
- days_since_purchase → how cold they are
- predicted_return_window → when they're likely hungry again
- preferred_channel → push / email / SMS
Decision logic:
IF days_since_purchase < predicted_return_window
→ hold. Don't message yet. Too early kills the nudge.
IF inside the return window
→ route to channel = preferred_channel
→ generate copy referencing last_purchase_item
("Your [item] is waiting at [store]")
IF window has passed with no return
→ escalate: stronger reason to return, not just a discount
Output: a 1:1 message, timed per person, written per person
Guardrail: never recommend an item not available at their store
The point isn’t the exact fields — it’s that one agent does the job a year of campaigns couldn’t. You configure the logic once. It runs forever, for every one-time buyer, each treated as an individual.
Use case two: the menu agent that keeps reactivation relevant
QSR catalogs never sit still — limited-time offers, regional items, price changes, sold-out lines. The fastest way to waste a reactivation message is to recommend something that isn’t on the menu at that customer’s store.
A catalog agent keeps the menu honest so the reactivation agent never lies:
AGENT: Menu Relevance & Localisation
Lives in: Braze Catalogs
Job: keep every item description current, local, and on-brand
so downstream agents recommend real, available products
Runs when:
- a new LTO (limited-time offer) launches
- an item sells out or returns at a store
- copy needs localising for a new market
Actions:
- rewrite item descriptions to brand voice
- flag items unavailable at a given store as "do not recommend"
- translate + localise copy per market
(US "fries" → UK "chips", etc.)
Why it matters:
Relevance at the moment of return is what converts visit #2.
Stale catalog data quietly kills the reactivation agent's accuracy.
These two agents work as a pair. The catalog agent guarantees the menu is true; the reactivation agent acts on it. Neither needs a marketer in the loop once the guardrails are set.
Braze reports early results worth noting — one brand saw a further uplift on its repeat campaign after moving to the Agent Console, and another doubled the incremental revenue of a key campaign against a control group. Vendor figures, not ours, but they point the right way.
Where Hightouch fits: the agent is only as good as its data
Here’s the part too many people skip. An agent routing on “what they bought and where” is only as smart as the data underneath it. If that data is stale, fragmented, or stitched to the wrong profile, the agent makes confident, wrong decisions at scale. That’s worse than no agent at all.
This is the warehouse job. Hightouch resolves transactions to a single customer profile in Snowflake and syncs the computed traits the agent actually needs straight into Braze:
HIGHTOUCH SYNC: Warehouse → Braze
Source: Snowflake (single resolved customer profile)
Traits computed in-warehouse, synced to Braze:
- purchase_cadence → avg days between orders
- predicted_return_window → when to fire the reactivation agent
- store_affinity → home store for localisation
- lifecycle_stage → one-time / repeat / loyal / lapsed
Second sync: same audience → paid media
→ customer already reactivated by the agent
is suppressed from acquisition ads
→ one brain, two destinations, no wasted spend
The agent stops guessing from email opens and starts deciding from real behaviour. And because the same resolved audience also syncs to paid media, a customer the agent has already won back stops being chased by acquisition spend. That’s the difference between a clever demo and a system that actually saves money.
The marketer becomes the conductor
When an agent handles the build, the routing, and the copy, the manual work disappears — but four jobs land squarely back on the marketer, and they’re the ones that decide whether the agent makes money or quietly burns it.
First, you write the guardrails. The reactivation agent above only works because someone told it never to promise an item that isn’t in the store, and to lead with relevance before reaching for a discount. Those aren’t settings — they’re commercial decisions. Get them wrong and the agent scales the mistake across millions of people.
Second, you define what “good” looks like in the output schema. The explanation field exists so you can audit why the agent sent what it sent, sample its reasoning weekly, and tighten the instructions when it drifts.
Third, you own the data contract. An agent routing on “predicted return window” is only as good as the trait Hightouch is syncing in — so the marketer’s job now includes knowing what’s in the warehouse, what’s stale, and what’s missing. Fourth, you hold the control group. The fastest way to lose trust in an agent is to deploy it everywhere at once with no way to prove it worked. Keep a holdout, measure incremental lift, and let the numbers — not the novelty — decide how much you hand over next.
That’s the real shift: less time building this week’s send, more time setting the rules, watching the outputs, and proving the return. It’s a harder job than it sounds, and a more valuable one.
The hidden millions stop being hidden
The one-to-two opportunity was always real. What’s changed is that you no longer need an army to capture it. The first job you hand an agentic CRM isn’t something exotic — it’s the most valuable job in the book: get the one-time buyer to come back, continuously, one person at a time. Get the data right with Hightouch, let the agents run the lifecycle in Braze, and step into the conductor’s role. Do that, and the hidden millions stop being hidden. They start compounding.
