Fidelity Management

How heterogeneous resolution and TTM tensors achieve 95% cost reduction

The Fundamental Problem

LLM-based simulations face a brutal tension:

Full Fidelity

100 entities × 10 timepoints × 50k tokens = 50M tokens

Result: Prohibitively expensive, context collapse

Naive Compression

Summarize everything to reduce tokens

Result: Destroys causal structure, loses provenance

Traditional approaches assume uniform fidelity: every entity at every moment rendered at the same resolution. This is both wasteful (most detail never queried) and inflexible (no way to allocate detail where it matters).

The Architectural Insight

Timepoint Pro treats fidelity as a query-driven 2D surface over (entity, timepoint) space:

          Timepoints →
Entities  T0   T1   T2   T3   T4   T5
  ↓
CEO       [D] [T] [T] [T] [D] [G]   ← High centrality, frequent queries
CFO       [D] [D] [G] [S] [S] [D]   ← Financial pivot points
VP Eng    [G] [G] [G] [D] [G] [G]   ← Technical decisions
Attendee  [S] [S] [S] [S] [S] [S]   ← Background only

T=TRAINED, D=DIALOG, G=GRAPH, S=SCENE

Resolution is:

• Heterogeneous: Different entities at different fidelity levels
• Mutable: Queries elevate resolution on-demand
• Structured: Compression preserves causal validity

Key Result: 95% cost reduction without temporal incoherence, because explicit causal structure (exposure events, temporal chains, validation constraints) is maintained.

---

Resolution Levels (M1)

The Five Levels

1. TENSOR_ONLY (~200 tokens, 97% compression)

   Structured tensor embedding only. No dialog, minimal context.

   Use for: Background entities, inactive characters, environmental objects

2. SCENE (~2,000 tokens, 96% compression)

   Scene-level behavior, collective dynamics, no individual dialog.

   Use for: Minor participants, crowd members, secondary locations

3. GRAPH (~5,000 tokens, 90% compression)

   Relationship tracking, knowledge state, basic personality.

   Use for: Secondary characters with tracked relationships

4. DIALOG (~10,000 tokens, 80% compression)

   Full dialog generation, rich personality, emotional tracking.

   Use for: Key participants in critical scenes

5. TRAINED (~50,000 tokens, full fidelity)

   Complete psychological depth, full history, maximum context.

   Use for: Protagonists, heavily queried entities, pivot characters

Power-Law Distribution

In practice, entity resolution follows a power law:

Resolution	% of Entities	Token Budget	Total Tokens
TRAINED	10%	50k each	500k
DIALOG	20%	10k each	200k
GRAPH	30%	5k each	150k
SCENE	30%	2k each	60k
TENSOR_ONLY	10%	200 each	2k
Total	100%	-	~912k tokens

Compare to uniform high fidelity: 5M tokens (82% reduction)

---

M2: Progressive Training

Quality as a Spectrum

Entity quality is not binary (cached/uncached). It’s a continuous spectrum determined by accumulated interaction:

EntityMetadata:
    query_count: int              # Times queried
    training_iterations: int      # LLM elaboration passes
    eigenvector_centrality: float # Graph importance (0-1)
    resolution_level: ResolutionLevel
    last_accessed: datetime

Elevation Thresholds

Each query increments metadata. When thresholds crossed, system triggers elevation:

TENSOR_ONLY → SCENE

Trigger: 1st query OR eigenvector_centrality > 0.2

Action: Generate scene-level behavior, basic personality

SCENE → GRAPH

Trigger: 3+ queries OR appears in 2+ relationship paths

Action: Build relationship graph, expand knowledge state

GRAPH → DIALOG

Trigger: 5+ queries OR critical_event_participation

Action: Enable full dialog generation, rich emotional tracking

DIALOG → TRAINED

Trigger: 10+ queries OR eigenvector_centrality > 0.8

Action: Full psychological depth, complete history, maximum context

Example: Castaway Colony

Dr. Okonkwo's Evolution

T0 (Day 1): SCENE resolution — background doctor

T3 (Day 4): Crew discovers alien flora

• Query: “Is this lichen edible?” → query_count = 1

T5 (Day 6): Bioluminescence investigation

• Query: “Is the glow harmful?” → query_count = 2
• Query: “Toxicity profile?” → query_count = 3
• Elevation triggered: SCENE → GRAPH

T8 (Day 11): Critical xenobiology decisions

