How Self-Models Work

TL;DR

• A self-model is a persistent, structured representation of what an AI product understands about an individual user: their beliefs, preferences, expertise, and goals, each tracked with confidence scores
• Unlike chat logs or user profiles, self-models evolve through interaction. They get more accurate over time, handle contradictions, and decay stale information
• Self-models enable AI products to move from generic to genuinely personal, compounding value with every interaction instead of resetting to zero each session

Self-models are persistent, structured representations of individual users that give AI products the ability to understand, not just remember. The concept draws on decades of user modeling research [1] and addresses the core limitation of current AI products: they accumulate data without accumulating understanding. This post explains what self-models are, how they work under the hood, and why they represent a fundamental shift in how AI products relate to users.

The Problem Self-Models Solve

Every AI product faces the same fundamental challenge: users interact dozens or hundreds of times, but the product never gets meaningfully better at understanding them.

Chat history grows linearly but does not convert into understanding. User profiles capture demographics but miss what users actually think, need, and care about. Recommendation engines track behavior but confuse what someone clicked with what they wanted [2].

The result is the convergence problem [3]. After the first few interactions, most AI products plateau. Conversation 100 feels the same as conversation 10. The AI has more data but no deeper understanding. Users notice, and they leave.

Self-models solve this by introducing a structured layer between raw data and AI behavior. Instead of storing what happened (logs) or what a user looks like (profiles), a self-model stores what the product understands about the user: what they believe, what they know, what they prefer, and how confident the product is in each of those assessments.

What a Self-Model Contains

A self-model has three core components.

Beliefs. Structured statements about what the user thinks, knows, or values. Each belief has a confidence score (0.0 to 1.0) that reflects how much evidence supports it. A belief like “this user prefers concise technical explanations” might start at 0.4 after a few interactions and climb to 0.85 after consistent reinforcement across dozens of conversations.

Observations. The raw evidence that beliefs are derived from. Every interaction, every choice, every piece of feedback becomes an observation. Observations are the input; beliefs are the distilled output. The self-model maintains the link between them, so every belief is traceable back to the evidence that formed it.

Contexts. Dimensions that organize beliefs and observations into meaningful categories. A user might have beliefs tracked across contexts like “technical expertise,” “communication style,” “domain knowledge,” and “goals.” Contexts allow the self-model to provide relevant understanding without dumping everything into the AI prompt.

1// A self-model for one user← Persistent, structured, evolving
2const selfModel = await clarity.getSelfModel(userId);
3
4// Beliefs with confidence scores← Not guesses. Tracked evidence.
5selfModel.beliefs = [
6  { statement: "Prefers concise answers", confidence: 0.87, observations: 14 },
7  { statement: "Expert in distributed systems", confidence: 0.72, observations: 8 },
8  { statement: "Evaluating for enterprise deployment", confidence: 0.65, observations: 5 },
9];
10
11// Inject into any AI interaction← The AI now knows who it is talking to
12const response = await llm.generate({
13  systemPrompt: buildPrompt(selfModel),
14  userMessage: currentMessage,
15});

How Self-Models Evolve

Static profiles are written once and decay. Self-models are designed to change.

The Architecture

Self-models sit between the data layer and the AI layer. They consume observations from any source (conversations, clicks, feedback, API events) and produce structured understanding that any AI interaction can use.

1// 1. Observe: capture any user interaction← Feed the self-model
2await clarity.observe(userId, {
3  context: "product-usage",
4  observation: "User exported data to CSV for the third time this week",
5});
6
7// 2. The engine updates beliefs automatically← Belief extraction happens server-side
8// → Belief formed: "Prefers bulk data export workflows" (conf: 0.6)
9// → Existing belief reinforced: "Power user, data-oriented" (conf: 0.7 → 0.78)
10
11// 3. Retrieve understanding for any AI interaction← Inject into prompts, recommendations, UX
12const model = await clarity.getSelfModel(userId);
13const relevant = model.beliefsForContext('product-usage');

Why Self-Models Are Different from Alternatives

Self-models vs. chat history. Chat history stores what was said. Self-models store what it means. A thousand messages in a chat log do not tell an AI that the user is a senior engineer evaluating for enterprise deployment. A self-model with three high-confidence beliefs does.

