LLM Actions in Customer.io Are a Power Tool, Not a Slot Machine: A Credits-First Playbook for SMBs

In 1895, a San Francisco mechanic named Charles Fey built the first three-reel coin-operated slot machine. He called it the Liberty Bell. Three reels, five symbols—a diamond, a heart, a spade, a horseshoe, and a cracked Liberty Bell—1,000 combinations, and a jackpot of 20 nickels for three bells in a row.

Fey refused to sell the design. He rented Liberty Bells to saloons across the city and kept the manufacturing rights to himself, working out of a Market Street workshop until the 1906 earthquake destroyed it and most of his stock. His three-reel layout is the direct ancestor of every slot machine in use today, recognised by the State of California as Historical Landmark #937.

Fey's invention worked for one reason: each pull cost a fixed, trivial amount, and the outcome felt unpredictable enough to keep you reaching for the next nickel. That is exactly the wrong way to think about Customer.io's new LLM Actions—and exactly the way a lot of marketing teams are about to think about them. The credits look cheap. The outputs look magical. And in two weeks, the introductory 100,000-credit bundle is gone, with no measurable lift to show for it.

This post is the playbook I'd hand a marketing manager at an SMB before they turn the feature on. It covers what LLM Actions actually do, the credit math you need to sanity-check, and the four use cases that earn their credits. Then it covers the three anti-patterns that quietly drain them, and the pre-go-live checklist that separates "we tried AI" from "we proved it lifted conversion by 14%".

What LLM Actions actually are

LLM Actions are a new native step inside any Customer.io campaign workflow. The step fires at runtime for each individual customer in the journey, calls a large language model with whatever prompt and context you've defined, and stores the response as a journey attribute or customer attribute. From there, the output is available to personalise message copy, drive branching logic, or trigger another workflow.

There are no webhooks. No third-party services. No engineering ticket. You drop a "Run LLM" step into the journey, write the prompt in Liquid, define the output schema, and ship.

Customer.io introduced the feature on 8 April 2026 as part of its largest product release to date. The same launch added the AI Agent, Goals, WhatsApp, LINE, and a redesigned workflow builder. LLM Actions are the piece most likely to either pay for themselves or quietly blow your budget, depending on what you point them at.

If you're new to journey-based campaign building, the foundations are covered in our complete guide to Customer.io journeys. Read that first, then come back. The rest of this post assumes you know what a campaign workflow is.

How AI credits actually work

AI credits are the unit of consumption. Every time an LLM Action fires for a customer, the call consumes credits based on the model you picked and the combined length of your prompt, context, and output.

Three things to understand before you turn the feature on:

One. Every paying Customer.io account receives a one-time grant of 100,000 credits, valid for 90 days from the date of becoming a paying customer. That's your runway to experiment. After 90 days, unused credits expire.

Two. Additional credits cost $10 per 100,000 credits, purchased through your account team.

Three. Customer.io's own baseline is that 100,000 credits equates to approximately 100,000 actions when using Gemini 2.5 Flash Lite, the cheapest model on the menu. Switch to Balanced and you'll use credits faster. Switch to Reasoning and you'll burn through them several times faster again. Longer prompts, longer context, and longer outputs all multiply the per-call cost.

Worked credit math for three real use cases

These are back-of-envelope figures using the Gemini 2.5 Flash Lite baseline (one credit per action) and rough multipliers for heavier models. Customer.io has not published exact per-model rates, so treat these as planning estimates, not contractual numbers. They're enough to make the trade-offs visible.

Use case A—lead qualification scorer, 1,000 leads, Quick model. Short prompt, short JSON output ("hot" / "warm" / "cold" with a one-line reason). Roughly 1,000 credits. That's 1% of your introductory bundle for an entire month of new-lead scoring. Cheap.

Use case B—persona classifier on every new signup, 1,000 new users a month, Reasoning model. Longer prompt with several attributes, multi-sentence rationale, classification output. If the Reasoning model burns credits at, say, five times the baseline, that's 5,000 credits. Still under 5% of the introductory bundle. Useful.

Use case C—per-send subject-line rewriter on a weekly newsletter, 10,000 recipients, Balanced model, four sends a month. Long prompt (the original subject plus customer context), long output (the new subject plus a body fragment). At a conservative two-times multiplier on the baseline, that's 20,000 credits per send, 80,000 credits per month. The entire 100,000-credit introductory bundle, gone in five weeks, on a feature whose lift you can't reliably attribute.

