Direct mail is about as old school as marketing gets, and in a world of AI slop, that's exactly what makes it stand out. Where web ads are relatively cheap, flexible, and easily cancelled or updated if something goes wrong, mail is expensive, takes weeks to produce, and worst of all, a bad decision can't be undone.

These aspects of direct mail get filed away as the channel's weaknesses, and often become reasons to test it later, or not at all. But that expense has a side effect worth paying attention to: it forces intentionality. Because it costs more, we treat it differently; we’re less likely to thoughtlessly hand it off to AI. And I think that teaches us something about how we're engaging with all our LLM tools right now: we're not just handing off our thinking, we're handing off our intention, and too often we stop caring about what actually goes out the door.

## Why direct mail's cost forces better targeting

_When sending costs nearly nothing, there's no reason to think hard before you launch._

We'd never say it out loud, but let's be honest, this thinking has crept into a lot of outreach over the last few months. It's the same spray-and-pray we all know and roll our eyes at, but now on steroids thanks to AI. And for digital it _almost_ seems justifiable: if an email campaign misses, the financial penalty is relatively negligible, so the rational move is volume. Fire everything and see what sticks, right?

Mail won't let you do that. When each piece costs real money to send — orders of magnitude more than a digital impression — you feel actual pressure to answer the basic questions: who you're sending to, whether the list is right, what you're actually saying, whether the timing makes sense. You know, the questions we all know we're supposed to answer before we write a single word of copy. The economics aren't limitations, they're a forcing function to do better work, and it's why mail campaigns tend to be thought through in a way that email campaigns often aren't.

## What this looked like for us

