PersonaTree: Structured Memory for LLM Agents

• PersonaTree is a hierarchical structured memory model that organizes long dialogue histories into trunks, branches, and leaves for explicit, lasting user profiling.
• It employs executable operations and support paths that transform event-level evidence into higher-level claims to maintain controllability and interpretability.
• Empirical evaluations show that PersonaTree enhances personalization accuracy and token efficiency compared to traditional flat memory models in LLM dialogue systems.

Searching arXiv for the PersonaTree papers and closely related work referenced in the data. Tool call: arxiv_search(query="PersonaTree Structured Lifecycle Memory for Person Understanding in LLM Agents", max_results=5) PersonaTree denotes a class of structured memory frameworks for persistent and personalized LLM agents in which long interaction histories are converted into an explicit tree rather than retained as a flat text buffer. In the 2026 arXiv literature, the term is used in two closely related but distinct formulations: as a globally maintained core memory tree for long-term user profiling in the "Inside Out" framework (Zhao et al., 8 Jan 2026), and as a structured lifecycle memory for person understanding with explicit support paths from evidence to higher-level claims (Hou et al., 3 Jun 2026). Across both formulations, the central premise is that durable personalization requires more than retrieval of past snippets: situated evidence must be compressed, abstracted, and maintained as a coherent user model under finite context budgets.

1. Conceptual scope and problem setting

PersonaTree is proposed against a common failure mode in long-horizon dialogue systems: dialogue histories grow without bound, while context windows remain finite, so naïve history concatenation introduces noise accumulation, high latency or token cost, reasoning degradation, and persona inconsistency (Zhao et al., 8 Jan 2026). A related diagnosis is that many persistent-memory methods emphasize information retention and retrieval but give limited account of how accumulated interaction evidence becomes person understanding, such as preferences, states, values, constraints, habits, and boundaries (Hou et al., 3 Jun 2026).

The two main PersonaTree formulations differ in emphasis but share a common schema-formation view. The "Inside Out" paper frames the problem as structured long-term user state tracking and treats the tree as the carrier of long-term user profiling (Zhao et al., 8 Jan 2026). The later paper frames persistent memory as a lifecycle process in which event-level evidence is abstracted into recurring patterns and then into stable person-level claims (Hou et al., 3 Jun 2026). In both cases, the tree is intended to preserve controllability, interpretability, and compactness.

Aspect	"Inside Out" PersonaTree	Structured lifecycle PersonaTree
Primary role	Core memory tree for user profiling	Memory for person understanding
Main hierarchy	Trunk, branches, leaves	Leaf evidence, mid patterns, root claims
Main operation	Executable tree edits	Writing, consolidation, path retrieval

A common misconception is that PersonaTree is merely a retrieval index. The published formulations treat it instead as an editable memory state. One version emphasizes executable operations such as ADD, UPDATE, DELETE, and NO_OP; the other emphasizes explicit support paths from evidence to claims, confidence-guided promotion, and retrieval at only the abstraction depth required by the query (Zhao et al., 8 Jan 2026).

2. Representational structure

In the "Inside Out" formulation, PersonaTree is a globally maintained core memory tree organized as trunk, branches, and leaves (Zhao et al., 8 Jan 2026). The trunk is constrained by an initial schema and defines the top-level writable space. That schema is initialized from a biopsychosocial decomposition into Biological, Psychological, and Social dimensions. Branches refine those top-level dimensions into more specific facets, and leaves are the final writable memory slots, each storing a compact text string that summarizes a user attribute or preference. The stated purpose of trunk constraint is controllable growth, memory compression, and consistency preservation.

The structured-lifecycle formulation formalizes memory for a user $u$ as

$$\mathcal{T}_u=(\mathcal{V}^{L}_u,\mathcal{V}^{M}_u,\mathcal{V}^{R}_u,\mathcal{E}_u),$$

with leaf, mid, and root node sets plus typed support edges (Hou et al., 3 Jun 2026). Each node is written as

$v=(x,t,a,z,c,\ell),$

where $x$ is textual content, $t$ temporal metadata, $a$ task or schema attributes, $z$ an embedding, $c$ confidence, and $\ell \in \{L,M,R\}$ the abstraction level. Leaves store event-level evidence from one interaction or a short segment; mids store recurring patterns derived from multiple leaves; roots store durable person-level claims such as personality traits, values, principles, objective identity facts, and hard boundaries.

The most distinctive representational feature of the latter framework is the explicit support path. A retrieved structure may take the form Root $\rightarrow$ Support-Mid $$\mathcal{T}_u=(\mathcal{V}^{L}_u,\mathcal{V}^{M}_u,\mathcal{V}^{R}_u,\mathcal{E}_u),$$0 Evidence-Leaf(s), allowing the agent not only to answer a person-understanding query but also to expose why a higher-level claim is believed (Hou et al., 3 Jun 2026). This suggests that PersonaTree is not only a compression device but also an auditable abstraction structure.