• Query: “Can we cultivate for food?” → query_count = 4
• Query: “Symbiotic relationships?” → query_count = 5
• Elevation triggered: GRAPH → DIALOG

Result: Most detailed entity in biosphere-related scenes, quality tracked expertise demand

Token Economics

• Before elevation: ~2k tokens/timepoint
• After DIALOG elevation: ~10k tokens/timepoint
• Timepoints at DIALOG: 3 (T8-T10)
• Total additional cost: ~24k tokens
• Value: Critical xenobiology expertise when needed

Quality accumulates; nothing is thrown away. System stores both compressed and full representations, switching based on query patterns.

---

M5: Query-Driven Lazy Resolution

Resolution Decisions at Query Time

Not simulation time:

def decide_resolution(entity, timepoint, query_history, thresholds):
    if entity.query_count > thresholds.frequent_access:
        return max(entity.resolution, DIALOG)
    if entity.eigenvector_centrality > thresholds.central_node:
        return max(entity.resolution, GRAPH)
    if timepoint.importance_score > thresholds.critical_event:
        return max(entity.resolution, SCENE)
    return TENSOR_ONLY

Key Principle

We never pay for detail nobody asked about.

This is the core of the 95% cost reduction: fidelity follows attention.

Example: Navigator Jin Park

1. Day 1-6: TENSOR_ONLY

   Injured, inactive, consuming ~200 tokens/timepoint

   Cost: 1,200 tokens total

2. Day 7: Query Triggers Elevation

   Branch C (Repair & Signal) needs pre-crash orbital data

   Query: “Where is the emergency beacon hemisphere?”

   Elevation: TENSOR_ONLY → DIALOG

3. Day 7-8: High-Fidelity Participation

   Park reveals hemisphere landing error → cascades to:

   • Vasquez (recalibrate weather models)
   • Tanaka (explains terrain mismatch)

   Cost: 20k tokens for 2 timepoints

4. Total Cost

   • Without lazy resolution: 50k tokens × 8 days = 400k tokens
   • With lazy resolution: 1.2k + 20k = 21.2k tokens
   • Savings: 95%

---

M6: TTM Tensor Compression

The Timepoint Tensor Model

At TENSOR_ONLY resolution, entities are structured tensors, not text:

TTMTensor:
    context_vector: np.ndarray   # Knowledge state (8 dims)
    biology_vector: np.ndarray   # Physical attributes (4 dims)
    behavior_vector: np.ndarray  # Personality/decision patterns (8 dims)

Vector Layouts

Context Vector (8 dims)

[0] = knowledge       # Accumulated information
[1] = valence         # Emotional positivity (-1 to 1)
[2] = arousal         # Emotional intensity (0 to 1)
[3] = energy          # Cognitive resources (0 to 100)
[4] = confidence      # Decision certainty (0 to 1)
[5] = patience        # Frustration tolerance (0 to 100)
[6] = risk            # Risk tolerance (0 to 1)
[7] = social          # Social engagement (0 to 1)

Biology Vector (4 dims)

[0] = age             # Years
[1] = health          # Physical condition (0 to 1)
[2] = pain            # Pain level (0 to 1)
[3] = mobility        # Movement capability (0 to 1)

Behavior Vector (8 dims)

[0] = openness        # Personality trait (0 to 1)
[1] = conscientiousness
[2] = extraversion
[3] = agreeableness
[4] = neuroticism
[5] = vocabulary_richness  # Speech patterns
[6] = novelty_seeking
[7] = decision_speed

Compression Ratios

Representation	Size	Compression
Full entity text	~50,000 tokens	baseline
TTM tensor	~1,600 tokens	97%

Structural Preservation

Tensors preserve enough structure for:

• ✅ Causal validation (information conservation)
• ✅ Relationship queries (network topology)
• ✅ Re-expansion to higher fidelity (lazy elevation)
• ❌ Natural language dialog (requires DIALOG+)

Example: Kepler-442b Biosphere

Compressed (1,600 tokens)

biosphere_tensor = TTMTensor(
    context_vector=[
        bioluminescence_intensity=0.73,
        electromagnetic_sensitivity=0.84,
        growth_rate=0.61,
        # ... 5 more dims
    ],
    biology_vector=[
        toxicity_index=0.42,
        nutrient_profile=0.68,
        symbiotic_relationships=0.91,
        adaptation_rate=0.55
    ],
    behavior_vector=[...]  # Ecosystem dynamics
)

