PAiNT: Perspective-Aware AI Identity and Narrative Toolkit for Generating Labeled Digital Footprints

Abstract

Modeling a user’s evolving goals, values, and affect over time is central to perspective-aware AI, yet progress is bottlenecked by the lack of longitudinal data with ground-truth labels for the latent identity state. We introduce PAiNT (Perspective-Aware AI Identity and Narrative Toolkit), a generative framework that simulates long-horizon persona trajectories and emits corresponding multimodal artifacts with ontology-aligned labels of the latent identity state that produced them. PAiNT decouples identity dynamics from artifact generation via a typed Persona Matrix and Situation Graph, coordinated through a multi-agent loop with validation-gated transitions and bounded-window history conditioning. Across four personality archetypes, four backbone LLMs, and three architectural ablations, evaluated with a nine-metric suite calibrated on published longitudinal data, we find that (i) persona initialization produces a durable identity signal that persists above stochastic event noise; (ii) multi-agent orchestration and history conditioning govern distinct quality dimensions, with removal of either causing different failure modes; and (iii) a coherence frontier constrains the trade-off between temporal resolution and horizon, with substantial penalties at daily granularity. We release PAiNT and PAi-Bench, a human-validated benchmark of 1200 labeled multimodal artifacts.

1. Introduction

Humanity is entering a new phase of human–machine symbiosis where AI systems are no longer just tools, but also persistent partners embedded in the fabric of daily life. Yet, today’s AI systems are fundamentally perspective-blind: they lack a persistent, evolving representation of a specific user’s goals, values, affect, and constraints. This limitation matters most in longitudinal settings, where users rely on AI not only for isolated queries but also for extended tasks such as navigating career change, managing health decisions, coordinating complex workflows, or interacting within extended reality (XR) environments [1]. In such settings, effective support requires more than stylistic personalization or retrieval of recent context; it requires modeling how a user’s internal state changes over time.

A central obstacle to this goal is a severe data bottleneck. Learning to model evolving user perspective would require longitudinal digital footprints—for example, emails, chats, calendars, and decision traces—spanning months or years. In practice, such data are difficult to use for research because they are privacy-sensitive, fragmented across proprietary silos, and largely unlabeled with respect to internal state [2,3]. We may observe what a user wrote or did, but not directly why they acted, what they felt, or which constraints shaped the decision. As a result, progress on perspective-aware AI is limited not only by modeling challenges but also by the absence of auditable, structurally supervised longitudinal datasets.

Perspective-Aware AI (PAi) [4] offers a useful conceptual frame for addressing this gap. In PAi, a user’s evolving perspective is represented explicitly through a structured object—a Chronicle—that can encode goals, values, affect, and social context over time. Under this view, the problem is not only to generate personalized outputs, but to model and maintain an explicit representation of the perspective that gives rise to them [5,6]. However, data-driven methods for building and evaluating such systems remain constrained by the lack of suitable training and benchmarking resources.

To address this problem, we introduce PAiNT (Perspective-Aware AI Identity and Narrative Toolkit), a generative framework for simulating long-horizon persona trajectories and producing paired outputs: multimodal digital artifacts together with explicit, ontology-aligned labels of the latent identity state that produced them. PAiNT decouples identity dynamics from artifact generation through three core structures: a Persona Matrix that tracks evolving identity attributes, a Persona Path that records event-driven state transitions, and a Situation Graph that encodes the entity’s perspective in each local situation (Figure 1). Because identity state is explicit rather than implicit in an LLM context window, it can be inspected, ablated, and quantitatively evaluated, making the resulting data structurally supervised and suitable for controlled experimentation.

Our contributions are fourfold:

• We introduce PAiNT, a state-conditioned generative framework that decouples latent identity dynamics from observable artifacts. This design exposes identity state as explicit supervision, enabling controlled ablation, drift analysis, and future downstream learning on synthetic longitudinal data.
• We provide a systematic evaluation of PAiNT across archetypes, temporal configurations, backbones, and architectural ablations. This evaluation identifies which components govern which quality dimensions and characterizes a coherence frontier between temporal resolution and simulation horizon.
• We introduce a reusable metric suite for longitudinal identity simulation, including temporal drift diagnostics calibrated from published longitudinal data, a three-phase narrative coherence pipeline, and cross-modal graph-alignment metrics.
• We release PAi-Bench, a benchmark of longitudinal, multimodal, perspective-labeled digital footprints generated with PAiNT and curated with human oversight, to support future research on perspective-aware AI and longitudinal perspective inference.

Together, PAiNT and PAi-Bench provide a structured foundation for generating, evaluating, and benchmarking synthetic longitudinal perspective data without relying on real user histories. The full release is available at https://github.com/flybits/paint (accessed on 16 June 2026).

2. Related Work

PAiNT lies at the intersection of persona simulation, longitudinal user modeling, commonsense reasoning, and perspective-aware AI. The most important distinction from prior work is that PAiNT makes evolving identity state explicit, structured, and inspectable, rather than leaving it implicit in prompts, memories, or latent model behavior. This explicit-state design enables supervision, controlled ablation, and drift analysis over long horizons.

2.1. Persona Simulation and Generative Agents

Early work on personalized generation showed that explicit user profiles can improve dialogue consistency. Li et al. [7] introduced speaker embeddings for persona-consistent neural conversation models, and Zhang et al. [8] proposed Persona-Chat, where dialogue is conditioned on textual persona descriptions. Mazaré et al. [9] later scaled persona-based modeling using large collections of Reddit user profiles.

Large language models enabled more realistic and longer-horizon simulations. Thoppilan et al. [10] demonstrated sustained conversational behavior in LaMDA, while Park et al. [11] introduced Generative Agents, where agents evolve through memory streams and produce believable social behavior over time. However, in these systems, the state governing behavior is largely implicit. This limits direct inspection, controlled manipulation of identity variables, and quantitative analysis of how internal perspective changes over time. PAiNT differs by externalizing this state into a structured Persona Matrix and aligned Situation Graphs, making the simulated identity trajectory directly available for supervision and analysis.

Related work has also explored synthetic persona-grounded data generation. Jandaghi et al. [12] proposed a generator–critic framework for producing high-quality persona-grounded dialogues, and Chan et al. [13] introduced PersonaHub to generate large-scale synthetic personas. Building on structured human-attribute taxonomies, Wang et al. [14] developed DeepPersona to scale narrative-complete synthetic personas, endowing simulated agents with coherent life histories and value systems. However, these efforts focus primarily on static persona specification or dialogue generation. To maintain persona coherence over extended horizons without exceeding context limits, recent architectures have also explored identity-driven retrieval-augmented generation [15]. By contrast, PAiNT targets longitudinal digital footprints and pairs generated artifacts with explicit internal-state labels, enabling structurally supervised learning rather than only artifact-level generation.

2.2. Longitudinal Modeling and Commonsense Reasoning

Long-term personalization requires representations that remain useful over extended interaction histories. Ning et al. [16] proposed User-LLM, which compresses historical user information into embeddings for personalization and retrieval. Extending longitudinal tracking to real-world multimodal data, Yang et al. [17] introduced SensorPersona to continually extract evolving persona states from mobile sensor streams. Such approaches are useful for scalability, but the resulting representations are not directly interpretable and are therefore less suitable when explicit perspective variables, state tracing, or drift analysis are required.

Our work is also related to commonsense reasoning about latent mental state. Rashkin et al. [18] introduced Event2Mind, which infers intents and emotional reactions from events, and Sap et al. [19] developed ATOMIC, a large commonsense knowledge graph encoding causal and social if–then relations. These resources model generic regularities about human behavior. In contrast, PAiNT models the perspective of a particular individual in a particular situation. Its Situation Graphs ground latent goals, affect, and interpretations in temporally situated identity trajectories rather than in population-level commonsense templates alone.

PAiNT is further grounded in the Perspective-Aware AI (PAi) framework of Alirezaie et al. [20,21], which introduces Chronicles as user-centered knowledge structures for representing goals, values, and affect over time. PAiNT operationalizes this idea for synthetic data generation: each Situation Graph captures a localized slice of perspective, while a sequence of such graphs forms a longitudinal trajectory consistent with the broader notion of a Chronicle. By generating these graphs together with multimodal artifacts, PAiNT produces the paired supervision needed for downstream perspective-inference tasks such as Situation Graph Prediction, which we identify as a key direction for future work.

2.3. Bias, Ethics, and Perspective-Awareness

PAiNT is motivated in part by the limitations of one-size-fits-all foundation models. Bender et al. [22] characterized such models as “stochastic parrots,” warning that they lack contextual understanding, while Bommasani et al. [23] argue that foundation models tend to homogenize users by defaulting to statistical averages. These concerns are especially relevant when systems are expected to interact with users whose goals, values, and interpretations differ systematically from population norms.

Prior work has documented such harms empirically. Sheng et al. [24] showed that neural text generation can exhibit gender and racial biases, and Lucy and Bamman [25] found stereotyped portrayals in generated narratives. Lewicki et al. [6] further argue that fairness cannot be assessed independently of context, and Weidinger et al. [26] catalog broader risks of large-scale language models, including misalignment with user needs and values.

While alignment methods such as RLHF [27] improve general helpfulness, they optimize toward a generic user preference rather than explicitly modeling user-specific perspective. Real-world multimodal datasets such as Ego4D [28] capture rich first-person experience, but they do not provide direct labels for the internal states that shape observable behavior and may be difficult to use because of privacy and governance constraints. PAiNT is intended as a complementary alternative: it generates privacy-safe, auditably labeled longitudinal data in which the internal states that produce observable behavior are exposed explicitly, enabling controlled research on perspective-aware modeling without direct access to sensitive real-world histories.

2.4. Positioning Relative to Prior Frameworks

Table 1. Comparison of PAiNT with representative persona-simulation and user-modeling frameworks across five capability axes.

Framework	State Representation	Explicit & Inspectable State	Longitudinal Modeling	Supervision (GT Labels)	Multimodal Generation	Downstream Learning
Persona-Chat [8]	Textual description	✗	✗	✗	✗	✗
PersonaHub [13]	Textual/attribute	✗	✗	✗	✗	Partial
Generative Agents [11]	Implicit stream	✗	✓  (impl.)	✗	✗	✗
User-LLM [16]	Embedding	✗	✓	✗	✗	✓
DeepPersona [14]	Structured attribute	✗	✗	✗	✗	Partial
PAiNT (ours)	Explicit structured	✓	✓	✓	✓	✓

The green checkmark (✓) and red cross (✗) indicate full support and lack of support, respectively. “✓ (impl.)” indicates that temporal evolution occurs but the underlying identity state is implicit rather than explicitly represented; “Partial” indicates partial or task-limited support for the corresponding axis. “GT” denotes groundtruth.

consolidates the distinctions drawn above across five capability axes identified as central to longitudinal perspective modeling: how identity state is represented, whether that state is explicit and inspectable, whether the framework models change over time, whether it emits ground-truth supervision for the latent state, whether it generates multimodal artifacts, and whether it supports downstream learning. Prior systems each occupy a partial region of this space. Static persona methods such as Persona-Chat [8] and PersonaHub [13] provide structured persona specifications but neither model temporal evolution nor expose labeled state. Generative Agents [11] produce believable long-horizon behavior, but the state governing that behavior remains implicit in memory streams and is therefore unavailable as supervision. User-LLM [16] models longitudinal user history and supports downstream tasks, yet compresses identity into embeddings that are not directly inspectable. More recent synthetic-persona generators such as DeepPersona [14] produce narrative-rich personas, but as static specifications without per-timestep state labels or multimodal output. PAiNT is distinguished not by excelling on any single axis, but by being the only framework that couples all five: it represents identity state explicitly, exposes it as inspectable ground-truth supervision, evolves it longitudinally, and conditions multimodal artifact generation on it, yielding paired data suitable for downstream perspective inference. We position PAiNT against these systems conceptually rather than through a shared quantitative benchmark, because our evaluation metrics presuppose access to explicit ground-truth latent state—precisely the supervision PAiNT produces—which these external systems do not expose. A direct numerical comparison would therefore require re-implementing each system under PAiNT’s supervision regime, altering the very systems being compared.

3. Problem Setting and Design Requirements

We study the problem of generating longitudinal, perspective-labeled digital footprints for a single focal entity (an individual) over a time horizon T. PAiNT is designed primarily as an open-ended persona simulator and data generator, and secondarily as a source of structured labels that can support downstream modeling of latent perspective state.

3.1. Generative Setting and Outputs

Let $\mathcal{S}$ denote a user-provided persona scaffolding, instantiated as a structured schema of identity constraints, and let ${\varphi }_{\Theta }$ denote the generation configuration, including the random seed, temporal resolution, horizon, event taxonomy, and modality policy. A PAiNT run takes $(\mathcal{S},\Theta )$ as input and generates a temporally ordered sequence of situations indexed by discrete timesteps $t\in \{1,\dots ,T\}$. The simulation is initialized with an identity state $P_0$ derived from the input schema using a model $\varphi$ (such as an LLM):

$$P_0\sim {\varphi }_{\Theta }(·\mid \mathcal{S}),$$

(1)

and an initial history summary $H_0$, which may be empty or derived from $\mathcal{S}$. Here, T denotes the simulation horizon, and $P_T$ the terminal identity state.

At each timestep, the framework produces four coupled objects:

$$\mathcal{D}={\left(P_t,E_t,G_t,X_t\right)}_{t=1}^T.$$

(2)

Specifically:

• $P_t$ is the Persona Matrix, representing the entity’s identity state at time t. It contains both relatively stable attributes (e.g., background factors and enduring traits) and dynamic attributes (e.g., goals, affect, relationships, stress, and habits) that may evolve over time.
• $E_t$ is the exogenous event or situation trigger at time t (e.g., “job interview,” “conflict with teammate,” “health setback,” “product launch”), sampled from a controlled taxonomy.
• $G_t$ is the Situation Graph, an ontology-aligned structured representation of the entity’s perspective in the current situation, including variables such as goals, affect, appraisal, social roles, constraints, and salience. Within the simulated dataset, it serves as the structured label for downstream supervised or self-supervised tasks.
• $X_t$ is a set of multimodal artifacts emitted at time t (e.g., messages, emails, photos, phone calls, or voice memos), treated as partial and noisy observations of the underlying state and situation.

State-Conditioned Dynamics

The simulated persona trajectory is modeled as a state-conditioned process. At each timestep t, the event $E_t$ is sampled according to an event-transition mechanism ${\pi }_{\Theta }$, conditioned on the previous identity state $P_{t-1}$ and a bounded history summary $H_{t-1}$. The identity state is then updated through a transition mechanism ${\tau }_{\Theta }$:

$$E_t\sim {\pi }_{\Theta }(·\mid P_{t-1},H_{t-1}),P_t\sim {\tau }_{\Theta }(·\mid P_{t-1},E_t,H_{t-1}).$$

(3)

The history summary $H_{t-1}$ is computed by a history aggregation function $h_{\Theta }$ over bounded windows of prior identity states and events:

$$H_{t-1}=h_{\Theta }\left(P_{t-k:t-1},E_{t-m:t-1}\right),$$

(4)

where k and m are user-defined history context window sizes for past Persona Matrix states and events, respectively. For early timesteps, when the full window is not yet available, these sequences are truncated to the observed prefixes. Here, $P_{t-k:t-1}$ denotes the ordered sequence $(P_{t-k},P_{t-k+1},\dots ,P_{t-1})$, and $E_{t-m:t-1}$ is defined analogously.

Given the current state $P_t$, event $E_t$, and history summary $H_{t-1}$, the Situation Graph is constructed by a labeling function $g_{\Theta }$, and the observable artifacts are generated by an artifact generator ${\rho }_{\Theta }$:

$$G_t=g_{\Theta }(P_t,E_t,H_{t-1}),X_t\sim {\rho }_{\Theta }(·\mid P_t,E_t,G_t,H_{t-1}).$$

(5)

This factorization separates identity evolution (${\pi }_{\Theta },{\tau }_{\Theta }$), perspective labeling ($g_{\Theta }$), and artifact generation (${\rho }_{\Theta }$). Consequently, PAiNT generates longitudinal multimodal trajectories together with structured labels $(P_t,G_t)$, while enabling controlled ablations and analysis of identity drift through the explicit state sequence $(P_1,\dots ,P_T)$.

3.2. Downstream Use Cases

PAiNT is designed to support controlled training and evaluation for perspective-aware modeling tasks. Given observations $X_{1:t}$, which may be noisy, partial, and multimodal, a downstream model may be asked to:

• infer $P_t$ (state estimation),
• infer $G_t$ (perspective labeling),
• predict future events or states such as $E_{t+1}$ or $P_{t+1}$ (forecasting), or 
• detect inconsistencies, anomalies, or regime shifts over time (diagnostics).

• Because PAiNT provides structured latent states and perspective labels together with observable artifacts, these tasks can be evaluated directly while still allowing coherent uncertainty and partial observability through $X_t$.

3.3. Design Requirements

To support controlled generation and reliable evaluation, PAiNT is designed around seven core requirements:

• R1: Factorized Control. The generator should support independent manipulation of priors, temporal resolution, and horizon length in order to enable systematic ablation studies.
• R2: Temporal Coherence. Identity dynamics should preserve stable traits while allowing bounded, event-driven evolution of dynamic attributes.
• R3: Causal Consistency. Generated trajectories should satisfy causal plausibility and narrative non-contradiction, with deterministic validation where possible.
• R4: Ontological Grounding. Structured outputs ($P_t,G_t$) should conform to fixed schemas so that label spaces remain stable and comparable across runs.
• R5: Cross-Modal Alignment. Generated artifacts ($X_t$) should remain consistent with the underlying perspective labels ($G_t$), supporting downstream inference from noisy observations.
• R6: Auditability. Seeds, configurations, prompts, and generation traces should be logged to support reproducibility and inspection.
• R7: Privacy Safety. The framework should generate diverse and rich persona data without requiring sensitive real-world user histories.

Taken together, these requirements define PAiNT as a controlled and auditable framework for generating longitudinal, perspective-labeled datasets with explicit state structure, explicit temporal dynamics, and measurable validity properties. The following sections describe how the architecture and generation pipeline operationalize these requirements and how they are assessed in the evaluation protocol.

4. PAiNT Framework

PAiNT is a generative pipeline that: (i) simulates a user-defined persona’s internal and external experiences over time and (ii) produces a corresponding multimodal digital footprint grounded in the simulated persona trajectory. Its core design principle is the decoupling of latent identity dynamics—how a person changes—from the observable artifacts they emit—what a person writes, says, or photographs. This matches the formal separation between state transitions (${\tau }_{\Theta }$) and artifact generation (${\rho }_{\Theta }$) established in Section 3, and it is this property that makes PAiNT’s outputs structurally supervised: because identity state remains explicit and inspectable, it can serve as structured supervision for downstream perspective-inference tasks, be independently manipulated for ablation, and be quantitatively analyzed for drift and coherence.

PAiNT is implemented as a structured, multi-stage generative pipeline with validation-gated transitions and bounded retries. Long-horizon coherence is maintained through bounded history conditioning using recent states and events. This mechanism instantiates the design requirements introduced in Section 3, especially factorized control (R1), temporal coherence (R2), ontological grounding (R4), auditability (R6), and privacy safety (R7).

The framework comprises eight stages organized into three phases:

• Persona Initialization (Stages 1–3), which constructs the initial persona specification, event space, and initial state.
• Persona Trajectory Simulation (Stages 4–5), which generates the longitudinal state–event trajectory and supporting label registry.
• Artifact Generation (Stages 6–8), which produces Situation Graphs and multimodal artifacts conditioned on the simulated trajectory.

Figure 2 summarizes the data flow. We first introduce the main data structures, then describe the three phases of the pipeline, followed by implementation details and the downstream task enabled by the generated data.

4.1. Core Data Structures

PAiNT operates over five principal data structures: the input persona scaffolding $\mathcal{S}$, the event taxonomy $\mathcal{E}$, the time-indexed Persona Matrix $P_t$, the longitudinal Persona Path ${\left\{(P_t,E_t)\right\}}_{t=1}^T$, and the Situation Graph $G_t$ associated with each timestep.

4.1.1. Persona Scaffolding ($\mathcal{S}$)

The Persona Scaffolding is the user-populated input schema that specifies high-level identity constraints for the initial persona state. In our implementation, it is organized into eight typed dimensions: demographic identity, professional life, personality and mindset, motivations and goals, decision-making style, social context, frustrations, and notable preferences. Each dimension is represented through a validated sub-schema with explicit field definitions. This scaffolding provides the controllable starting point of the simulation: users may fix selected identity attributes while leaving others underspecified for the generator to complete consistently.

4.1.2. Event Taxonomy ($\mathcal{E}$)

The Event Taxonomy is a fixed, versioned catalogue of life events used to constrain the event space. In our implementation, it contains 260 events organized into 14 categories, including educational events, career milestones, relationship dynamics, emotional stressors, daily-life situations, and technological interactions. Because $\mathcal{E}$ is loaded from a static specification file, event selection remains reproducible and auditable across runs. Using a controlled taxonomy also limits open-ended hallucination and enables systematic ablations over event categories (R1).

4.1.3. Persona Matrix ($P_t$)

The Persona Matrix is a temporally indexed, structured representation of identity state. It encodes both constant traits that must remain invariant across all timesteps (e.g., handedness, eye color, ethnicity) and dynamic attributes (e.g., stress level, coping styles, relationships, goals) that evolve in response to events. The schema comprises fourteen semantically distinct feature clusters:

• Personality Features: Big Five (OCEAN) traits on continuous scales in $[1,5]$;
• Physical Traits: embodiment features—categorical strings (hair color, ethnicity, gender, skin tone) and continuous floats (height in cm, weight in lbs). Constant.
• Physical Health: health metrics (BMI as continuous float, fitness level on $[1,5]$).
• Mental Health: stress and anxiety levels on $[1,5]$, depression symptoms (string list).
• Demographic Features: strings (name, profession, nationality, education, marital status) and enumerated categories (age group, income class).
• Family and Friends: typed relationship list with closeness scores on $[1,5]$.
• Coping Styles: avoidance, impulsivity, emotional reactiveness, emotional regulation, escapism on $[1,5]$.
• Wellness and Lifestyle: work–life balance on $[1,5]$, sleep quality (enumerated), work style (enumerated), screen time on $[1,12]$ h, nutrition quality on $[1,5]$.
• Belief System: existential, nihilist, humanist, stoic orientations and political leaning on $[0,1]$; religion (string).
• Goals: short-term and long-term objectives (string lists); life driver narrative (string).
• Fears: aversive motivations and vulnerabilities (string list).
• Habits: communication style (enumerated), quirks (string list), irritants (string list).
• Interests: hobbies, general interests, social affiliations (all string lists).
• Constant Features: immutable categorical strings (handedness, eye color). Constant.

Every field is typed and range-constrained via a rigid schema that is enforced programmatically at every state transition, satisfying ontological grounding (R4). Validator agents are instructed to enforce that constant clusters remain unchanged and that numeric attributes stay within their declared bounds. The cluster definitions and their scales are informed by established constructs in personality and social psychology: the OCEAN dimensions follow the Five-Factor Model [29], coping-style dimensions draw on standard coping inventories such as the Brief-COPE [30], relational closeness is operationalized in the tradition of interpersonal-closeness measures, and belief-system orientations are represented as continuous dimensions in the spirit of established human-values frameworks. We adopt these as structured operationalizations to ground the simulation in recognized identity constructs rather than ad hoc attributes; we do not claim the specific scales constitute validated psychometric instruments.

4.1.4. Persona Path (${(P_t,E_t)}_{t=1}^T$)

Personality traits are not static; longitudinal studies confirm that major life events drive measurable trait-level change, with the magnitude varying by individual rigidity and life stage [31]. The Persona Path is the longitudinal backbone of the simulation. At each timestep t, it records the event $E_t$ and the resulting updated state $P_t$. Informally, each transition captures an event, the persona’s reaction to that event, and the state update induced by it. The Persona Path therefore constitutes the canonical latent trajectory from which all downstream labels and artifacts are derived.

4.1.5. Situation Graph ($G_t$)

The Situation Graph is an ontology-aligned structured representation of the individual’s perspective at timestep t. Each $G_t$ is represented as a set of (subject, predicate, object) triplets ${\mathcal{T}}_t=\left\{(s,p,o)\right\}$. Each node $v=(\kappa ,\nu ,\mathit{val})$ carries a kind $\kappa$ drawn from a fixed vocabulary of 13 semantic types (

Table 2. Situation Graph node types ($\kappa$), their type-specific entity enumerations ($\nu$), and allowed values. Closed: the value is fully determined by $\nu$. Open: the value is drawn from the finite, persona-specific label registry produced by Stage 5 and populated by the Autolabeler in Stage 6.

Node Type ($\mathit{\kappa }$)	Allowed Entities ($\mathit{\nu }$)	Allowed Values
MainParticipant	{Person}	Open (value from Stage 5)
Participant	{FamilyMember, Friend, RomanticPartner, Acquaintance}	Open (value from Stage 5)
Activity	{Activity}	Open (value from $\mathcal{E}$ via Stage 5)
Location	{Global, Country, Region, City}	Open (value from Stage 5)
LocationType	{Home, Work, School, Park, Restaurant, Cafe, Hotel, Airport, Gym, Beach, Theatre, Museum, Library}	Open (value from Stage 5)
DayTime	{Morning, Afternoon, Evening, Night}	Closed (value $\in \nu$)
Duration	{Brief, FewHours, HalfDay, FullDay}	Closed (value $\in \nu$)
Ambience	{Serene, Cozy, Vibrant, Chaotic, Mysterious, Majestic, Bleak, Romantic, Calm}	Closed (value $\in \nu$)
SocialContext	{Intimate, Casual, SemiFormal, Professional, Ceremonial}	Closed (value $\in \nu$)
Weather	{Rainy, Sunny, Snowy, Cloudy, Foggy, Windy, Stormy}	Closed (value $\in \nu$)
Temperature	{Hot, Warm, Cool, Cold, Freezing}	Closed (value $\in \nu$)
Emotion	{Happy, Sad, Fear, Disgust, Anger, Surprise}	Closed (value $\in \nu$)
Valence	{Positive, Negative}	Closed (value $\in \nu$)

), an entity type $\nu$ drawn from a type-specific enumeration, and a free-text value populated by the autolabeler in Stage 6. The construction and structural validation of these relational representations builds conceptually upon recent advances in contextual scene graph generation [32], adapting visual-spatial grounding techniques to track latent psychological state. An illustrative example of a fully constructed Situation Graph for a single timestep is provided in Figure 3.

Edges are drawn from 16 typed relations organized into five semantic groups: core action, spatiotemporal, atmospheric, environmental, and psychological (

Table 3. Situation Graph constraint map: complete set of valid (source kind → target kind) pairs for each of the 16 edge types. The five semantic edge groups—core action, spatiotemporal, atmospheric, environmental, and psychological—were designed to cover the canonical dimensions of human situation representation identified in cognitive science [33,34].

Semantic Group	Edge Type (p)	Valid $({\mathit{\kappa }}_{\mathit{s}}\to {\mathit{\kappa }}_{\mathit{o}})$
Core action	performs	MainParticipant → Activity
	experiences	MainParticipant → Activity; Participant → Activity
	joins	Participant → Activity
	interacts_with	MainParticipant → Participant; Participant → MainParticipant; Participant → Participant
Spatiotemporal	occurs_at	Activity → Location
	has_type	Location → LocationType
	occurs_during	Activity → DayTime
	lasts_for	Activity → Duration
Atmospheric	has_ambience	Activity → Ambience; Location → Ambience
	has_social_context	Activity → SocialContext; Location → SocialContext
Environmental	has_weather	Activity → Weather
	has_temperature	Activity → Temperature
Psychological	feels	MainParticipant → Emotion; Participant → Emotion
	has_valence	Emotion → Valence
	evokes	Activity → Emotion
	conveys_valence	Activity → Valence

). A predefined constraint map $\mathcal{A}:\mathrm{EdgeKind}\to \mathcal{P}(\mathrm{NodeKind}\times \mathrm{NodeKind})$ specifies the valid source–target node-type pairs for each edge type. Table 3 provides the complete constraint map; a triplet $(s,p,o)$ is structurally valid if and only if $({\kappa }_s,{\kappa }_o)\in \mathcal{A}\left(p\right)$. This rigid schema ensures that every generated graph is structurally valid (R4), providing explicit, ontology-grounded supervision for downstream perspective inference tasks.

4.2. Phase I: Persona Initialization (Stages 1–3)

Phase I defines and constructs the initial state of the simulated persona as well as the controlled event space from which future situations will be sampled.

4.2.1. Stage 1: Backstory Generation

Given a Persona Scaffolding $\mathcal{S}$, an LLM generates a coherent narrative backstory $\mathcal{B}$ that integrates all eight scaffolding dimensions into a unified biographical text. The prompting strategy encourages three properties: (i) every scaffolding field must be incorporated, (ii) personality traits must be illustrated through concrete behaviors rather than abstract descriptions, and (iii) the narrative must maintain internal logical consistency across life chronology, relationships, and motivations. Because $\mathcal{B}$ is synthesized entirely from $\mathcal{S}$ without reference to real individuals, this stage satisfies privacy safety (R7).

A representative prompt for this stage is provided in Appendix A.1.

4.2.2. Stage 2: Event Taxonomy Loading

The Event Taxonomy $\mathcal{E}$ is loaded from a static, versioned JSON specification containing 260 events across 14 categories. The taxonomy is a fixed, human-curated resource organized as a dictionary mapping category names to lists of specific events. This deterministic loading ensures full reproducibility (R6) and provides a controlled, auditable event space that supports systematic ablation over event categories (R1).

A representative filtering prompt is provided in Appendix A.2.

4.2.3. Stage 3: Initial Persona Matrix Extraction

The backstory $\mathcal{B}$ is processed by an LLM to extract and synthesize the initial Persona Matrix $P_0\sim {\varphi }_{\Theta }(·\mid \mathcal{S})$. The LLM maps narrative elements to the fourteen schema clusters, quantifies traits on their defined scales (e.g., Big Five on $[1,5]$, belief orientations on $[0,1]$), and infers reasonable values for underspecified attributes while maintaining internal consistency. The output is validated against the full typed schema to ensure all required fields are present, correctly typed, and within declared bounds (R4).

A representative system prompt for this extraction step is provided in Appendix A.3.

4.3. Phase II: Trajectory Simulation (Stages 4–5)

Phase II generates the latent longitudinal trajectory of the focal individual. Given the initial Persona Matrix $P_0$ and the event taxonomy $\mathcal{E}$, it constructs the Persona Path ${\left\{(P_t,E_t)\right\}}_{t=1}^T$ through sequential, state-conditioned simulation. This trajectory forms the structured backbone from which later labels and multimodal artifacts are derived.

To maintain coherence over long horizons, each timestep is generated through a validation-gated loop conditioned on the bounded history summary $H_{t-1}$ and cumulative narrative summaries. Stage 4 constructs the Persona Path itself, while Stage 5 derives a reusable registry of label values for subsequent Situation Graph generation.

4.3.1. Stage 4: Persona Path Generation

Stage 4 is the core simulation stage of PAiNT. It generates the full Persona Path ${\left\{(P_t,E_t)\right\}}_{t=1}^T$ through a multi-agent event-processing loop in which each timestep is gated by specialized validation agents. Rather than relying on a single prompt to produce an entire transition, the pipeline decomposes each event–reaction–update cycle into discrete substeps with independent validation. This modular design improves controllability and helps mitigate incoherence over long trajectories.

The generation pipeline processes T events sequentially using an EventProcessingAgent that orchestrates ten specialized sub-agents in sequence:

• Category Selection: selects an event category from $\mathcal{E}$ conditioned on recent history $H_{t-1}$;
• Event Selection: samples a specific event from the selected category;
• Time Selection: assigns a date and time within the simulation horizon;
• Event Validation: rejects implausible events, near-duplicates within the recent history window, life-stage inconsistencies, or overrepresented categories;
• Reaction Generation: produces the persona’s emotional and behavioral response conditioned on $P_{t-1}$ and $H_{t-1}$;
• Reaction Validation: checks that the reaction is sufficiently specific, state-consistent, and temporally appropriate;
• State Update Generation: proposes an updated Persona Matrix $P_t$ reflecting the impact of the event;
• State Validation: enforces schema invariants, including constant-feature preservation and valid value ranges;
• State Finalization: applies the validated state update;
• Summary Generation: produces a natural-language summary of the transition for long-range context management.

Each generate–validate pair (steps 2/4, 5/6, 7/8) operates with a bounded retry mechanism of up to R = 3 attempts per validation. For events, if all attempts fail validation, a deterministic fallback event (e.g., “daily routine”) with probability $1.0$ is auto-approved, guaranteeing completion. For reactions and state updates, the last attempt is accepted on exhaustion. This bounded retry protocol ensures that the pipeline always terminates (R3) while maintaining generation quality through multi-round refinement.

At each step, generation is conditioned on the history summary (Equation (4)), $H_{t-1}=h_{\Theta }(P_{t-k:t-1},E_{t-m:t-1})$, where k and m are configurable sliding-window sizes (default k = m = 3). The sliding window keeps the structured state passed to each agent within a fixed token budget. To preserve long-range narrative context beyond this window, the Summary Generation sub-agent appends a natural-language summary after every state transition; the accumulated summaries are then passed alongside the windowed state to each agent, giving it access to the persona’s complete history without requiring the full sequence of structured Persona Matrices.

Representative event-selection and event-validation prompts are provided in Appendix A.4.1 and Appendix A.4.2, respectively; analogous prompts govern reaction generation, reaction validation, Persona Matrix update, and Persona Matrix validation within the same loop.

4.3.2. Stage 5: Label Extraction

Stage 5 derives a reusable registry of label values from the completed Persona Path. This registry is not itself a Situation Graph; rather, it is an intermediate structure used in Stage 6 to instantiate graph nodes with persona-consistent participants, locations, and activities. Its role is therefore to bridge the latent trajectory generated in Stage 4 and the ontology-aligned labels constructed in Phase III.

The pipeline is implemented as a three-node agent graph with a conditional loop:

• Seed List Agent: extracts initial label values from $P_0$ and the backstory $\mathcal{B}$ for five expandable node types: MainParticipant, Participant, Activity, Location, and LocationType.
• Iterative List Agent: scans each $(P_t,E_t)$ pair in the Persona Path to identify additional label values from the event context (e.g., names of people involved, locations visited, activities performed).
• List Verifier Agent: validates, merges, and deduplicates extracted values. A conditional edge routes back to Step 2 if $t<T$; otherwise the loop terminates.

The output is a typed dictionary that maps each node kind to its available grounded values (e.g., Participant ↦ {“Maya”: “Friend”, “Josh”: “Acquaintance”}). Stage 6 then uses this registry to populate Situation Graph nodes with consistent, trajectory-aligned identifiers.

4.4. Phase III: Artifact Generation (Stages 6–8)

Phase III converts the simulated latent trajectory into explicit perspective labels and observable multimodal artifacts. Given the Persona Path ${\left\{(P_t,E_t)\right\}}_{t=1}^T$, this phase first constructs a Situation Graph $G_t$ for each timestep and then generates a corresponding set of artifacts $X_t$. In this way, the latent state trajectory produced in Phase II is translated into labeled, partially observable digital footprints.

4.4.1. Stage 6: Situation Graph Generation

For each tuple $(P_t,E_t,R_t)$ in the Persona Path—where $R_t$ is the persona’s reaction to $E_t$ generated in natural language—Stage 6 produces a Situation Graph $G_t=g_{\Theta }(P_t,E_t,H_{t-1})$ (Equation (5)) via a two-step process. First, an LLM extracts an unlabeled graph as a set of $(subject,predicate,object)$ triplets, constrained to use only the 13 node types, 16 edge types, and valid source–target pairs defined by Table 3, with a maximum of 20 nodes per graph. Each graph must include at minimum a MainParticipant, Activity, Location, DayTime, Emotion, and Valence node.

Second, an Autolabeler populates the value field of each node by selecting from the finite, persona-specific label registry produced in Stage 5. Recall that the label registry maps each expandable node kind to its set of grounded label values (e.g., Participant $\mapsto \{“\mathrm{Maya}”:“\mathrm{Friend}”,“\mathrm{Josh}”:“\mathrm{Acquaintance}”\}$; Activity $\mapsto \left\{“\mathrm{Making}\mathrm{a}\mathrm{New}\mathrm{Friend}”:“\mathrm{Activity}”\right\}$). Given the unlabeled graph produced in Step 1, the current Persona Matrix $P_t$, and the event context $E_t$, the Autolabeler selects the registry label that best fits each node’s role in the situation, grounding abstract node types to persona-consistent entities (e.g., mapping a Location node typed as City to “Toronto” rather than a generic placeholder). For closed-enumeration node types (Table 2), no autolabeling is required: the value is fully determined by the entity type $\nu$.

This design plays a critical role in maintaining cross-timestep character coherence. Because every node value is drawn from the same shared label registry across all T timesteps, the Autolabeler enforces referential consistency: the same friend, location, or recurring activity is always denoted by the same canonical identifier throughout the trajectory. Without this mechanism, independently generated graphs could introduce synonymous but lexically distinct references to the same entity (e.g., “Maya” at t = 3 vs. “Friend” at t = 12), degrading entity co-reference and downstream artifact quality. In effect, the label registry acts as a persona-specific but trajectory-global controlled vocabulary, and the Autolabeler is the mechanism that binds each graph to it. This grounding propagates directly into Stages 7–8: because artifact specification and generation are conditioned on $G_t$, the specificity and consistency of registry values determine whether the resulting text, image, and audio artifacts exhibit coherent, persona-differentiating content across the full simulation horizon.

A representative prompt for graph generation is provided in Appendix A.5.

4.4.2. Stage 7: Artifact Specification

Given $(P_t,E_t,G_t)$, Stage 7 determines which artifacts should be generated for the current situation and with what parameters. Its purpose is to translate the latent state and structured perspective label into a concrete artifact-generation plan while preserving cross-modal alignment. This stage is implemented as a three-layer pipeline:

• Constraint Filtering: a Universal Constraints Agent applies both rule-based and LLM-based filters to eliminate implausible artifact types. Rule-based checks enforce behavioral plausibility, such as limiting posting frequency or rejecting image types that would be inconsistent with the situation. An LLM-based coherence check then verifies that each remaining artifact type is appropriate given $P_t$ and $G_t$.
• Footprint Flow Construction: an LLM determines the set, ordering, and dependency structure of the artifacts to be generated for the current timestep, producing a structured generation plan.
• Parameter Generation: for each selected artifact type, the pipeline generates detailed modality-specific parameters, such as recipients, tone, visual content, or audio characteristics, using validated typed schemas.