3. Update, maintenance, and memory evolution

The "Inside Out" paper formulates personalized dialogue as explicit state tracking and state-conditioned generation:

$$\mathcal{T}_u=(\mathcal{V}^{L}_u,\mathcal{V}^{M}_u,\mathcal{V}^{R}_u,\mathcal{E}_u),$$1

For each dialogue chunk $$\mathcal{T}_u=(\mathcal{V}^{L}_u,\mathcal{V}^{M}_u,\mathcal{V}^{R}_u,\mathcal{E}_u),$$2, the system performs state construction, operation generation, safe parsing and execution, and versioned persistence, yielding an updated tree $$\mathcal{T}_u=(\mathcal{V}^{L}_u,\mathcal{V}^{M}_u,\mathcal{V}^{R}_u,\mathcal{E}_u),$$3 and final compressed memory $$\mathcal{T}_u=(\mathcal{V}^{L}_u,\mathcal{V}^{M}_u,\mathcal{V}^{R}_u,\mathcal{E}_u),$$4 (Zhao et al., 8 Jan 2026). Memory editing is delegated to MemListener, a lightweight model trained to transform dialogue into executable operations from $$\mathcal{T}_u=(\mathcal{V}^{L}_u,\mathcal{V}^{M}_u,\mathcal{V}^{R}_u,\mathcal{E}_u),$$5. The parser then enforces path and capacity constraints, values are required to be strings or allowed deletion markers, overlong values are compressed to fit per-leaf budget, and conflict resolution is handled during operation generation rather than execution.

The structured-lifecycle PersonaTree adopts a different maintenance policy centered on conservative writing and confidence-guided consolidation (Hou et al., 3 Jun 2026). When a new leaf $$\mathcal{T}_u=(\mathcal{V}^{L}_u,\mathcal{V}^{M}_u,\mathcal{V}^{R}_u,\mathcal{E}_u),$$6 is extracted, attachment to a mid node $$\mathcal{T}_u=(\mathcal{V}^{L}_u,\mathcal{V}^{M}_u,\mathcal{V}^{R}_u,\mathcal{E}_u),$$7 is gated by a schema-compatibility predicate and a validator-aware match score:

$$\mathcal{T}_u=(\mathcal{V}^{L}_u,\mathcal{V}^{M}_u,\mathcal{V}^{R}_u,\mathcal{E}_u),$$8

Here $$\mathcal{T}_u=(\mathcal{V}^{L}_u,\mathcal{V}^{M}_u,\mathcal{V}^{R}_u,\mathcal{E}_u),$$9 maps validator judgment to support, conflict, or unrelated evidence. A leaf attaches to the best mid only if the match exceeds $v=(x,t,a,z,c,\ell),$0; otherwise it remains orphaned until later consolidation. Mid-level consolidation groups orphan leaves using schema attributes, temporal proximity, and semantic similarity, while root promotion is stricter and requires thresholds on confidence, support size, and temporal coverage.

Confidence itself is updated with a decayed log-odds rule:

$v=(x,t,a,z,c,\ell),$1

Support raises confidence, conflict lowers it, and lack of new evidence causes drift toward baseline (Hou et al., 3 Jun 2026). This mechanism is used for update decisions, retrieval selection, pruning, and promotion from patterns to durable claims.

4. Retrieval and generation

The "Inside Out" PersonaTree defines two inference modes (Zhao et al., 8 Jan 2026). In latency-sensitive mode, the system reads the final tree $v=(x,t,a,z,c,\ell),$2, uses non-empty leaf texts as a personalized prior, concatenates them with the user query $v=(x,t,a,z,c,\ell),$3, and generates a response in one pass. In agentic on-demand detail mode, the query is expanded into multiple attribute-focused queries conditioned on $v=(x,t,a,z,c,\ell),$4, evidence is retrieved in parallel, reranked and fused into a context $v=(x,t,a,z,c,\ell),$5, and the final answer is generated from $v=(x,t,a,z,c,\ell),$6. The tree therefore acts both as a direct personalization prior and as a controller for deeper retrieval.

The structured-lifecycle PersonaTree makes retrieval explicitly query-conditioned (Hou et al., 3 Jun 2026). A routing model predicts the required abstraction level,

$v=(x,t,a,z,c,\ell),$7

and an attribute predictor $v=(x,t,a,z,c,\ell),$8 estimates query attributes. Leaf queries are answered with concrete event evidence, mid queries with patterns or recent states, and root queries with stable claims, optionally accompanied by supporting mids and leaves. For roots and mids, the rendering depth can be $v=(x,t,a,z,c,\ell),$9 for the root alone, $x$0 for root plus supporting mid, or $x$1 for the full root-mid-leaf chain.

