The Death Certificate of SaaS 1.0 CRM — Boutique Clienteling Is the First Domino

OpenAI’s `text-embedding-3` costs $0.02 per million tokens. In 2022 the equivalent was ~$2. That’s a 100× cost collapse in 36 months.

This matters because the central architectural decision of an AI-native CRM — storing every email, note, and meeting as a vector that can be semantically retrieved — was a luxury until the day it wasn’t. Attio’s entity resolution layer, the thing that quietly lets it know “台積電 = TSMC = Taiwan Semiconductor” without a rulebook, costs pennies per thousand contacts now.

In May 2025 Salesforce rewrote Agentforce’s entire pricing model, mid-flight.

• Salesforce claimed 18,500 Agentforce deals signed. Their own earnings disclosures clarified only 9,500 were paid — a 51% conversion from “closed” to “actually generating revenue.” • Simple-task success rate: 58%, per Salesforce’s own benchmark. • Oliv.ai’s independent analysis of 50+ B2B deployments: 77% failed to reach production. • Analysts downgraded Salesforce stock in late 2025, naming Agentforce as “distracting Salesforce’s core business.” • CX Today described Salesforce’s 2025–2026 acquisition spree as “reading like a checklist of Agentforce’s known weaknesses.”

This is not “early days.” This is a post-mortem in real time, with the patient still walking around.

Between 2024 and 2026, LVMH, Kering, and Zegna publicly moved clienteling AI in-house.

• LVMH’s MaIA handles 2 million requests per month across 40,000 employees. • Kering Luce claims +15–20% AOV uplift on pilot deployments. • Zegna X already drives 45% of boutique revenue through its own digital clienteling layer.

Houses that have bought every CRM on earth for 20 years decided in 2024 that the vendors weren’t going to catch up in time. That’s not a ringing endorsement of the category.

The alignment of these three — embedding economics collapsing, Agentforce publicly stalling, and luxury maisons defecting to in-house builds — made 2026 the inflection year. Not 2024. Not 2028.

Before (Salesforce/HubSpot): AI lives in a panel. You click “Generate summary” or “Suggest next action.” The AI is a tool you visit.

After (Attio): AI is a column. A Member record has `[AI] churn_risk`, `[AI] spending_preferences`, `[AI] recommended_action` — fields that recompute every time underlying data changes. You never click anything.

I wrote this in my own Loomr design doc before I saw Attio describe it: *“AI is not a ‘feature you go to’ — it’s a field type. Every time you open a record, AI fields auto-update based on the latest data.”* The moment you frame AI as data rather than as a feature, half of SaaS 1.0’s UX vocabulary stops making sense.

Before: Salesforce gives an LLM the Account.Name and the Stage=Negotiation field, then hopes the LLM hallucinates something coherent.

After: When you open a customer record, the system has already retrieved the last 10 emails, the 3 meeting transcripts, the open support tickets, and the last campaign response — as a vector-similarity package — before your click finishes loading.

The difference a sales rep feels: SaaS 1.0 gives you *“Dear [First Name], I hope this email finds you well.”* SaaS 3.0 gives you *“Following up on the concern you raised last Tuesday about implementation timing — I checked with our team and...”*

Before: `IF spend > $10,000 AND tier = Silver THEN upgrade_to(Gold)`. Brittle rules written by a CRM admin two years ago, never revisited, silently wrong for 30% of edge cases.

After: The workflow trigger fires and an agent node — not an if/else — looks at spending trend, category shift, frequency change, seasonality, churn signals, and then decides. The rule file is replaced by a prompt and a set of action tools.

I’ve watched SAs at boutiques I designed for write rules, forget they’d written them, and then be surprised when a VIP got an automated message during a sensitive negotiation. The automation was the problem. Removing the automation and putting judgment in the loop is the only fix.

Before: Open reports → set filters → pick date range → choose segment → sort → export.

After: Type “Which VIP members had declining spend last month and haven’t been contacted?” → interactive result you can drill into.

Attio’s Series B announcement put this most plainly: they raised to scale “the first AI-native CRM for go-to-market builders” — language that only makes sense if you believe the substrate, not the UI, is the product.

The asymmetry isn’t that 3.0 has NL query and 1.0 doesn’t — it’s that NL query on a SaaS 1.0 schema routinely returns wrong answers, because the underlying data model was never designed to be queried this way.

This is the paradigm I missed when I first sketched Loomr. I had four paradigms and a working prototype, and then I tried to deploy it into a real boutique’s reality and discovered that the boutique didn’t have a clean stack to integrate with.