That third one is the trap. It's the slot machine.

Four use cases that earn their credits

The pattern that earns credits is the same in every case: ask the LLM one question whose answer governs the next ten steps. The output is small. The downstream leverage is large.

Intent scoring

Replace a nest of conditional branches with a single classification step. Pass the customer's recent activity, ask the model for one of ready_to_buy, comparing_options, just_browsing, needs_support, or churn_risk, store the result as a journey attribute, and branch on it downstream.

You get cleaner workflows, fewer points of failure, and a classification you can A/B against a heuristic. The credit cost is small because the input is small and the output is one tag plus a reason. The leverage is large because the tag governs which sequence the customer enters next.

Persona classification

Same pattern, different question. Pass attributes plus behavioural events—job title, company size, features used, support tickets—and ask for power_user, casual_user, struggling_user, or champion_user. Use the result for routing and segmentation, not for content generation.

If you already run advanced segmentation in Customer.io, persona classification is the natural next layer. Hard-coded segments answer "what is true about this customer right now?". LLM-driven persona classification answers "what kind of customer is this?"—a question that's hard to express as a filter rule but easy to express as a prompt.

Dynamic branching

The generalised version of the two above. Any time you'd otherwise build a 12-condition decision tree, ask the LLM the question once and branch on the answer. You'll write less Liquid, maintain fewer rules, and avoid the silent failures that creep in when a branching tree grows past a certain size.

Sentiment-driven follow-up routing

Analyse the customer's last support interaction, classify it as positive, neutral, or negative, and route into the right post-support sequence. Positive sentiment goes into a review request. Negative sentiment goes into a "what could we have done better?" sequence with a human handoff option.

This is the use case rule-based segmentation cannot replicate. Sentiment is per-message, per-customer, per-moment. There's no last_sentiment attribute you can set deterministically—unless you build one with an LLM Action.

What all four have in common: the LLM produces a decision, not a deliverable. Small output. Big downstream impact. A few credits per customer. A campaign that gets measurably smarter.

Three anti-patterns that burn credits with nothing to show for it

These are the use cases that feel like obvious wins on the demo and turn into budget holes the first time you run them at scale.

Per-send subject-line variants

Generating a unique subject line for every recipient looks clever in a deck. In practice, it does three things wrong. The prompts are long—you have to give the model enough context to write something on-brand. The outputs are long—you're paying for two or three sentences per send. And the lift is impossible to attribute, because every recipient saw a different subject.

You already have a tool for subject-line testing. It's called A/B testing with two human-written variants and statistical significance. If the AI-generated variant beats the human one, that's worth knowing. If you can't measure it, it's not.

The same logic applies to building reusable subject-line libraries. Generate them once, in Customer.io Design Studio or your editor of choice, save them as components, and use them as templates. Don't pay the model to write the same thing 10,000 times.

Broad "rewrite this email" prompts

The single most expensive thing you can do with an LLM Action is feed it a long input and ask for a long output. "Take this welcome email and rewrite it for this customer" is the worst combination of all three credit multipliers: a heavy prompt, a heavy context payload, and a heavy generated response.

If you wouldn't pay a freelancer £0.50 per send to rewrite the body copy on every send to every customer, don't pay the model to do it either. Use Liquid for the personalisation a rule can express. Use an LLM Action for the decisions a rule can't.

Sentiment analysis on data you already have

If you have last_nps_score, subscription_status, or a churn-risk flag set elsewhere in your stack, asking the model to "analyse this customer's likely sentiment" is paying to learn what you already know. The rule-based answer is free, deterministic, and instant. The LLM answer costs credits, takes longer, and adds variance.

This sounds obvious written down. It is not obvious when you're prompted by a demo that shows a friendly model classifying customer sentiment in real time. The check is: do I already have a deterministic signal for this? If yes, use it. If no, that's when the LLM Action earns its keep.

Journey attributes vs customer attributes: pick the temporary one

Customer.io defaults LLM Action outputs to journey attributes, and their own recommendation is to leave them there for most use cases. That's the right default and you should respect it.

A journey attribute lives for the duration of one campaign. When the customer exits the journey, the attribute expires. No profile clutter. No stale tags accumulating over time. No refresh cadence to manage.