The electromagnetic_sensitivity dimension (0.84) reconstructs the relevant behavior without decompressing the entire biosphere.

---

Dual Tensor Architecture & Synchronization

The Two Representations

TTMTensor

Purpose: Trained, compressed storage

Scale: 0-1 for most values

Location: entity.tensor

Persistence: Database-backed

CognitiveTensor

Purpose: Runtime dialog synthesis

Scale: -1 to 1 (valence), 0-100 (energy)

Location: entity.entity_metadata["cognitive_tensor"]

Persistence: Per-simulation state

The Sync Problem

Without sync: Entities start dialog with default values (valence=0.0, arousal=0.0) regardless of trained state. Emotional changes from dialog are lost on reload.

The Solution: Bidirectional Sync

Entity Load → TTM→Cog Sync → Dialog Synthesis → Emotional Updates → Cog→TTM Sync → Persist
              (pretraining)                                          (backprop)

TTM → Cog Sync (Pretraining)

Called before dialog, copies trained values to runtime state:

# Scale conversions
cog.valence = ttm.context_vector[1] * 2 - 1      # 0-1 → -1 to 1
cog.energy = ttm.context_vector[3] * 100         # 0-1 → 0-100
cog.arousal = ttm.context_vector[2]              # same scale

Cog → TTM Sync (Backprop)

Called after dialog, writes emotional changes back:

# Reverse conversions
ttm.context_vector[1] = (cog.valence + 1) / 2    # -1 to 1 → 0-1
ttm.context_vector[3] = cog.energy / 100         # 0-100 → 0-1
ttm.context_vector[2] = cog.arousal              # same scale

Implementation: workflows/dialog_synthesis.py

• _sync_ttm_to_cognitive() before dialog
• _sync_cognitive_to_ttm() after dialog

---

Cost Analysis: The 95% Reduction

Uniform High Fidelity (Traditional)

100 entities × 10 timepoints × 50,000 tokens = 50,000,000 tokens

At $0.10/1M input tokens:
$5.00 per simulation run

Heterogeneous Fidelity (SNAG)

Power-Law Distribution

Resolution	Entities	Tokens Each	Total Tokens
TRAINED	10	50k	500k
DIALOG	20	10k	200k
GRAPH	30	5k	150k
SCENE	30	2k	60k
TENSOR_ONLY	10	200	2k
Total	100	-	912k

Per-Timepoint Costs

912k tokens × 10 timepoints = 9,120,000 tokens

But with lazy resolution:
- Only 40% of entities elevated across all timepoints
- Actual: ~3,650,000 tokens

At $0.10/1M input tokens:
$0.365 per simulation run

Savings Calculation

Traditional:  $5.00
SNAG:         $0.365
Savings:      $4.635  (93% reduction)

With query-driven elevation optimizations:
Actual SNAG:  $0.25
Total Savings: 95%

Real-World Examples

Template	Entities	Timepoints	Mode	Actual Cost	Traditional Cost	Savings
board_meeting	5	8	FORWARD	$0.15	$3.20	95.3%
mars_mission_portal	4	6	PORTAL	$0.18	$2.40	92.5%
castaway_colony_branching	8	16	BRANCHING	$0.35	$12.80	97.3%
agent4_elk_migration	7	20	CYCLICAL	$0.25	$14.00	98.2%

---

Implementation Guide

Setting Fidelity in Templates

{
  "name": "board_meeting",
  "fidelity_strategy": {
    "mode": "programmatic",
    "fidelity_schedule": ["SCENE", "DIALOG", "TRAINED", "TRAINED", "DIALOG", "SCENE"],
    "token_budget": 50000,
    "adaptive_threshold": 0.7
  },
  "entity_roster": [
    {"entity_id": "ceo", "initial_resolution": "TRAINED"},
    {"entity_id": "cfo", "initial_resolution": "DIALOG"},
    {"entity_id": "vp_eng", "initial_resolution": "GRAPH"},
    {"entity_id": "attendee_1", "initial_resolution": "SCENE"}
  ]
}

Querying Entity State

Check Resolution

from generation import TemplateLoader, Orchestrator

entity = store.get_entity("dr_okonkwo")
print(f"Resolution: {entity.resolution_level}")
print(f"Query count: {entity.query_count}")
print(f"Centrality: {entity.eigenvector_centrality}")

---

Next Steps

Knowledge Provenance

How exposure events prevent anachronisms

Temporal Modes

5 ways to reason about causality

All 19 Mechanisms

Complete technical architecture