Selection is performed under a token budget:

$x$2

This operationalizes a central design claim: different questions require different evidence depths, so compactness should come from selective rendering rather than indiscriminate truncation (Hou et al., 3 Jun 2026).

5. Training procedures and empirical results

The "Inside Out" framework trains MemListener first by supervised fine-tuning with

$x$3

where $x$4 includes the dialogue chunk, previous tree state, and rules (Zhao et al., 8 Jan 2026). It is then optimized with reinforcement learning using process-based rewards, a DAPO-style objective inside a GRPO framework, group size $x$5, and rewards $x$6. The reward is produced by an LLM-as-judge prompt that scores the predicted operation list against ground truth, with Qwen3-32B in reasoning mode used as the discriminator during RL training.

Empirically, that paper evaluates on PersonaMem, described as containing user static demographic information plus dynamic evolving attributes, about 10 multi-turn conversations per history, around 32K tokens total context, and 15 categories of real-world personalization tasks (Zhao et al., 8 Jan 2026). Reported metrics include Overall accuracy and seven query-skill categories: Recall-Facts, Pref-Rec, New-Ideas, Recall-Reason, Pref-Evol, Gen-New, and Recall-User. With DeepSeek-R1-0528 as the response model, the best PersonaTree configuration achieves Overall $x$7, compared to $x$8 for ALL Dialogue and $x$9 for MemoryOS, corresponding to gains of $t$0 and $t$1. With DeepSeek-V3.1, the best PersonaTree configuration reaches $t$2, improving by $t$3 over Only LLM, $t$4 over ALL Dialogue, and $t$5 over MemoryOS. The paper also reports that trained PersonaTree uses only about $t$6 tokens of memory context on average versus around $t$7 for Full Dialogue.

The structured-lifecycle PersonaTree is evaluated on six benchmarks—KnowMe, LongMemEval, RealPref, RealMem, CUPID, and LoCoMo-Plus—with three answer backbones: Qwen3-32B, Gemini 3 Flash, and GPT-5.4 Mini (Hou et al., 3 Jun 2026). It ranks first in 12 of 18 compact scores and reaches the top two in 16 settings. On RealPref, the paper reports a score improvement from $t$8 to $t$9, a P95 answer-input reduction from $a$0 to $a$1 tokens, and a reduction in growth per 100 turns from $a$2 to $a$3. Ablations indicate that hierarchy improves abstract person understanding on KnowMe: Leaf Only scores $a$4, No Root $a$5, and PersonaTree $a$6, with the largest gain on T7, which rises from $a$7 to $a$8. A retrieval ablation on RealPref compares Flat Nodes at $a$9 with PersonaTree Path at $z$0, with preference alignment improving from $z$1 to $z$2, answer quality from $z$3 to $z$4, and context decreasing from $z$5 to $z$6 tokens.

6. Related work, disambiguation, and limitations

PersonaTree belongs to a broader movement toward hierarchical memory for LLM systems, but its published formulations are more explicitly person-centric than several related tree-based methods. MemTree, for example, represents memory as a directed tree of summarized content, embeddings, parent pointers, child sets, and depth, and supports online insertion, ancestor abstraction, and collapsed-tree retrieval for multi-turn dialogue understanding and document question answering (Rezazadeh et al., 2024). A plausible implication is that PersonaTree and MemTree share a hierarchical-memory intuition, but PersonaTree is more explicitly organized around user profiling or person understanding, with either schema-constrained editing or evidence-to-claim support paths.

The name should also be distinguished from unrelated tree-based architectures in other fields. ARTree is a deep autoregressive graph model for phylogenetic inference over unrooted bifurcating tree topologies (Xie et al., 2023). Treeformer is a CKY-inspired hierarchical encoder for phrase and sentence representations in Transformers (Patel et al., 2022). Semantic Neural Tree is a hierarchy-aware architecture for human parsing (Ji et al., 2019). TreeView is a feature-space partitioning method for interpreting deep neural networks via decision-tree surrogates (Thiagarajan et al., 2016). These systems share the use of tree structure, but not the person-understanding objective central to PersonaTree.

Both PersonaTree papers are explicit about limitations. The "Inside Out" paper notes that the biopsychosocial schema is limited in scope, the current memory representation is text-string based, and real deployment would require privacy control, sensitive-field stratification, and user-facing memory management (Zhao et al., 8 Jan 2026). The structured-lifecycle paper states that evaluation is on text-based interaction histories, that benchmarks are English-language, and that multimodal or speech-based interaction is not tested (Hou et al., 3 Jun 2026). Taken together, these limitations indicate that PersonaTree is best understood as an explicit memory architecture for long-term personalization in text-centric LLM agents, rather than a complete solution to general lifelong user modeling.