A customer attribute persists. Once you've classified a customer as power_user, that tag stays on the profile until you overwrite it. If the model was wrong, or the customer's behaviour has shifted, or six months have passed and you haven't rerun the classification, the tag is now misleading every campaign that reads it.

Persist outputs as customer attributes only when you have a clear answer to three questions: which campaigns need this value beyond the current journey, who owns refreshing it, and how often does it get refreshed. If you can't answer all three, leave the output as a journey attribute and live with the fact that you'll classify the same customer again in the next campaign. The few credits you "save" by persisting are not worth the data-hygiene mess that follows. Customer.io's own guidance on customer attributes is worth reading before you reach for the persist toggle.

A pre-go-live checklist

Before you flip the feature on for a live campaign, run through these.

Set a fallback value on every output attribute. Customer.io's docs are explicit: if the LLM call fails and no fallback is set, the output attribute remains unset, and any downstream branch that reads it will misroute. Pick a safe default ("unknown", false, the cautious branch) for every output your campaign relies on.

Pick one campaign. Not three. The first deployment of LLM Actions should be a single, low-risk campaign with a clear success metric. Resist the urge to add the feature to your welcome sequence, your re-engagement flow, and your churn-risk workflow on day one.

Define a credit budget upfront. Decide how many credits this campaign can consume in its first month. Set the number before you turn it on. If you don't, you'll find out what the number was when the bundle runs out.

Run a holdout against the non-AI version. Same campaign, same trigger, half the audience routed through the LLM Action and half through your existing deterministic alternative. This is non-negotiable. Without a holdout, you cannot tell whether the lift came from the LLM, the new copy, the new sequence design, or the underlying offer.

Decide your kill criteria. Before you launch: what's the threshold at which you turn the feature off? Cost per conversion above £X. Conversion rate below Y%. Negative variance against the holdout at week four. Write it down. Tell your manager. Stick to it.

What this means for SMB lifecycle teams

LLM Actions are a real capability shift for marketers who don't have engineering resources to wire up webhooks and external AI services. The runtime decisioning use cases—intent, persona, sentiment, dynamic branching—are the ones to start with. They're cheap on credits, they produce decisions your existing logic can't replicate, and the lift is measurable against a holdout.

The content-generation use cases are the slot machine. They look the most impressive on the demo, they're the easiest to enable, and they're the fastest way to burn through 100,000 credits without learning anything you can defend in a quarterly review.

Pick one decisioning use case. Run it against a holdout. Prove the lift. Then expand. That's the credit-first playbook.

If you'd like a second pair of eyes on which use case to pick first, or you'd rather hand the whole rollout to someone who's done it before, book a call. NerveCentral is a certified Customer.io partner and we run this kind of audit and rollout for SMB lifecycle teams every week.

Frequently asked questions

Q: How much do Customer.io AI credits cost?

Additional AI credits cost $10 per 100,000 credits, purchased through your Customer.io account team. Every paying Customer.io account also receives a one-time introductory grant of 100,000 credits, valid for 90 days from the date of becoming a paying customer. Unused credits expire at the end of the 90-day window.

Q: What are Customer.io LLM Actions?

LLM Actions are a native campaign step in Customer.io that calls a large language model at runtime for each individual customer in a journey. The model's response is stored as a journey attribute or customer attribute, which you can then use to personalise message copy, drive branching logic, or trigger downstream steps. They replace the need for webhooks and external AI services for in-journey personalisation and decisioning.

Q: Should I use Customer.io LLM Actions for subject lines?

For most SMBs, no. Per-send subject-line generation has long prompts, long outputs, and produces a unique variant per recipient—which makes the credit cost high and the lift impossible to attribute. Stick to human-written subject lines tested with A/B splits, and reserve LLM Actions for decisioning use cases (intent scoring, persona classification, sentiment routing) where the output is small and the leverage is large.

Q: How many AI credits does one LLM Action use?

Customer.io's baseline is that 100,000 credits equates to approximately 100,000 actions when using Gemini 2.5 Flash Lite, the cheapest model. Picking a Balanced or Reasoning model uses credits faster, and longer prompts, context payloads, and outputs all multiply the per-call cost. Customer.io has not published exact per-model rates, so the practical answer is: run a small test campaign, count the credits consumed, and extrapolate.

Q: What's the difference between journey attributes and customer attributes in Customer.io?

