Per-User Models Beat Cohort Segmentation

TL;DR

• Cohort segmentation groups users into buckets and serves each bucket an average experience, flattening the individual differences that actually drive retention and conversion
• Per-user models (N=1) build a unique structured understanding of each user that evolves with every interaction, and the compute cost is now lower than maintaining segment infrastructure
• The architectural shift from segments to self-models eliminates segment sprawl, reduces engineering overhead, and produces measurably better personalization

Per-user models beat cohort segmentation because they build unique, evolving understanding of each individual rather than serving the average experience for a group of thousands. As Bluecore’s research puts it [1], “segmentation does not equal personalization.” Where segmentation targets groups, personalization targets individuals at scale [2]. This post covers why N=1 personalization is now computationally feasible, the architecture for replacing segments with self-models, and the engineering overhead reduction that comes from eliminating segment sprawl.

How Cohort Segmentation Actually Works

The standard architecture looks like this. You collect behavioral data: clicks, page views, feature usage, purchase history. You run that data through a classification pipeline that assigns each user to one or more segments. Then your application layer reads those segment assignments and serves content, features, or experiences accordingly.

The problem is not the classification step. Modern ML can cluster users accurately. The problem is what happens after classification.

Once a user is assigned to a segment, they receive the experience designed for the average member of that segment. A power user segment might include someone who uses your product eight hours a day for deep analysis and someone who uses it two hours a day for quick reporting. Both get the “power user” experience. Their actual needs are fundamentally different, but the system cannot see that because the segment is the resolution limit. As Scientific American explains [3], personal taste is nuanced. Just because someone liked a particular film does not mean they like all films in that genre, yet group-based systems assume otherwise.

As products mature, teams respond by adding more segments. Four becomes twelve becomes forty-seven. Each new segment spawns its own rules, A/B tests, content variants, and feature flags. The personalization system becomes a configuration management problem. As the challenges of implementing segmentation strategies compound [4], engineering time shifts from building product to maintaining segment logic.

Why N=1 Is Now Computationally Feasible

Three technical shifts made per-user models practical at scale.

Inference cost collapse. According to Andreessen Horowitz’s analysis of “LLMflation,” [5] the cost of equivalent LLM inference is decreasing by roughly 10x every year. What cost $60 per million tokens in 2021 costs $0.06 today. Epoch AI’s research [6] shows the decline rate ranges from 9x to 900x annually depending on the benchmark, with the fastest drops occurring after January 2024. This means maintaining a structured belief model per user is now trivially cheap compared to the engineering cost of managing segment classification tables.

Structured state over raw embeddings. Early per-user approaches tried to maintain a unique embedding vector per user. This was expensive, hard to interpret, and difficult to update incrementally. Self-models use structured beliefs with explicit confidence scores and observation counts. Updating a belief is a targeted operation, not a full re-embedding.

API-first delivery. Instead of maintaining personalization logic in your application code (where segment rules live), per-user understanding lives in an external API. Your application asks the API what it knows about a user and adapts accordingly. The personalization logic is a query, not a configuration.

The Architecture in Practice

Here is what the integration looks like. Instead of checking segment membership, you query the user’s self-model and let their individual beliefs drive the experience.

1// Old: Check segment membership← Cohort approach
2const segment = await getSegment(userId);
3if (segment === 'power-user') { showAdvancedDashboard(); }
4else if (segment === 'casual') { showSimplifiedView(); }
5
6// New: Query user's self-model← N=1 approach
7const selfModel = await clarity.getSelfModel(userId);
8const beliefs = selfModel.beliefs;
9
10const prefersDepth = beliefs.find(
11  b => b.domain === 'workflow'
12)?.confidence > 0.8;← Individual belief, not bucket
13
14const isTimeConstrained = beliefs.find(
15  b => b.domain === 'context'
16)?.confidence > 0.7;
17
18// Same user can prefer depth AND need speed← Segments force a choice. Self-models capture both.
19if (prefersDepth && isTimeConstrained) {
20  showDetailedDashboardWithQuickActions();
21}

The key difference is in the comment: same user can prefer depth AND need speed. Segments force users into one bucket. Self-models capture the full complexity of individual preferences, and those preferences have confidence scores that update with every interaction.

What Happens When You Eliminate Segments

When you replace segment-based personalization with per-user models, three things change.

Engineering overhead drops. No more segment rules to maintain. No more cross-segment A/B tests to coordinate. No more migration logic when segment definitions change. The self-model API handles all of this as a continuous process.

Personalization accuracy increases. Instead of serving the average experience for a segment of thousands, you serve an experience informed by what you actually know about this specific user. McKinsey’s research on personalization [7] found that companies excelling at personalization generate 40 percent more revenue from those activities than average players, and that personalization most often drives 10 to 15 percent revenue lift overall. Moving from segment-level to individual-level understanding is a key driver of that gap.

The system gets smarter over time. Segments are static until a team manually redefines them. Self-models update with every interaction. A user who was a casual user last month but has been doing deep analysis this week gets an experience that reflects their current behavior, not their historical segment assignment. This mirrors the direction platforms like Spotify are heading with their individual Taste Profiles [8], which capture personal habits and “vibes” rather than placing users into genre buckets.

Three Steps to Move Beyond Segments

1. Audit your current segment overhead. Count your segments. Count the engineering hours spent maintaining segment rules, A/B tests, and content variants per segment. This is your baseline cost. Most teams are surprised by how much infrastructure supports their segmentation logic.

2. Run a parallel test. Pick one user journey: onboarding, feature discovery, or upgrade conversion. Run your existing segment-based personalization alongside per-user self-model personalization for the same cohort. Measure engagement depth, task completion, and conversion at 30 and 60 days.

3. Talk to us about replacing your segment infrastructure. The migration from segments to per-user models is less disruptive than maintaining the segment sprawl that accumulates every quarter.

References

1. Bluecore’s research puts it
2. personalization targets individuals at scale
3. Scientific American explains
4. As the challenges of implementing segmentation strategies compound
5. Andreessen Horowitz’s analysis of “LLMflation,”
6. Epoch AI’s research
7. McKinsey’s research on personalization
8. individual Taste Profiles
9. Progress Software describes this core tension well

Related

• Three Layers of AI Personalization Architecture
• Scalability Problems in AI Personalization
• Building AI That Adapts to Each User