Before: “Integration” means writing API connectors. Mulesoft adapters for Salesforce. Custom OAuth flows for HubSpot. The CRM is a hub, and everything else needs to plumb into it through structured endpoints.

After: Integration is ingestion of unstructured data. The CRM doesn’t need a Cegid API connector — it needs to read a Cegid CSV export, a screenshot of the POS dashboard, and the WhatsApp thread between the SA and the VIP, and stitch them into a coherent customer record.

The boutique reality: a small luxury watch dealer in Hong Kong runs Cegid for POS, Shopify for ecommerce, WhatsApp Business for VIP communication, an iPad notes app for SA call logs, and a paper logbook for repairs. This is the median stack, not the worst case. SaaS 1.0 says “we need 5 integrations.” SaaS 3.0 says “we need to ingest 5 unstructured streams.”

I’ll call this Headless Clienteling because it’s the same insight headless commerce had a decade ago: stop assuming the system of record owns the surface area where the relationship actually happens. The relationship happens in WhatsApp, Instagram DMs, in-store conversations, WeChat voice notes. SaaS 3.0 lets the CRM listen wherever the relationship lives and never asks the user to migrate anything.

The hard part of building a boutique clienteling product isn’t writing a vector database query. It’s deciding what to do with a smudged photo of a handwritten alteration order and a 40-second WeChat voice memo in Cantonese.

The Agentforce numbers from Section 01 tell the surface story. The architectural reason underneath is that Salesforce’s data model was designed in 2005 for relational integrity and AppExchange compatibility. Every custom field is a migration. Every schema change risks breaking 2,000+ partner integrations.

This isn’t a refactor. It’s an amputation.

But here’s the more aggressive framing. Salesforce isn’t trying to catch Attio. Salesforce is running a janitorial operation on 20 years of accumulated data debt. Salesforce’s own research has consistently found that reps spend roughly 72% of their time on non-selling activities — data entry, field updates, report building, admin tasks. That number hasn’t meaningfully improved in a decade despite billions invested in automation.

77% of B2B Agentforce deployments fail (Oliv.ai) not because the agent can’t reason, but because the data it reasons over is garbage.

Loomr, Attio, and Day.ai don’t have this problem because their substrate is self-cleaning by design. When AI is a field type, the field updates itself. When context is prepared automatically, there’s no stale snapshot. When agents replace if/else, there’s no rule file to maintain. When integration is ingestion, there’s no API breakage when the source system updates.

A CRM that needs constant cleaning is a janitorial CRM. A CRM you never have to clean is a substrate. These are not the same product.

This is the subtext of every Agentforce deployment conversation: the AI doesn’t work without the data layer, the data layer doesn’t work without buying more modules, and the modules don’t work without admin hours nobody has.

Breeze ships, users don’t hate it, and it’s integrated into HubSpot’s surfaces. The problem: the most valuable features sit behind the highest-tier pricing. The data model is still the old HubSpot data model — the context a Breeze agent gets is still the same thin layer a Salesforce Einstein agent gets. HubSpot’s architectural decisions are 10 years younger than Salesforce’s, which is why Breeze feels less broken — but the gap to Attio is the same structural gap.

Dynamics 365’s Sales Copilot works. It’s also the same Copilot that ships with Word and Excel. Microsoft’s bet is “we’ll win because our AI is free when you already pay for Office.” This is a distribution play, not an architecture play. It’ll work for enterprises that standardize on Microsoft. It won’t work for boutiques that don’t have Office 365.

None of these three are stupid companies. They solved a 2005–2020 problem better than anyone. The thing that’s killing them in 2026 is the same thing that won them 2015: a relational data model with rigid schemas and rule-based automation, tightly integrated with a large partner ecosystem that now acts as ballast.

Size makes this harder, not easier.

Day.ai’s founder, ex-HubSpot CPO Christopher O’Donnell, frames it: *“This is the Cursor for CRM, it’s the same pattern.”* Read that literally. Cursor won by rewriting the substrate developers work on top of, not by making a better IDE. Day.ai’s thesis is that the CRM substrate is due for the same rewrite — vertical-by-vertical, with the incumbent’s generality becoming a liability rather than an asset.

The headline everyone misses: the biggest luxury buyers in the world built in-house rather than buy. LVMH MaIA, Kering Luce, and Zegna X are not experiments. They’re production systems handling millions of requests and driving double-digit AOV uplift. This means:

1. Every vendor’s luxury sales pitch in 2026 now competes against an internal build that’s already running 2. The signal “luxury houses build rather than buy” is the single loudest market diagnosis of existing vendor quality 3. This trend stops at the tier-1 houses. A 4-store boutique brand cannot build MaIA. They are the abandoned middle.

I searched — and could not find a single pure-play AI-native CRM targeting independent boutiques in 2024–2026. The signals coming out of the existing players are not “we’re building toward this.” They’re the consolidation of the desperate:

• Tulip and Salesfloor merged in March 2026 to form “the largest global provider of AI-powered customer engagement solutions.” Two competitors merging into the “largest” provider is the language of survivors, not winners. This is blood in the water. • Cegid’s G2 reviews include “how NOT to design a program for retail” and “crashes during sales.” • Farfetch Platform Solutions — which had Harrods, Balenciaga, and Saint Laurent as clients — was shut down by Coupang in 2025.

The pattern: the old guard can’t innovate, so it’s scaling for survival. Mergers, layoffs, shutdowns. These aren’t signs of a category being defended. They’re signs of a category being abandoned.

The question to ask in your next roadmap meeting: “Can a user run this product without ever seeing our primary UI?”

If the answer is no — if your product is fundamentally a set of views over a database that require human navigation — you are building SaaS 1.0. Adding an AI button to the top-right corner doesn’t change this.

A red flag: the last time you added a custom field to your main entity, it took more than a day to reach production. The second red flag: your “AI feature” is an LLM call that ignores the user’s historical context.

What you can actually do: propose an internal hackathon project where your company builds a pure agent-addressable API surface over your existing data model. Not to ship — to see whether it’s even possible.

The habit that needs to die: designing schemas as immutable.

For 10 years I designed clienteling products where adding a new field was a ticket, a sprint, and a training session. In Attio’s world, a user tells the system “I want to track each customer’s preferred communication channel” and it’s done.

The new skill to invest in: prompt design for agent workflows. The designer’s job is moving from “where does the button go” to “what should the agent optimize for.” This is more like writing a product spec than designing a screen.

When I first saw Attio, I felt a specific kind of sick — the feeling of realizing that a skill I’d spent years sharpening was becoming less valuable. It took me a few weeks to figure out the honest response: the skill wasn’t the IA decisions. The skill was understanding what a sales associate at a luxury boutique actually needs to do their job. That’s still valuable. The IA decisions were the wrong layer to protect.

The niche most likely to tip first is independent luxury boutique clienteling. The 2-year window is wide open because three preconditions are met:

1. Incumbents are dying or merging (Cegid, Farfetch Platform, Tulip+Salesfloor) 2. The biggest buyers have defected to in-house, freeing the vendor market from their demands 3. There is no SaaS 3.0 native entrant targeting this segment

The honest risk: boutique owners are not tech-first buyers. Sales cycle is relationship-driven, not demo-driven. You need to actually walk into stores and build trust one boutique at a time.

In luxury, taste is a technical requirement called Brand Alignment. A SaaS 1.0 CRM has no concept of brand voice. A bolt-on AI speaks in generic corporate English: *“Dear Mr. Tanaka, thank you for your continued patronage.”* Brunello Cucinelli doesn’t talk like that. Hermès doesn’t talk like that.

Loomr’s defensible wedge: let a boutique upload their lookbooks, training manuals, brand guidelines, and historical SA-to-VIP correspondence, and use that corpus to fine-tune the agent’s voice. Not “what to say” — “how a brand like ours would say it.”

SaaS 1.0 has no path to this because their data model has no concept of brand voice as a first-class entity. SaaS 3.0 horizontals (Attio, Clay) don’t optimize for it because their target customer is a B2B SaaS sales team. The wedge for a vertical luxury entrant is exactly this gap.

I am building Loomr — a prototype that tries to test whether the five paradigms above are buildable by a solo designer in a constrained vertical, with brand voice as the defensible layer. I’m not claiming it’s the answer. I’m claiming the attempt is worth making, and I couldn’t find anyone else making it.

• 0–3 yes: You’re early. Keep watching. You still have time to plan. • 4–6 yes: You’re in the danger zone. Start running experiments now — your window is 18 months. • 7–9 yes: The rewrite is already happening to your category. Exit options are narrowing every quarter. • 10–12 yes: You are the Salesforce of your category, and it’s 2012 and Slack hasn’t launched yet.