A journey attribute lives for the duration of one campaign and expires when the customer exits the journey. A customer attribute persists on the profile until it's overwritten. Customer.io recommends storing LLM Action outputs as journey attributes by default, because most outputs are only useful in the context of the current campaign. Persisting them creates data-hygiene problems: stale tags, no clear refresh cadence, attribute sprawl across the profile.

Q: What's the best Customer.io LLM Action use case for an SMB?

Intent scoring or persona classification, run against a holdout. Both produce a small, structured output that replaces a nest of conditional branches with one classification step. Credit cost is low. The downstream impact—routing, sequence selection, message tone—is large. Start with one such use case in one campaign, prove the lift against a deterministic alternative, then expand.

Q: What happens if a Customer.io LLM Action fails mid-journey?

The system automatically retries the call. If retries are exhausted and you've set a fallback value, the journey continues with the fallback. If retries are exhausted and you have not set a fallback, the output attribute remains unset—and any downstream branch that reads it will misroute. Always set a fallback on every output attribute.

Q: Do I need to set a fallback value on an LLM Action output?

Yes. Customer.io's default is no fallback, which means a failed call leaves the attribute unset. Any downstream conditional that reads the attribute will fail or misroute. Setting a safe default ("unknown", the cautious branch, false) on every output is the single most important pre-launch check.

Q: How do I measure ROI on a Customer.io LLM Action?

Run a holdout. Split the audience for the campaign so half goes through the LLM Action and half goes through your existing deterministic alternative—a rule-based segment, a heuristic, the previous version of the campaign. Compare conversion, revenue, or whatever your campaign-level metric is. Without a holdout, any lift you see could be the new copy, the new sequence, the underlying offer, or the LLM. You'll never know which.

Q: Can I use Customer.io LLM Actions without a developer?

Yes. LLM Actions are configured entirely in the campaign builder using Liquid to inject customer attributes and events into the prompt. There are no webhooks to wire, no API keys to manage, no external services to maintain. A lifecycle marketer who knows the Customer.io Liquid basics can set up an LLM Action without engineering support.

Q: How quickly will 100,000 AI credits run out?

It depends entirely on what you point them at. A lead-qualification scorer running on 1,000 new leads a month using the Quick model will use roughly 1,000 credits a month—the bundle lasts the full 90-day window. A per-send subject-line rewriter on a 10,000-recipient newsletter using a Balanced model can burn 20,000 credits per send, exhausting the bundle in five weeks. Plan the spend per campaign before you turn the feature on.

Q: Which model should I pick—Quick, Balanced, or Reasoning?

Start with Quick (the Gemini 2.5 Flash Lite baseline) for classification and scoring tasks. The output is small, the credit cost is low, and most decisioning use cases don't need deeper reasoning. Move up to Balanced or Reasoning only when you have a specific quality problem with the Quick output—wrong classifications, brittle outputs, missed nuance—and you've measured it. Don't pick the heavier model because it sounds smarter on the menu.

Q: Can Customer.io LLM Actions replace a webhook to OpenAI?

For in-journey decisioning and personalisation, yes. LLM Actions remove the latency, the auth management, the retry logic, and the external service dependency that a webhook-to-OpenAI setup brings. You keep the webhook approach when you need a model or capability Customer.io doesn't offer, or when the LLM call needs to happen outside a journey context.

Q: Are LLM Actions safe to use on customer data?

Customer.io states that data sent to its hosted models is not used for model training. For Gemini models specifically, you can set safety thresholds across predefined categories (harassment, hate speech, dangerous content) and block outputs that exceed them before they reach a customer. Every account also has access to a compliance prompt—a persistent instruction layer applied across every LLM Action in the account—that lets you set brand-voice and regulatory guardrails once and have them respected everywhere.

Sources

• LLM Actions: AI decisioning built into your workflows—Customer.io, 2026
• Customer.io's biggest product release: AI Agent and more—Customer.io, 8 April 2026
• AI marketing demo: AI Agent, Goals, WhatsApp, LINE, and more—Customer.io, 8 April 2026
• AI credits—Customer.io Docs, 2026
• LLM actions: Generate data & decisions with AI—Customer.io Docs, 2026
• Generate data & decisions with LLM actions in campaigns—Customer.io Release Notes, 8 April 2026
• Manage customer attributes—Customer.io Docs, 2026
• Charles August Fey—Immigrant Entrepreneurship, biographical entry
• California Historical Landmark #937—Liberty Bell Slot Machine Site—California Office of Historic Preservation