Self-models vs. user profiles. Profiles are static snapshots written by the user or inferred once. Self-models evolve continuously. A profile says “role: engineer.” A self-model says “expert in distributed systems (confidence 0.72, based on 8 observations), currently evaluating orchestration tools (confidence 0.65, based on 5 observations), prefers concise technical answers (confidence 0.87, based on 14 observations).”

Self-models vs. fine-tuning. Fine-tuning bakes user preferences into model weights. This is expensive, slow to update, and creates one model per user (or per cohort). Self-models are runtime context: fast to update, cheap to store, and immediately effective. Research shows fine-tuning also risks catastrophic forgetting [4], where learning new preferences destroys previously learned capabilities.

Self-models vs. RAG. Retrieval-augmented generation retrieves relevant documents. Self-models retrieve relevant understanding about the person asking. RAG answers the question “what information is relevant?” Self-models answer the question “who is asking, and what do they need?” [5] The two are complementary, not competing.

Privacy and Transparency

Self-models are designed to be user-owned and transparent.

Users can see their model. Unlike opaque recommendation algorithms, a self-model is inspectable. Users can see what the product believes about them, how confident it is, and what evidence formed each belief. This is not a feature. It is a design principle.

Users can correct their model. If the product got something wrong, the user can correct it. This is more powerful than it sounds: it turns user feedback from a complaint channel into a calibration mechanism. Every correction makes the model more accurate.

Users can delete their model. Full data portability and deletion. The self-model belongs to the user. This is not just good ethics; it builds the trust that makes users willing to let the product learn about them in the first place. Research shows 92% of consumers trust brands more when they are transparent about data use [6].

No PII required. Self-models track beliefs, not identity. “Prefers concise answers” and “expert in distributed systems” are understanding, not personal data. The model can be deeply useful without storing names, emails, or demographic information.

What This Means for Products

Products built on self-models compound value over time. Each interaction makes the product more useful for that specific user. This creates organic switching costs: users do not want to leave because they would lose months of accumulated understanding. Research from Bain shows that a 5% increase in retention can boost profits by 25-95% [7].

The first interaction with a self-model-aware product is roughly equivalent to any other product. The tenth is noticeably better. The hundredth is incomparably better. This is the compounding advantage that turns a good product into an irreplaceable one.

Build With Self-Models

Clarity provides the Self-Model API that handles the full pipeline: observation ingestion, belief extraction, confidence tracking, contradiction handling, and context injection.

1import Clarity from '@clarity-api/sdk';← npm install @clarity-api/sdk
2
3const clarity = new Clarity({ apiKey: process.env.CLARITY_API_KEY });
4
5// Create a self-model for a user
6const model = await clarity.createSelfModel({
7  userId: "user_123",
8  contexts: ["expertise", "goals", "preferences"],
9});
10
11// Observe interactions
12await clarity.observe('user_123', {
13  context: "expertise",
14  observation: "Asked detailed questions about distributed consensus algorithms",
15});
16
17// Retrieve understanding
18const selfModel = await clarity.getSelfModel('user_123');
19// selfModel.beliefs → structured, confidence-weighted understanding
20// selfModel.contexts → organized by dimension
21// selfModel.observations → traceable evidence chain

References

1. User Modeling and User Profiling: A Comprehensive Survey (Purificato et al., 2024)
2. Scientific American: How Recommendation Algorithms Work and Why They May Miss the Mark
3. Forethought: Why Are Some Chatbots Still Bad?
4. Luo et al.: An Empirical Study of Catastrophic Forgetting in Large Language Models During Continual Fine-tuning
5. Letta: RAG is Not Agent Memory
6. California Management Review: Balancing Personalized Marketing and Data Privacy in the Era of AI
7. Bain & Company: Retaining Customers Is the Real Challenge
8. User Modeling in the Era of Large Language Models (Tan and Jiang, 2023)
9. Guided Profile Generation for Personalization (USC, 2024)
10. PersonaMem: Benchmarking LLM Personalization (2025)

Related

• Memory Is the New Moat
• Self-Models vs Fine-Tuning
• RAG Is Not Personalization