LLM-Maintained Dynamic User Profiles: Synthesis vs. Event Accumulation

Executive Summary

Every system that tries to remember a person eventually confronts the same fork in the road: keep appending what happened, or periodically rewrite what it means. Append-only event logs are simple, auditable, and lossless, but they degrade retrieval as they grow, surface contradictions with no arbitration mechanism, and force the consuming LLM to re-derive "who this person is" from scratch on every read. Synthesized profiles — a small set of dimensions (role, goals, preferences, communication style, open threads) that get rewritten as new information arrives — solve the compression and freshness problem but introduce a different failure mode: LLM-driven consolidation is lossy and, per recent research, can make memory actively worse than no memory at all if left unchecked. The state of the art across both industry (ChatGPT's two-tier "saved memories" + "chat history synthesis," Anthropic's memory tool, Zep/Graphiti's bi-temporal graphs) and research (MemGPT/Letta's self-editing core memory, generative agents' reflection trees, Mem0's ADD/UPDATE/DELETE/NOOP controller) converges on a hybrid: retain a durable, low-level event/episodic record as the source of truth, and layer a periodically-regenerated, dimensioned synthesis on top for fast injection into context — with explicit temporal metadata to defuse staleness, and an increasingly common pattern of separating human-owned/protected fields from model-writable ones. A dimension-based portrait (role, work threads with last-confirmed dates, concerns/asks, blocker patterns, style) plus a protected human-owned "background" field sits squarely in this convergent design space; its two key choices — dating each claim rather than timestamping the whole profile, and hard-partitioning ownership rather than relying on prompt instructions — track what the research literature identifies as the two highest-leverage mitigations for synthesis's core risks.

How Production Systems Maintain User Profiles

ChatGPT runs a genuinely two-tier system. "Saved memories" are explicit, user-triggered facts ("remember I'm vegetarian") that persist until deleted and are fully auditable in a settings list. Layered on top since mid-2025 is "reference chat history," which OpenAI itself has described as analogous to human sleep-consolidation: the model periodically reviews past conversations in the background and synthesizes inferred memories — communication preferences, professional context, recurring goals, "values and tone" — into what OpenAI now calls a memory summary, "a standing profile" rather than a list of facts (OpenAI, OpenAI Help Center, Shlok Khemani, "ChatGPT Memory and the Bitter Lesson"). Crucially, this second layer is not independently inspectable as a list the way saved memories are — only a rolled-up "memory summary" is shown, and users edit it by typing free-text corrections rather than deleting individual facts. Simon Willison's widely-cited critique captures the downside: a system that builds an opaque model of the user without giving them the underlying model to inspect, with "context collapse" bleeding work, family, and hobby context together (Simon Willison, TechCrunch).

Anthropic's Claude took a more mechanistic, developer-controlled route: a client-side memory tool where Claude explicitly reads/writes files under a /memories directory it manages itself, checking memory before each task and persisting what it learns as discrete files rather than one rewritten blob, with per-project isolation (Claude Platform Docs, VentureBeat). This is closer to MemGPT's file-based self-editing than to ChatGPT's synthesized-summary model — the "profile" here is an emergent property of many small files rather than one canonical document.

Character.AI, by contrast, illustrates the low end of the spectrum: an intentionally shallow ~400-character "memory box" plus five pinned messages per character, explicitly chat-scoped rather than global — a design that traded persistence for the ability to scale to millions of concurrent characters (Character.AI blog, KinthAI). It's a useful negative case: companion apps that want emotional continuity (Replika-style products, generally) tend to converge back toward some synthesized-persona model precisely because raw pinned snippets don't scale into "this AI knows me."

Academic and Open-Source Memory Systems

MemGPT/Letta (Berkeley, 2023) framed the LLM as a memory-constrained OS process: a small in-context "core memory" (persona + human blocks) that the agent edits via function calls, backed by out-of-context "archival" and "recall" storage it pages in and out. The key move is that the agent itself rewrites its own persona and human-facts blocks as it learns — self-editing memory rather than an external pipeline (Letta Docs, lmatlas.com).

memU (NevaMind-AI) stores memory as Markdown documents organized into topic-based "memory" and procedural "skill" tracks, with a three-layer model (RecallFile → RecallFileSegment → Resource). Its notable mechanism is reconciled indexing: when a profile file is re-committed after an update, only changed lines are re-embedded — unchanged lines keep their vectors — making profile rewrites computationally cheap and, implicitly, diff-able (memU GitHub).