• The candidate artifact pool spans six text types (email, text message, social media post, journal entry, search query, Twitter post), six audio types (phone recording, voicemail, conversation, voice memo, ambient soundscape, audio clip), and three image types (photo, phone photo, family picture).

4.4.3. Stage 8: Multimodal Artifact Generation

Modality-specific generators produce observable artifacts $X_t\sim {\rho }_{\Theta }(·\mid P_t,E_t,G_t,H_{t-1})$ (Equation (5)), conditioned on the artifact parameters from Stage 7. The three modality generators execute as parallel tasks:

• Text: Email, text message, social media post, journal entry, and search query—generated via persona-aware structured prompting with first-person voice, natural hesitations, and typed output schemas.
• Audio: Voice memos, voicemails, conversation recordings, and ambient soundscapes—generated through a multi-agent pipeline (context analysis → script writing → tone initialization → voice design → audio effects → humanization) with a voice registry for speaker consistency and text-to-speech synthesis conditioned on emotional state. For soundscapes, the pipeline skips script writing, tone initialization, and voice design.
• Image: Photos and visual content—generated via text-to-image models with identity-consistent character embeddings derived from $P_t$.

• All modality generators receive a unified Situation State Description derived from $G_t$, ensuring cross-modal consistency (R5). Artifacts are stored with rich metadata linking each item to its generative context $(P_t,E_t,G_t,\Theta )$, supporting full auditability (R6).

A representative text-modality system prompt is provided in Appendix A.6.

4.5. Implementation

PAiNT is implemented in Python 3.12.3 with three core dependencies.

Prefect orchestrates the eight-stage pipeline as a directed acyclic graph of tasks: Stages 1→2→3→4 execute linearly; Stage 6 depends on Stages 1 and 4; Stage 7 depends on Stages 4 and 6; and Stage 8 depends on Stages 4, 6, and 7, with its three modality generators (text, audio, image) executing as parallel sub-tasks. Each Prefect task supports automatic retries (up to 2) and input-based caching for incremental re-runs.

LangGraph is used for multi-agent coordination in the stages that require conditional control flow. In particular, it supports the validation-gated event-processing loop in Stage 4 and the iterative label registry construction in Stage 5. Pydantic is used throughout the pipeline to enforce typed schemas and validate structured outputs.

The framework supports configurable LLM backends through a provider abstraction and exposes the main generation parameters through $\Theta$, including the random seed, temporal resolution, simulation horizon, and context window sizes $(k,m)$. All generated outputs—including configurations, prompts, intermediate states, labels, and final artifacts—are persisted with provenance metadata, enabling reproducibility (R6) and controlled ablation studies (R1).

The full source code, documentation, and usage instructions are available in the project repository1.

Downstream Task: Situation Graph Prediction

The paired data produced by PAiNT—multimodal artifacts $X_t$ alongside ontology-aligned Situation Graph labels $G_t$—naturally support the downstream task of Situation Graph Prediction (SGP): given observable artifacts from a single situation, the structured perspective representation $G_t$ that encodes the entity’s goals, affect, social context, and appraisal is inferred. The SGP task is formally defined in prior work [35] as a structured inverse-inference problem: recovering an ontology-aligned perspective representation $G_t$ from observable multimodal artifacts $X_t$. In the PAi paradigm, SGP is an important supervised task because a sequence of predicted Situation Graphs can form the basis of a longitudinal Chronicle.

PAiNT’s contribution to SGP in this paper is as a data generator and benchmarking resource. By exposing $G_t$ as an explicit label with complete coverage within the simulation, PAiNT provides paired artifact–graph data intended to support future training and evaluation for SGP-style tasks. We demonstrate and evaluate a basic SGP pipeline on the downstream SGP task (Section 7.8), but defer measuring the transfer utility of the generated supervision to future work. A more detailed description of the released benchmark resource is provided in Section 7.

5. Metrics and Evaluation Protocol

We evaluate PAiNT using a metric suite designed to assess structural validity, temporal coherence, narrative consistency, and multimodal faithfulness2. The metrics are organized into three families (

Table 4. Summary of the PAiNT evaluation metrics. The suite includes constraint-satisfaction metrics, which function as validity checks, and characterization metrics, which support comparative analysis across experiments.

Metric	Definition
Category: Persona Representation Quality
Structural
OCV: Ontology & Constraint Validity	Checks whether each Persona Matrix satisfies the schema and ontology constraints (field types, value ranges, invariants).
Temporal
TSCD: Temporal Smoothness & Controlled Drift	Detects implausibly large per-step attribute changes using calibrated daily rate caps and hard absolute ceilings.
TMD: Temporal Macro Drift	Detects generative stagnation by measuring cumulative drift budget utilization for state-like attributes across the full trajectory.
TVS: Temporal Volatility Structure	Evaluates whether the distributional pattern of step-level drift activity exhibits structured variability—neither mechanically uniform nor chaotically erratic.
THC: Temporal Horizon Compliance	Evaluates whether the generated trajectory respects the configured simulation horizon, penalizing both temporal undershoot and overshoot with an asymmetric band-pass scoring function.
Event-Driven
EQ: Event Quality	Measures the fraction of sampled events that appear in the canonical Event Taxonomy, detecting event hallucination.
NCNC: Narrative Coherence & Non-Contradiction	Assesses logical consistency of the event timeline using rule-based prerequisite checks, attribute-scoped NLI contradiction detection, and an LLM-based narrative plausibility audit.
Category: Distributional & Stability Diagnostics
Silhouette Score (Inter-Class Separation)	Quantifies how well Persona Matrices cluster by archetype in identity state space using the mean silhouette coefficient.
Final-State Spread (Intra-Class Stability)	Measures within-archetype dispersion of terminal identity states across stochastic seeds using mean Euclidean distance to the archetype centroid.
Category: Artifact–Graph Alignment
SGC: Situation Graph Consistency	Evaluates whether generated artifacts entail (and do not contradict) facts encoded in the corresponding Situation Graph.
SGF: Situation Graph Faithfulness	Evaluates whether facts asserted by generated artifacts are grounded in the corresponding Situation Graph, penalizing contradictions and treating ungrounded elaboration as neutral.

, Figure 4): persona representation quality, which evaluates structural, temporal, and event-driven properties of the evolving Persona Path; distributional and stability diagnostics, which quantify inter-archetype separability, intra-archetype dispersion, and the geometry of identity trajectories in state-vector space; and data generation quality, which evaluates graph-level consistency and cross-modal alignment of generated artifacts.

Three design principles guide this suite. First, complementary coverage: each metric targets a failure mode not captured by the others, so the suite functions as an interlocking diagnostic rather than a collection of redundant scores. Second, requirement traceability: every metric operationalizes at least one of the design requirements R1–R7 (Section 3). Third, dual-role scoring: some metrics function as constraint-satisfaction checks, where violations indicate direct failures of the framework’s declared operating conditions, while others function as characterization diagnostics that support comparative analysis without defining a universal benchmark of realism. This distinction, used throughout Section 6, is critical for interpretation.

Within persona representation quality, we distinguish three sub-categories. Structural metrics verify that each generated Persona Matrix is well formed with respect to the PAiNT schema (OCV). Temporal metrics evaluate how numerical attributes evolve across consecutive transitions: whether the trajectory respects the configured simulation horizon (THC), whether individual steps remain plausible (TSCD), whether sufficient cumulative change accrues over the full trajectory (TMD), and whether the distributional pattern of step-level drift activity exhibits structured variability rather than a mechanically uniform or chaotically erratic pattern (TVS). Event-driven metrics assess the quality and coherence of the event sequence itself: whether selected events are grounded in the canonical taxonomy (EQ) and whether the resulting narrative satisfies causal logic and semantic plausibility (NCNC).

5.1. Notation

Throughout this section, we assume a single identity with a single trajectory ${\left\{(P_t,E_t,G_t,X_t)\right\}}_{t=1}^T$, as defined in Section 3. Each event $t\in \{1,\dots ,T\}$ is an evaluation unit.

For any metric score S, we use the following conventions:

• $S_t\in [0,1]$ denotes the event-level score at timestep t.
• For any index set $\mathcal{I}\subseteq \{1,\dots ,T\}$, the aggregated score over $\mathcal{I}$ is $S\left(\mathcal{I}\right):={\displaystyle \frac{1}{\left|\mathcal{I}\right|}}{\sum }_{t\in \mathcal{I}}{S}_t$.
• When the index set is the full trajectory, we write $S:=S\left(\{1,\dots ,T\}\right)={\displaystyle \frac{1}{T}}{\sum }_{t=1}^T{S}_t$, and refer to S (without subscript) as the trajectory-level score.

When needed, we additionally use $S_t\left(x_t^{\left(m\right)}\right)$ to denote the score for a single artifact $x_t^{\left(m\right)}\in X_t$ of modality $m\in {\mathcal{M}}_t$ associated with event t.

5.2. Persona Representation Quality Metrics

This section introduces seven metrics—organized into structural (OCV), temporal (THC, TSCD, TMD, TVS), and event-driven (EQ, NCNC) sub-categories—that quantitatively evaluate the quality and coherence of evolving personas as represented through the Persona Matrix (Section 4). The Persona Matrix tracks both stable dimensions (e.g., ethnic background) and dynamic dimensions (e.g., stress level, work-life balance) that evolve as the persona experiences simulated events over time.

5.2.1. Ontology and Constraint Validity (OCV)

• Question.

Is every generated Persona Matrix structurally well formed according to the PAiNT schema?

OCV is a structural prerequisite: it checks that every piece of data produced by the pipeline is valid with respect to the fundamental rules and constraints defined by the Persona Matrix schema. PAiNT applies OCV to two distinct data structures: the Persona Matrix (Stage 4) and the Situation Graph (Stage 6). For each structure, OCV verifies that all attributes conform to their respective schemas, as defined in Section 4.1.3 and Section 4.1.5 for the Persona Matrix and Situation Graph, respectively. If structural validity fails, no downstream metric can be trusted, because temporal, narrative, and distributional analyses all assume well-typed input. Since PAiNT generates data used to train graph-based machine learning models, it is critical that both the Persona Matrix structure and Situation Graph generated by PAiNT follow their pre-defined schema. OCV measures how well the data follow the desired structure quantitatively.

• Design.

In our implementation, OCV is evaluated by passing each data structure through the same Pydantic schema that PAiNT uses internally for validation. A structure that passes all schema checks receives a score of 1.0; a structure with k faulty attributes out of $N_{\mathrm{attr}}$ total receives a proportionally reduced score.

Formally, let ${\left\{P_t\right\}}_{t=1}^T$ be the sequence of Persona Matrices for the identity. Let $N_{\mathrm{attr}}$ be the total number of attributes in the schema, and let $k\left(P_t\right)$ denote the count of attributes in $P_t$ that violate schema constraints. We define the OCV score for timestep t as:

$${\mathrm{OCV}}_t=\left\{\begin{array}{cc}0,\hfill & \mathrm{if}{P}_t\mathrm{is}\mathrm{missing},\hfill \\ \max \left(0,1-\frac{k\left(P_t\right)}{N_{\mathrm{attr}}}\right),\hfill & \mathrm{otherwise}.\hfill \end{array}\right.$$

The trajectory-level OCV is the average across all T timesteps:

$$\mathrm{OCV}:={\displaystyle \frac{1}{T}}{\displaystyle \sum _{t=1}^T}{\mathrm{OCV}}_t.$$

• Note.

The two data structures exhibit qualitatively different OCV behavior, reflecting differences in their generation mechanisms. For Persona Matrices, PAiNT’s Stage 4 pipeline includes a self-regeneration mechanism that discards any matrix failing Pydantic validation and retries generation until it succeeds, guaranteeing $\mathrm{OCV}=1.0$ by construction across all reported experimental conditions. We therefore treat Persona Matrix OCV as a pipeline guarantee rather than a differentiating experimental outcome. For Situation Graphs, no equivalent regeneration loop is applied in Stage 6, so OCV functions as a standard empirical metric.

5.2.2. Temporal Horizon Compliance (THC)

• Question.

Does the generated trajectory respect the specified simulation horizon, or is the generator overshooting or undershooting the target time window?

PAiNT is configured with an explicit simulation horizon $H_{\mathrm{target}}$ (e.g., 365 days for a one-year simulation, 1825 days for five years). A well-behaved generator should produce a Persona Path whose temporal span closely matches this target: a trajectory configured for one year should not terminate after three months (undershoot) or stretch to three years (overshoot). Unlike the other temporal metrics (TSCD, TMD, TVS), which evaluate the content of attribute transitions, THC evaluates the temporal scaffolding itself. Consequently, THC serves as a critical upstream diagnostic: because TSCD, TMD, and TVS scale their allowed drift budgets based on elapsed time, a generator that overshoots the horizon artificially inflates its allowed variance. THC ensures that fundamental temporal calibration failures do not appear falsely competitive on downstream metrics.

• Design: span ratio and coverage.

Let $\{d_1,\dots ,d_T\}$ denote the dates parsed from the Persona Matrices $\{P_1,\dots ,P_T\}$. We define the actual horizon as

$$H_{\mathrm{actual}}=\max \left(1,(\underset{i}{\max }{d}_i-\underset{i}{\min }{d}_i)\mathrm{in}\mathrm{days}\right),$$

(6)

clamped to a minimum of 1 day. The span ratio is:

$$r={\displaystyle \frac{H_{\mathrm{actual}}}{H_{\mathrm{target}}}}.$$

(7)

THC combines two complementary sub-scores: a span score that penalizes deviations in total trajectory length, and a coverage score that penalizes events placed outside the nominal window.

• Span score.

The span score evaluates the ratio r against an acceptable band $[r_{\mathrm{under}},r_{\mathrm{over}}]$ using an asymmetric linear band-pass function (Equation (A3) in Appendix C). The asymmetry is deliberate: overshoot is penalized more aggressively than undershoot. A generator that undershoots by 50% receives a span score of 0.60—degraded but not catastrophic—while a generator that overshoots by $2\times$ receives a span score of 0.10, reflecting a fundamental failure of temporal control. Full parameterization and rationale are provided in Appendix C.

• Coverage score.

The coverage score measures the fraction of Persona Matrices whose dates fall within the nominal simulation window $[d_1,d_1+H_{\mathrm{target}}]$:

$$f_{\mathrm{in}}={\displaystyle \frac{\left|\{i:d_i\le d_1+H_{\mathrm{target}}\}\right|}{T}}.$$

(8)

A trajectory with $f_{\mathrm{in}}=1.0$ places all events within the target window; a trajectory that overshoots will have $f_{\mathrm{in}}<1.0$ because late events fall outside the window. Coverage complements the span score: a generator that concentrates most events within the target window but allows a few to spill over will receive high coverage but a reduced span score.

• Final THC score.

The trajectory-level THC is a weighted combination of the two sub-scores:

$$\mathrm{THC}=w_{\mathrm{span}}·{\mathrm{BP}}_{\mathrm{span}}\left(r\right)+w_{\mathrm{cov}}·f_{\mathrm{in}},$$

(9)

where $w_{\mathrm{span}}=0.60$ and $w_{\mathrm{cov}}=0.40$. The higher weight on span reflects the primacy of total horizon compliance: a trajectory that covers the right timeframe is more valuable than one that merely keeps events within the window by truncating early.

• Limitations.

THC evaluates temporal extent but not temporal density: a trajectory that places 90 events in the first month and 10 in the remaining 11 months will score well despite exhibiting highly uneven event spacing. A dedicated event-spacing metric is a direction for future work.

5.2.3. Temporal Smoothness and Controlled Drift (TSCD)

• Question.

Are individual transitions between consecutive Persona Matrices plausible—i.e., do numerical identity attributes change at rates consistent with empirically calibrated human dynamics?

A person’s core traits and internal states should not change abruptly from one moment to the next. A persona whose stress level jumps from 1.0 to 5.0 between two events separated by three days, or whose Big Five openness shifts by two full points in a single step, is exhibiting implausible dynamics regardless of whether the schema is well formed. TSCD detects such implausibly large per-step attribute changes, serving as a per-transition upper bound on the rate and magnitude of identity evolution.

• Design: rate caps and absolute ceilings.

For each monitored numerical attribute $a\in {\mathcal{A}}_{\mathrm{num}}$, we define two calibrated thresholds:

• A daily rate cap $r_a>0$: the maximum plausible sustained change per elapsed day. This represents the rate that would be implausible to sustain across the full inter-event interval $\Delta t$—it is not the maximum possible single-day fluctuation (which can be higher for volatile attributes like weight due to hydration effects), but rather the rate at which sustained drift becomes incoherent.
• A hard absolute ceiling $M_a>0$: the maximum allowable magnitude of change in a single transition, regardless of elapsed time. This acts as a secondary guard for long inter-event gaps where the rate check alone would become too permissive.

These thresholds are calibrated against the attribute scales defined in the Persona Matrix schema. For example, personality traits (OCEAN) are scored on a $[1,5]$ scale with a range of 4.0, while belief system attributes are scored on a $[0,1]$ scale with a range of 1.0. The rate caps are scaled proportionally so that the constraint strength (expressed as a fraction of the attribute’s total range) is comparable across all dimensions. The rate caps are grounded in published longitudinal data for personality traits, body weight, and perceived stress, then extended to remaining attributes by proportional scaling; the full derivation protocol and complete parameter table are provided in Appendix B (

Table A1. TSCD daily rate caps ($r_a$) and absolute ceilings ($M_a$) for all monitored attributes. Attributes above the mid-rule are derived via the 99th-percentile protocol (Equation (A2)); those below are set by proportional range-matching.

Attribute	Scale	${\mathit{r}}_{\mathit{a}}$	${\mathit{M}}_{\mathit{a}}$
Personality (O,C,E,A,N)	$[1,5]$	0.002	1.5
Body weight (kg)	cont.	0.050	7.0
Stress level	$[1,5]$	0.010	3.0
Fitness	$[1,5]$	0.003	2.0
Coping styles †	$[1,5]$	0.003	1.5
Relational closeness ‡	$[1,5]$	0.004	2.0
Work–life balance	$[1,5]$	0.004	2.0
Nutritional habits	$[1,5]$	0.003	2.0
Belief system §	$[0,1]$	0.0005	0.4

^† Avoidance, impulsivity, emotional reactiveness, emotional regulation, escapism. ^‡ Per relationship type. ^§ Existential, nihilist, humanism, stoicism, political leaning. Scaled entries preserve the same constraint strength (rate cap as a fraction of the attribute’s total range) as the empirically anchored attribute. Three attributes are excluded from monitoring: height (adult invariant), BMI (derived; would double-penalize weight), and anxiety level (unbounded schema range).

).

• Attribute set.

We monitor $|{\mathcal{A}}_{\mathrm{num}}|=21$ fields spanning Big Five personality traits (5), weight (1), fitness (1), stress level (1), coping styles (5), work-life balance (1), nutritional habits (1), relational closeness (1, per relationship type), and belief system dimensions (5, on a $[0,1]$ scale). Three attributes are explicitly excluded: height (invariant for adults—any change is a schema error, not a drift violation), BMI (a derived field whose inclusion would double-penalize weight changes), and anxiety level (no bounded schema range is defined, making rate-cap calibration undefined). The complete monitored attribute set is listed in Appendix B.3.

• Violation criterion.

For a transition from $P_{t-1}$ to $P_t$ with elapsed time $\Delta t_t$ days, the observed change in attribute a is ${\delta }_{a,t}=|P_t\left(a\right)-P_{t-1}\left(a\right)|$, and the implied daily rate is ${\delta }_{a,t}/\Delta t_t$. A violation is flagged when either:

$${\displaystyle \frac{{\delta }_{a,t}}{\Delta t_t}}>r_a(\mathrm{rate}\mathrm{violation}:\mathrm{too}\mathrm{fast})$$

(10)

or

$${\delta }_{a,t}>M_a(\mathrm{ceiling}\mathrm{violation}:\mathrm{too}\mathrm{large}\mathrm{in}\mathrm{absolute}\mathrm{terms}).$$

(11)

Let $V_t\subseteq {\mathcal{A}}_{\mathrm{num}}$ be the set of attributes that trigger a violation at transition t, and let $F_t\le \left|{\mathcal{A}}_{\mathrm{num}}\right|$ be the number of attributes successfully observed (i.e., present and numeric in both $P_{t-1}$ and $P_t$). The per-transition TSCD score is:

$${\mathrm{TSCD}}_t=\left\{\begin{array}{cc}0,\hfill & \mathrm{if}{P}_{t-1}\mathrm{or}{P}_t\mathrm{is}\mathrm{missing},\hfill \\ 1-{\displaystyle \frac{|V_t|}{F_t}},\hfill & \mathrm{otherwise}.\hfill \end{array}\right.$$

(12)

The trajectory-level TSCD is averaged over all $T-1$ transitions:

$$\mathrm{TSCD}:={\displaystyle \frac{1}{T-1}}{\displaystyle \sum _{t=2}^T}{\mathrm{TSCD}}_t.$$

(13)

• Elapsed time handling.

The elapsed time $\Delta t_t$ is computed from the date fields of consecutive Persona Matrices, clamped to a minimum of 1 day to prevent division-by-zero in rate calculations. This clamping means that multiple events occurring on the same simulated day are evaluated under the strictest possible rate constraint, which is the desired behavior: sub-daily attribute fluctuations should be minimal.

• Limitations.

TSCD evaluates individual transitions in isolation. A trajectory in which every step is smooth but attributes never cumulatively change—generative stagnation—will receive a perfect TSCD score. This complementary failure mode is addressed by TMD (Section 5.2.4).

5.2.4. Temporal Macro Drift (TMD)

• Question.

Over the full trajectory, do state-like attributes accumulate meaningful change commensurate with the elapsed time, or is the persona generatively stagnant?

A trajectory can satisfy TSCD perfectly—every step small and smooth—yet produce a persona that barely evolves across hundreds of simulated days. This complementary failure mode is generative stagnation. A persona whose stress level, fitness, or relational closeness remains effectively unchanged over a simulated year is not exhibiting the expected accumulation of change over time for state-like attributes, regardless of how smooth each individual step is. TMD detects this failure by measuring how much of the available drift budget each attribute actually consumed.

• Design: budget utilization.

For each state-like attribute a, the maximum available drift budget across the full trajectory is derived directly from the TSCD daily rate caps:

$${\mathrm{TV}}_{\max }\left(a\right):={\displaystyle \sum _{t=2}^T}{r}_a·\Delta t_t,$$

(14)

where $r_a$ is the daily rate cap (the same parameter used by TSCD) and $\Delta t_t$ is the elapsed time in days for transition t. The observed total variation is:

$${\mathrm{TV}}_{\mathrm{obs}}\left(a\right):={\displaystyle \sum _{t=2}^T}|P_t\left(a\right)-P_{t-1}\left(a\right)|.$$

(15)

The utilization ratio is:

$$u_a:=\min \left(1,{\displaystyle \frac{{\mathrm{TV}}_{\mathrm{obs}}\left(a\right)}{{\mathrm{TV}}_{\max }\left(a\right)}}\right)\in [0,1].$$

(16)

The min clamp handles the case where TSCD violations cause observed drift to exceed the rate-cap budget; such attributes have trivially consumed their full budget and receive no TMD penalty. A per-attribute score is then computed:

$${\mathrm{TMD}}_a=\left\{\begin{array}{cc}1.0,\hfill & \mathrm{if}{u}_a\ge {\theta }_a,\hfill \\ u_a/{\theta }_a,\hfill & \mathrm{if}{u}_a<{\theta }_a,\hfill \end{array}\right.$$

(17)

where ${\theta }_a$ is a minimum utilization threshold for attribute a. If a state-like attribute uses at least ${\theta }_a$ fraction of its available budget, no penalty is applied; otherwise, the penalty is proportional to the shortfall.

The trajectory-level TMD score is the weighted mean across all state-like attributes, where each attribute is weighted by the number of transitions $n_a$ for which it was successfully observed:

$$\mathrm{TMD}:={\displaystyle \frac{{\sum }_{a\in {\mathcal{A}}_{\mathrm{state}}}{n}_a·{\mathrm{TMD}}_a}{{\sum }_{a\in {\mathcal{A}}_{\mathrm{state}}}{n}_a}}.$$

(18)

• Attribute classification: state-like vs. trait-like.

TMD intentionally restricts evaluation to state-like attributes—those for which stagnation is pathological. The monitored set ${\mathcal{A}}_{\mathrm{state}}$ includes: weight, fitness, stress level, work–life balance, nutritional habits, emotional reactiveness, and relational closeness (per relationship type). Trait-like attributes—Big Five personality traits, belief system dimensions, and most coping styles—are explicitly excluded from TMD. Stagnation in stable traits is not a failure; it is an expected property of coherent personas. The full classification rationale is provided in Appendix B.4.

• Minimum utilization thresholds.

Default thresholds are ${\theta }_a=0.05$ (5% budget utilization) for most attributes. Two exceptions are made: weight uses ${\theta }_a=0.03$ because its rate cap ($0.050$ kg/day) yields a large absolute budget where 5% already represents non-trivial kilogram-scale movement; stress uses ${\theta }_a=0.08$ because it is the most volatile state-like attribute and a frozen stress trajectory is the clearest signal of generative stagnation.

• Key properties.

TMD has several properties that distinguish it from simpler stagnation detectors such as a stall rate (the fraction of transitions with zero observed change): (i) it is continuous—no binary cliff from step-count thresholds; (ii) it is density-invariant—${\mathrm{TV}}_{\max }$ scales with actual elapsed days, so sparse and dense simulations are compared fairly; (iii) it inherits TSCD rate caps—a single shared parameter set ensures consistency, though this also means calibration errors are correlated; (iv) it is robust to epsilon gaming—cumulative total variation cannot be inflated by tiny per-step nudges without accumulating real movement.

• Limitations.

TMD measures the amount of cumulative change but not its distributional pattern across steps. A trajectory that concentrates all change in a single burst and then stagnates for the remaining steps may still satisfy TMD’s budget threshold. This distributional failure mode is addressed by TVS (Section 5.2.5).

5.2.5. Temporal Volatility Structure (TVS)

• Question.

Does the pattern of identity drift across timesteps exhibit the statistical texture of naturalistic variability—neither mechanically uniform nor chaotically erratic—and at a plausible overall activity level?

TSCD and TMD together bound individual-step and cumulative drift, but neither evaluates the distributional shape of drift activity across the trajectory. A generator that produces mechanically identical step sizes at every transition (uniform activity), or that alternates wildly between near-zero and maximal updates (erratic oscillation), satisfies both TSCD and TMD but fails to produce the naturalistic variability expected in real human change. TVS addresses this gap by characterizing the statistical structure of the step-level drift sequence.

• Design: normalized step utilization.

For each transition t (comparing $P_{t-1}$ to $P_t$ with elapsed time $\Delta t_t$ days), we compute a normalized step utilization ${\tilde{D}}_t$ that expresses how much of the available TSCD rate budget was consumed at that step:

$${\tilde{D}}_t:={\displaystyle \frac{1}{|{\mathcal{A}}_t|}}\sum _{a\in {\mathcal{A}}_t}{\displaystyle \frac{|P_t\left(a\right)-P_{t-1}\left(a\right)|}{r_a·\Delta t_t}},$$

(19)

where ${\mathcal{A}}_t\subseteq {\mathcal{A}}_{\mathrm{num}}$ is the subset of attributes successfully observed in both $P_{t-1}$ and $P_t$, and $r_a$ is the TSCD daily rate cap for attribute a.

Intuitively, ${\tilde{D}}_t=0$ means nothing moved at step t; ${\tilde{D}}_t=1$ means every attribute simultaneously hit its TSCD rate ceiling; ${\tilde{D}}_t>1$ indicates TSCD violations (over-drift) at that step. The sequence $({\tilde{D}}_2,\dots ,{\tilde{D}}_T)$ encodes the full temporal activity profile of the trajectory.

• Three diagnostic statistics.

From the utilization sequence, we extract three statistics that characterize complementary aspects of distributional health.

(i) Mean utilization ($\overline{D}$): the overall activity level across the trajectory.

$$\overline{D}:={\displaystyle \frac{1}{T-1}}{\displaystyle \sum _{t=2}^T}{\tilde{D}}_t.$$

(20)

(ii) Coefficient of variation ($\mathrm{CV}$): the distributional spread of activity across steps.

$$\mathrm{CV}:={\displaystyle \frac{{\sigma }_{\tilde{D}}}{\overline{D}+\epsilon }},$$

(21)

where ${\sigma }_{\tilde{D}}=\sqrt{{\displaystyle \frac{1}{T-2}}{\sum }_{t=2}^T{({\tilde{D}}_t-\overline{D})}^2}$ is the sample standard deviation, and $\epsilon ={10}^{-8}$ prevents division by zero.

(iii) Sequential jitter ($\mathcal{J}$): mean-normalized first-difference roughness, measuring step-to-step irregularity.

$$\mathcal{J}:={\displaystyle \frac{\frac{1}{T-2}{\sum }_{t=3}^T|{\tilde{D}}_t-{\tilde{D}}_{t-1}|}{\overline{D}+\epsilon }}.$$

(22)

• Band-pass scoring.

Each statistic is evaluated against an acceptable band $[v_{\min },v_{\max }]$ using a linear band-pass function:

$$\mathrm{BP}(x;v_{\min },v_{\max },w):=\left\{\begin{array}{cc}1,\hfill & \mathrm{if}{v}_{\min }\le x\le v_{\max },\hfill \\ \max \left(0,1-{\displaystyle \frac{d\left(x\right)}{w}}\right),\hfill & \mathrm{otherwise},\hfill \end{array}\right.$$

(23)

where $d\left(x\right)=\max (v_{\min }-x,x-v_{\max },0)$ is the distance from the nearest band edge and $w>0$ is the penalty half-width controlling how rapidly the score decays outside the band.

The bands and penalty half-widths (all set to $w=0.40$) are as follows:

Statistic	Acceptable Band	Penalty Half-Width
$\overline{D}$ (MeanUtil)	$[0.05,0.80]$	0.40
CV	$[0.25,0.90]$	0.40
$\mathcal{J}$ (Jitter)	$[0.20,0.95]$	0.40

The band boundaries are motivated by the mathematical behavior of each statistic at its extremes. For $\overline{D}$, a value below $0.05$ implies near-complete stagnation: on average, fewer than 5% of the available drift budget is consumed per step, meaning the persona barely changes regardless of elapsed time. A value above $0.80$ implies that the trajectory sustains near-maximal drift continuously—as though every simulated period is one of extreme personal upheaval. For CV, a value below $0.25$ indicates that step-level activity is nearly uniform across the trajectory, a mechanical regularity inconsistent with the episodic nature of real human change; a value above $0.90$ indicates that activity is so unevenly distributed that a handful of steps account for almost all drift while the rest are effectively inert. For $\mathcal{J}$, a value below $0.20$ indicates that the activity level changes very smoothly from step to step—suggestive of a templated or deterministic generator rather than naturalistic variation—while a value above $0.95$ indicates wild oscillation between high and low activity at every transition. The penalty half-width $w=0.40$ is set to be comparable in magnitude to the band widths, ensuring scores decay gradually outside the acceptable range rather than dropping sharply at the boundary. In the absence of high-resolution longitudinal ground truth for identity drift, these bounds should be interpreted as heuristic guardrails rather than a calibrated realism baseline.

• Final score.

Using the shorthands: ${\mathrm{BP}}_{\overline{D}}:=\mathrm{BP}(\overline{D};0.05,0.80,0.40)$, ${\mathrm{BP}}_{\mathrm{CV}}:=\mathrm{BP}(\mathrm{CV};0.25,0.90,0.40)$ and ${\mathrm{BP}}_{\mathcal{J}}:=\mathrm{BP}(\mathcal{J};0.20,0.95,0.40)$, the TVS score is the equally weighted mean of the three band-pass scores:

$$\mathrm{TVS}:={\displaystyle \frac{1}{3}}{\mathrm{BP}}_{\overline{D}}+{\displaystyle \frac{1}{3}}{\mathrm{BP}}_{\mathrm{CV}}+{\displaystyle \frac{1}{3}}{\mathrm{BP}}_{\mathcal{J}}.$$

(24)

Equal weighting reflects the fact that each statistic captures a distinct property: overall activity level, distributional spread, and sequential texture.

• Attribute set.

TVS uses the same set of $|{\mathcal{A}}_{\mathrm{num}}|=21$ numerical attributes as TSCD (Section 5.2.3), with the same exclusions (height, BMI, anxiety level) and the same rate caps $r_a$.

• Limitations.

The band calibration is empirical and may not transfer to substantially different simulation configurations (e.g., radically different temporal resolutions or persona schemas). We mitigate this by choosing wide bands and providing the band parameters as configurable inputs. Additionally, TVS evaluates drift patterns at the trajectory level and does not localize specific timesteps where the volatility structure degrades—it is a global diagnostic, not a per-step score.

5.2.6. Event Quality (EQ)

• Question.

Are the events sampled during trajectory generation grounded in the canonical Event Taxonomy, or is the generator hallucinating events outside the predefined catalogue?

PAiNT employs a controlled Event Taxonomy—a predefined catalogue of plausible life events organized into categories (Section 4.1.2). Even with Stage 2 loading and Stage 4 event validation, the event-selection step may still produce events whose names do not appear in this taxonomy. Such hallucinated events undermine the controlled event space on which later evaluation depends: if the event inventory is not stable, downstream metrics that rely on event semantics (e.g., NCNC prerequisite rules) may be operating on undefined or unintended inputs.

• Design.

Let $\mathcal{E}$ denote the set of all event names in the canonical Event Taxonomy. EQ measures the fraction of trajectory events whose name appears in the taxonomy:

$$\mathrm{EQ}:={\displaystyle \frac{1}{T}}{\displaystyle \sum _{t=1}^T}{1}_{\{E_t\in \mathcal{E}\}}.$$

(25)

A score of 1.0 indicates that all sampled events are grounded in the taxonomy and no hallucination occurred.

• Implementation.

The canonical event list is stored as a JSON dictionary mapping category names to lists of event names. Event matching is performed by exact string comparison after whitespace trimming; no fuzzy matching is applied. This strict matching is intentional—it tests whether the generator produces events exactly as specified in the taxonomy, not merely events that are semantically similar.

• Relationship to PAiNT pipeline stages.

In the full PAiNT pipeline, Stage 2 (Event Taxonomy Loading) curates the event list and Stage 4 (Persona Path Generation) includes an Event Validation agent with retry logic. EQ therefore also functions as an end-to-end test of these validation mechanisms: a score below 1.0 indicates that the validation agents are failing to catch hallucinated events.

• Limitations.

EQ is a necessary but not sufficient condition for event quality. A taxonomy-grounded event may still be contextually implausible for a given persona (e.g., “Retirement” for a 20-year-old)—such semantic violations are the domain of NCNC (Section 5.2.7). Additionally, EQ does not evaluate the diversity or distribution of event selection within the taxonomy; a trajectory that repeatedly samples the same event would score 1.0 on EQ despite exhibiting generative monotony.

5.2.7. Narrative Coherence and Non-Contradiction (NCNC)

• Question.

Is the generated event timeline logically consistent and narratively plausible—free from causal violations, factual contradictions, and implausible sequences?

In PAiNT, the simulated event timeline must be both logically consistent and narratively plausible. A single evaluation mechanism is insufficient: rule-based systems can miss higher-level semantic incoherence, LLM-based audits may be variable, and pairwise NLI checks cannot capture global trajectory plausibility on their own. We therefore evaluate NCNC using three complementary components, each targeting a different class of failure.

• Phase 1: Rule-based NCNC.

This component acts as a deterministic constraint checker, verifying that the sequence of events respects fundamental laws of causality (hard constraints). It applies a set of common-sense prerequisite rules—such as “Marriage” must occur before “Divorce” for the same partner, or “Job loss” cannot precede “Employment” at the same company—across the full sequence of T events. Each rule $r\in \mathcal{R}$ specifies a set of dependent patterns (events that require a precondition) and a corresponding set of prerequisite patterns (events that must have occurred earlier in the timeline). Matching is performed case-insensitively against event names and descriptions.

An event at time t is considered flagged if it matches a dependent pattern and no prior event matches the corresponding prerequisite. Let $1_{\mathrm{flagged}}\left(t\right)=1$ if event t is flagged, and 0 otherwise.

$${\mathrm{NCNC}}_t^{\mathrm{Rule}}:=1-1_{\left\{\mathrm{flagged}\right\}}\left(t\right),{\mathrm{NCNC}}_{\mathrm{Rule}}:={\displaystyle \frac{1}{T}}{\displaystyle \sum _{t=1}^T}{\mathrm{NCNC}}_t^{\mathrm{Rule}}.$$

(26)

The complete prerequisite rule set is provided in Appendix D.

• Phase 2: Attribute-scoped NLI contradiction detection.

While rules catch hard causal violations, they cannot detect factual contradictions within the generated content. This component uses a structured extraction and Natural Language Inference (NLI) pipeline to identify contradictions at the level of individual facts.

The pipeline operates in three stages: (1) Structured fact extraction: an LLM extracts atomic facts from each event as tuples $(\mathrm{category},\mathrm{attribute},\mathrm{value},\mathrm{assertion})$, where categories are constrained to a fixed set (employment, location, relationship, education, financial, health, social, identity, habits); (2) Candidate identification: facts are grouped by $(\mathrm{category},\mathrm{attribute})$ and filtered for simultaneous contradictions (same timestep, different values) and unexplained reversions ($A\to B\to A$), while facts at different timesteps with different values are classified as legitimate state transitions; (3) NLI confirmation: only the filtered candidate pairs are evaluated by a DeBERTa-v3-large cross-encoder NLI model [36], with a contradiction confirmed only at confidence threshold ≥ 0.80. Implementation details are provided in Appendix D.

Let ${\mathcal{I}}_{\mathrm{NLI}}\subseteq \{1,\dots ,T\}$ be the set of timesteps implicated by any confirmed NLI contradiction. The NLI-based score is:

$${\mathrm{NCNC}}_{\mathrm{NLI}}:=1-{\displaystyle \frac{|{\mathcal{I}}_{\mathrm{NLI}}|}{T}}.$$

(27)

• Phase 3: LLM-based semantic audit.

Neither rules nor pairwise NLI can assess global narrative plausibility—whether the overall arc of the persona’s life makes sense as a coherent trajectory. This component utilizes the semantic reasoning capabilities of an LLM, prompted with (i) the backstory and (ii) the observable event timeline. The LLM is instructed to identify five categories of issues: logical contradictions, causal violations, temporal impossibilities, character breaks, and repetition artifacts. It returns a set of issues, each with implicated event indices and a severity level in $\{\mathrm{high},\mathrm{medium},\mathrm{low}\}$.

Let ${\mathcal{I}}_{\mathrm{LLM}}\subseteq \{1,\dots ,T\}$ be the set of events implicated by any issue:

$${\mathrm{NCNC}}_{\mathrm{LLM}}:=1-{\displaystyle \frac{|{\mathcal{I}}_{\mathrm{LLM}}|}{T}}.$$

(28)

• Combined NCNC score.

The three phase scores are combined as a weighted average:

$$\mathrm{NCNC}:=w_{\mathrm{Rule}}·{\mathrm{NCNC}}_{\mathrm{Rule}}+w_{\mathrm{NLI}}·{\mathrm{NCNC}}_{\mathrm{NLI}}+w_{\mathrm{LLM}}·{\mathrm{NCNC}}_{\mathrm{LLM}},$$

(29)

where $w_{\mathrm{Rule}}=0.35$, $w_{\mathrm{NLI}}=0.35$, and $w_{\mathrm{LLM}}=0.30$. The weighting reflects relative confidence: rule-based checks are deterministic and noise-free; NLI checks are concrete but may contain model noise; LLM audits are the most expressive but also the most variable.

• Design rationale: why three phases?

The three-phase design addresses a fundamental tension in narrative evaluation. Rule-based systems are precise but narrow—they can only check pre-specified patterns and miss emergent incoherence. NLI models can detect factual contradictions but lack temporal reasoning and cannot distinguish a legitimate state transition from a true contradiction without explicit scoping. LLM-based judges can reason holistically about narrative plausibility but are prone to hallucination and inconsistency, and their judgments are not reproducible. By combining all three, NCNC achieves coverage across hard logic (Phase 1), structured factual consistency (Phase 2), and soft semantic plausibility (Phase 3).

• Limitations.

The rule-based component is limited by the coverage of the prerequisite rule set; violations of rules not in $\mathcal{R}$ will not be detected. The NLI component depends on the quality of structured fact extraction, which is itself LLM-generated and may miss or misclassify facts. The LLM audit is non-deterministic and may flag different issues across replicates. We mitigate this variability by running R independent replicates where feasible and reporting mean scores.

5.2.8. Identity State Vectorization for Distance-Based Analyses

To support clustering and distance-based diagnostics, each hierarchical Persona Matrix $P_t$ is mapped to a flat Identity State Vector $v_t\in {\mathbb{R}}^D$.

We construct $v_t$ by concatenating three sub-vectors:

$$v_t=v_t^{\mathrm{psy}}\oplus v_t^{\mathrm{fix}}\oplus \left(\lambda v_t^{\mathrm{nar}}\right),$$

(30)

where $D=15+K+3072$ and each component draws from the Persona Matrix schema (Section 4.1.3) as follows.

• Core Psychology ($v_t^{\mathrm{psy}}\in {[0,1]}^{15}$).

This sub-vector concatenates three groups of continuous scalars, each linearly rescaled to $[0,1]$: the Big Five personality traits (openness, conscientiousness, extraversion, agreeableness, neuroticism; originally $[1,5]$), five coping-style dimensions (avoidance, impulsivity, emotional reactiveness, emotional regulation, escapism; originally $[1,5]$), and five belief-system dimensions (existential, nihilist, humanism, stoicism, political leaning; natively $[0,1]$, clamped).

• Fixed Identity ($v_t^{\mathrm{fix}}\in {\{0,1\}}^K$).

Eight categorical fields are one-hot encoded under a shared column registry that fixes column order across all runs: income class, age group, work style, average sleep quality, communication style, handedness, eye color, and gender. The registry is seeded with all schema-defined enum values before any data are processed; free-text variants encountered at runtime (e.g., “woman” → “female”) are canonicalized before encoding. In the experiments reported here, $K=30$.3

• Narrative ($v_t^{\mathrm{nar}}\in {\mathbb{R}}^{3072}$).

The persona’s life driver, long-term goals, and fears fields are concatenated into a single string and embedded with OpenAI text-embedding-3-large (dimension 3072). The scaling factor $\lambda$ prevents the high-dimensional embedding from dominating Euclidean distances: we set $\lambda =0.05$ for t-SNE visualisation and $\lambda =0.5$ for centroid-based analyses (Silhouette Score, Final-State Spread).

• Design note.

By construction, the state vector captures identity-defining attributes—personality, demographics, beliefs, and goals—while deliberately excluding volatile state variables (stress level, fitness, weight, work–life balance) that evolve in response to events. The latter are separately evaluated by the temporal metrics TSCD and TMD (Section 5.2.3 and Section 5.2.4). This separation ensures that the distributional diagnostics measure whether archetype identity persists across stochastic seeds, rather than whether transient state fluctuations happen to converge.

5.2.9. Inter-Class Separation: Silhouette Score

• Question.

Do distinct archetype priors produce separable regions in identity state space, or does the generator collapse different archetypes into overlapping clusters?

For each state vector $v_i$ belonging to archetype cluster $C_i$, define the mean intra-cluster distance $a\left(i\right)$ and the mean nearest-cluster distance $b\left(i\right)$:

$$\begin{array}{cc}\hfill a\left(i\right)& ={\displaystyle \frac{1}{|C_i|-1}}\sum _{\begin{array}{c}j\in C_i\\ j\ne i\end{array}}d(i,j),\hfill \end{array}$$

(31)

$$\begin{array}{cc}\hfill b\left(i\right)& =\underset{C\ne C_i}{\min }{\displaystyle \frac{1}{\left|C\right|}}\sum _{j\in C}d(i,j),\hfill \end{array}$$

(32)

where $d(i,j)=\parallel v_i-v_j{\parallel }_2$. The per-point silhouette score is:

$$s\left(i\right)={\displaystyle \frac{b\left(i\right)-a\left(i\right)}{\max \left(a\right(i),b(i\left)\right)}}\in [-1,1],$$

(33)

and the overall silhouette score is the population mean:

$$\overline{S}={\displaystyle \frac{1}{n}}{\displaystyle \sum _{i=1}^n}s\left(i\right).$$

(34)

Values near $+1$ indicate tight, well-separated clusters; values near 0 indicate overlapping clusters; negative values indicate systematic misassignment.

5.2.10. Final-State Spread (Intra-Class Stability)

• Question.

Given the same archetype prior and generation configuration, do independent stochastic runs converge to consistent terminal identity states, or does randomness cause unbounded divergence?

For each archetype a with R independent runs, we compute the centroid of the terminal state vectors and the mean Euclidean distance to that centroid:

$${\mu }_a={\displaystyle \frac{1}{R}}{\displaystyle \sum _{r=1}^R}{v}_T^{\left(r\right)},$$

(35)

$${\overline{d}}_a={\displaystyle \frac{1}{R}}{\displaystyle \sum _{r=1}^R}{∥v_T^{\left(r\right)}-{\mu }_a∥}_2.$$

(36)

Lower ${\overline{d}}_a$ indicates greater terminal-state consistency: stochastic event noise does not erase the archetype identity signal. Final-State Spread is reported per-archetype rather than aggregated, preserving diagnostic granularity for identifying which archetypes are most sensitive to stochastic variation.

5.3. Data Generation Quality

These metrics evaluate alignment between generated artifacts and their corresponding Situation Graphs. Unlike structural validity metrics, they are best interpreted diagnostically: they characterize coverage, groundedness, and contradiction patterns rather than defining a single normative target for realistic artifacts.

5.3.1. Situation Graph Entailment Consistency (SGC)

• Question.

Do generated artifacts entail the facts encoded in their corresponding Situation Graph, or do they omit or contradict ground-truth content?

SGC measures the extent to which generated artifacts reflect facts encoded in their corresponding Situation Graphs. For example, if the graph states that a person is jogging in a park with a friend, SGC evaluates whether the generated text, image, or audio is consistent with that content rather than omitting or contradicting it.

Let ${\mathcal{M}}_t$ denote the set of modalities generated at event t, and let ${\mathcal{T}}_t$ denote the set of fact triplets extracted from the Situation Graph $G_t$. For each artifact $x_t^{\left(m\right)}\in X_t$ and hypothesis triplet $h\in {\mathcal{T}}_t$, let $p_{\mathrm{ent}}(h\mid x_t^{\left(m\right)})$ and $p_{\mathrm{con}}(h\mid x_t^{\left(m\right)})$ be the NLI (Natural Language Inference) probabilities that artifact $x_t^{\left(m\right)}$ entails or contradicts hypothesis h. Define the artifact-level score:

$${\mathrm{SGC}}_t\left(x_t^{\left(m\right)}\right)={\displaystyle \frac{1}{\left|{\mathcal{T}}_t\right|}}\sum _{h\in {\mathcal{T}}_t}{\displaystyle \frac{p_{\mathrm{ent}}(h\mid x_t^{\left(m\right)})-p_{\mathrm{con}}(h\mid x_t^{\left(m\right)})+1}{2}}.$$

(37)

The event-level SGC score is:

$${\mathrm{SGC}}_t={\displaystyle \frac{1}{\left|{\mathcal{M}}_t\right|}}\sum _{m\in {\mathcal{M}}_t}{\mathrm{SGC}}_t\left(x_t^{\left(m\right)}\right).$$

(38)

The final SGC is reported as the mean over all t.

5.3.2. Situation Graph Faithfulness (SGF)

• Question.

Are the facts asserted by generated artifacts grounded in the corresponding Situation Graph, or does the artifact introduce hallucinated or contradictory content?

While SGC measures coverage—whether the artifact reflects Situation Graph facts—it does not evaluate whether the artifact introduces unsupported or contradictory content. SGF addresses this complementary direction by reversing the premise–hypothesis relation: the Situation Graph serves as the premise, and artifact-extracted triplets serve as hypotheses. Intuitively, SGF measures the groundedness of the artifact: how much of what the artifact asserts is actually supported by the graph.

For each artifact $x_t^{\left(m\right)}\in X_t$, let ${\mathcal{T}}_t^{\mathrm{art}}$ denote the set of triplets extracted from the artifact and ${\mathcal{T}}_t$ denote the label triplets from the Situation Graph $G_t$. For each artifact-asserted triplet $h\in {\mathcal{T}}_t^{\mathrm{art}}$, a verdict $v\left(h\right)\in \{+1,-1,0\}$ is assigned using the same three-way classification as SGC: $v\left(h\right)=+1$ if the Situation Graph entails h, $v\left(h\right)=-1$ if it contradicts h, and $v\left(h\right)=0$ if h is neither supported nor contradicted (ungrounded elaboration).

The artifact-level SGF score is:

$${\mathrm{SGF}}_t\left(x_t^{\left(m\right)}\right)={\displaystyle \frac{1}{\left|{\mathcal{T}}_t^{\mathrm{art}}\right|}}\sum _{h\in {\mathcal{T}}_t^{\mathrm{art}}}{\displaystyle \frac{v\left(h\right)+1}{2}}.$$

(39)

This maps entailed triplets to $1.0$, contradicted triplets to $0.0$, and ungrounded triplets to $0.5$—treating elaboration beyond the Situation Graph as neutral rather than penalizing it. The event-level SGF score is:

$${\mathrm{SGF}}_t={\displaystyle \frac{1}{\left|{\mathcal{M}}_t\right|}}\sum _{m\in {\mathcal{M}}_t}{\mathrm{SGF}}_t\left(x_t^{\left(m\right)}\right).$$

(40)

The final SGF is reported as the mean over all t.

• SGC–SGF complementarity.

SGC and SGF form a complementary pair for cross-modal alignment. SGC asks whether the artifact covers the graph content; SGF asks whether the artifact remains grounded in that content. A high-SGC, low-SGF artifact covers the Situation Graph well but introduces substantial unsupported or contradictory material, whereas a high-SGF, low-SGC artifact is grounded but incomplete. Reporting both metrics helps distinguish omission failures from hallucination or contradiction failures.

• Limitations.

SGF’s treatment of “unknown” verdicts as neutral (score $0.5$) is a deliberate design choice that is agnostic about whether ungrounded elaboration is acceptable; a stricter variant could penalize unknowns more aggressively. Both SGC and SGF inherit limitations of the triplet extraction pipeline—facts the parser fails to extract are not evaluated.

6. Experiments

We evaluate PAiNT through five complementary experiments addressing three questions: (i) whether it generates longitudinal identity trajectories that preserve archetypal structure while still allowing controlled variation, (ii) which architectural components govern specific quality dimensions, and (iii) whether the resulting labels, artifacts, and runtime footprint are sufficiently coherent and practical for intended downstream use. The experiments probe five regimes: identity persistence, temporal robustness under horizon compression, architectural contribution, artifact–label alignment, and cost–quality trade-offs across backbone models.

Concretely, Experiment 1 tests whether trajectories remain archetype-consistent over time while preserving seed-level variability; Experiment 2 stress-tests temporal coherence under different horizon/resolution settings; Experiment 3 isolates the contributions of multi-agent orchestration and bounded-history conditioning through ablations; Experiment 4 evaluates the structural validity and semantic alignment of generated Situation Graphs and multimodal artifacts; and Experiment 5 examines computational and financial deployment cost across backbone models. Together, these experiments move from latent-state quality to observable-output quality and finally to operational feasibility.

Section 6.1 first defines the shared conventions used throughout the evaluation. Section 6.2, Section 6.3, Section 6.4, Section 6.5 and Section 6.6 then present the five experiments, each organized around a specific objective, compact setup, relevant metrics, and brief interpretation. Because the metric suite in Section 5 mixes constraint-satisfaction checks with characterization diagnostics, we report only the metrics that are analytically central to the claim under study.

6.1. Experimental Conventions

Before presenting the experiments, we clarify how the evidence in this section should be read. PAiNT is evaluated not as a single black-box predictor on a fixed benchmark, but as a controlled generative framework whose outputs must satisfy structural, temporal, narrative, and cross-modal requirements. Accordingly, different metrics play different epistemic roles: some verify whether the generator satisfies its declared constraints, while others characterize how it behaves under controlled changes in archetype, horizon, architecture, or backbone.

• Evaluation philosophy.

The experiments are designed as structured stress tests rather than population-level statistical studies. Their purpose is to determine whether PAiNT behaves coherently under controlled manipulations, where it fails, and which components are responsible. This framing is especially important because long-horizon multimodal generation remains computationally expensive, making exhaustive large-scale hypothesis testing impractical at this stage. The results therefore provide controlled empirical evidence about framework behavior, not population-level effect estimates.

• Score interpretation.

The metric suite in Section 5 contains two kinds of measurements. The first consists of constraint-satisfaction metrics, such as schema validity (OCV), taxonomy membership (EQ), horizon compliance (THC), and contradiction checks within narrative coherence (NCNC). For these metrics, high scores indicate compliance with explicit design requirements, while low scores indicate direct violations. The second consists of characterization metrics, such as volatility structure (TVS), temporal smoothness and controlled drift (TSCD), temporal macro drift (TMD), inter-archetype separation (Silhouette Score), intra-archetype terminal consistency (Final-State Spread), situation-graph consistency (SGC), and situation-graph faithfulness (SGF). These do not define a universal notion of correctness; instead, they characterize how the generator behaves across archetypes, horizons, ablations, or backbones. Throughout Section 6, we therefore distinguish between validity-style evidence and diagnostic evidence.

• Common configuration settings.

Unless otherwise stated, all experiments use the same PAiNT implementation and evaluation pipeline described in Section 4 and Section 5. We keep fixed the event taxonomy, Persona Matrix schema, Situation Graph ontology, and metric definitions, together with the same validation-gated generation protocol and logging infrastructure. When comparing archetypes, horizons, or architectural variants, non-target factors are held constant as much as possible. When comparing backbone models, prompts, schemas, and orchestration logic are likewise fixed so that differences reflect backbone behavior rather than prompt redesign.

• Selective metric reporting.

Not every metric is equally informative for every experiment. For example, inter-archetype separation is central to identity persistence but irrelevant to deployment cost, while horizon compliance is critical in temporal stress testing but secondary in artifact alignment. We therefore report only the metrics that are analytically relevant for the claim under study, and treat prerequisite invariants such as structural validity as such rather than as differentiating outcomes.

We follow this convention throughout the remainder of Section 6: each experiment isolates a specific question, reports the metrics most relevant to that question, and interprets them according to whether they function as hard validity checks or comparative diagnostics.

6.2. Experiment 1: Identity Persistence Across Archetypes

• Objective.

This experiment tests whether PAiNT’s identity initialization produces a durable archetype signal that persists above stochastic event noise over the full trajectory. We evaluate three claims: C1, transition-level stability, measured by TSCD (Section 5.2.3); C2, inter-class separation in identity state space, measured by the Silhouette Score (Section 5.2.9); and C3, terminal-state consistency across independent runs of the same archetype, measured by Final-State Spread (Section 5.2.10).

• Setup.

We generate trajectories using GPT-5.2 for Stages 1–4. Four archetypes are evaluated: Reserved (Anika), Role Model (Brian), Self-centered (Danielle), and Average (Ethan), initialized from personality-cluster priors following Gerlach et al. [37]. All conditions share the same event pool with stochastic selection. For each archetype, we run $R=5$ seeds ($n=20$ total runs), each with $T=50$ events over a one-year horizon. Occupation, age, location, and start year are held constant across conditions. For state-space analyses, each Persona Matrix is mapped to an Identity State Vector as defined in Section 5.

• Evaluation lens.

We report only the metrics directly tied to the three claims: TSCD for transition-level stability (C1), Silhouette Score for inter-archetype separation (C2), and Final-State Spread for within-archetype terminal consistency (C3). Broader temporal and narrative diagnostics are deferred to experiment 3 (Section 6.4).

• Results.

• C1: Transition-level stability.

The overall mean TSCD is $0.814$ (

Table 5. Experiment 1 summary. All trajectories generated with GPT-5.2.

			Per-Archetype
Metric	Claims	Overall	Anika	Brian	Danielle	Ethan
TSCD	C1	0.814	0.838	0.843	0.755	0.819
Silhouette Score	C2	0.269	0.273	0.113	0.443	0.246
Final Spread	C3	0.932	1.138	0.881	0.961	0.746

), indicating that most per-step updates remain within the calibrated drift bounds. Danielle shows the lowest TSCD ($0.755$), consistent with a more volatile prior. The temporal profile in Figure 5 also reveals a clear warm-up effect: early transitions are less stable, while later transitions converge toward a higher and more stable regime. This pattern is plausible, as early events establish the trajectory and therefore induce larger state updates than later events that reinforce an already-formed identity.

• C2: Inter-class separation.

Archetype separation is moderate but persistent. The mean silhouette score is $\overline{S}=0.269$, with Danielle showing the strongest isolation (0.443) and Brian the weakest (0.113). The t-SNE projection in Figure 6 shows that independent runs remain organized by archetype in identity state space rather than collapsing into a single mixed distribution. The centroid decomposition in

Table 6. Pairwise centroid distance decomposition by sub-vector component, sorted by full distance (descending).

Pair	Full	Core	Fixed	Narrative
Brian–Danielle	2.279	1.440	1.727	0.369
Danielle–Ethan	2.087	1.086	1.746	0.375
Anika–Brian	1.881	0.829	1.651	0.356
Anika–Danielle	1.846	1.313	1.254	0.355
Anika–Ethan	1.755	0.533	1.648	0.282
Brian–Ethan	0.754	0.604	0.328	0.306

offers an initial clue: the Brian–Ethan pair is separated by only 0.328 on the fixed demographic sub-vector—far below the ≥1.25 separation seen for every other pair—suggesting their overlap may stem from shared demographic encodings rather than a collapse of the psychological or narrative signal. We test this directly below.

To assess whether this separation reflects genuine psychological and narrative structure rather than shared demographic encodings, we recomputed the silhouette score on a reduced Identity State Vector with the fixed-identity sub-vector $v^{\mathrm{fix}}$ (the eight demographic one-hot fields) removed, holding all else constant (

Table 7. Inter-archetype silhouette under the full Identity State Vector versus a reduced vector with the fixed-identity (demographic one-hot) sub-vector $v^{\mathrm{fix}}$ removed. Mean silhouette coefficient (Euclidean), $n=250$ per archetype, $\lambda =0.5$.

Archetype	Full	Reduced	$\mathbf{\Delta }$
Anika	0.273	0.451	$+0.178$
Brian	0.113	0.513	$+0.400$
Danielle	0.443	0.469	$+0.026$
Ethan	0.246	0.173	$-0.073$
Overall	0.269	0.401	+0.133

). Removing the demographic block increases overall separation from 0.269 to 0.401 (+0.133), with three of four archetypes improving. The effect is most pronounced for Brian, whose silhouette rises from 0.113—the weakest under the full vector—to 0.513, the strongest under the reduced vector. This confirms and sharpens the Brian–Ethan proximity reported in the centroid decomposition (Table 6): Brian’s low full-vector separation was an artifact of demographic overlap with Ethan, masking a well-separated psychological and narrative signal beneath. The sole exception is Ethan (the Average archetype), whose separation declines from 0.246 to 0.173—expected, since the least psychologically distinctive archetype is the one most dependent on demographic features for separation. Taken together, this confirms that inter-archetype separation arises primarily from the psychological and narrative attributes that PAiNT is designed to model, not from the shared demographic scaffold.

• C3: Terminal-state consistency.

Terminal consistency is also supported. The overall mean terminal spread is $\overline{d}=0.9315$ (Table 5), with Ethan showing the tightest convergence (0.7456) and Anika the widest spread (1.1382). Across timesteps, mean within-archetype spread remains below inter-archetype centroid distance (Figure 7), including at the terminal state. This indicates that stochastic runs of the same archetype converge to a bounded neighborhood while preserving separation from the other archetypes.

• Interpretation.

Taken together, the results support all three claims under the tested conditions. PAiNT produces trajectories that are predominantly smooth at the transition level, remain separable across archetypes, and converge to archetype-consistent terminal neighborhoods despite stochastic event variation. The evidence should nevertheless be read as directional rather than inferential, since each condition uses only $R=5$ seeds and no formal significance testing is performed. The main conclusion is that archetype initialization remains strong enough to persist above stochastic noise while still allowing controlled within-archetype variation.

6.3. Experiment 2: The Longitudinal Stress Test

• Objective.

This experiment characterizes a coherence frontier: the trade-off between temporal resolution and simulation horizon when the same event count is distributed across different timescales. We evaluate four claims: C1, structural invariance across horizons; C2, resolution-dependent drift behavior; C3, systematic temporal-profile advantages for long-horizon configurations; and C4, narrative robustness in the rule-based and factual components of NCNC (Section 5.2.7), together with archetype-specific vulnerability in the plausibility component under temporal compression.

• Setup.

All trajectories were generated with GPT-5.2 for Stages 1–4. We evaluate two archetypes—Danielle (highest drift volatility in Experiment 1, Section 6.2) and Ethan (most stable terminal convergence)—under two horizon settings: 100 events over 100 days (short; approximately daily resolution) and 100 events over 5 years (long; approximately multi-week resolution). Each condition uses $R=5$ seeds, for 20 runs in total.

• Evaluation lens.

We report the temporal and narrative metrics most central to the frontier hypothesis: OCV, TSCD, TMD, TVS, EQ, THC, a simple Composite score defined as their mean, and the three-phase NCNC breakdown (Rule, NLI, LLM, Combined).

• Results.
• C1: Structural invariance.

OCV is 1.00 in all 20 runs, confirming that schema validity is preserved across both horizons and both archetypes under the current pipeline.

• C2: Resolution-dependent drift.

Temporal compression reduces local drift compliance, but not uniformly across archetypes. Short-horizon TSCD is lower than long-horizon TSCD for both Danielle ($0.800\to 0.833$) and Ethan ($0.872\to 0.882$). However, Ethan’s short-horizon TSCD (0.872) remains higher than Danielle’s long-horizon TSCD (0.833), indicating that archetype dynamics contribute at least as much as horizon setting to drift behavior.

• C3: Temporal profile.

The strongest horizon effects appear in TVS and THC. For both archetypes, TVS increases sharply under the long horizon (Danielle: $0.667\to 0.961$; Ethan: $0.653\to 0.983$), while THC rises from a uniform 0.760 in all short-horizon runs to at least 0.964 in all long-horizon runs. By contrast, TSCD, TMD, and EQ change more moderately. This produces a clear composite advantage for long-horizon settings: Danielle improves from 0.818 to 0.917, and Ethan from 0.846 to 0.935 (

Table 8. Experiment 2: Mean metric scores by archetype and horizon ($R=5$ seeds per condition). All generated with GPT-5.2.

Archetype	Horizon	TSCD	TMD	TVS	EQ	THC	Composite
Danielle	short	0.800 ± 0.02	0.701 ± 0.11	0.667 ± 0.00	0.982 ± 0.01	0.760 ± 0.00	0.818 ± 0.02
Danielle	long	0.833 ± 0.03	0.751 ± 0.11	0.961 ± 0.09	0.994 ± 0.01	0.964 ± 0.01	0.917 ± 0.02
Ethan	short	0.872 ± 0.03	0.807 ± 0.01	0.653 ± 0.02	0.988 ± 0.01	0.760 ± 0.00	0.846 ± 0.01
Ethan	long	0.882 ± 0.02	0.781 ± 0.04	0.983 ± 0.02	0.998 ± 0.00	0.966 ± 0.01	0.935 ± 0.01

and

Table 9. Experiment 2: Conditions ranked by Composite score.

Rank	Horizon	Persona	Composite
1	long	Ethan	0.935
2	long	Danielle	0.917
3	short	Ethan	0.846
4	short	Danielle	0.818

).

• C4: Narrative robustness.

The NCNC results (

Table 10. Experiment 2: NCNC scores by archetype and horizon (mean ± std, $R=5$). All generated with GPT-5.2.

		Rule		NLI		LLM		Combined
Archetype	Horizon	Mean	Std	Mean	Std	Mean	Std	Mean	Std
Danielle	long	1.000	0.00	0.998	0.00	0.932	0.05	0.979	0.01
Danielle	short	0.998	0.00	0.994	0.01	0.790	0.12	0.934	0.04
Ethan	long	0.998	0.00	0.988	0.01	0.870	0.09	0.956	0.02
Ethan	short	1.000	0.00	0.990	0.01	0.836	0.10	0.947	0.03

) separate cleanly into robust constraint satisfaction and resolution-sensitive plausibility. The Rule and NLI components remain consistently high across all conditions (means ≥ 0.988), indicating that causal prerequisites and attribute-level consistency are largely preserved under compression. The LLM component is more sensitive. Danielle shows a substantial drop under the short horizon ($0.932\to 0.790$, std = 0.121), whereas Ethan degrades only modestly ($0.870\to 0.836$, std = 0.100). The combined NCNC score therefore remains high overall, but its decomposition reveals that temporal compression disproportionately affects narrative plausibility for the more volatile archetype.

• Interpretation.

These results support what we call the coherence frontier: a multi-dimensional trade-off between temporal resolution, simulation horizon, and archetype volatility. Long-horizon configurations are systematically stronger, but the degradation is not uniform across metrics. As Figure 8 shows, the main penalties of temporal compression fall on TVS and THC, suggesting that volatility structure and horizon compliance are the most resolution-sensitive dimensions of the framework. At the same time, the comparison between Danielle and Ethan shows that archetype dynamics matter independently of resolution: the higher-volatility profile degrades more strongly in drift compliance and narrative plausibility under compression. The evidence should nevertheless be read as directional rather than inferential, since the experiment uses only two archetypes and $R=5$ seeds per condition. The main conclusion is that some quality dimensions remain relatively robust under compression, whereas others exhibit structural ceilings that sharply constrain short-horizon performance within the tested design space.

6.4. Experiment 3: Ablation Study—PAiNT vs. No-Agent vs. No-Memory

• Objective.

This experiment isolates the contribution of PAiNT’s two principal architectural components—multi-agent orchestration and sliding-window history conditioning—across four backbone LLMs. We evaluate four claims: C1, orchestration improves structural integrity and event validity; C2, history conditioning is critical for temporal coherence; C3, backbone families exhibit different performance profiles rather than a single uniform ranking; and C4, THC (Section 5.2.2) is a necessary upstream diagnostic because it reveals temporal calibration failures that other temporal metrics can obscure.

• Setup.

We compare three variants: PAiNT (full pipeline), No-Agent (single-pass generation with history retained but no validation/retry), and No-Memory ($H_{t-1}=\varnothing$ with orchestration retained). Four backbones are evaluated: GPT-5.2, GPT-4o, DeepSeek-V3, and Qwen3-235B-A22B-Instruct. This yields 12 conditions with $R=5$ seeds each (60 runs total), all at $T=50$ events over a one-year horizon. A single archetype, demographic assignment, and event taxonomy are held fixed to isolate architectural and backbone effects.

• Evaluation lens.

We report the metrics most relevant to the ablation claims: EQ, TSCD, TMD, TVS, THC, and the NCNC decomposition (Rule, NLI, LLM). We also report a Temporal composite defined as the mean of TSCD, TMD, TVS, and THC; the NCNC composite defined as the weighted average in Equation (29) ($0.35·\mathrm{Rule}+0.35·\mathrm{NLI}+0.30·\mathrm{LLM}$); and an Overall Composite that aggregates Temporal, EQ, and NCNC.

• Results.

Table 11. Experiment 3: Summary scores sorted by Composite. Shaded (gray) rows denote the full PAiNT pipeline; unshaded rows are ablation variants (No-Memory, No-Agent).

Model	Variant	Temporal	EQ	NCNC	Composite
GPT-5.2	PAiNT	0.854 ± 0.02	1.000 ± 0.00	0.965 ± 0.02	0.940 ± 0.01
GPT-4o	PAiNT	0.807 ± 0.06	1.000 ± 0.00	0.933 ± 0.03	0.913 ± 0.02
GPT-4o	No-Memory	0.761 ± 0.03	1.000 ± 0.00	0.918 ± 0.03	0.893 ± 0.01
GPT-5.2	No-Agent	0.702 ± 0.04	0.972 ± 0.02	0.970 ± 0.02	0.881 ± 0.02
GPT-5.2	No-Memory	0.721 ± 0.02	0.992 ± 0.01	0.926 ± 0.02	0.880 ± 0.01
DeepSeek	No-Memory	0.736 ± 0.05	0.992 ± 0.02	0.899 ± 0.04	0.876 ± 0.02
DeepSeek	PAiNT	0.626 ± 0.05	0.996 ± 0.01	0.895 ± 0.08	0.839 ± 0.03
Qwen3	PAiNT	0.601 ± 0.04	1.000 ± 0.00	0.911 ± 0.03	0.837 ± 0.02
Qwen3	No-Memory	0.567 ± 0.04	1.000 ± 0.00	0.916 ± 0.03	0.828 ± 0.02
GPT-4o	No-Agent	0.578 ± 0.03	0.948 ± 0.05	0.876 ± 0.03	0.801 ± 0.02
DeepSeek	No-Agent	0.540 ± 0.07	0.948 ± 0.06	0.823 ± 0.05	0.770 ± 0.04
Qwen3	No-Agent	0.542 ± 0.03	0.636 ± 0.17	0.896 ± 0.06	0.691 ± 0.06

provides the overall ranking by composite score, while Figure 9 reports the full per-metric breakdown used in the claim-by-claim analysis below.

• C1: Structural integrity and event validity.

The results support the claim that orchestration is most strongly associated with event validity and a major driver of structural reliability under the reported metrics (Figure 9). Under the full PAiNT pipeline, EQ remains near-perfect across all four backbones (≥0.996, with 1.000 for GPT-5.2, GPT-4o, and Qwen3), whereas removing orchestration is accompanied by the largest degradation, especially for open-weight models. The clearest case is Qwen3, where EQ drops from 1.000 under PAiNT to 0.6360 under No-Agent. Proprietary backbones are more robust under ablation (No-Agent EQ ≥ 0.948), but still degrade relative to the full system. A similar pattern appears in narrative plausibility: DeepSeek’s NCNC_LLM falls to 0.432 without agents, but recovers to 0.655 under PAiNT. By contrast, NCNC_Rule and NCNC_NLI remain near ceiling across all conditions, suggesting that low-level causal and factual consistency is comparatively robust, while open-ended narrative plausibility benefits more directly from orchestration.

• C2: History conditioning for temporal coherence.

Removing memory degrades temporal coherence most clearly in TVS and, in some cases, THC. For GPT-5.2, TVS drops from 0.854 under PAiNT to 0.400 under No-Memory. The most severe failure occurs for Qwen3, where No-Memory yields THC = 0.168, corresponding to a severe horizon overshoot. These results indicate that history conditioning is especially important for maintaining naturalistic volatility structure and temporal frame awareness, even when the validation loop is preserved.

• C3: Backbone-dependent profiles.

The backbones do not differ by a single scalar notion of quality; instead, they exhibit distinct performance profiles. Proprietary models occupy the top two composite scores under the full pipeline, led by GPT-5.2/PAiNT at 0.903 and GPT-4o/PAiNT at 0.871 (Table 11). At the same time, open-weight models remain competitive in selected dimensions: DeepSeek/PAiNT achieves the highest TMD (0.916), and Qwen3/PAiNT achieves perfect scores on EQ, NCNC_Rule, and NCNC_NLI. The main divergence is temporal: the open-weight models tend to combine strong cumulative drift with weaker smoothness or volatility structure, producing less balanced temporal profiles overall.

• C4: THC as upstream diagnostic.

THC exposes calibration failures that would otherwise remain partially hidden (Figure 9). Without THC, Qwen3/No-Memory would appear mid-tier on TSCD, TMD, and TVS alone; once THC is included, its temporal score drops to 0.5674 because those scores were achieved over a severely expanded horizon. The same logic applies to DeepSeek/PAiNT, whose high TMD (0.9159) is partly offset by horizon overshoot (THC = 0.6489). THC also clarifies the mechanism of single-pass failure: No-Agent settings do not merely degrade slightly, but often collapse chronologically, with GPT-4o, DeepSeek, and Qwen3 all showing catastrophic THC values near 0.16–0.22. This indicates that orchestration is not only a quality enhancer, but also a practical requirement for maintaining long-range temporal pacing.

• Interpretation.

Taken together, the ablation results show that PAiNT’s two core components are associated with different quality dimensions. We note at the outset that these ablations alter prompt structure and per-call token budget alongside the targeted component; the results below should therefore be read as identifying which components are associated with which quality dimensions, rather than as isolating their independent causal contribution. Multi-agent orchestration is the stronger correlate of event validity, narrative plausibility, and chronological pacing, whereas history conditioning is particularly important for temporal coherence and volatility structure. Across the four backbones, retaining orchestration (No-Memory) yields a higher composite score than retaining memory alone (No-Agent) in three of four cases, with the fourth showing only a small gap. This pattern suggests that active validation is the higher-priority architectural component overall, although the evidence remains directional because the ablations also alter prompt structure and generation flow. More broadly, the experiment shows that backbone choice should be driven by the specific quality dimension required for the downstream task: proprietary backbones are more balanced overall, while open-weight models can remain competitive in narrower dimensions under the full PAiNT architecture. This coupling is partly intrinsic: orchestration and memory improve quality through additional validation passes and context, which necessarily raise token consumption (Section 6.6), so component and cost are not fully separable.

• Limitations.

These results are informative but should be interpreted while understanding their caveats. First, each condition uses $R=5$ seeds, so point estimates may retain non-trivial variance. Second, the ablation variants differ not only in the targeted component but also in prompt structure and generation flow, which weakens causal attribution. Third, the TVS band-pass parameters were calibrated on proprietary-model behavior and may partially disadvantage open-weight backbones. Fourth, the experiment uses a single archetype and a one-year horizon, so the observed interactions may not fully generalize. Finally, NCNC_LLM relies on a single LLM judge without inter-judge agreement analysis.

6.5. Experiment 4: Situation Graph Alignment and Artifact Faithfulness

• Objective.

This experiment evaluates whether, given validated Persona Paths, the downstream pipeline (Stages 5–8) produces structurally valid Situation Graphs and artifacts that remain meaningfully aligned with those graph labels. We evaluate three claims: C1, generated Situation Graphs achieve majority schema compliance, with violations attributable primarily to the graph-generation process rather than to archetype identity; C2, artifact label coverage follows a modality hierarchy, with modality exerting a stronger effect than archetype; and C3, artifact-asserted facts are more often ungrounded elaborations than outright contradictions, with text artifacts achieving the strongest entailment.

• Setup.

For each of the four archetypes from Experiment 1 (Section 6.2), we select the Persona Path closest to the archetype centroid as fixed input to Stages 5–8. We then generate $R=5$ seeds per archetype (20 runs total). GPT-5.2 is used for Situation Graph construction (Stage 6) and text artifact generation; triplet extraction for text, image, and audio transcript is performed using Gemini 3 Pro. Artifacts span text (emails, messages, journal entries, social media, search queries), image (photos, visual content), and audio (voice memos, ambient soundscapes).

All SGC and SGF scores are computed only for steps whose Situation Graph passes schema validation with OCV ≥ 0.80, rather than requiring perfect validity. On inspection, sub-perfect OCV typically reflects values or edge types that deviate from the exact schema-expected form while still encoding the intended, semantically meaningful content, rather than structural breakdown of the graph; such graphs remain reliable references for SGC and SGF, which evaluate semantic artifact–graph alignment rather than exact schema compliance. Requiring OCV = 1.0 would therefore bias the evaluation toward the simplest situations without improving the quality of the alignment signal. On average, 39.3 of 50 steps per run satisfy this threshold, yielding approximately 786 evaluated steps across the 20 runs. As an instrument check, we also evaluate an NLI self-entailment ceiling using identical premise–hypothesis triplets. Across all 1000 steps, mean self-SGC/self-SGF is 0.965, implying that roughly 3.5 percentage points of measured deficit are attributable to instrument limitations rather than generation quality alone.

• Evaluation lens.

We report three classes of evidence: OCV for graph structural validity; SGC for label coverage, that is, how much graph content is reflected in the artifact; and SGF for groundedness, that is, how much of what the artifact asserts is supported by the graph. These metrics are diagnostic rather than normative: perfectly maximal SGC or SGF would imply unrealistically tight coupling between a compressed Situation Graph and a naturalistic artifact. In practice, the more informative failure modes are low SGC, which indicates weak conditioning on the graph, and high contradiction rates in SGF, which indicate active hallucination or conflict.

• Results.
• C1: Graph structural validity.

Situation Graphs achieve majority schema compliance. Mean OCV is $0.8190\pm 0.0395$ overall (

Table 12. Experiment 4: Situation Graph OCV by archetype (mean ± std, $R=5$). Graphs generated with GPT-5.2.

Archetype	OCV (Mean)	OCV (Std)
Anika (Reserved)	0.824	0.037
Brian (Role Model)	0.810	0.039
Danielle (Self-centered)	0.820	0.041
Ethan (Average)	0.822	0.041
Overall	0.819	0.040

), indicating that most graph attributes are structurally valid, though the residual error rate remains non-trivial. Scores are tightly clustered across archetypes (range: 0.8098–0.8241), supporting the claim that the violations arise primarily from the graph-generation process rather than from archetype-specific difficulty. This identifies Stage 6 as a current structural bottleneck: graph generation would likely benefit from stronger post hoc validation or a regeneration mechanism analogous to the one used for Persona Matrices in Stage 4.

• C2: Label coverage follows a modality hierarchy.

A clear modality ordering emerges in SGC (

Table 13. Experiment 4: SGC by archetype and modality (mean ± std, $R=5$). The Mean row reports the cross-archetype mean for each modality.

Archetype	Text	Image	Audio
Anika	0.681 ± 0.08	0.511 ± 0.13	0.577 ± 0.10
Brian	0.659 ± 0.09	0.518 ± 0.13	0.570 ± 0.10
Danielle	0.655 ± 0.10	0.498 ± 0.12	0.543 ± 0.10
Ethan	0.655 ± 0.10	0.517 ± 0.12	0.590 ± 0.08
Mean	0.662 ± 0.02	0.511 ± 0.02	0.570 ± 0.02

): text achieves the highest coverage (0.662), followed by audio (0.570), then image (0.511). This ordering is consistent across archetypes, while archetype-to-archetype variation per modality remains comparatively small (Text: 0.655–0.681; Image: 0.498–0.518; Audio: 0.543–0.590). The evidence therefore supports the claim that modality is the dominant predictor of coverage. Danielle tends to score slightly lower than the other archetypes across modalities, but the effect is modest relative to the modality gap itself.

• C3: Groundedness is limited more by elaboration than by contradiction.

The same modality ordering appears in SGF (

Table 14. Experiment 4: SGF by archetype and modality (mean ± std, $R=5$). The Mean row reports the cross-archetype mean for each modality.

Archetype	Text	Image	Audio
Anika	0.592 ± 0.08	0.503 ± 0.11	0.525 ± 0.09
Brian	0.581 ± 0.09	0.509 ± 0.12	0.499 ± 0.10
Danielle	0.575 ± 0.10	0.501 ± 0.10	0.478 ± 0.10
Ethan	0.583 ± 0.11	0.501 ± 0.10	0.506 ± 0.09
Mean	0.582 ± 0.02	0.505 ± 0.02	0.502 ± 0.02

): text achieves the highest groundedness (0.582), while image (0.505) and audio (0.502) are lower and nearly tied. The verdict distribution in

Table 15. Experiment 4: SGF verdict distribution by modality (% of artifact triplets).

Modality	Positive TE (%)	Non TE (%)	Negative TE (%)	N
Text	31.3	53.4	15.3	12,960
Image	19.8	59.3	20.9	21,606
Audio	18.0	64.8	17.3	12,635
Overall	22.5	59.2	18.4	47,201

provides the clearest interpretation: the dominant category is non-entailment without contradiction (59.2%), whereas negative entailment accounts for 18.4% of artifact triplets overall. Text achieves both the highest entailment rate (31.3%) and the lowest contradiction rate (15.3%), while image exhibits the highest contradiction rate (20.9%). These results support the claim that the main gap is not direct conflict with the Situation Graph, but elaboration beyond what the graph encodes. In that sense, the absolute SGF score should be interpreted together with the verdict composition rather than in isolation.

• Interpretation.

Taken together, the results suggest that the downstream pipeline is already a useful graph-conditioned artifact generator, but its quality is shaped by two different bottlenecks. The first is structural: Situation Graph generation achieves only moderate OCV, and this limits how many steps can be evaluated downstream. The second is modality-dependent grounding: text artifacts are consistently the most aligned and grounded, whereas image and audio artifacts contain more information that falls outside the graph or is harder to recover reliably through triplet extraction. The positive SGC–SGF association in Figure 10 indicates that these are not competing objectives in the present setup: better artifacts tend to be both more comprehensive and more grounded. The evidence should nevertheless be read as diagnostic rather than inferential, since each archetype uses only $R=5$ seeds and the NLI-based measurement pipeline itself has a ceiling below 1.0. The main conclusion is therefore not that artifact fidelity has been solved, but that the current pipeline is already informative enough to localize the dominant structural and modality-specific bottlenecks.

• Limitations.

These results are informative, but we note some caveats that should be considered. First, the Situation Graph label space is uneven: emotionally positive latent labels are overrepresented, which may make some hypotheses easier to entail than more specific surface-level facts. Second, with $R=5$ seeds per condition, per-archetype SGC and SGF estimates retain non-trivial variance. Third, the NLI measurement ceiling of 0.965 implies that a small portion of the observed score deficit is attributable to instrument limitations rather than generation quality. Finally, both SGC and SGF inherit limitations from the triplet extraction pipeline. In particular, facts not extracted are not evaluated, and SGF’s neutral scoring of “unknown” verdicts is one of several defensible choices—stricter alternatives that penalize ungrounded triplets would shift absolute SGF values, but not the cross-modality and cross-archetype comparisons our findings rely on.

6.6. Experiment 5: Cost–Quality Trade-Offs

• Objective.

This experiment evaluates the operational cost of deploying PAiNT and relates that cost to the quality patterns established in Experiments 3–4 (Section 6.4 and Section 6.5). We focus on two questions: first, how the four backbone models compare in monetary cost and wall-clock time for the core persona simulation phase (Stages 1–4); and second, how resource demands scale when the full PAiNT pipeline (Stages 1–8) is executed end-to-end with the highest-performing backbone.

• Setup.

Cost estimates are derived from the mean per-run token counts observed in our experiments for trajectories of $T=50$ events with $R=5$ seeds. Backbone comparison uses the full PAiNT configuration from Experiment 3 (Section 6.4) for Stages 1–4. Full-pipeline scaling is measured from 20 complete GPT-5.2 runs spanning Stages 1–8. Prices reflect the API endpoints used in our experiments as of April 2026 and exclude caching discounts, bulk-rate agreements, or infrastructure-specific optimizations.

• Evaluation lens.

We report input tokens, output tokens, estimated USD cost, and wall-clock time. Cost is interpreted jointly with the quality evidence from Experiment 3 (Section 6.4): the main issue is not simply which model is cheapest, but which model offers the most useful balance between quality, cost, and latency under the full PAiNT architecture.

• Results.
• Backbone comparison for Stages 1–4.

Table 16. Estimated per-run cost for the persona simulation phase of 50 timesteps (Stages 1–4) under the full PAiNT configuration. Token counts are means over $R=5$ seeds. Costs are calculated as $(\mathrm{Input}\times \mathrm{Rate})+(\mathrm{Output}\times \mathrm{Rate})$.

Model	Input (M)	Output (M)	Est. Cost (USD)	Time (min)
GPT-5.2	3.341	0.369	11.01	95.11
GPT-4o	2.364	0.209	7.99	42.04
DeepSeek-V3 †	2.570	0.188	4.00	125.15
Qwen3-235B-A22B †	3.332	0.346	1.25	193.62

^† Served via the Replicate API; proprietary models served via the OpenAI API.

summarizes the estimated per-run cost of the core simulation phase under the full PAiNT configuration, while

Table 17. Per-run token and runtime footprint by backbone and architectural variant from Experiment 3 (Section 6.4) ($R=5$ seeds). Shaded rows correspond to the full PAiNT pipeline. This table quantifies the computational overhead of orchestration and memory relative to the ablated variants.

Model	Variant	Input (M)	Output (M)	Time (min)
GPT-5.2	PAiNT	3.341	0.369	95.11
GPT-5.2	No-Memory	1.822	0.375	90.20
GPT-5.2	No-Agent	0.552	0.141	26.32
GPT-4o	PAiNT	2.364	0.209	42.04
GPT-4o	No-Memory	1.318	0.219	56.30
GPT-4o	No-Agent	0.370	0.059	9.60
DeepSeek	PAiNT	2.570	0.188	125.15
DeepSeek	No-Memory	1.306	0.216	124.73
DeepSeek	No-Agent	0.371	0.069	26.40
Qwen3	PAiNT	3.332	0.346	193.62
Qwen3	No-Memory	1.537	0.343	178.14
Qwen3	No-Agent	0.530	0.139	75.14

provides the corresponding token and runtime footprint across architectural variants. The cost landscape separates into three broad tiers. Qwen3 is the least expensive backbone at USD 1.25 per run, followed by DeepSeek-V3 at USD 4.00, GPT-4o at USD 7.99, and GPT-5.2 at USD 11.01. These differences are driven not only by token volume but also by provider-specific pricing structure: Qwen3 remains inexpensive despite high token consumption, whereas GPT-5.2 and GPT-4o incur substantially higher output-token costs.

Cost does not align monotonically with quality. GPT-5.2 delivers the strongest overall performance under the full PAiNT pipeline (Composite = 0.9027 in Experiment 3, Section 6.4) but at the highest monetary cost. GPT-4o provides the second-best quality (Composite = 0.8712) at 27% lower cost and less than half the wall-clock time. At the other extreme, Qwen3 is the most economical option but shows substantial weaknesses in temporal coherence, particularly on TVS. This confirms that deployment decisions should be guided by the specific quality floor required by the downstream use case rather than by cost alone.

• Architectural overhead.

Table 17 also clarifies the cost of PAiNT’s architectural safeguards. Across all four backbones, the full PAiNT pipeline requires substantially more tokens and time than either No-Agent or No-Memory. For example, GPT-5.2/PAiNT consumes 3.34 M input tokens and 95.1 min per run, compared with 0.55 M input tokens and 26.0 min for GPT-5.2/No-Agent. Similar gaps hold across the other backbones. This overhead is the operational price of the quality gains identified in Experiment 3 (Section 6.4): orchestration and history conditioning improve structural integrity and temporal coherence, but they do so by substantially increasing interaction depth and runtime.

• Full-pipeline scaling (Stages 1–8).

To estimate end-to-end deployment cost, we executed 20 complete PAiNT runs using GPT-5.2, the highest-performing backbone in Experiment 3 (Section 6.4). As shown in

Table 18. Resource consumption and estimated cost for the full PAiNT pipeline (Stages 1–8) using GPT-5.2. Values represent both the aggregate and mean across 20 complete persona trajectories.

Metric	Input (M)	Output (M)	Cost (USD)	Time (min)
Total (20 runs)	111.190	13.264	380.28	4202.84
Mean per run	5.560	0.663	19.01	210.14

, the full pipeline consumes on average 5.56M input tokens and 0.66M output tokens per persona, for a mean cost of USD 19.01 and a mean wall-clock time of 210.1 min. Relative to the Stages 1–4 baseline—whose cost–quality trade-off across backbones and architectural variants is shown in Figure 11—this corresponds to roughly 66% more input tokens, 80% more output tokens, and more than a doubling of elapsed time per run. At this scale, generating a dataset of 100 complete persona trajectories would cost approximately USD 1901 before parallelization or optimization.

• Interpretation.

Taken together, the cost results show that PAiNT is already practical for controlled research-scale generation, but still expensive enough that deployment choices must be metric-aware. GPT-5.2 serves as the highest-quality reference configuration, whereas GPT-4o appears to be the strongest practical compromise between quality, speed, and monetary cost. Open-weight backbones offer substantial savings, but those savings are meaningful only if the resulting trajectories satisfy the structural and temporal quality floors required by the intended downstream use case. More broadly, these results confirm that PAiNT’s architectural improvements are not free: validation and memory materially increase runtime and token consumption, so the framework should be configured according to whether the target application prioritizes maximum quality, lower cost, or faster iteration.

• Limitations.

These estimates are deployment-specific and should be interpreted accordingly. They depend on the API endpoints, pricing schedules, and inference settings used in our experiments, and therefore may change over time or under other providers. The analysis also excludes volume discounts, prompt caching, batching strategies, and parallel execution effects, all of which could materially change effective cost. Finally, the cost projections for open-weight backbones are meaningful only insofar as the corresponding models satisfy the quality floors required by the downstream task; a cheaper configuration is not useful if it fails the structural or temporal constraints established earlier in Section 6.

7. PAi-Bench

We release PAi-Bench, a curated benchmark resource generated by PAiNT and reviewed by a human expert, designed to support future evaluation of longitudinal perspective-inference systems. This section documents its composition, structural properties, thematic diversity, modality distribution, curation protocol, intended downstream use, and reproduction cost.

7.1. Composition

PAi-Bench comprises four persona trajectories—Anika (Reserved), Brian (Role Model), Danielle (Self-centered), and Ethan (Average)—each spanning 100 causally ordered events over approximately two years of simulated time (January 2015 to February 2017). The four personas share a fixed demographic profile (age 22, Toronto, early-career management/consulting analyst, university degree, low–middle income). Each archetype is anchored to one quadrant of the four-way Big Five typology of Gerlach et al. [37], and the released trajectory for each archetype was selected as the Persona Path closest to its archetype centroid in state-vector space, using the centroids computed in Experiment 1 (Section 6.2).

To amortize the cost of long-horizon generation, the 100 events per persona were produced as two contiguous 50-event halves. The second half resumes generation from the exact state reached at the end of the first: the Persona Matrix $P_{50}$, the partial Persona Path ${\left\{(P_t,E_t)\right\}}_{t=1}^{50}$, and the bounded history window $H_{50}$ are loaded as initial conditions for step $t=51$. Because the update rule depends only on the immediately preceding state and bounded history, this two-stage execution is operationally equivalent to a single $T=100$ run under the state-conditioned dynamics of PAiNT, differing only in sampling stochasticity. The merged Persona Path ${\left\{(P_t,E_t)\right\}}_{t=1}^{100}$ is the released object.

Each situation is paired with one ontology-aligned Situation Graph and three observable artifacts: one text artifact, one audio artifact, and one image artifact. In total, PAi-Bench contains 400 situations, 400 Situation Graphs, and 1200 observable multimodal artifacts across the four personas. This organization is important for downstream use: each event provides dense, per-situation graph supervision together with aligned multimodal observations.

7.2. Situation Graph Structure

Because every artifact in PAi-Bench is supervised by an ontology-aligned Situation Graph, the structural richness of those graphs directly affects the benchmark’s value for Situation Graph Prediction (Section 1) and related auditing tasks.

Table 19. Situation Graph structural statistics per archetype on PAi-Bench ($n=100$ graphs per archetype, 400 total). Nodes are counted as unique (kind, value) pairs appearing as a subject or object of at least one triplet.

Archetype	N Graphs	Min	Max	Mean	Median
Anika	100	9	19	12.59	12
Brian	100	12	15	12.77	13
Danielle	100	12	19	12.24	13
Ethan	100	12	15	12.72	13
Overall	400	9	19	12.83	13

summarizes the distribution of unique nodes per graph across the four trajectories. All 400 graphs comply with the schema constraints of Table 2 and Table 3: every graph contains the six required node kinds (MainParticipant, Activity, Location, DayTime, Emotion, Valence) and respects the typed edge constraint map. The overall mean is $\overline{n}=12.83$ unique nodes per graph (SD across archetypes $\approx 0.29$). Figure 12 shows that the benchmark graphs contain a stable core of required spatiotemporal and affective relations, while social and psychological predicates appear more selectively, reflecting their conditional role in the ontology.

Node values are drawn from the persona-specific label registry produced in Stage 5 (Section 4.3.2), which guarantees trajectory-global referential consistency: the same friend, workplace, or recurring activity is denoted by the same canonical identifier across all 100 events of a given persona. The expanded label registries are of comparable size across archetypes, with on average 32 Participant labels, 18 Location labels, and 11 LocationType labels per persona. Figure 13 further shows that the required node types occur in nearly all graphs, while optional node types such as Participant vary more substantially across situations, making the benchmark structurally consistent but still non-trivial for downstream graph inference.

7.3. Event Coverage and Thematic Diversity

The 400 situations in PAi-Bench draw from 80 distinct event titles in the PAiNT event taxonomy (Section 4.1.2), with each archetype covering between 47 and 55 unique titles (Anika: 55, Brian: 51, Danielle: 47, Ethan: 47). Figure 14 shows the 15 most frequent event titles across all four personas. The distribution is heavy-tailed: a small core of broadly shared life events (Acute injury, Achieving career goals, Experiencing workplace conflict, Learning a new skill, Financial planning) appears across all archetypes, while the long tail captures archetype-specific behavior—for example, Managing anxiety concentrates in Danielle (5 occurrences; absent in Ethan, ≤2 elsewhere), Taking out a loan concentrates in Danielle (5 vs. ≤3 elsewhere), Dental correction appears only for Anika (6), and Financial anxiety appears only for Ethan (4). This combination of a shared thematic core with archetype-specific divergence is what makes PAi-Bench suitable both for within-archetype longitudinal tracking and for across-archetype contrastive evaluation. The full rank-frequency distribution is shown in Figure 15.

7.4. Artifact Modality Breakdown

The 1200 observable multimodal artifacts are distributed as follows. Text artifacts (400) are dominated by short-form messages (41.2%) and journal entries (29.8%), with emails (17.2%) and social media posts (11.5%) making up the remainder. Audio artifacts (400) are predominantly voice memos (65.8%), followed by conversation recordings (11.8%), voicemails (9.8%), phone recordings (7.5%), and ambient/video-derived clips (5.2%). Image artifacts (400) are mostly point-of-view shots (87.5%), with selfies (9.0%), group photos (3.2%), and one screenshot rounding out the set. The strong skew toward first-person perspectives (voice memos, POV images, journal entries, SMS) reflects the design goal of producing artifacts that a real user would plausibly originate themselves, consistent with the longitudinal digital-footprint framing of PAi. A visual breakdown of these distributions across all three modalities is provided in Figure 16.

7.5. Curation and Human Validation

Leveraging the output of PAiNT, PAi-Bench was curated and validated by a domain expert. Every one of the 1200 generated artifacts across the four persona trajectories was manually inspected. Each event was assessed against four criteria: narrative plausibility, whether the event and reaction are coherent given the persona’s simulated state and history; artifact–graph alignment, whether the generated artifacts are consistent with the corresponding Situation Graph; factual consistency, whether artifact content such as embedded dates and named entities agrees with the simulated trajectory; and visual faithfulness, whether each rendered image matches its Situation Graph. Failure cases encountered during validation included incorrect or inconsistent event dates embedded in artifact content (e.g., text messages or journal entries referencing dates outside the simulated window), which aligns with the temporal calibration failures observed experimentally, particularly the horizon-overshoot patterns identified by the THC metric. Non-conforming artifacts were flagged and regenerated until they passed both automated checks and human validation: image artifacts failing visual faithfulness were re-rendered through a refinement pass, with 111 of 400 image artifacts (27.8%) regenerated in this way, and events flagged for causal violations or schema inconsistencies at earlier automated stages were likewise regenerated. Taken together, this human-in-the-loop curation layer is an essential complement to PAiNT’s automated validation, ensuring that PAi-Bench meets a quality standard suitable for meaningful downstream evaluation. The protocol provides a quality-control layer beyond the automated pipeline alone, reducing apparent visual mismatches and narrative breakdowns that would otherwise make downstream evaluation less meaningful.

7.6. Reproduction Cost

Table 20. PAi-Bench reproduction cost per archetype (100-event trajectory). LLM cost is computed as $\mathrm{USD}=(T_{\mathrm{in}}/{10}^6)·1.75+(T_{\mathrm{out}}/{10}^6)·14.00$ using the GPT-5.2 endpoint rates in effect as of April 2026. Non-token image and audio generation costs are excluded.

Archetype	Duration (h)	Input (M)	Output (M)	LLM Cost (USD)
Anika	6.36	10.61	1.24	35.88
Brian	6.69	11.25	1.32	38.18
Danielle	8.10	11.97	1.41	40.71
Ethan	6.64	11.13	1.28	37.41
Total	27.80	44.96	5.25	152.18

reports the wall-clock time, token consumption, and LLM-only API cost required to regenerate each trajectory end-to-end with GPT-5.2 as the backbone. Across the four personas, PAi-Bench was produced in 27.8 wall-clock hours using 44.96 M input tokens and 5.25 M output tokens, for a total LLM-only cost of approximately USD 152, or USD 0.38 per labeled situation.These figures exclude non-token API charges for image generation and audio synthesis, which are billed per asset rather than per token. Consistent with the trend reported in Experiment 5 (Section 6.6), cost scales sub-linearly with trajectory length because bounded-window history conditioning prevents prompt size from growing linearly with the event index.

7.7. Intended Use and Current Scope

PAi-Bench is designed to support two downstream tasks: (i) Situation Graph Prediction (Section 1), in which a model must infer the structured perspective representation from raw multimodal artifacts, and (ii) longitudinal identity tracking, in which a model must detect how identity state evolves across an event sequence. Because every situation is paired with an explicit Situation Graph and generated from a known Persona Matrix state, PAi-Bench provides dense, per-situation supervision that is unavailable in real-world digital-footprint datasets.

Concretely, the released artifacts admit several modes of use. For SGP model supervision and evaluation, the 400 paired (artifact, graph) instances can be split persona-wise—training on a subset of personas and evaluating on held-out personas—to test whether a model learns to recover perspective structure that generalizes across identities rather than memorizing persona-specific surface features. For longitudinal tracking, the per-timestep Persona Matrices $\left\{P_t\right\}$ supply ground-truth state trajectories against which a model’s inferred state sequence can be scored for drift detection, regime-shift identification, or state forecasting (Section 1). For contrastive evaluation, the shared thematic core across archetypes combined with archetype-specific divergence (Figure 15) supports both within-archetype longitudinal tracking and across-archetype discrimination. Because all labels are ontology-aligned and schema-validated, these tasks can be evaluated with the structural metrics defined in Section 5 rather than requiring task-specific annotation. While these tasks demonstrate the benchmark’s internal utility, a critical open question is the extent to which models trained on this synthetic, PAiNT-generated data will transfer to real-world, naturalistic human data. Currently, we lack empirical evidence certifying that performance on the PAiNT benchmark guarantees real-world generalization. As noted in Section 10, establishing this downstream transferability is a primary objective for future work.

In this paper, PAi-Bench is introduced as a released benchmark resource rather than a completed downstream benchmark study. The SGP task itself is formalized and shown to be non-trivial-but-learnable in prior work [35], where retrieval-augmented supervision substantially outperforms a zero-shot baseline on a single-persona pilot. PAi-Bench extends that line of work along three axes—multiple personality archetypes, full multimodal artifacts, and persona-grounded generation through the complete PAiNT pipeline rather than structure-first proxy generation. What remains open is therefore not whether SGP is learnable in principle, but whether supervision learned from PAiNT-generated data at this scale improves perspective inference, and in particular whether such gains transfer to human-authored digital footprints. We regard this transfer evaluation as the most important next step (Section 10): it is the experiment that would convert PAi-Bench from a structurally well-formed resource into a validated training signal. We make the benchmark, its generation pipeline, and its evaluation harness available specifically to enable that line of work.

7.8. Situation Graph Prediction Demo

To demonstrate one of the most fundamental perspective inference tasks that PAiNT enables, we present a zero-shot evaluation of Static Situation Graph Prediction (SGP) on PAi-Bench. In this task, a model is given the three multimodal artifacts from a single situation—a text artifact, an audio artifact, and an image artifact—and must infer the ontology-aligned Situation Graph $G_t$ encoding the entity’s perspective: who acted, where, when, in what social and emotional context, and under what environmental conditions. No persona history, prior events, or identity state is provided; the model operates on the static slice alone.

The inference pipeline processes each modality through an LLM capable of native multimodal input. Audio artifacts are first transcribed to text via a speech-to-text model, Whisper, and each modality is then passed to the LLM for modality-specific tuple extraction. The resulting per-modality $(s,p,o)$ candidate sets are then fused by the same LLM into a single unified Situation Graph prediction, with the full ontology schema enforced in the prompt to ensure structural compliance.

We evaluate three LLMs zero-shot—Gemini 2.5 Flash, Claude Sonnet 4, and Qwen3-235B—covering two proprietary and one open-weight model. No task-specific training is performed; models receive only the 13-node, 16-predicate ontology schema and a structural template. PAi-Bench data were generated using an OpenAI backbone, ensuring independence between the generation and evaluation pipelines. Performance is measured with three metrics—Strict F1, Soft F1 (the primary metric), and Predicate Violation Rate (PVR)—defined precisely in the next paragraph.

7.9. Task Format and Scoring

Each evaluation instance is a pair $(X_t,{\mathcal{T}}_t)$, where the input $X_t=\{x_t^{\left(m\right)}:m\in {\mathcal{M}}_t\}$ is the set of three multimodal artifacts (text, audio, image) for a single PAi-Bench situation, and the label is the set of $(s,p,o)$ triplets ${\mathcal{T}}_t$ that compose the ontology-aligned Situation Graph $G_t$ (Section 4.1.5). A model under evaluation maps $X_t$ to a predicted triplet set ${\widehat{\mathcal{T}}}_t$, which is scored against ${\mathcal{T}}_t$ at the triplet level. For each metric, we compute event-level precision, recall, and F1, and report the macro-average and standard deviation across all N = 400 situations. Strict F1 counts a predicted triplet as a match only when all three components $(s,p,o)$ are exactly equal as strings to those of some ground-truth triplet; this is a conservative lower bound, since 91.5% of ground-truth triplets contain at least one free-form open-vocabulary value (e.g., activity descriptions, participant names, location names) where lexical paraphrase is common. Soft F1—our primary metric—replaces exact equality with an embedding-based semantic test, in the spirit of BERTScore [38] and the soft-matching variants used in OpenIE evaluation [39]: each triplet $(s,p,o)$ is rendered as the concatenated string “$spo$” and embedded as a single vector under text-embedding-3-large. A predicted triplet contributes to soft precision if its maximum cosine similarity to any triplet in ${\mathcal{T}}_t$ reaches the threshold $\tau =0.8$, and a ground-truth triplet contributes to soft recall if its maximum similarity to any triplet in ${\widehat{\mathcal{T}}}_t$ reaches $\tau$; predicate substitutions are therefore penalized in proportion to how much they shift the embedded triplet’s overall semantics, rather than via hard equality on p alone. Predicate Violation Rate (PVR) is independent of ${\mathcal{T}}_t$ and measures structural compliance only: ${\mathrm{PVR}}_t=|\{(s,p,o)\in {\widehat{\mathcal{T}}}_t:p\notin \mathcal{R}\}|/|{\widehat{\mathcal{T}}}_t|$, where $\mathcal{R}$ is the set of 16 ontology-defined predicates (Table 3); lower is better. Together, Strict F1 lower-bounds lexical exactness, Soft F1 captures realistic semantic recovery, and PVR isolates schema adherence from semantic accuracy.

Table 21. Zero-shot SGP performance on PAi-Bench ($N=400$, $\tau =0.8$).

Metric	Gemini 2.5 Flash	Claude Sonnet 4	Qwen3-235B
Strict Exact Match
Precision	$0.043\pm 0.048$	$0.047\pm 0.062$	$0.052\pm 0.061$
Recall	$0.063\pm 0.069$	$0.053\pm 0.068$	$0.058\pm 0.065$
F1	$0.051\pm 0.055$	$0.050\pm 0.065$	$0.054\pm 0.062$
Soft Semantic Match
Precision	$0.138\pm 0.109$	$0.173\pm 0.150$	$0.128\pm 0.101$
Recall	$0.169\pm 0.133$	$0.175\pm 0.159$	$0.129\pm 0.100$
F1	$0.149\pm 0.115$	$0.171\pm 0.151$	$0.126\pm 0.097$
Structural Compliance
PVR ↓	$0.000\pm 0.000$	$0.000\pm 0.000$	$0.012\pm 0.078$
Prediction Volume
Triples/event	$19.9\pm 4.2$	$14.8\pm 1.6$	$15.7\pm 3.8$

and 

Table 22. Per-persona zero-shot SGP: Strict F1 and Soft F1 across models ($N=100$ per persona).

	Anika		Brian		Danielle		Ethan		Overall
Model	Strict	Soft	Strict	Soft	Strict	Soft	Strict	Soft	Strict	Soft
Gemini 2.5 Flash	0.056	0.158	0.044	0.139	0.053	0.141	0.050	0.156	0.051	0.149
Claude Sonnet 4	0.058	0.186	0.045	0.168	0.046	0.156	0.050	0.176	0.050	0.171
Qwen3-235B	0.061	0.149	0.045	0.108	0.046	0.112	0.062	0.137	0.054	0.126

, alongside Figure 17 and Figure 18 report the results.

These zero-shot scores are consistent with prior work formalizing the SGP task [35], which likewise finds zero-shot inference difficult and shows that in-context supervision substantially improves performance; the low scores therefore reflect the intrinsic difficulty of latent-state inference rather than a deficiency of the benchmark. These baseline results serve three purposes. First, they confirm that zero-shot SGP on PAi-Bench is non-trivial, establishing concrete lower-bound performance figures that future supervised or few-shot approaches can be benchmarked against. Second, the PVR = 0 result for both proprietary models shows that ontology-constraint following is not itself a bottleneck at this capability level, so future progress can focus on semantic recovery rather than structural compliance. Third, the predicate-level breakdown precisely identifies where gains are most needed: models must be better calibrated to ground-truth annotation conventions—particularly on emotional content, where current zero-shot models systematically over-elaborate—and must develop more robust mechanisms for recovering environmental context from artifact-level signals. Together, these findings establish a quantified starting point for future supervised training and few-shot evaluation on PAi-Bench.

8. Limitations

We identify several limitations that qualify the interpretation of the results presented in this work, organized into three categories: experimental scope, evaluation methodology, and framework constraints.

• Experimental Scope

PAiNT generates synthetic trajectories from controlled scaffolding inputs; it does not model any real population distribution. The four archetypes used here are intended as distinct seed priors grounded in prior literature [37], not as a claim that personality reduces to four types. In addition, all experiments fix a narrow demographic profile, so the reported results mainly characterize personality-driven variation within a constrained life context. Generalization to other ages, cultures, occupations, and socioeconomic settings remains untested.

• External Validity and Realism

A central limitation concerns what our evaluation does and does not establish about realism. PAiNT’s metric suite is predominantly internal: OCV, the temporal metrics (TSCD, TMD, TVS), NCNC, and the artifact-alignment metrics (SGC, SGF) assess structural validity, temporal coherence, and cross-modal consistency within the generated data, and several are calibrated against published longitudinal statistics for personality, weight, and perceived stress (Appendix B). What they do not establish is external validity: whether trajectories and artifacts scored highly by these metrics would be judged realistic by human evaluators, or whether they reproduce the distributional properties of real human life histories. This distinction mirrors the internal/external validation split emphasized in recent reviews of generative social simulation, which identify validation—rather than behavioral expressiveness—as the central unresolved challenge for LLM-based simulation [40]. Our framework is best understood as occupying the internal side of that divide: it provides explicit, auditable state supervision that makes the generated data structurally inspectable, but it does not, on its own, certify that the resulting trajectories are externally faithful to any real population. Establishing external validity—through human evaluation and downstream transfer—is the most important direction for future work (Section 10).

• Evaluation Methodology

PAiNT is evaluated only against its own ablations rather than against external longitudinal generators, because no directly comparable system currently exposes long-horizon identity state as explicit ground truth. Each condition uses $R=5$ seeds. This reflects a deliberate trade-off: long-horizon multimodal generation is computationally expensive (Section 6.6), and we prioritized broader coverage across archetypes, horizons, backbones, and ablations over deeper sampling within any single condition. Consistent with the framing of these experiments as controlled stress tests rather than population-level studies (Section 6.1), we report point estimates with standard deviations and interpret comparisons in terms of effect magnitude rather than null-hypothesis significance testing. Larger-scale evaluation with formal inferential statistics is a natural direction for follow-up work, particularly for comparisons where the effect size approaches the inter-seed variability. Finally, although the SGP demo (Section 7.8) demonstrates zero-shot evaluation on PAi-Bench, this work does not train any downstream model on PAiNT-generated data, so the transfer utility of the generated supervision as a training signal remains an open empirical question.

• Framework Constraints

PAiNT currently relies on a fixed, human-curated event taxonomy. This supports reproducibility, controlled ablations, and a well-defined EQ metric, but limits ecological coverage: real lives contain open-ended and culturally specific events outside the taxonomy. Extending PAiNT to a more open event space would likely improve realism, but would also weaken the experimental control that makes the current evaluation possible.

9. Discussion

The experiments highlight four cross-cutting themes for PAiNT and, more broadly, for perspective-aware longitudinal generation.

• Explicit identity state enables controlled analysis.

By making identity state explicit through the Persona Matrix, PAiNT turns longitudinal persona simulation into a controlled and auditable process rather than an implicit prompt-driven one. Experiment 1 (Section 6.2) shows that initialization priors persist over time, and Experiment 3 (Section 6.4) shows that orchestration and memory govern different quality dimensions. This makes failure modes easier to localize and improve.

• The coherence frontier is operational, not only diagnostic.

Experiment 2 (Section 6.3) shows that temporal resolution and simulation horizon interact in a structured way: TVS and THC are strongly resolution-sensitive, while other metrics degrade less. The practical implication is that simulation settings should be chosen based on downstream priorities rather than fixed by default.

• PAiNT provides structural safeguards, but quality remains backbone-dependent.

The ablation results show that PAiNT can enforce a strong structural floor across backbones, especially for taxonomy grounding and basic consistency. However, temporal and narrative quality still vary substantially by model. In practice, architecture and backbone contribute differently: the former improves reliability, while the latter still shapes the overall quality profile.

• The current evaluation is diagnostic rather than normative.

Several metrics in this work are most useful comparatively: they identify bottlenecks, trade-offs, and relative improvements, but they do not yet define what is “realistic enough” for downstream use. Establishing such thresholds will require either human evaluation or downstream learning experiments.

10. Future Work

The next phase of PAiNT development should focus on downstream validation, broader coverage, and stronger multimodal realism.

• Situation Graph Prediction.

The most direct next step is to use PAiNT and PAi-Bench as supervised data for Situation Graph Prediction: inferring $G_t$ from multimodal artifacts $X_t$. This would provide the first direct test of whether PAiNT-generated data are useful for downstream perspective inference rather than only structurally well formed. More broadly, such experiments would help identify which generation metrics are most predictive of downstream transfer.

• Human evaluation of realism.

All current evaluations are automated. A human study is needed to test whether trajectories and artifacts scored highly by the metric suite are also perceived as plausible, coherent, and natural. This is especially important for narrative and artifact quality, where automated proxies remain noisier than structured temporal metrics.

• Broader demographic and archetype coverage.

All experiments in this work fix a narrow demographic profile. Extending evaluation to other ages, occupations, cultural contexts, and socioeconomic settings is necessary to assess generalizability. The current four-archetype design should also be expanded toward continuous OCEAN initialization, enabling finer-grained exploration of the personality–dynamics landscape.

• Longitudinal artifact evolution.

PAiNT currently models identity-state change more strongly than observable style change. Over multi-year horizons, artifacts should also evolve physically and stylistically: images should reflect aging, audio should reflect vocal change, and text should reflect gradual shifts in writing style and communication habits. Incorporating temporally conditioned artifact generation would improve the ecological validity of the multimodal output.

• Stronger artifact conditioning.

Experiment 4 (Section 6.5) identifies the downstream artifact pipeline as a major quality bottleneck. Three directions are especially important: adding regeneration or stronger validation to Stage 6 graph generation, reducing modality-specific hallucination rates (especially for image artifacts), and exploring tighter graph-conditioned or retrieval-augmented generation to reduce the large proportion of ungrounded elaboration in SGF.

• Multi-persona interaction.

PAiNT currently simulates a single focal entity. Extending it to multi-persona settings would enable richer artifacts and richer downstream tasks, including dialogue modeling, relationship dynamics, collaborative decision-making, and perspective-taking in social environments. The existing relational fields in the Persona Matrix and participant structure in the Situation Graph provide natural starting points for this extension.

11. Ethics and Misuse

• Misuse potential.

PAiNT can generate realistic longitudinal digital footprints across text, audio, and image modalities. This creates clear misuse risks, including impersonation, social engineering, and the production of deceptive synthetic identities. The current framework includes several safeguards: generated data are tagged with provenance metadata, persona scaffoldings are created without reference to real individuals, and the framework is open-sourced for transparency and oversight. However, these measures are not sufficient on their own. Additional deployment safeguards—such as watermarking, provenance-preserving release formats, and access controls for high-fidelity generation—should be treated as necessary for any public-facing release.

• Bias and stereotype risks.

PAiNT inherits the biases of the underlying LLM backbones. In particular, the system may reproduce stereotyped associations between personality, behavior, occupation, or social outcomes that reflect training-data bias rather than meaningful structure. The current evaluation suite does not audit for such effects. Future work should therefore include explicit bias analysis, including stereotype detection and adversarial probing for demographic–personality confounds.

12. Conclusions

We introduced PAiNT, a generative framework for simulating long-horizon persona trajectories and producing multimodal digital artifacts paired with explicit, ontology-aligned identity labels. By making identity state observable rather than implicit, PAiNT enables controlled training, evaluation, ablation, and diagnosis for perspective-aware AI without relying on real user data.

Across the experiments, we showed three main findings. First, multi-agent orchestration and history conditioning support different quality dimensions: the former improves structural integrity, while the latter improves temporal realism. Second, PAiNT exhibits a coherence frontier: short-horizon, high-resolution simulation degrades some temporal dimensions much more than others, especially TVS and THC. Third, persona initialization produces a durable identity signal that remains visible above stochastic event noise across independent runs.

To our knowledge, PAiNT is the first framework to generate longitudinal, structurally supervised digital footprints with explicit identity state exposed as ground truth. We release the framework, evaluation suite, and PAi-Bench to support future work on perspective-aware AI and longitudinal perspective inference.