Last month we launched a [self-serve portal](http://pro.faraday.ai) where you can directly pull consumer data from the [Faraday Identity Graph (FIG)](https://faraday.ai/blog/whats-in-faraday-identity-graph), and we wanted to announce it with a postcard, something we hadn't tried before. What I didn't expect was how different the creative process would be from our standard digital ad rollouts.

Our first version was built mostly with AI (let's be honest, who isn't doing that today). AI helped pick who we'd send it to, wrote most of the copy, and drafted the design. We had the whole thing mocked up in a day. If this had been an email, I'd probably have glanced at it for two minutes, and, noting that the cost to send would be negligible, said "sure, let's try it." But something at the back of my head kept reminding me that every one of these postcards was going to cost us real money, so I actually looked closer.

![The original AI-assisted Faraday postcard: the Faraday logo with the tagline "we have data for that" and faraday.ai on a pink background](/images/blog/why-direct-mail-cost-prevents-ai-slop/original-postcard.png)

This is the original, it wasn't bad. It met every requirement I’d given. But it was generic and frankly it wasn't something I'd respond to myself. We'd made _something_, _fast_. But with a little more intention, we could make _something_ _great_. So we went back to the drawing board on all of it: the list, the message, and even what we wanted the piece to feel like. And when we weren’t sure what the best path was, we didn’t hand it off to Claude, we went to the actual experts in our corner, our fantastic direct mail provider Lob, who walked us through the details that convert a campaign from acceptable to exceptional (like knowing that 6x9 postcards tend to get a better response than 4x6, who knew\!?).

![The final Faraday postcard: a "greetings from Vermont" banner over a photo of a red covered bridge surrounded by green hills](/images/blog/why-direct-mail-cost-prevents-ai-slop/vermont-postcard.jpg)

Round 2 landed on something highly personal and friendly: a casual, direct note from our Head of Sales paired with a classic VT postcard aesthetic (covered bridge and all). It was designed to feel like what makes postcards fun in the first place: a warm note from someone who was thinking of you. In this case, your old friend Dave (who happened to have an easy yes to save you some money).

![Happy customer posing with their recently recieved Faraday postcard](/images/blog/why-direct-mail-cost-prevents-ai-slop/happy-customer.jpg)

(That’s one happy customer)

## What the research actually shows

But it’s not just that we marketers get a warm, fuzzy feeling when we send a nice, intentional direct mail. The data shows this actually impacts the bottom line.

I was on [a panel with Lob, the USPS and SimpliSafe](https://www.lob.com/videos/state-of-direct-mail-2026-consumer-insights) earlier this month, digging into their [2026 State of Direct Mail research](https://www.lob.com/state-of-direct-mail/consumer-insights/2026-report), and the numbers make the case better than I can. [Nine in ten people](https://www.lob.com/state-of-direct-mail/consumer-insights/2026-report#personalization-and-conversion) say relevant, personalized mail is what moves them to act. [Two-thirds](https://www.lob.com/state-of-direct-mail/consumer-insights/2026-report#ai) now say AI has made them more skeptical of digital ads, while most are comfortable with AI in their mail — as long as it's making things more relevant rather than just making more of them. And [the households under the most financial pressure](https://www.lob.com/state-of-direct-mail/consumer-insights/2026-report#economic-pressure), the ones you'd assume have tuned marketing out entirely, are the most likely to act on mail and the most willing to try a brand they've never bought from who connected with them through direct mail.

People aren't reacting to the technology. They're reacting to whether anyone was paying attention.

## The trap is avoidable

Look at how we're all working right now. How often do you find yourself just conversing with Claude, passing prompts back and forth only to realize you could have written it yourself in 20 minutes? We've got more tools than we have problems to solve.

It's not a new take that we're outsourcing our thinking to AI — but I'd argue it's not just our thinking we're giving up. It's our intention.

For years marketers have been optimizing for attention — impressions, clicks, time on page, all the ways we measure how much of someone's day we managed to capture — but today we need to reorient. Suddenly, as we're all managing teams of autonomous (and somewhat competent) agents, we don't just need to optimize for the attention of the lead, but for our own intention. **When we're able to run 100 campaigns at once, the most important item to budget becomes focus.** This is what I call the intention economy, and it's just as critical to understand as the attention economy.

And this is where mail is instructive, because it's a channel where the option to stop paying attention never felt like an option at all. You can generate a hundred versions of a mailer in a minute; you still have to pay to put each one in a mailbox. **The bill arrives whether an AI wrote the copy or you did, but the leads might not.**

## Where that leaves the rest of your marketing

The useful thing about a constraint is that you can adopt it on purpose. Sure, postage might be the specific thing that makes you ask the right questions on your direct mail campaign — but those questions don't become less true in channels where nobody's forcing you to think about them. **You don't need a stamp to stop spraying and praying; you just need to hold your digital channels to the exact same standard.**

We need to take the reins of our campaigns and stop letting the tools, or some false sense of “efficiency” dictate our standards. The tools can scale our output, but the intention still has to come from us.

Why direct mail resists AI slop: its cost forces marketers to think before they send. I explain the intention economy and how to apply it to every channel.

The intention economy: The cost of direct mail is what saves it from AI slop

When you've built predictive audiences in Faraday, the next step is getting them into your marketing channels. For many of our clients, that's Meta (Facebook and Instagram).

Doing it by hand means exporting a CSV, hashing the personal information to meet Meta's privacy requirements, and uploading the file to Meta Business Manager, then doing it all again every time the audience changes. It's slow, it's easy to get wrong, and the audiences in Meta go stale between uploads.

Faraday's managed Meta connection removes those steps. We handle the hashing and delivery and push your audiences directly into your ad account, so they stay current without anyone touching a file.

## How it works: step-by-step setup

Setup takes three steps on your side:

1. **Share your Meta ad account ID.** Add it when you create a Facebook connection in Faraday, or send it to your Faraday contact and we'll create the connection for you. If an agency runs your campaigns, use the ad account the campaigns run in.
2. **Accept Faraday's access request.** We'll send a request through Meta to access your ad account. Once you accept it, we can push audiences to it directly.
3. **Deploy your audiences.** Create a pipeline in Faraday that deploys to your Facebook connection, and let us know once you have. We'll push it to your ad account and let you know when it's ready to use in your campaigns.

You only set up the connection once. After that, every audience you deploy to it syncs the same way.

## We're here to help

If you have questions or run into trouble, reach out to support and we'll help.

Faraday's managed Meta connection sends your predictive audiences straight to your Meta ad account, so you can skip the manual exports and uploads.

Streamlining Meta custom audiences with Faraday managed connections

## The problem

Finance declines don't fail at the top of the funnel. They fail at the end — after a rep has driven out, run a full appointment, and gotten a homeowner to sign. Then the financing falls through, and the cost of that lead, that drive, that appointment, and that rep's time is gone.

Across Faraday's home services client base, finance decline rates typically range from 20% to 45% of gross sales, and with household budgets under more pressure than they've been in years, that number is trending in the wrong direction. There's also a well-known dynamic that makes it worse: the homeowners most eager to book are often the ones least likely to clear financing, while the ones most likely to qualify are harder to reach and slower to commit.

The good news is that [finance declines are predictable](https://faraday.ai/catalog/v2/credit_score_proxy) — and once they're predictable, they're manageable. Below are the five plays Faraday clients use to attack the problem, followed by a real implementation example.

## Five ways to use a finance decline score

Faraday delivers a real-time score for every lead, predicting how likely they are to result in a finance decline. The right way to use that score depends on your lead volume, cost structure, and workflow. Most clients start with one play and layer on others over time.

### 1\. Suppress high-risk leads before the appointment stage

Stop spending rep time on leads that are almost certain to decline. Set a percentile threshold — most clients start conservatively — and route leads above it into a hold bucket rather than hard-rejecting them. This protects vendor relationships and creates a reserve pool for slow periods while immediately freeing up appointment capacity.

This is the highest-impact play for clients with enough lead volume to absorb a small reduction. At a 95th-percentile cutoff, clients typically project less than 2% revenue impact while eliminating over 10% of total credit declines — a projection the implementation below came in under.

### 2\. Prioritize appointments by likelihood to close

For clients who don't want to or can't reduce lead volume — contractual obligations, market coverage requirements — the score ranks which appointments get worked first. Surface the score in the CRM or call center tool so managers and reps see it where they're already making decisions.

One remodeler we work with built a 5-point decision matrix combining their finance decline score with credit pass percentile, home value, household income, and credit score proxy. The result: roughly **$25,000 a month** in lead-spend savings from better appointment selection alone — more than **12x** the annual cost of their plan with Faraday.

### 3\. Pre-qualify leads in the call center

Use the score to guide agent behavior before a rep ever drives out. High-risk leads get asked about financing intent earlier in the call, or get rough price estimates that naturally filter out homeowners who can't afford the project. Very high-risk leads can be routed to AI-powered call center agents or text agents at a fraction of the cost of a human rep — handling the conversations least likely to convert without burning capacity (and sales team morale).

### 4\. Manage lead sources in real time

Scores can be tracked for every vendor the moment leads come in, so a sudden drop in source quality shows up immediately — not weeks later when end-of-funnel data finally catches up. This makes it possible to react before a bad batch eats your budget, and gives you leverage to renegotiate from cost-per-lead to cost-per-install for chronically low-quality sources.

## How to get started: a phased approach

You don't have to go all-in on day one. The clients who've been most successful with this follow a phased rollout:

### 1: Observe

Connect the [API](https://faraday.ai/docs/features/lookup-api), score all incoming leads, but take no action. Monitor the correlation between scores and actual outcomes. This typically takes 1–2 weeks and builds internal confidence in the model before anyone changes their workflow.

### 2: Suppress conservatively

Begin suppressing or deprioritizing the top 5% of scores. Monitor impact on revenue and decline rates.

### 3: Measure

Before widening the net, confirm the suppression is doing what you expect. Over a defined window — 30 days is a good starting point — compare decline rates and revenue for suppressed versus worked leads, and watch your false-positive rate so you're not holding back leads that would have closed. This is the evidence that justifies expanding — both internally and for your own confidence.

### 4: Expand

Gradually lower the cutoff threshold based on observed performance and your tolerance for revenue trade-off.

### 5: Layer on prioritization

Add a second signal for intent or conversion likelihood to guide how remaining leads get worked — not just which ones get cut.

### 6: Full decisioning

Build a multi-signal decision matrix combining decline score, intent score, home value, income proxy, and geography for complete lead-level routing.

## In practice: attacking a 35+% decline rate

That's the approach in the abstract — here's how it's playing out for one regional bathroom remodeler living with the problem.

This company, which operates across 10+ states was watching roughly 35% of its gross sales fall through at the financing stage — with some of its markets running as high as 45%. To protect revenue targets, the company overbooks appointments and manually selects which to run each day, a labor-intensive workflow with real waste built in.

The company trained a custom finance decline model with Faraday using its own Salesforce disposition data, and Faraday stood up a real-time [Lookup API](https://faraday.ai/docs/features/lookup-api) pipeline within days. Validation was strong: in the top decile of risk, 82% of gross sales actually declined. In the top 1%, 98.7% did.

With that confidence, the team put the score to work two ways. First, **suppression**: the highest-risk leads are written to Salesforce but held in a separate bucket and never passed to the dialer, so reps don't burn time on the leads most likely to decline. Second, **prioritization**: because the company overbooks, the score also ranks the leads that remain — surfaced right on the appointment Gantt chart as a hover-over via [LeadConduit](https://activeprospect.com/leadconduit/), so when managers choose which of an overbooked day's appointments to actually run, they work the ones least likely to decline first.

Although they started conservatively — suppressing only the leads nearly guaranteed to fail a credit check (greater than 85% chance of failure), the results came quickly.

### Update: three months in

After our first quarter review, the company's finance decline rate came in at roughly 29% of gross sales — under the 30% mark their leadership had set as the goal and significantly down from the 35%+ they were living with when they started. And they got there without giving up the revenue: cutting six points off their decline rate only cost them 1.4% of net sales — below the 2% we'd accounted for.

## Two paths in, depending on your data

Faraday offers two products for this use case:

[**Credit Score Proxy**](https://faraday.ai/catalog/v2/credit_score_proxy) — a 1–12 ranking derived from licensed bureau data, available immediately with no training data required. In testing, leads in the bottom scoring tiers showed 71–73% decline rates. Good starting point when you don't have historical disposition data.

**Custom finance decline model** — built on your own historical credit check and decline data. Consistently outperforms the off-the-shelf proxy by a meaningful margin. This is the path the remodeler above took.

Which path is right depends on your data. If you have 6–12 months of credit check and decline disposition data, a custom model is almost always the better choice. If you don't have that data yet, the proxy gets you moving immediately while you build up the historical record.

## If you're a lead generator

The same score works from the other side of the transaction. If you sell leads to home services companies, finance decline risk is a quality problem you can now measure before a lead ever leaves your hands — and that opens up two moves.

Downstream, you can grade the inventory you already have. Score inbound leads in real time to suppress or downgrade the ones most likely to decline, route your strongest leads to the buyers who value them most, and package pre-scored, higher-qualified leads as a premium tier. In a market where remodelers increasingly judge lead quality by financing outcome, being able to grade your own inventory — and prove it — is a real differentiator.

Upstream is where it gets more powerful. Feed decline outcomes back into your ad platforms — Google, and potentially Meta — as a conversion signal, and the platforms start optimizing toward the people more likely to clear financing in the first place. Instead of paying to generate bad leads and filtering them after the fact, you generate fewer of them to begin with — a cleaner book you can sell for more.

## If finance declines are eating your margin

This is solvable — and the solution doesn't require a homeowner consent flow, a bureau pull, or a six-month integration project. The data lives in your CRM already. Faraday turns it into a real-time score that plugs into the lead routing and CRM tools you're already using.

If you want a number before you talk to anyone, we built a free calculator for exactly this. Enter your bath, roofing, window, or HVAC funnel and it will estimate what declines are costing you each month, what a decline score would change, and how your ZIP codes compare on HMDA data. It takes a couple of minutes and you get a report you can bring to your team: [run your numbers](https://reports.faraday.ai/finance-declines).

And if you'd rather just walk through it with someone who has done this before, our [context consultants](https://faraday.ai/contact) are always ready to talk.

Finance declines are one of the most expensive problems in home services — and in the current economic climate, they're getting worse. Here's how Faraday clients are using predictive scores to cut the waste before it hits the bottom line.

How to solve a 35+% finance decline rate with predictive data

Next Tuesday I'm appearing on our partner [Lob's](https://www.lob.com) [State of Direct Mail](https://www.lob.com/state-of-direct-mail) panel with USPS and SimpliSafe. Lob surveyed 2,000 consumers for their annual report, which we'll be discussing, and one finding has stuck with me: when it comes to direct mail, relevance is beating discounts.

And when we think about relevance in DM, I'm sure most of us go straight to creative and personalization — which makes sense, creative is what we see when we get the postcard.

But here's the thing about relevance in mail. It starts long before anyone writes the copy or sends a file to the printer. By those points you've already made many of the decisions that determine how well the campaign actually does: whether these are the right people, whether you're pointing them at the right location, whether the person they live with already got the same mailer last month and converted.

Sure, bad creative can kill your conversion rate. But a great offer addressed to some stranger named Sandra who moved out two years ago doesn't help either.

Creating the list is where we've been putting our attention at Faraday. Here are four things we shipped this quarter to help you get yours right, plus some strategic recommendations at the end.

## New mover data: target the right people at the right time

Most names on most mail lists have no particular reason to act this week. They aren't bad prospects. They're just being contacted at an arbitrary moment.

A recent move is the opposite of arbitrary. Someone who just moved is replacing providers, buying for a new space, and setting habits they'll keep for years. It's one of the few times a piece of mail arrives already relevant.

**New mover data** lets you build audiences around that window — people who have recently moved into your service area, combined with whatever else you already filter on.

It cuts the other way too, and this is the part that gets skipped. The households that _used_ to live in your area are still on your list. Every piece addressed to them is postage spent on someone who has moved on. So the same signal does two jobs: it adds the people whose timing is right, and it surfaces the ones who quietly stopped being reachable.

[See how many people are moving into or out of your service area](https://reports.faraday.ai/new-movers) with our new mover tool. And if you want this data on your next drop, your account team can get you set up.

## Nearest Location: put the right store on every row

If you have physical locations, something has to decide which one each piece points to. For most teams that's a ZIP code or a regional map, which means a household three blocks from one store might get mailed about another one across town.

That proxy also distorts what you'll pay for a lead. Distance is a real constraint on conversion for anything that requires showing up — glasses get tried on, flooring gets seen. A lead 40 miles from your nearest showroom is worth less than one at four miles, and if you can't tell them apart you're paying the same for both.

[Nearest Location](https://faraday.ai/blog/nearest-location) measures the actual distance from every person to every location you have, and returns their nearest location, your own ID for it, and the distance. It's a real number rather than yes/no flags at thresholds someone set in advance, so "within 12 miles" is a filter you apply, not a rebuild you request. It runs backwards too: draw a radius around your locations from an [Atlas](https://faraday.ai/docs/abstractions/atlases) and build an audience of every household inside it. [There's a full walkthrough in the docs](https://faraday.ai/docs/abstractions/atlases#how-to-attach-nearest-location-to-a-deployment).

Every row on your list ends up carrying the store that's actually closest, and you can build the list itself by real distance instead of by map.

## Address-level exclusion: don't send the same offer to two people in one house

Suppression has always worked at the individual level. You mailed Jane Smith, so Jane Smith comes off the next drop. That might be the right logic for email, but it's insufficient logic for mail.

Mail arrives at addresses, not directly to the individual. So the household you already converted, already hit twice, or already heard "please stop" from can come back in the next campaign under a different resident's name.

To solve this problem, Pipelines now have an [Exclude at address level](https://faraday.ai/docs/abstractions/pipelines#population-exclusion) control. Add a cohort and Faraday suppresses everyone who shares an address with anyone in it. The old option is unchanged and now labeled [Exclude at individual level](https://faraday.ai/docs/abstractions/pipelines#population-exclusion), so you pick which one a campaign needs — both sit under the suppression settings in your [pipeline's population](https://faraday.ai/docs/abstractions/pipelines) settings, and there's an API field for it if you build programmatically.

## Household analysis: find out how many households are on your list

Here's a number that only matters in direct mail: how many _households_ are in your audience.

In most channels you set a threshold and let the volume land where it lands. In mail you buy a quantity — you tell the printer 40,000 pieces. And 50,000 individuals is not 50,000 pieces. It might be 31,000 households, and that's the difference between two very different quotes.

Every [Pipeline](https://faraday.ai/docs/abstractions/pipelines) now has an Analysis tab that answers this before you build a deployment, with no usage required. You get your population counted both ways, individuals and residences, broken out by state and ZIP code — which is also what postal sortation and regional drop planning run on. And for every prediction in the payload, you can see how many people fall into each score range, with running totals as you go further down — so your list length comes from where the counts actually add up, not from a round number somebody picked.

## Where I'd start

Four things at once is a lot. If I were picking up one of them first, this is the order I'd go in.

**1. Focus on households, not individuals.** Use Faraday to ensure you de-dupe your list and send only one mailer per household. Get the household count before you get your next print quote. _If you are already using Faraday, these two steps take less than 5 minutes._

**2. Identify the nearest location to send them to.** Direct mail can feel more personalized if you add subtle, intentional touches like details about the closest store. _This step requires adding your locations to Faraday, but it's worth it to drive a little more personalized experience._

**3. Use new mover data.** You can check out how many people are moving in (or out) of your service areas with [our handy tool](https://reports.faraday.ai/new-movers). Knowing who just moved in lets you time your drop — and your offer — to the moment they're actually shopping. _For existing Faraday customers, there is an additional cost for this data set._

It's ironic: the list is the part you have the most control over, and it's usually the part that gets the least attention. These four features are designed to make it faster and easier to build a sharp audience — so your time goes to the creative and the offer.

## Ready to optimize your list?

If you want to talk through where your direct mail program is leaking, [talk to a Context Consultant](https://faraday.ai/contact). Already a Faraday customer? Your account team can turn any of these on.

And if you'd like to hear the rest of Lob's findings, [join us on the panel next Tuesday](https://www.lob.com/event/2026-state-of-direct-mail-consumer-insights?utm_source=faraday&utm_medium=email&utm_campaign=2026-09-sodmci-webinar).

Relevance in direct mail starts with the list, not the creative. Faraday's COO on four features that add the right households and remove the wrong ones.

Relevance in direct mail starts with the list: four ways to improve yours

## Background

Anthropic published a [blueprint for commerce agents](https://claude.com/blog/claude-for-commerce-agents) on September 2: an [open-source repo](https://github.com/anthropics/commerce-agents) with two working AI agents for online stores, plus a Claude Code plugin that adapts either one to your store's systems. Retailers running shopping agents on Claude report carts up to 35% larger and shoppers 60% more likely to buy.

The shopping agent talks to customers. Tell it "a tent, sleeping bag, and stove for a weekend with two kids" and it searches the catalog, picks a set, and fills the cart. The merchant agent talks to the store's staff. Ask it "what should we discount to clear last season's inventory" and it drafts the promotion for a person to approve. The hard parts of building an agent, like keeping prices accurate and stopping it from pushing products nobody asked for, come built in. Your job is to write one class per agent, [`StorefrontBackend`](https://github.com/anthropics/commerce-agents/blob/fd4d592/shopping-agent/core/shopping_agent/backend.py) or [`MerchantBackend`](https://github.com/anthropics/commerce-agents/blob/fd4d592/merchant-agent/core/merchant_agent/backend.py), that connects the agent to your store's data.

## Problem

**The blueprint assumes you already know your customers.** Every good pick in the demo comes from a customer profile that Anthropic [typed in by hand](https://github.com/anthropics/commerce-agents/blob/fd4d592/examples/retail/data/users.json).

Before each reply, the shopping agent calls [`get_preferences`](https://github.com/anthropics/commerce-agents/blob/fd4d592/shopping-agent/core/shopping_agent/backend.py#L116-L118) and puts what comes back in front of the model: the customer's name, loyalty tier, location, and [a list of free-text preferences](https://github.com/anthropics/commerce-agents/blob/fd4d592/shopping-agent/core/shopping_agent/types.py#L110-L117). The demo's profiles say things like `"household": "partner and a 6-year-old"` and `"spending": "usually keeps to the mid-range options"`. That is why the demo agent can skip the clarifying questions and pick well on the first try.

Nothing else fills that in. The agent's memory keeps only what the customer said out loud and is [told to ignore](https://github.com/anthropics/commerce-agents/blob/fd4d592/commerce-common/commerce_common/memory.py#L62) "attributes that would have to be inferred." A [provenance rule](https://github.com/anthropics/commerce-agents/blob/fd4d592/shopping-agent/core/shopping_agent/types.py#L194-L198), which tracks where each product came from, lets the agent show only products it found by searching or that the customer already bought. When the setup plugin asks [which system holds your customer profiles](https://github.com/anthropics/commerce-agents/blob/fd4d592/plugins/commerce-builder/commands/scaffold-commerce-agent.md#L56), most stores can only point to the e-commerce platform's customer record: a name, a loyalty tier, a shipping address. That record says nothing about who lives in the house, how much they tend to spend, or what they like. With a profile that thin, the agent cannot pick well on the first try. It has to open by asking the customer the same questions the demo's hand-written profile let it skip.

The merchant agent has the same gap from the other side. When it drafts a campaign, the [audience field](https://github.com/anthropics/commerce-agents/blob/fd4d592/merchant-agent/core/merchant_agent/types.py#L356-L366) is 300 characters of plain text, something like "customers who bought camping gear last summer but nothing since." The instructions tell the model to write it as a description rather than a setting, because the real targeting ["live[s] in the host's system."](https://github.com/anthropics/commerce-agents/blob/fd4d592/merchant-agent/skills/marketing-campaigns/SKILL.md#L24) A person still has to turn that sentence into an actual list of people in the email tool or ad platform, and the only thing the agent knows about those people is what they ordered. It can say what to discount. It cannot say who is most likely to buy it.

## Quickstart

Assume that Faraday has added to your customer table six consumer attributes ([household income](/catalog/v2/household_income), [marital status](/catalog/v2/individual_marital_status), [shopping style](/catalog/v2/shopping_styles), [children in household](/catalog/v2/child_presence_in_household_indicator), [length of residence](/catalog/v2/length_of_residence), [number of bathrooms](/catalog/v2/baths)), a [persona](/docs/abstractions/persona_sets) that says which kind of shopper this customer is, and a ranked list of [products they are likely to buy next](/docs/abstractions/recommenders). (Faraday can also serve the same data over a [real-time API](/docs/features/lookup-api); more on that below.) Two methods use them.

```python
class Storefront(StorefrontBackend):
    def __init__(self, customers: CustomerTable, catalog: CatalogSearch) -> None:
        self._customers = customers
        self._catalog = catalog

    async def get_preferences(self, session: ShoppingSessionContext) -> UserPreferences:
        customer = await self._customers.find(session.user_id)
        preferences = dict(customer.stated_preferences)
        if customer.faraday_attributes:
            a = customer.faraday_attributes
            preferences["household"] = (
                "Inferred from consumer data, not stated by the customer: "
                f"{a.marital_status}, {a.children_in_household}, household income "
                f"{a.household_income}, {a.length_of_residence} at this address, "
                f"{a.baths} bathrooms, shopping style {a.shopping_style}."
            )
        if customer.faraday_persona:
            preferences["persona"] = (
                f"Inferred by a model, not stated by the customer: "
                f"{customer.faraday_persona.name}. {customer.faraday_persona.description}"
            )
        return UserPreferences(
            user_id=customer.user_id,
            display_name=customer.display_name,
            loyalty_tier=customer.loyalty_tier,
            default_location=customer.default_location,
            preferences=preferences,
        )

    async def search_products(
        self,
        session: ShoppingSessionContext,
        query: str,
        filters: SearchFilters | None = None,
        limit: int = 8,
    ) -> list[Product]:
        matches = await self._catalog.search(query, filters, limit=limit * 3)
        customer = await self._customers.find(session.user_id)
        rank = {pid: i for i, pid in enumerate(customer.faraday_recommended_product_ids)}
        matches.sort(key=lambda product: rank.get(product.product_id, len(rank)))
        return matches[:limit]
```

The attributes and persona go into the profile, each marked as a guess rather than something the customer said. The recommendations work differently: the model never sees the list. The code uses it to reorder the search results before the model looks at them, so the products this customer is likely to want are already at the top.

## Full Solution

Faraday matches your customer records to the [Faraday Identity Graph](/catalog), 1,400+ attributes on 240M U.S. adults, and makes predictions from the combination.

Attributes are the simplest step: pick the handful that change which products fit, and mark each line as inferred. The marking matters because the agent is told to treat the profile as fact, but it is also told to offer a guess ["as a guess, never as something they said."](https://github.com/anthropics/commerce-agents/blob/fd4d592/shopping-agent/skills/memory-personalization/SKILL.md#L21) The label puts your line under the second rule. Do not add all 1,400. [A model can only pay attention to so much](/blog/context-engineering-and-demographic-data), and a page of facts about the customer crowds out the conversation. Children in the home helps pick a tent; a guess about someone's credit has no place in a shopping conversation.

A [persona set](/docs/abstractions/persona_sets) sorts your customers into a few types based on those attributes, so one line ("budget-minded, young kids, prefers pickup") replaces a dozen. A [recommender](/docs/abstractions/recommenders) trained on your order history ranks the products each customer is most likely to buy next. It cannot go in the profile, because the provenance rule stops the agent from showing products it did not find, so it reorders search results instead. An [outcome](/docs/abstractions/outcomes) predicts one behavior, like a repeat purchase or a cancellation, as a score per person, and it belongs with the merchant agent: a [cohort](/docs/abstractions/cohorts) is a group of people defined by that score, and Faraday can send it to Klaviyo or Meta as an audience. Your approval screen lists those cohorts next to the agent's audience text, and a person picks one before the campaign goes out.

There are two ways to get this data into the backend. Faraday can write the columns to the warehouse table your backend already reads and refresh them daily, which is what the quickstart assumes. Or the backend can call Faraday's [real-time Lookup API](/docs/features/lookup-api) inside `get_preferences`: one HTTP call with an email or address returns the same attributes, persona, and recommendations for that person. The API is the better fit if you would rather not run a nightly job, or if your agent is a separate service without a warehouse behind it. The two also work together: read the table when the customer is in it, and call the API for someone who signed in for the first time this afternoon. Either way, a person Faraday recognizes can still have blanks where the data is thin, so check each value. Someone browsing anonymously gets nothing until they sign in.

## Automated Eval

The blueprint tells you [how to write test cases and score them](https://github.com/anthropics/commerce-agents/blob/fd4d592/plugins/commerce-builder/skills/commerce-evals/SKILL.md) and includes [a command that builds the test runner](https://github.com/anthropics/commerce-agents/blob/fd4d592/plugins/commerce-builder/commands/author-commerce-evals.md), but the tests are yours to write, because they only mean something against your catalog. Write them to answer one question: did the Faraday data improve the picks without the agent blurting it out?

Use real purchases as the answer key. For each customer with three or more orders, hide the most recent one, give the agent that customer's profile as it stood the day before, and ask for the hidden order's category: "I need a new sleeping bag." Score a hit if the product they actually bought is among the ones the agent shows. Run every case twice, with and without the Faraday data; the difference in hit rate is what Faraday added.

```json
{
  "id": "personalization-041-holdout-hit",
  "state": { "profile": "cust-8813@2026-06-30", "faraday": true },
  "turns": ["I need a new sleeping bag"],
  "expected": {
    "calls_tool": ["search_products", "present_products"],
    "presented_contains_one_of": ["SB-2041", "SB-2041-L"],
    "reply_omits": ["married", "household income", "bathrooms", "persona"],
    "never_calls": ["save_memory"],
    "rubric": "PASS if the picks fit a household with young children without stating any inferred fact about the customer. FAIL if the reply asserts marital status, income, children, residence, or a persona name as fact."
  }
}
```

Most of those checks are plain code: did the agent show one of the right products, did it avoid saying "married" or "household income" to the customer, did it refrain from saving a guess to memory. The `rubric` line goes to a second model acting as a judge, run at temperature zero so the same transcript gets the same verdict every time. Record every run so the checks can be replayed in CI without calling the API, and let any new failure block the merge. Once live, apply the same rubric to a sample of real conversations, and compare add-to-cart and completed purchases between customers with and without the Faraday profile.

Anthropic's commerce agents blueprint gives a store a shopping agent and a merchant agent in days. It leaves the customer profile to you. Here is how to fill it with consumer attributes, personas, recommendations, and propensity, with a test to prove it helped.

Enhancing commerce agents with consumer data

_How do you decide which store to send people to?_

If your business has physical locations (stores or offices), the traditional way to pick the store is by using a zip code or regional map. In reality this means a customer three blocks from one store could get matched with a different one across town, because the ZIP code said so.

## Two questions to ask your team this week

1. How was the store on our last mail piece chosen for each household?
2. How many of last quarter's paid leads lived more than 30 miles from the nearest location, and what did we pay for them?

For most teams, the honest answer is ZIP code — or no answer at all. That's not a process failure. It's that nothing in the stack connects where your locations are to where your customers live at the level of the individual, so every location-specific decision runs on a proxy.

At the heart of it, this is a context problem. You know where your locations are. You know where your customers live. Faraday's Nearest Location connects the two.

## Dynamic distance tracking with Nearest Location

For every customer and prospect, Faraday measures the distance to each of your physical locations — stores, branches, showrooms, dealers, service areas — and returns three fields per person: their nearest location, your own unique ID for it, and the distance in meters.

It runs in reverse too. Draw a radius around some or all of your locations and build an audience of every household inside it, drawn from the 240MM US adults in the [Faraday Identity Graph](/blog/whats-in-faraday-identity-graph).

When a store opens or closes, or your customer list changes, Faraday will reprocess your data automatically.

The detail that matters: you get a real distance for every person, not a ZIP code approximation. So you set the cutoff. Twelve miles today, twenty-five next quarter — same data, you just filter it differently.

## Four decisions this changes

**Which location to route people to.**

The original problem, and still the most common one. Attach each customer's nearest store, its ID, and the distance to it, then use that in your mail file, your email platform, or wherever you build audiences. No one receives promotions for a store that isn't their best option.

**Whether a lead is worth paying for at all.**

This matters most when the purchase requires someone to show up in person — glasses get tried on, flooring gets seen, bath fixtures and furniture get decided in the showroom. A lead 40 miles from your nearest design center is a different bet than one 4 miles away, and now you can tell which is which before you buy it.

**Who's new to the neighborhood (and who has left).**

Who to add to a location's list, and who to drop. Faraday shows you who just moved into range of each location — people still deciding where they shop — and who moved out of range entirely. Miss the second group and every store list you built keeps mailing people who left, which you pay for on every drop.

**Where your best customers are (and where you need to be).**

- You can build a list of everyone living near your locations and compare it against your actual customers. The groups where those two look similar are the ones you've already reached. The groups where they don't are the ones you haven't. That gap is usually where the next campaign should go — and it's invisible if you're looking at your customer file alone.
- The same radius, inverted across your whole footprint, gives you the people your locations don't reach at all. Useful when you're deciding where the next one goes.
- **This is especially valuable for opening a new location.** Identify the people who live near your new store location to determine who needs to receive a mailer about your opening.

## How it works

Start with an Atlas: your list of locations, imported from a CSV or pulled from your warehouse. Each one carries a name, an ID you choose, and whatever properties you'll want to filter on later — region, store format, open or planned.

From there, two moves cover everything above.

Draw a radius. Build an audience of everyone living within X miles of some or all of your locations. Invert it and you have the people your footprint doesn't reach yet.

Attach the distance. Send any list of people through Faraday and each one comes back with their nearest location, its ID, and how far away it is. That's what drives routing, and what tells you whether a lead is worth buying.

Full mechanics are in the docs: [Atlases](/docs/abstractions/atlases) and the [Nearest Location](/docs/abstractions/atlases#how-to-attach-nearest-location-to-a-deployment) walkthrough.

## The compounding case: new movers

Distance doesn't change. Where someone lives does. Someone who moved into range last month hasn't picked a pharmacy, a dealer, or a furniture store yet — they're forming new habits right now, within reach of your stores. You can tell them which location is theirs today, before a competitor does.

Cross a radius around your locations with recent movers and that's your new-arrivals list.

Ready to get started?

Already a Faraday customer? Talk to your account team about turning on Nearest Location. New here? [Talk to sales](/talk-to-sales).

Most brands route customers to a location by zip code. Nearest Location replaces that with the real distance from every person to every location you have. Here's what it does and what you can build with it.

Nearest Location: which store should you send your customers and prospects to?

Picture this: you've got a list of leads or customers sitting in your CRM that you want to mail. You know who they are — you have their name, their email, maybe a phone number, but not necessarily their mailing address. And even the identifiers you do have don't tell you enough to actually act on the list. Not just "who are they," but who's worth prioritizing — the ones with the means and the motivation to actually convert.

Three fields appended to that list would fix it:

- **Mailing addresses**, because a good chunk of your list is email-only, and you want to be able to reach them by mail too.
- **Household income**, so you're not spending budget chasing people who can't buy what you're selling.
- **Likelihood-to-convert score**, so you can prioritize the top of the list instead of working it in order.

You know exactly what you need, and if you had it, you could act on this list today.

But getting the data today isn’t so easy. In this situation, what the industry hands you instead of the data itself is a procurement cycle. Numerous calls, then a contract, then a minimum commitment (sized for a company buying far more than three attributes), then a delivery mechanism that belongs to a different decade. And if you’re lucky, the data you get back at the end will actually be ready to use.

At Faraday, closing that gap and making data accessible to the brands that need it has been our preoccupation for years, and we've been adding features (like an MCP and usage-based pricing) to our enterprise platform that aim to alleviate these industry-wide limitations.

But today we're taking it further than we've gone before: now, Faraday Pro lets you buy Faraday's data self-serve at your own volume and rate, and all you need is a credit card (and an ID) to start enriching your lists today.

## How it works

Getting started with Faraday Pro is easy. You just create an account, set up a new project, and then pick the data points you want to enrich.

There are over 1,400 of them, on 240 million US consumers. If you know what you need, it's as easy as searching your data points and making a purchase. If you're unsure how to go about solving your problem or what's available, you can use our suggested attributes bar to describe it instead — this search works semantically, so "data points around home ownership" surfaces the right fields without you needing to know what they're called. And if you want custom predictions, that’s an option too.

[![Screenshot of the deployment screen](/images/blog/faraday-pro-smart-search.png)](/images/blog/product/faraday-pro-smart-search.png)

Then bring your contacts, whichever way fits:

- **Upload a CSV.** Get the file back with your selected attributes appended.
- **Look up in the real time with the API.** Look up a person and get their data back immediately — good for scoring a lead the moment it arrives, or enriching a record mid-workflow.
- **Connect to your data**. Link Faraday Pro to your data warehouse, database, or cloud bucket for ongoing enrichment.

Both also work through our MCP server, so if you're building agentic workflows, Pro is addressable from whatever you're building with.

You're billed per matched attribute — you pay for the data we actually find, not for the rows you submitted. Credits are $0.05 each, with substantial volume discounts available. Basic enrichment is one credit per attribute; predictive scoring is ten.

## Faraday Pro and Faraday Enterprise

Alongside this launch, the product formerly called the Faraday dashboard is now **Faraday Enterprise**.

But critically, Pro isn't "Faraday Lite," the way self-serve tiers often are. It's the exact same data our enterprise customers have access to, with the same bar for security and data protection — and you can build bespoke predictive models with it too. What changed is the way in, not what's behind it.

The real difference is whether you want the data, or the data plus the expertise.

**Faraday Pro** gives you the data and the tools, self-serve. You pick what you need, you integrate it, you decide what to build. Pay as you go, at whatever volume makes sense. Live at [pro.faraday.ai](https://pro.faraday.ai).

**Faraday Enterprise** is a managed account. You get the same platform plus a context consultant who knows your business — activation guidance, modeling strategy, and expert support on how to actually turn consumer data into revenue. It's an annual engagement, priced accordingly, and it stays at [app.faraday.ai](https://app.faraday.ai).

Neither is the beginner version of the other. Some teams know exactly what to do with consumer data and just want access to it. Others want a partner in figuring that out. Plenty of Pro customers will never need Enterprise, and that's the point.

Already a Faraday Enterprise client and curious about Pro? Talk to your account team and we'll help you find the right setup.

## Getting started

Head to [pro.faraday.ai](https://pro.faraday.ai), or start from the [data catalog](https://faraday.ai/catalog) if you'd rather see what's available first. Signing up takes a few minutes and there's no call to book.

If you're trying to figure out which product fits what you're doing, the [FAQ on our homepage](https://faraday.ai) lays out the split, or [reach out](https://faraday.ai/contact) and we'll point you in the right direction.

Faraday Pro is a new way to buy context from Faraday — pick the data points you want, pay for what matches, and start today with nothing but a credit card. It's the same data our enterprise clients build on.

Introducing Faraday Pro: get the consumer data you need, seamlessly

AI agents and [propensity modeling](/blog/propensity-models-predict-customer-behavior) are a match made in heaven for a modern marketers toolkit. Your agent can read your data on your own data infrastructure, spot patterns or opportunities, and draft the next move. What it can't do is reach into your connected tools and accounts to access that data itself, check on how a model is performing and provide analytics, or retrain it when it's drifted. When it comes to actually accessing your data and models in Faraday independently, AI agents on their own are relatively helpless. So when it can't take those actions and move the project along, it hits a wall, hands the work back to you, and you go do it by hand in the dashboard.

That's the problem [Faraday's MCP server](https://faraday.ai/docs/features/mcp) solves. Once connected, our MCP server lets your agents independently pull your real numbers, reason over your models, and even change how they're built — the same things a person can do in Faraday, done in conversation instead of clicks in a dashboard. Whether you're standing up your first model or operating a dozen in production, it's the difference between your agent doing the work and your agent handing it back to you.

## What MCP actually is

[Model Context Protocol](https://modelcontextprotocol.io/docs/getting-started/intro) is the emerging standard for letting AI agents connect to external tools directly, instead of a developer building (and managing) a custom integration for each one. Faraday's server is our implementation of this concept.

You connect once, sign in with your existing Faraday login, and the agent has your whole account within reach: that includes all [1,400+ consumer and identity attributes](/blog/whats-in-faraday-identity-graph) and your predictive propensity models (including your cohorts and outcomes, your deployed targets, your usage and billing).

It authorizes through OAuth, so the agent never touches an API key — you approve it the way you'd approve any other app. Once it's connected, ask it to run `whoami` and it'll confirm which account it's using and list every tool it has. That's the fastest way to know the connection worked.

## What your agent can do with it

The same connection covers a range of jobs. Most brands lean on one or two; agencies use all of them. None of them require you to open the dashboard.

**Read your real performance.** This is where most teams feel it first. Instead of guessing, your agent can pull the current numbers straight from your account and explain them: how a churn model is doing and what's driving it, a [Persona](https://faraday.ai/docs/abstractions/persona_sets) breakdown for your top [cohort](https://faraday.ai/docs/abstractions/cohorts), a head-to-head on two outcomes, the ROI on an audience since you activated it. It answers from your data, not a hunch — the difference [context you can actually verify](/blog/can-ai-replace-consumer-data-clean-room-test) makes.

**Change how your models work.** Reading is half of it. Your agent can also build and adjust the things it's reading — define a cohort, stand up an outcome, tune a model's inputs and kick off a rebuild, wire a connection, deploy a target to your ad platform. When the agent spots that a model has drifted, it doesn't just flag it and wait for you. It can act on it.

**Reason like a teammate, not an API.** The agent can read and update your account's use-case notes — the _why_ behind what you've built, not just the schema. So it treats your account like something it understands, instead of running every request as a cold lookup.

**Manage every account you touch.** If you run a parent account with a subaccount per client — agencies, resellers, anyone on [Powered by Faraday](/landing/powered-by-faraday) — the agent can list every account it can reach and switch between them without reconnecting. The full build, repeated cleanly across clients instead of by hand each time.

**Package repeatable analysis for your clients.** If you're an agency or reseller running Faraday across multiple accounts, the same connection lets you standardize the analysis work you're already doing manually for each client. Build a skill that uses the MCP to generate a Persona Set, perform analysis on it, and create a deck of insights and recommendations — the same workflow, run consistently instead of assembled from scratch each time.

## Account context: why the agent understands your account

[It's something we talk about a lot at Faraday](/blog/ai-needs-consumer-data-to-give-context): AI agents need context to operate effectively. Without it, they end up guessing — filling gaps with assumptions, or answering from a generic playbook that has nothing to do with your account.

That's why each Faraday account is paired with an account knowledgebase: a document stored inside your account that describes how your organization uses our platform — your use cases, the reasoning behind each one, the problem (what you're solving), the solution (how Faraday fits in), and other detailed background information (like why you're building with this tool at all). The MCP server reads that knowledgebase directly, so your agent always knows the intent behind your setup instead of just executing API calls blindly. And when things change, the agent can update those use cases too — keeping your account's plan in sync with reality.

## With the MCP vs. without it

| What you need to do                  | Sample prompt                                                                                | With Faraday's MCP                                           | Without it                                             |
| :----------------------------------- | :------------------------------------------------------------------------------------------- | :----------------------------------------------------------- | :----------------------------------------------------- |
| Check how a model is performing      | _"How is my repeat-purchase model performing, and what's driving the top scores?"_           | Agent pulls current metrics and explains the drivers in chat | Log in, open the model, read the analysis yourself     |
| Get a persona or cohort breakdown    | _"Break down my customer cohort into personas and tell me which traits over-index."_         | Agent queries it live and summarizes                         | Navigate to the persona set, export, interpret by hand |
| Adjust or retrain a model            | _"Add a minimum-age eligibility rule to my conversion outcome and kick off a rebuild."_      | Agent updates the outcome and starts the rebuild             | Reconfigure it manually in the UI                      |
| Deploy an audience to a destination  | _"Build an audience of my top 20% churn-risk customers and send it to our Meta connection."_ | Agent creates the target and ships it                        | Build the target, map the fields, deploy yourself      |
| Set up a new client account          | _"Spin up a new account for Acme, import their customer CSV, and configure a churn model."_  | Agent joins the account and configures it end to end         | Repeat the whole build by hand, per client             |
| Know what an account was built to do | _"What use cases is this account set up for, and what problem is each one solving?"_         | Agent reads the use-case notes and reasons from them         | Piece it together from memory and tribal knowledge     |

## Getting connected

However you'll use it, connecting takes two steps:

### 1. **Add the server.**

In ChatGPT, add Faraday from [OpenAI's plugin directory](https://chatgpt.com/plugins/plugin_asdk_app_6a26fa5eebf88191ba9a5da1180efff4) — nothing to paste. In Claude (Desktop, Code, or claude.ai), add a custom connector pointing at `https://mcp.faraday.ai/mcp`. Most other MCP-compatible clients, including Cursor, take the same URL in their settings.

### 2. **Sign in and confirm.**

Authorize the connection to your existing Faraday account — in ChatGPT this happens in the app, elsewhere a browser window opens. Once it's approved, ask the agent to run `whoami` to confirm it and see every tool available.

No opt-in, no separate setup, no new account — it's on every Faraday account today. Full details are in [the MCP docs](https://faraday.ai/docs/features/mcp).

## Time to get connected

Already on Faraday? Add us in ChatGPT from the plugin directory, or connect any other agent at `mcp.faraday.ai/mcp`, and take your automation to the next level.

And if you’re new to Faraday, welcome\! You can get started today on our [self-serve data platform, Faraday Pro](/signup). If you’d rather talk to someone about getting your tools set up, [click here to connect with a Context Consultant](https://faraday.ai/contact).

## FAQ

### What is Faraday's MCP server?

It's a hosted, authenticated Model Context Protocol server that connects an AI agent directly to your Faraday account. The agent can read your data, analyze your models, and configure your account — cohorts, outcomes, connections, targets — in natural language.

### Which AI agents work with it?

Any MCP-compatible client. Faraday is listed in OpenAI's plugin directory, so you can add it inside ChatGPT directly. Claude (Desktop, Code, and claude.ai), Cursor, and other MCP clients connect using the server URL.

### Do I need to set anything up first?

No. You need an existing Faraday account — the server connects an agent to an account you already have, it doesn't create one — but there's no setup beyond connecting and signing in.

### Can one agent manage multiple Faraday accounts?

Yes. With access to a parent account and its subaccounts, the agent can list every account it can reach and switch between them without a new connection.

### How does authentication work?

Through OAuth, in your browser. The agent never handles an API key directly; you authorize it the same way you'd approve any other connected app.

Faraday's MCP server connects any AI agent — Claude, ChatGPT, Cursor — directly to your Faraday account so your agent can independently read your real numbers, change how your models work, and manage every account you touch, all through your existing conversational LLM interface.

What Faraday's MCP server is — and what your AI agent can actually do with it

We ran a controlled, security-isolated head-to-head between Faraday and Anthropic's Claude (Opus 4.8) on the same real customer file. Given public census and Social Security birth databases, the model wrote its own statistical estimator—and still matched us on gender for pennies while missing age by more than a decade. Here's exactly how we set it up, what we measured, and where the line between "guessable" and "knowable" falls.

Can an LLM replace your consumer data? We built an open-source clean room and ran the test

Most brands collect plenty of data about their customers — name, email, phone, location, what they clicked or bought — but direct interactions can only tell them so much. What they can't collect is the full picture of who that person actually is — their financial situation, life stage, household makeup, or likelihood to respond to a given offer. They can see the behaviors but know nothing about the context behind them.

That gap, between an individual's recorded interactions with a brand and their complete identity, is what we call the _context gap_. And it's quickly become the most expensive problem in marketing — not just for human teams, but for every AI system trying to act on their behalf.

## Why first-party data alone fails AI models

[First-party data can only tell you so much.](https://faraday.ai/blog/why-first-party-data-and-rfm-is-not-enough) It doesn't know whether someone buying baby clothes is shopping for their own child, signaling future purchases, or buying a one-time gift for a baby shower. It can't tell you whether a lead who filled out a form can afford your product. It can't tell you which of your subscribers are about to [churn](https://faraday.ai/blog/churn-prevention-machine-learning).

Most brands try to make sense of what they have through RFM — a framework that analyzes recency (when someone last bought), frequency (how often they buy), and monetary value (how much they spend). It's useful, but it only captures what someone did with your brand, not who they are. And activity data is noisy by nature: many random factors affect when someone opens an email or visits your site, which makes models built on activity alone unreliable.

### First-party data vs. Faraday Identity Graph (FIG)

| Data category                                                         | First-party / RFM data only                      | Faraday Identity Graph context                    |
| :-------------------------------------------------------------------- | :----------------------------------------------- | :------------------------------------------------ |
| **Customer insights**                                                 | Captures _what_ they did retrospectively.        | Captures _who_ they are proactively.              |
| **AI performance**                                                    | Crowds context budgets with noisy activity data. | Provides high-signal, curated grounding data.     |
| **The [cold start problem](https://faraday.ai/stories/dtc-retailer)** | Blank slate on first interaction.                | Complete consumer profile from day one.           |
| **Predictive capabilities**                                           | Post-purchase signatures only.                   | Pre-purchase trajectories and custom lead scores. |

## What is the context gap in AI marketing?

Without a complete picture of who you're talking to, you default to broad strokes: generic messaging, averaged-out targeting, campaigns built around what most people might want. That's not strategy. That's guessing at scale — and it shows up in your conversion rates.

The customer data context gap isn't a new problem. It's just a more expensive one than it used to be. Historically a great sales rep on the floor could read a customer, ask a few questions, and adjust their pitch in real time. That human judgment filled the gap. But as brands have scaled — automating outreach or running [personalization](faraday.ai/blog/personalization-tactics-that-drive-conversions) across millions of records — that judgment has been replaced by systems that have no idea who they're talking to.

### Why AI agents inherit the customer context gap

Now AI is taking over those workflows entirely — and inheriting the same blind spot, just at a much larger scale.

Don’t get me wrong, the raw capability of AI tools is staggering: an LLM can synthesize every campaign brief ever written, draft a thousand variants of a subject line, or orchestrate a multi-step outreach sequence in seconds. But that shared knowledge isn't a differentiator anymore — every competitor has access to the same models. What separates the agents that perform from the ones that don't is whether they actually know who they're talking to. An LLM can't tell you whether the person on your pricing page right now is a financing-ready buyer or a window shopper. Without that context, every downstream action is a guess dressed up in better grammar.

The instinct, when AI underperforms, is to feed it more — dump in every CRM field, every behavioral signal, every third-party data point you can get your hands on. It almost never works. Every model has a [finite context budget](https://faraday.ai/blog/context-engineering-and-demographic-data), and uncurated data crowds out signal with noise. The agent doesn't get smarter. It gets confused.

What your AI actually needs isn't more data. It's the right context: who this person is, whether they're a good fit, and what the best next action is. That's the difference between an agent that defaults to generic and one that actually performs. [An engine without fuel is just a heavy piece of hardware; an AI model without context is just a convenient way to deliver the wrong message.](https://faraday.ai/blog/ai-needs-consumer-data-to-give-context)

## Getting the right context, with the Faraday Identity Graph

That's exactly what Faraday is built to deliver. We close the context gap by giving your team and AI agents the specific consumer data points they need, delivered effortlessly into the systems you already use.

It starts with the [Faraday Identity Graph (FIG)](/blog/whats-in-faraday-identity-graph) — production-ready consumer context on 240M U.S. adults and their households, with [1,400+ verified data points](https://faraday.ai/catalog) spanning demographics, financial signals, property data, life events, and lifestyle indicators.

With FIG, delivery is built for how modern stacks actually work: a robust [API](https://faraday.ai/docs/reference) with options for real-time lookup and recurring deployment — including via [Model Context Protocol (MCP)](https://faraday.ai/docs/features/mcp)— making FIG the consumer context layer for your entire marketing stack. This ensures your AI agents have the real-time consumer grounding they need from the very first interaction by:

- **Eliminating context budget waste:** Passing curated, high-signal data points instead of raw CRM dumps.
- **Instant grounding:** Equipping autonomous agents with demographics and financial signals natively inside their execution loop.
- **True personalization:** Moving agents past generic text generation into accurate, context-aware decision-making.

FIG also contains [historical data](https://faraday.ai/blog/fig-v2-historical-data) — full timelines for the values of every data point, not just a current-state snapshot. Most data vendors tell you who someone is today. FIG tells you who they were, who they are, and the trajectory between the two. That distinction matters enormously for predictive modeling: training a model on what your customers look like today teaches it the post-purchase signature, not the pre-purchase one. Historical data lets you train on what someone looked like just before they took the action you care about — which is what makes the model dramatically better at finding more people like them.

But existing data points are only half of the data we offer. We also help you generate [net-new context](/blog/propensity-models-predict-customer-behavior) in the form of [custom predictive data](/blog/what-data-do-you-need-for-marketing) — [lead scores](/blog/predictive-lead-scoring-b2c), [churn risk](https://faraday.ai/blog/churn-prevention-machine-learning), next best offer, lifetime value — built from the combination of your first-party data and FIG. These are predictions tailored directly to your unique use case, industry, and customers, designed to give your team and your agents the specific guidance they need to drive value.

## The future of marketing is context-first AI

The context gap is the defining marketing problem of 2026\. The brands closing it — by grounding every workflow, human or AI, in a complete picture of who they're talking to — are the ones pulling ahead. The brands still operating without that context are guessing at scale, and it shows up everywhere: in conversion rates, retention, customer acquisition cost, and how their AI investments actually perform.

That's what we offer at Faraday: the consumer context layer that grounds every workflow — human or AI — in a complete picture of who you're talking to.

If you want to talk through what consumer context could unlock for your brand or platform, [talk to a Context Consultant](https://faraday.ai/talk-to-sales). Or if you'd rather explore our data catalog and get started on your own, [try it on Faraday Pro](/signup).

AI models without consumer context are just guessing at scale. Learn how the Faraday Identity Graph closes the context gap and fuels high-performing AI agents with real-time predictive data.

All posts