Mem0 runs a three-stage extraction → consolidation → retrieval pipeline: for each new candidate fact, an LLM-based controller compares it against the top-k most similar existing memories and classifies the operation as ADD, UPDATE, DELETE, or NOOP — an explicit, per-fact contradiction-resolution step rather than a wholesale rewrite. Its graph variant (Mem0g) stores typed entities and relations in Neo4j for relational/temporal queries at roughly double the token cost (Mem0 arXiv paper).

Zep/Graphiti goes furthest on temporal rigor: a bi-temporal knowledge graph tracking both valid time (when a fact was true in the world) and ingestion time (when the system learned it), across four timestamps per edge. When a new fact contradicts an old one, Graphiti closes the old fact's validity window rather than deleting it — preserving full point-in-time queryability ("what did the user believe in January?") while ensuring current-state queries never surface stale facts (Zep arXiv paper, Neo4j blog, Graphiti GitHub).

MIRIX formalizes six parallel memory types (Core, Episodic, Semantic, Procedural, Resource, Knowledge Vault) each owned by a dedicated sub-agent, notably separating a "Knowledge Vault" for verbatim-must-preserve facts (addresses, phone numbers) from synthesized Core/Semantic memory — an early version of the protected-vs-synthesized split (MIRIX arXiv).

Stanford's Generative Agents (Park et al., 2023) originated the reflection tree: raw observations are leaf nodes; the agent periodically (triggered by accumulated salience) recursively queries and summarizes its own memory stream into progressively more abstract "reflections" — e.g., synthesizing dozens of research-related observations into the self-notion "Klaus is highly dedicated to his research." This is the clearest academic precedent for dimension-style synthesis: raw events feed a tree whose upper layers are exactly the kind of standing trait a profile field wants to capture (ar5iv paper, MemX glossary).

Synthesis vs. Accumulation: The Trade-offs

Pure event accumulation has a well-documented failure mode researchers call "context bloat" or "information explosion": interaction history grows monotonically, retrieval degrades as more near-duplicate or superseded entries dilute the top-k, latency and cost climb, and the consuming model gets "distracted by irrelevant past errors" (survey discussion, Agent-Memory-Paper-List survey). Worse, similarity search is provably bad at telling a contradiction from a duplicate: one 2026 study found cosine similarity distinguishes a contradicted fact from a rephrased duplicate at AUROC 0.59 — essentially chance — because a stale fact phrased close to the current query often outranks a fresher, differently-worded one (Temporal Validity in Retrieval Memory, arXiv). This is the concrete mechanism behind "an event log that never says what's still true."

Synthesis addresses exactly this by collapsing many events into a standing claim with one current value per dimension — but it isn't free. The consolidation step is where errors concentrate: a 2026 UIUC/Tsinghua study, "Useful Memories Become Faulty When Continuously Updated by LLMs," found that as LLM-driven consolidation proceeds, memory utility rises and then falls below the no-memory baseline — in one setting GPT-5.4 failed 54% of ARC-AGI problems it had previously solved unaided once its own consolidated memory was in the loop. The root cause: the consolidating model doesn't reliably decide what belongs together, what should survive compression, or what should stay episodic — it misgroups, overgeneralizes, and because each rewrite operates on the previous rewrite's output, small errors compound (arXiv 2605.12978, project page). A companion paper, "Supersede," isolates the same problem on real conversational data: replacing full context with a bounded self-maintained memory dropped fact-freshness accuracy from 92% to 77% even on a frontier model, showing this is a maintenance failure, not a comprehension failure, and doesn't disappear with a stronger model (arXiv 2606.27472).

The staleness dimension has its own literature. MemoryBank (Zhong et al., AAAI) borrowed the Ebbinghaus forgetting curve directly: memory "strength" decays exponentially unless reinforced by recall, giving old, unused facts a principled way to fade rather than linger indefinitely as false-current (MemoryBank, arXiv 2305.10250). Zep/Graphiti's answer is structural rather than probabilistic — explicit valid-time windows rather than decay scores. Both are attempts to solve the same need: a synthesized claim needs some marker of when it was last true — a "last-confirmed date" — or the profile silently drifts into fiction.

Rewrite-vs-Append Mechanics

Two mechanical patterns dominate. Incremental merge (Mem0's ADD/UPDATE/DELETE/NOOP, Graphiti's edge-invalidation) processes one new fact at a time against existing state — cheap, auditable per-operation, but requires a reliable per-fact contradiction detector, which is exactly what similarity search struggles with. Full or partial rewrite (ChatGPT's memory-summary regeneration, generative agents' reflection synthesis, MemGPT's block editing) regenerates a whole document or block from an underlying source of truth — better at producing coherent, readable prose, but each rewrite is a fresh chance for the "faulty consolidation" failure mode above, since the model reconstructs from (potentially already-lossy) prior state rather than fully from raw ground truth.

The emerging mitigation across systems is a two-tier design: keep an append-only, lossless episodic/raw layer as ground truth (Mem0's underlying store, MemGPT's archival memory, Graphiti's episode provenance, memU's Resource layer), and treat the synthesized profile as a disposable, regeneratable view over it rather than the system of record. This means a bad rewrite is recoverable — regenerate from raw events — rather than a permanent, compounding loss. The "User as Code" paper pushes this further, proposing that raw conversation feed an append-only log that is periodically checkpointed into typed, structured state (not prose), because aggregate/logical queries ("how many times has this person raised X") collapse to 6–43% accuracy under free-text retrieval but stay near 99% when the checkpoint is executable/structured code rather than a rewritten paragraph (arXiv 2606.16707).

Human-Owned vs. Machine-Rewritten Fields

Ownership separation is a recurring but still under-formalized pattern. The clearest architectural precedent is the system-prompt/memory split itself: system prompts (or CLAUDE.md-style project instructions) are human-authored and never silently rewritten by the model, while memory/context blocks are model-writable and explicitly lower-precedence or higher-churn. General agent-memory engineering guidance increasingly names this directly — separating "structured (machine-enforceable)" from "unstructured (narrative)" data, and applying explicit precedence rules so newer/more-authoritative sources win deterministically rather than via LLM judgment call (agent memory engineering guide, Tim Kellogg, "Agent Memory Patterns"). MIRIX's "Knowledge Vault" for verbatim-preserve facts is a narrower version of the same idea scoped to why a field is protected (must not be paraphrased/lost) rather than who owns it (must not be model-altered).

A human-entered "background" field that the synthesis pass never touches is a sharper, more explicit instance of this pattern than most production systems currently implement: rather than relying on prompt-level instructions ("don't change this part"), it hard-partitions storage so the model literally cannot emit a write to that field — which sidesteps the entire class of "LLM ignored the protection instruction" failures that plague single-document rewrite systems.

Profile Schema and Dimension Design

Across the systems surveyed, recurring dimensions cluster into a small set: stable identity/role (MIRIX's persona block, MemGPT's "human" block), preferences and communication style (a 2026 personalization survey names Communication Style, Information Disclosure, Problem-solving Style, and Personal Affective Style as four stable cross-context dimensions — arXiv 2602.22680), goals/ongoing work (ChatGPT's "recurring goals," generative agents' higher-level reflections), and verbatim/must-not-lose facts (MIRIX's Knowledge Vault, Zep's provenance-linked edges).

Notably, several designs distinguish stable traits (rarely change, safe to keep in a rewritten summary) from volatile state (changes often, needs a timestamp or validity window rather than blind overwrite) — which maps onto splitting a mostly-static "role & responsibilities" dimension from explicitly dated "current work threads" and "blocker patterns" dimensions. This stable-vs-volatile split, rather than a flat list of fields, appears to be the more important design axis than the specific dimension names chosen.

Design Recommendations for Agent Builders

Drawing the threads together, the pattern that recurs across the strongest systems:

1. Never let the synthesized profile become the sole record — keep raw events as recoverable ground truth underneath it.
2. Date claims, not documents — attach "last confirmed" metadata per fact/dimension rather than one timestamp for the whole profile, since different dimensions go stale at different rates.
3. Resolve contradictions structurally where possible (explicit supersession/invalidation) rather than trusting an LLM to notice a conflict via similarity search, which the evidence shows is unreliable.
4. Treat profile regeneration as disposable and re-derivable, not incremental-only, so a bad synthesis pass is a cheap mistake rather than a compounding one.
5. Hard-partition human-owned fields at the storage layer rather than instructing the model to leave them alone — instruction-based protection is exactly the failure mode the consolidation-drift research warns about.
6. Separate stable identity dimensions from volatile working-state dimensions explicitly in the schema, since they need different update cadences and different staleness handling.

None of this is fully solved — even frontier models still degrade under repeated self-consolidation — so the safest production posture, matching Zep, Mem0, and memU alike, is to keep synthesis as a read-optimized view, never the write-optimized source of truth.