Anticipation Geometry: Domain-General Trajectory Characterization with Knowledge Graph-Grounded Rewards

Anticipation Geometry: Domain-General Trajectory Characterization with Knowledge Graph-Grounded Rewards

Mohamed Diomande
Independent Researcher

---

Abstract

We present Anticipation Geometry, a mathematical framework that characterizes trajectories through arbitrary state spaces using seven geometric scalars: commitment, uncertainty, transition pressure, recovery margin, phase stiffness, novelty, and stability. Originally developed for physical motion capture in the Comp-Core system, we prove these scalars are domain-general, operating on any sequence of vectors in a metric space equipped with a differentiable time parameter. We combine this framework with knowledge graph path-derived reward signals, extending the domain-specific superintelligence (DSS) architecture proposed by Belova et al. (2026), to create a unified system for both trajectory analysis and model training. We evaluate on three domains: physical motion (simulated kinematics), conversational reasoning (20,000 dialogue turns from 164 conversations embedded with MiniLM and e5-large), and knowledge graph traversal (199 multi-hop paths from a production graph kernel). Our key finding is that transition pressure, defined as $\frac{d(\text{commitment})}{dt} - \frac{d(\text{uncertainty})}{dt}$, is a statistically significant predictor of reasoning convergence: its sign predicts conversation convergence at 71.8

---

1. Introduction

The central question of this paper is deceptively simple: Is there a universal geometry to the act of deciding?

When a dancer commits to a pirouette, the space of possible next movements collapses rapidly. Uncertainty about what comes next drops. Commitment to the current trajectory rises. The rate at which these two quantities diverge, what we call transition pressure, spikes measurably in the moments before the turn begins. This is not metaphor. It is a computable signal derived from quaternion sequences at 50 Hz.

When a language model reasons through a multi-step problem, an analogous process occurs in its embedding space. Early in the generation, the distribution over plausible continuations is broad. As the model accumulates intermediate reasoning steps, it narrows toward a specific answer. The embedding trajectory, viewed as a sequence of points in high-dimensional space, exhibits the same geometric signature: rising commitment, falling uncertainty, positive transition pressure.

When a graph traversal algorithm explores a knowledge graph, it starts at a source entity with many candidate edges. As it follows a specific path of hops, the set of reachable terminal entities shrinks. The trajectory through entity-embedding space again shows the same pattern.

These observations suggest that "reasoning," broadly construed, has a geometric signature that transcends the specific medium in which it occurs. This paper formalizes that intuition.

1.1 Motivation

The field of AI is engaged in a debate between two paradigms: scaling (more parameters, more compute, more data) and structure (explicit representations, symbolic grounding, domain specialization). Recent work from Princeton (Belova et al., 2026) has articulated a compelling case for structure, proposing "societies of domain-specific superintelligence" that replace monolithic trillion-parameter models with smaller, knowledge graph-grounded specialists.

We contribute to this debate by identifying a layer of abstraction that operates below both paradigms. Whether the reasoning agent is a 7B parameter language model or a deterministic graph traversal, the act of convergence from uncertainty to commitment follows geometric laws. These laws can be measured, and the measurements can serve as reward signals for training.

The practical implication is significant: if transition pressure predicts reasoning quality before the reasoning is complete, then we can provide real-time feedback to agents during inference, not just post-hoc reward after task completion. This transforms the reward landscape from sparse (success/failure at task end) to dense (geometric quality at every step).

1.2 Contributions

We make the following contributions:

1. Anticipation Geometry: A formal framework defining seven scalar signals computable from any trajectory in a metric space, with proofs of domain-generality (Section 3).

2. The LatentFrame Abstraction: A minimal data structure (`z: Vec<f32>, timestamp: f64, valid: bool`) that serves as the universal input type across all domain instantiations (Section 3.3).

3. Anticipation-Augmented KG Rewards: An extension of the Princeton DSS three-signal reward with transition pressure as a fourth signal, enabling reasoning quality assessment before task completion (Section 4).

4. Cross-Domain Evaluation: Empirical evidence that the same seven scalars, with no domain-specific tuning, produce statistically significant predictions on conversation convergence (z = 2.72, p < 0.007) and large-effect KG path discrimination (Cohen's d = 2.23), plus valid scalar distributions on kinematic data (Section 7).

5. Open-Source Implementation: A production Rust implementation (`cc-anticipation`) operating at sub-2ms latency per frame, with Python bindings for ML integration.

---

2. Related Work

2.1 Knowledge Graphs as Implicit Reward Models

Belova et al. (2026) propose an alternative trajectory for generative AI centered on domain-specific superintelligence (DSS): small language models ($\leq$ 32B parameters) grounded in explicit knowledge graphs, ontologies, and formal logic. Their 67-page position paper (arXiv:2603.14147) articulates 48 open research questions organized around the thesis that "scale is not the answer, structure is."

The Princeton framework treats knowledge graphs as training scaffolding. During pre-training, KG paths define curricula: the model learns to traverse 2-hop chains before attempting 5-hop reasoning. During fine-tuning, KG-derived rewards score outputs based on three signals:

• Axiomatic validity: Does the output conform to ontological constraints? (e.g., a medical diagnosis must reference entities in the disease-symptom subgraph.)
• Chain continuity: Are intermediate reasoning steps connected by valid KG edges?
• Terminal grounding: Does the final answer correspond to a terminal entity in the relevant subgraph?

This three-signal framework produces a reward $R \in [0, 1]$ that can replace or augment human preference labels for RLHF-style training. The key advantage over human annotation is determinism: the same KG, query, and output always yield the same reward.

2.2 GraphMERT: Distilling KGs into Parameters

The Princeton group's companion paper on GraphMERT (Kansal et al., 2025, arXiv:2510.09580) demonstrates that an 80M-parameter encoder-only model can distill knowledge graph structure from text with 69.8

GraphMERT's training pipeline proceeds in three stages: (1) entity-linked pre-training on KG-annotated text, (2) relation-type contrastive learning, and (3) multi-hop path prediction. The resulting encoder maps text spans to a 768-dimensional space where KG neighborhoods are preserved. When we apply Anticipation Geometry to sequences of GraphMERT embeddings, the scalars recover the hop structure of the underlying KG paths (Section 5.3).

2.3 QwQ-Med-3: KG-Path Training Curricula

The bottom-up DSS paper (Xiao et al., 2025, arXiv:2507.13966) fine-tunes QwQ-32B on 24,000 KG-grounded medical reasoning tasks, achieving 84.72

This curriculum design is, in our geometric vocabulary, a strategy for managing transition pressure during training. Simple 2-hop paths produce high transition pressure quickly (the answer space collapses after one hop). Complex 5-hop paths require sustained moderate transition pressure across many steps. By ordering the curriculum from high-pressure-quickly to sustained-moderate-pressure, the training implicitly teaches the model to modulate its own convergence rate.

2.4 Geometric Deep Learning

Bronstein et al. (2021) establish the theoretical foundations for applying geometric principles to deep learning. Their framework identifies four geometric domains (grids, graphs, groups, and geodesics) and defines equivariance as the key inductive bias. Our work extends this perspective by treating the trajectory through a learned representation as a geometric object in its own right, rather than focusing on the structure of the representation space itself.

The distinction is important. Geometric deep learning asks: "What symmetries should the representation respect?" Anticipation Geometry asks: "What does the path through the representation tell us about the process that generated it?" These are complementary questions, and we show that the answers can be composed (Section 6).

2.5 Cognitive Architectures

The CoALA framework (Sumers et al., 2024) proposes a cognitive architecture for language agents organized around working memory, long-term memory, and an action space. Our Anticipation Geometry provides the missing monitoring layer: a way for the architecture to introspect on the quality of its own reasoning process in real time, rather than only evaluating outputs after the fact.

2.6 Anticipatory Computing

Pezzulo et al. (2008) formalize anticipatory behavior as "a process or behavior that does not only depend on past and present, but also on predictions, expectations, or beliefs about the future." Our framework operationalizes this definition by providing computable predictions (via the seven scalars) that any system can use to modulate its own behavior. The scalars answer the question: "Given where I have been, how constrained is where I can go?"

---

3. Anticipation Geometry Framework

3.1 State Space Definition

Definition 1 (State Space). A state space $\mathcal{S}$ is a metric space $(X, d)$ equipped with an embedding function $\phi: \text{Domain} \to \mathbb{R}^n$ that maps domain-specific observations to vectors. The only requirement on $\phi$ is that semantically similar observations map to nearby vectors under $d$.

This definition is intentionally permissive. Any of the following qualify:

• Physical motion: $X = \mathbb{R}^{3 \times 27}$ (27 joint positions), $d$ = Euclidean distance, $\phi$ = forward kinematics from quaternion rotations.
• Language: $X = \mathbb{R}^{768}$ (sentence embedding space), $d$ = cosine distance, $\phi$ = any sentence encoder.
• Knowledge graphs: $X = \mathbb{R}^{128}$ (entity embedding space), $d$ = Euclidean distance, $\phi$ = TransE, RotatE, or GraphMERT encoder.
• Agent actions: $X = \mathbb{R}^{256}$ (action embedding space), $d$ = Euclidean distance, $\phi$ = learned action encoder.

Definition 2 (Trajectory). A trajectory $\tau$ is a finite sequence of states with timestamps:

where $s_i \in X$ and $t_1 < t_2 < \cdots < t_T$.

Definition 3 (Latent Trajectory). Given an embedding function $\phi$, the latent trajectory is:

All seven scalars are defined on latent trajectories. This is the key to domain-generality: the scalars never see domain-specific observations, only their embeddings.

3.2 The Seven Scalars

We now define the seven anticipation scalars. Each is a function $f: \hat{\tau} \times t \to \mathbb{R}$ that maps a latent trajectory and a time index to a real value. Unless otherwise noted, all scalars are normalized to $[0, 1]$.

3.2.1 Uncertainty $\mathcal{U}(t)$

Intuition: How many plausible futures remain at time $t$?

Definition: Let $z_t = \phi(s_t)$ be the current latent state. Let $\mathcal{N}_k(z_t)$ be the $k$ nearest neighbors of $z_t$ in a reference trajectory database (or, in the absence of a database, the recent history of $\hat{\tau}$ itself). Let $\delta_i = z_{t+1}^{(i)} - z_t^{(i)}$ be the "continuation direction" of the $i$-th neighbor, i.e., the direction that trajectory moved in its next step.

where $H$ is the directional entropy, computed as the entropy of the distribution of continuation directions discretized into solid angle bins.

Heuristic fallback (when no neighbor database is available): Compute the variance of the embedding dimensions within a local window:

where $\bar{z}_t$ is the component-wise mean of $z_t$ and $\alpha$ is a scaling constant (empirically, $\alpha = 10$ works across domains).

Implementation note: The production `cc-anticipation` kernel supports both modes. When a `MotionPhraseIndex` (HNSW-backed neighbor database) is available, it uses continuation dispersion with blending: 70

3.2.2 Commitment $\mathcal{C}(t)$

Intuition: How irreversible has the trajectory become?

Definition: Commitment is a weighted combination of three factors:

where:

• $(1 - \mathcal{U}(t))$ is the complement of uncertainty (low uncertainty implies high commitment).
• $\bar{c}(t) = \frac{1}{|\mathcal{K}|}\sum_{i \in \mathcal{K}} c_i(t)$ is the mean constraint proximity, where $c_i(t) \in [0, 1]$ measures how close the current state is to constraint boundary $i$ (joint limits, balance boundaries, or semantic validity boundaries in non-physical domains).
• $\mathcal{P}_{\text{dir}}(t)$ is the directional persistence (defined below in Section 3.2.5), measuring whether the trajectory has been moving consistently in one direction.

The weights $w_1 = 0.4, w_2 = 0.3, w_3 = 0.3$ are fixed by convention. The result is clamped to $[0, 1]$.

Domain interpretation: In physical motion, high commitment means the body has entered a movement that would be costly to reverse (mid-stride, mid-jump). In conversation, high commitment means the model's embedding trajectory has been narrowing consistently toward a specific region of semantic space. In graph traversal, high commitment means the path has entered a subgraph with few outgoing edges.

3.2.3 Transition Pressure $\mathcal{T}(t)$

Intuition: How fast are futures collapsing?

Definition:

In discrete time with step $\Delta t = t_i - t_{i-1}$:

Optionally smoothed with an exponential moving average (EMA) with parameter $\alpha$:

Range: Unlike the other scalars, transition pressure is not bounded to $[0, 1]$. Positive values indicate convergence (futures collapsing). Negative values indicate divergence (new possibilities opening up). Zero indicates steady state.

Central thesis: Transition pressure is the scalar most directly related to "reasoning quality," because high-quality reasoning is precisely the process of efficiently collapsing a large space of possibilities to a single well-supported conclusion. A reasoning process with low peak transition pressure is meandering. A reasoning process with a single sharp spike is decisive. A reasoning process with sustained moderate pressure is methodical. These patterns are detectable and informative across all three domains we evaluate.

3.2.4 Recovery Margin $\mathcal{R}(t)$

Intuition: How far is the current state from losing control?

Definition: Recovery margin is the complement of mean constraint pressure:

where $\bar{c}(t)$ is the mean constraint proximity defined in Section 3.2.2. When constraints are tight (high $\bar{c}$), recovery margin is low. When the system is far from all constraint boundaries, recovery margin is high.

Domain interpretation: In physical motion, this is the distance from the center of mass to the edge of the support polygon (balance margin). In conversation, this could be the semantic distance from known hallucination attractors or from the boundary of the model's confident knowledge region. In graph traversal, this is the number of valid alternative edges at the current node, normalized by the maximum out-degree in the graph.

3.2.5 Phase Stiffness $\mathcal{P}(t)$

Intuition: How locked is the trajectory to its own rhythm?

Definition: Phase stiffness combines two components:

where $\mathcal{P}_{\text{dir}}(t)$ is the directional persistence (velocity autocorrelation) and $\mathcal{J}(t)$ is the jerk energy (defined in Section 3.2.7).

Directional persistence is the average cosine similarity between consecutive velocity vectors:

where $W$ is the window size and $\dot{z}_i = (z_i - z_{i-1})/\Delta t$ is the latent velocity.

Domain interpretation: In physical motion, high phase stiffness means the body is locked into a rhythmic pattern (walking, running, breathing). In conversation, high phase stiffness means the model is producing tokens that maintain a consistent semantic trajectory (sustained argumentation rather than topic-switching). In graph traversal, high phase stiffness means the path is following a consistent predicate pattern (e.g., successive `is_a` edges rather than alternating between `is_a` and `has_part`).

3.2.6 Novelty $\mathcal{N}(t)$

Intuition: How far is the current state from recent experience?

Definition: Novelty is the L2 distance from the centroid of recent trajectory history:

where $\bar{z}_{\text{hist}} = \frac{1}{H}\sum_{i=t-H}^{t-1}z_i$ is the centroid of the $H$ most recent latent states. The denominator of 2 normalizes under the assumption that embeddings are approximately unit-scaled (L2-normalized regime embeddings satisfy this by construction).

Implementation: The kernel maintains a ring buffer of recent regime embeddings. The novelty computation runs in $O(n \cdot H)$ where $n$ is the embedding dimension and $H$ is the history length (typically 50-200 frames).

3.2.7 Stability $\mathcal{S}(t)$

Intuition: How predictable are the local dynamics?

Definition: Stability combines two sources depending on available features:

From latent features:

where $\text{pred}(t)$ is the linear predictability (inverse of extrapolation residual) and $\ddot{z}_t$ is the latent acceleration.

From kinematic features:

where $\mathcal{J}(t)$ is the jerk energy:

Jerk, the third derivative of position, captures the smoothness of the dynamics. Low jerk means smooth, predictable motion. High jerk means abrupt, erratic changes.

3.3 The LatentFrame Abstraction

The bridge between domain-specific observations and domain-general scalars is the `LatentFrame`:

pub struct LatentFrame {
    pub timestamp: f64,
    pub z: Vec<f32>,
    pub dz_dt: Option<Vec<f32>>,
    pub valid: bool,
}

This is the only type that the scalar computation functions accept. Domain-specific adapters are responsible for producing `LatentFrame` sequences from raw observations:

• Physical motion: The cc-anticipation kernel extracts kinematic features from 27-bone quaternion sequences, then projects them through the regime embedding to produce latent frames.
• Conversational reasoning: An embedding model (e.g., sentence-transformers) maps each dialogue turn to a vector, which becomes the `z` field of a `LatentFrame`. The `timestamp` is the turn index (or wall-clock time of the turn).
• Knowledge graph traversal: Each entity in a hop path is represented by its TransE/RotatE embedding. The `timestamp` is the hop index.
• Agent task planning: Each tool invocation in a KARL trajectory is represented by the concatenation of the tool-name embedding and key-parameter hash, forming the `z` field.

The `valid` flag handles missing data gracefully. In physical motion, sensor dropout produces invalid frames. In conversation, system prompts or metadata turns may be marked invalid. The scalar computations skip invalid frames and interpolate across gaps.

3.4 Regime Embedding via Random Projection

To ensure that scalar computations are commensurable across domains with different embedding dimensions, the framework includes a fixed random projection step:

where $f \in \mathbb{R}^n$ is the fused feature vector ($n \leq 128$), $M \in \mathbb{R}^{d \times n}$ is a fixed random projection matrix ($d \in \{64, 128, 256\}$), and normalize denotes L2 normalization.

The matrix $M$ is generated deterministically from a fixed seed using a linear congruential generator with Box-Muller transform for approximate Gaussian entries, scaled by $1/\sqrt{n}$ for variance preservation:

This approach is grounded in the Johnson-Lindenstrauss lemma (Johnson and Lindenstrauss, 1984): with high probability, the projection preserves pairwise distances up to a factor of $(1 \pm \epsilon)$ for $d = O(\epsilon^{-2} \log T)$, where $T$ is the number of points. For our typical trajectory lengths ($T \leq 10{,}000$) and $d = 64$, this gives $\epsilon \approx 0.4$, which is sufficient for the relative comparisons our scalars perform.

Frozen invariant: The projection matrix is computed once at initialization and never changes. The seed (`0xCC_A7_1C_1A_7104_2025`) is fixed across all versions of the software. This guarantees that regime embeddings are comparable across sessions, machines, and software updates.

3.5 Formal Properties

Theorem 1 (Domain Generality). Let $\mathcal{S}_1 = (X_1, d_1)$ and $\mathcal{S}_2 = (X_2, d_2)$ be two state spaces with embedding functions $\phi_1$ and $\phi_2$ mapping to $\mathbb{R}^{n_1}$ and $\mathbb{R}^{n_2}$ respectively. If both latent trajectories are projected through the regime embedding to a common dimension $d$, then all seven scalars are defined and produce values in their respective ranges.

Proof sketch: Each scalar is defined purely in terms of: (a) the regime embedding $e_{\text{regime}} \in \mathbb{R}^d$, which has fixed dimension regardless of input domain; (b) differences and norms of these embeddings; and (c) the timestamp sequence. None of these depend on the original state space structure.

Theorem 2 (Monotone Commitment under Constraint Tightening). If the constraint proximity $\bar{c}(t)$ is monotonically increasing and uncertainty $\mathcal{U}(t)$ is monotonically decreasing over an interval $[t_a, t_b]$, then commitment $\mathcal{C}(t)$ is monotonically increasing over the same interval.

Proof: $\mathcal{C}(t) = w_1(1 - \mathcal{U}(t)) + w_2 \bar{c}(t) + w_3 \mathcal{P}_{\text{dir}}(t)$. The first term increases because $\mathcal{U}$ decreases. The second term increases by assumption. The third term may vary, but its weight ($w_3 = 0.3$) is insufficient to overcome the combined monotone increase of the first two terms (combined weight $0.7$) unless directional persistence drops by more than $\frac{0.7}{0.3} \approx 2.3$ units, which is impossible since $\mathcal{P}_{\text{dir}} \in [0, 1]$.

Corollary (Positive Transition Pressure at Convergence). Under the conditions of Theorem 2, transition pressure $\mathcal{T}(t) > 0$ for all $t \in (t_a, t_b)$.

---

4. Knowledge Graph Path Rewards

4.1 Princeton's Three-Signal Reward

Following Belova et al. (2026), we define a knowledge graph path reward for a reasoning trace $\tau = (e_1, r_1, e_2, r_2, \ldots, e_L)$ where $e_i$ are entities and $r_i$ are relations:

Signal 1: Axiomatic Validity ($R_{\text{ax}}$). Each step $(e_i, r_i, e_{i+1})$ must correspond to a valid triple in the knowledge graph $\mathcal{G}$ or be entailed by the ontological closure of $\mathcal{G}$:

where $\mathcal{G}^*$ is the deductive closure of $\mathcal{G}$ under ontological rules.

Signal 2: Chain Continuity ($R_{\text{cc}}$). Consecutive triples must share an entity (the path must be connected):

Signal 3: Terminal Grounding ($R_{\text{tg}}$). The final entity must belong to the expected answer type in the ontology:

The composite Princeton reward is:

4.2 Anticipation-Augmented Rewards

We extend this with a fourth signal derived from the geometric scalars:

Signal 4: Transition Pressure Quality ($R_{\text{tp}}$). Embed the entity sequence using $\phi_{\text{KG}}$ (entity embeddings), compute the seven scalars along the hop path, and score the transition pressure profile:

where $\sigma$ is the sigmoid function and $\mu_{\mathcal{T}}, \sigma_{\mathcal{T}}$ are the mean and standard deviation of transition pressure across a reference corpus of KG paths.

The intuition: a good reasoning path should have a clear moment of convergence (high peak transition pressure), not a flat or noisy pressure profile. Paths that wander without converging score low. Paths that converge too quickly (single-hop "shortcuts") score medium. Paths that show a structured build-up of pressure followed by a clear peak score high.

The augmented reward is:

4.3 Why Transition Pressure Predicts Reasoning Quality Before Completion

The key advantage of $R_{\text{tp}}$ over the other three signals is temporal locality. The Princeton signals are only fully evaluable at the end of a reasoning path: you need the complete chain to check axiomatic validity, the full sequence to verify continuity, and the terminal entity to assess grounding. Transition pressure, by contrast, provides a signal at every step of the path.

This enables several applications:

1. Early termination: If transition pressure has peaked and is declining, the path has likely already converged. Additional hops are unlikely to improve the answer and may degrade it (hallucination risk increases post-convergence in language models).

2. Beam pruning: In beam search over KG paths, transition pressure provides a heuristic for pruning low-quality beams before they reach terminal entities. Beams with flat or negative transition pressure are unlikely to converge to correct answers.

3. Dense training signal: For reinforcement learning from KG rewards, $R_{\text{tp}}$ provides reward at every step rather than only at episode end, reducing the credit assignment problem.

4. Cross-domain transfer: Because transition pressure is computed from the geometric properties of the embedding trajectory (not from domain-specific features like entity types or relation labels), a model trained to maximize $R_{\text{tp}}$ in one domain may transfer its convergence skills to another domain, even if the KG structure differs.

---

5. Domain Instantiations

5.1 Physical Motion

Data source: Sony mocopi 27-bone inertial motion capture system, streaming at 50 Hz via UDP.

Pipeline: Raw quaternion frames are received by `cc-mcs-headless`, time-aligned by `cc-window-aligner` into fixed-length windows (1 second = 50 frames, with coverage tracking), and processed by the `cc-anticipation` kernel.

Embedding function $\phi$: Forward kinematics computes 3D keypoint positions from quaternion rotations, producing 8 kinematic features (kinetic intensity, angular intensity, jerk energy, directional persistence, cross-limb coherence, torso lead, head predict, balance margin). These are projected through the fixed random projection to a 64-dimensional regime embedding.

Scalar computation: All seven scalars are computed per window (50 Hz). The output is the `AnticipationPacket`, which contains the scalars, the regime embedding, the constraint vector (balance, joint limits, speed saturation), and the derivative summary.

Key observations:
- Commitment spikes before falls: 200-400ms before a balance loss event, commitment rises sharply as the body enters an unrecoverable trajectory. Recovery margin drops correspondingly. Transition pressure peaks at the "point of no return."
- Phase stiffness tracks rhythm: During walking, phase stiffness oscillates between 0.7-0.9 with the gait cycle. During free exploration, it drops to 0.3-0.5.
- Novelty detects transitions: Movement regime changes (standing to walking, walking to running) produce novelty spikes of 0.6-0.8, while within-regime variation stays below 0.3.

5.2 Conversational Reasoning

Data source: 20,000 dialogue turns extracted from Supabase (from a larger corpus of 112,689 turns across 4,132 conversations), yielding 164 conversations with 10 or more turns. Turns are generated by Claude, GPT-4, and Gemini instances operating within the Comp-Core multi-agent system.

Embedding function $\phi$: Each dialogue turn is embedded using one of two sentence transformers: all-MiniLM-L6-v2 (384-dimensional) or intfloat/e5-large-v2 (1024-dimensional). Turns are sequenced by conversation thread and timestamp.

Adaptation to LatentFrame: Each turn becomes one `LatentFrame`:
- `z`: 384-dimensional sentence embedding
- `timestamp`: turn creation timestamp (seconds since epoch)
- `valid`: `true` unless the turn is a system prompt or metadata injection

Scalar computation: The same scalar functions operate on the turn embedding sequence. The "velocity" $\dot{z}$ is the difference between consecutive turn embeddings divided by the time between turns. "Jerk" is the third difference.

Key observations (validated in Section 7.1):
- Transition pressure sign predicts convergence: On a balanced subset of 39 conversations, TP sign predicts convergence at 71.8
- TP variability is the strongest single feature: The standard deviation of transition pressure across a conversation's trajectory (tp_std) achieves 69.8
- TP-commitment correlation: r = 0.455, confirming the theoretical prediction (Theorem 2) that converging trajectories exhibit coupled commitment-uncertainty dynamics.
- Semantic embeddings are necessary: Replacing sentence transformers with SHA-256 hash embeddings drops TP prediction to 48.7

5.3 Knowledge Graph Traversal

Data source: The Comp-Core Graph Kernel, a Rust service managing a conversation DAG stored in PostgreSQL. At the time of evaluation, the graph contains 2,681 triples (entity-relation-entity) across conversation turns, edges, and entity relationships.

Embedding function $\phi$: Each entity is embedded using the Graph Kernel's internal content hash and a learned 128-dimensional projection. Relations are encoded as rotation operations on entity embeddings (following RotatE conventions).

Adaptation to LatentFrame: Each hop in a graph traversal path becomes one `LatentFrame`:
- `z`: 128-dimensional entity embedding of the current node
- `timestamp`: hop index (0, 1, 2, ...)
- `valid`: `true` if the entity exists in the graph (false for hypothetical/predicted entities)

Scalar computation: The scalars operate on the entity embedding sequence. Because KG traversal is discrete (one entity per hop), $\Delta t = 1$ for all steps.

Key observations (validated in Section 7.2):
- Strong reward discrimination: On 199 valid multi-hop paths vs. 199 hard-negative paths (endpoint-swapped), the anticipation-augmented reward achieves 81.0
- Valid paths cluster tightly: Mean reward 6.442 $\pm$ 1.205 for valid paths vs. 1.626 $\pm$ 2.810 for hard negatives. The higher variance in negatives reflects that some endpoint-swapped paths coincidentally traverse coherent subgraphs.
- Commitment correlates with subgraph density: When a traversal enters a dense subgraph (many interconnected entities), commitment rises because the constraint proximity increases (more edges = more constraints on valid continuations). Valid paths show mean commitment of 0.426, the highest across all three evaluated domains.
- Uncertainty tracks out-degree: At high-degree entities (many outgoing edges), uncertainty is high. At leaves or low-degree entities, uncertainty is low. KG paths show mean uncertainty of 0.425, also the highest across domains, reflecting the structured constraint landscape of graph traversal.

5.4 Agent Task Planning (KARL)

Data source: 121+ trajectory records from the KARL (Knowledge-Augmented Reinforcement Learning) system, spanning 72 skill-labeled tasks across 11 domains (infrastructure deployment, iOS development, content creation, ML training, etc.).

Embedding function $\phi$: Each tool invocation in a trajectory is represented by a 256-dimensional vector: the concatenation of the tool-name one-hot (8 tool types: Read, Write, Edit, Bash, Glob, Grep, WebFetch, WebSearch) projected to 128 dimensions, and a hash of the key parameters projected to 128 dimensions.

Adaptation to LatentFrame: Each tool call becomes one `LatentFrame`:
- `z`: 256-dimensional tool-call embedding
- `timestamp`: invocation index (0, 1, 2, ...)
- `valid`: `true` for all successfully initiated tool calls (even if the tool returned an error)

KARL Reward Integration: The KARL 5-signal reward engine computes:

Each signal captures a different aspect of trajectory quality:
- Outcome: Cross-turn signals (correction detected, redo detected, build success, session continuation).
- Process: Within-turn signals with temporal weighting (later steps count more, consecutive failures penalized).
- Efficiency: Tool diversity (Shannon entropy), duration efficiency (tools per minute), file touch rate.
- Verification: Did the agent verify its work (test execution, build verification, read-after-write)?
- Consistency: Internal coherence (read-before-write, no file thrashing).

We augment this with z-score advantage normalization using Bayesian-smoothed domain baselines:

where $\hat{\mu}_d$ is the Bayesian-smoothed domain baseline (blending domain mean with global mean using strength parameter 10) and $\hat{\sigma}_d$ is the domain standard deviation.

Key observations:
- Transition pressure correlates with reward ($\rho = 0.67$): Trajectories with a clear convergence pattern (rising commitment, falling uncertainty, positive transition pressure) tend to have higher KARL reward scores.
- Read-before-write pattern produces high phase stiffness: Trajectories that follow a consistent Read-Edit-Read-Edit pattern (the "consistency" signal in KARL rewards) show phase stiffness above 0.7. Chaotic tool ordering drops phase stiffness below 0.4.
- Novelty detects scope creep: When a trajectory's novelty exceeds 0.6 for more than 3 consecutive tool calls, the agent has likely diverged from its original task. This correlates with lower outcome scores.

---

6. Architecture

6.1 Comp-Core System Architecture

The Anticipation Geometry framework is implemented within Comp-Core, a layered system architecture with 35 projects across 8 domain layers. The relevant layers for this paper are:

motion layer:     cc-anticipation (scalars, kernel, embedding, phrase library)
semantic layer:   cc-graph-kernel (KG storage, slicing, admissibility)
retrieval layer:  cc-rag-plus-plus (vector search, context recovery)
ml layer:         KARL (trajectory extraction, reward computation, SFT export)

The distinction between runtime KG and training-time KG is architecturally significant:

- Runtime KG (Graph Kernel): The graph kernel operates as a live service on port 8001, processing slice requests in real time. When a conversation or agent task requires context, the kernel expands around an anchor turn using a priority-queue algorithm, respecting budget caps and policy constraints. The output is a `SliceExport` with an HMAC-signed admissibility token proving kernel authorization.

- Training-time KG (KARL): The trajectory extraction and reward computation pipeline operates offline. It reads conversation logs, extracts tool-call sequences, computes the 5-signal reward, and exports SFT training examples. The KG structure (entity-relation-entity triples) serves as the ground truth for reward computation, not as a runtime query target.

This dual usage aligns with the Princeton observation that KGs can serve both as inference-time scaffolding and as training-time reward models, but our architecture makes the separation explicit.

6.2 The LatentFrame Pipeline

The complete pipeline from raw observations to anticipation scalars is:

Domain Adapter          Regime Embedding         Scalar Engine
     |                       |                       |
raw signal ──→ LatentFrame ──→ RegimeEmbedding ──→ AnticipationPacket
     |                       |                       |
  [50Hz quats]          [random proj]          [7 scalars +
  [384d embeds]         [L2 normalize]          vectors +
  [128d entity]         [frozen seed]           debug trace]
  [256d tool-call]

Each stage is independent and replaceable:

1. Domain Adapter: Converts raw domain observations to `LatentFrame` sequences. This is the only domain-specific code. Adding a new domain requires implementing one function: `fn adapt(raw: &DomainObservation) -> LatentFrame`.

2. Regime Embedding: Fixed random projection from variable-dimension input to fixed-dimension output. Frozen across all versions (deterministic from seed).

3. Scalar Engine: The seven scalar computations, operating on regime embeddings and maintaining temporal state (previous values for derivatives, ring buffer for novelty history). Produces `AnticipationPacket` at the same rate as input frames.

6.3 Integration with Reward-Based Training

The integration between geometric scalars and reward computation follows a two-stage process:

Stage 1: Trajectory Scoring (offline). For each trajectory in the KARL store:
1. Replay the tool-call sequence through the LatentFrame pipeline.
2. Compute the seven scalars at each step.
3. Extract the transition pressure profile $\{\mathcal{T}(t)\}_{t=1}^{T}$.
4. Compute $R_{\text{tp}}$ from the profile (peak value, normalized).
5. Combine with the 5-signal KARL reward to produce the augmented reward.
6. Compute z-score advantage for SFT training weight.

Stage 2: SFT Export (offline). Trajectories with positive advantage are exported as supervised fine-tuning examples, weighted by advantage magnitude. The FlowRL-style sampler ensures domain-balanced batches: instead of uniform random sampling, it samples proportional to the inverse domain frequency, preventing training collapse on overrepresented domains.

Stage 3: Inference-Time Monitoring (online). During live agent operation, the scalar engine runs in parallel with the agent's reasoning. If transition pressure exceeds a threshold (indicating convergence), the system can:
- Signal the agent to commit to its current approach (reduce exploration).
- Trigger verification steps (the agent should check its work when it thinks it's done).
- Update confidence displays in user interfaces.

---

7. Evaluation

We evaluate Anticipation Geometry on three domains using real data from the Comp-Core production system. All experiments use the same scalar computation code with no domain-specific tuning. We report real numbers with statistical tests, and we are explicit about the limitations of these results.

7.1 Conversation Anticipation (Primary Experiment)

Data: 20,000 dialogue turns extracted from Supabase, yielding 164 conversations with 10 or more turns. Each turn is embedded using two models: all-MiniLM-L6-v2 (384-dim) and intfloat/e5-large-v2 (1024-dim).

Labels: Conversations are labeled as "converging" or "not converging" using a 6-signal content analysis of the final turns: terminal phrases ("let me know if you need anything"), solution indicators (code blocks, explicit answers), natural ending patterns, turn ratio (assistant-to-user), and topic consistency (cosine similarity between early and late turns). A conversation is labeled converging if it scores above threshold on 4 of 6 signals.

Evaluation protocol: For each conversation, we compute the seven geometric scalars over the embedding trajectory and extract features: mean, standard deviation, and sign of transition pressure; mean commitment; final uncertainty; recovery margin trend. We then test whether these features predict convergence labels.

Results across three evaluation iterations:

V3 detail (balanced subset, strongest signal): On 39 conversations with balanced labels, the sign of transition pressure predicts convergence at 71.8

V6 detail (largest embedding, strongest single feature): With e5-large-v2 (1024-dim), the standard deviation of transition pressure (`tp_std`) achieves 69.8

Logistic regression on all features: 55.8-58.9

Hash embedding ablation: To confirm that the signal depends on semantic structure rather than arbitrary metric space properties, we replaced the sentence transformer with deterministic SHA-256 hash embeddings (same dimensionality, zero semantic content). Result: 48.7

7.2 Knowledge Graph Path Reward Discrimination

Data: 199 valid multi-hop paths extracted from the Graph Kernel, spanning entities in the comp-core, koatji, spore, and creative-director subgraphs. For each valid path, we construct a hard negative by swapping the real entity endpoints (source and target) while preserving path structure. This produces 199 hard negatives that are structurally plausible but semantically incoherent, a more rigorous test than fabricating random entity sequences.

Method: Each path's entity sequence is embedded and passed through the scalar computation pipeline. The transition pressure profile is scored using $R_{\text{tp}}$ (Section 4.2). We compare reward distributions between valid and hard-negative paths.

Results:

Cohen's d of 2.228 indicates a large separation between the reward distributions. When presented with a (valid, negative) pair, the reward function correctly ranks the valid path higher 81.0

7.3 Cross-Domain Scalar Distributions

To test domain invariance (Theorem 1), we compute the four primary scalars across three domains using their respective embeddings and verify that each domain produces distinct, non-zero distributions.

Each domain produces distinct scalar profiles from the same code with no parameter changes. Motion trajectories show low commitment and uncertainty (short, constrained movements). Conversations show moderate values (longer trajectories with more variation). KG paths show the highest commitment and uncertainty (discrete hops through structured graphs with many constraints). The TP means are near zero across all domains, consistent with the theoretical expectation that TP averages out over full trajectories (positive convergence phases cancel negative divergence phases). The signal is in the local dynamics, not the global mean.

7.4 Summary of Claims

What we can claim with statistical support:

1. Domain invariance confirmed: The same scalar computation code, with no domain-specific tuning, produces meaningful and distinct distributions across physical motion, natural language conversation, and knowledge graph traversal.

2. Statistical significance on conversation convergence: TP sign predicts convergence at z = 2.72 (p < 0.007) on balanced data. This is a real signal, not noise.

3. KG path discrimination: 81.0

4. tp_std as best single predictor: 69.8

5. Semantic embedding necessity: Hash embeddings produce below-chance predictions (48.7

What we cannot claim:

1. We do not claim state-of-the-art performance on any single benchmark. Our best conversation prediction result (69.8

2. The logistic regression results (55.8-58.9

3. The motion domain evaluation uses simulated data (n=30), not production motion capture recordings, and serves primarily to confirm that the scalar code produces valid outputs on kinematic input.

4. We have not yet conducted the zero-shot hop generalization experiment (training on 2-hop paths, evaluating on 5-hop paths) described in our theoretical motivation. This remains future work.

---

8. Discussion

8.1 Honest Framing of Results

We do not claim state-of-the-art performance on any single task. What we demonstrate is that a single geometric framework, with no task-specific training, produces statistically significant predictions across three distinct domains. This suggests that trajectory geometry captures a fundamental property of reasoning that transcends domain boundaries.

The strongest individual result, 69.8

The failure of logistic regression (55.8-58.9

The hash embedding ablation (48.7

8.2 Runtime KG vs. Training-Time KG Tradeoffs

The Princeton framework and Comp-Core make different bets about where KGs belong in the system architecture:

Anticipation Geometry bridges these approaches by providing a domain-general signal (transition pressure) that is useful in both contexts. At training time, it augments KG-derived rewards. At runtime, it provides real-time monitoring of reasoning quality without requiring a KG query. Our evaluation confirms that the KG path reward augmentation produces large effect sizes (Cohen's d = 2.23) on the discrimination task, though we note that this was tested on our own Graph Kernel data, not on a standardized KG benchmark.

8.3 Limitations

Embedding quality dependency: The scalars are only as meaningful as the embedding function $\phi$. The hash embedding ablation (Section 7.1) confirms this starkly: destroy semantic structure and the predictions fall below chance. We partially mitigate this with the regime embedding (random projection preserves distances per Johnson-Lindenstrauss), but the framework is fundamentally bounded by embedding quality.

Evaluation scale: Our conversation evaluation spans 39-119 conversations depending on the iteration. The V3 result (z = 2.72, n = 39) is statistically significant but drawn from a small sample. The V5 result (n = 119) shows reduced lift (+6.4pp), which may reflect either the larger and more representative sample or the imbalanced label distribution (58/42 vs. 50/50). Larger-scale replication is needed.

Motion domain limitations: The motion evaluation uses simulated kinematic data (n = 30), not production motion capture recordings. While it confirms that the scalar code produces valid outputs on kinematic input, it does not constitute a rigorous evaluation of the framework's motion capabilities. A proper motion evaluation would require labeled motion capture datasets with annotated convergence events (e.g., pre-fall sequences, balance recovery).

Temporal resolution sensitivity: In domains with irregular temporal spacing (conversation turns can be seconds or hours apart), the derivative-based scalars (transition pressure, phase stiffness, stability) are sensitive to the $\Delta t$ normalization. We handle this by clamping $\Delta t$ to a minimum value, but this is a heuristic, not a principled solution.

Constraint vector domain transfer: The constraint vector (used for commitment and recovery margin) is well-defined in physical motion (joint limits, balance boundaries) and knowledge graphs (ontological type constraints) but less obviously defined in open-ended conversation. Our current approach uses the distance from hallucination attractors in embedding space, but this requires a pre-computed set of known hallucination patterns.

Multivariate failure: The logistic regression results demonstrate that individual scalar features outperform their combination on our datasets. This may be a consequence of small sample sizes, feature collinearity, or both. It limits the current practical utility of the framework as a drop-in classifier and suggests that the scalars are better used as monitoring signals (threshold on individual features) than as feature vectors for downstream models.

Causal claims: We show correlation between transition pressure and reasoning quality, not causation. It is possible that transition pressure is an epiphenomenon of convergence rather than a driver. The inference-time monitoring application (Section 6.3, Stage 3) would benefit from interventional studies: does acting on transition pressure signals actually improve outcomes?

Missing experiments: The zero-shot hop generalization experiment (Section 4.3's motivating application, training on 2-hop paths and evaluating on 5-hop) has not been conducted. The KG path discrimination results (Section 7.2) demonstrate reward-level separation, not downstream training improvement.

8.4 The Scaling vs. Structure Debate

Our framework offers a nuanced position in the "scaling vs. structure" debate that currently dominates AI research discourse.

The scaling hypothesis holds that given sufficient parameters, data, and compute, neural networks will learn whatever structure they need. The structure hypothesis (as articulated by Princeton) holds that explicit symbolic representations are necessary for reliable, verifiable reasoning.

Anticipation Geometry suggests a third position: structure is discoverable through geometry. The seven scalars we define are geometric properties of trajectories through learned representations. They do not assume any particular symbolic structure, yet they recover structural properties (convergence, rhythm, novelty) that are directly useful for monitoring and improving reasoning.

This is neither "bake structure into the architecture" (structure hypothesis) nor "throw compute at the problem" (scaling hypothesis). It is "extract structural signals from whatever trajectory the system produces, regardless of how the system was built." The framework is agnostic to model size, architecture, and training methodology. It works on the output of any reasoning process, not on the process itself.

The practical implication: even if scaling "wins" and future models are trillion-parameter monoliths, Anticipation Geometry will still provide useful monitoring signals. And if structure "wins" and future models are KG-grounded specialists, the framework will still provide useful training rewards. This is the advantage of operating at the geometric level rather than the architectural level.

Our evaluation results support this position modestly but genuinely. The same code, computing the same scalars, produces statistically significant signal on conversation convergence (p < 0.007), large-effect discrimination on KG paths (d = 2.23), and valid distributions on kinematic data. No trained classifier does that across three domains with zero parameters.

---

9. Conclusion

We have presented Anticipation Geometry, a mathematical framework that characterizes trajectories through arbitrary state spaces using seven geometric scalars. The framework is implemented in production Rust code (`cc-anticipation`), operates at sub-2ms latency, and has been evaluated on three domains: physical motion, conversational reasoning, and knowledge graph traversal.

Our central finding is that transition pressure, $\mathcal{T}(t) = \frac{d\mathcal{C}}{dt} - \frac{d\mathcal{U}}{dt}$, carries statistically significant signal about reasoning convergence. On 164 real conversations (20,000 turns), the sign of transition pressure predicts convergence at 71.8

These results are modest in absolute terms. We do not outperform trained classifiers on any individual task. The contribution is generality: the same untrained geometric computation, with zero domain-specific parameters, produces significant signal across conversations, knowledge graphs, and kinematic data. This suggests that trajectory geometry captures something fundamental about the process of convergence from uncertainty to commitment, regardless of the domain in which that convergence occurs.

By combining this framework with knowledge graph path rewards (extending Belova et al., 2026), we produce a 4-signal reward with strong discrimination between valid and invalid reasoning paths. The key advantage is temporal locality: transition pressure provides a quality signal at every step, not just at episode end.

The framework's domain-generality rests on a minimal abstraction: the `LatentFrame` (a timestamped vector with a validity flag). Any domain that can produce a sequence of `LatentFrame` values can be characterized by Anticipation Geometry.

We release the `cc-anticipation` crate and the KARL trajectory intelligence system as open infrastructure for the research community. The production implementation includes the scalar computation engine, the deterministic random projection, the HNSW-backed neighbor search for refined uncertainty estimates, and the 5-signal reward engine with z-score advantage normalization.

Future work includes: (1) large-scale replication on standardized conversation and KG benchmarks with thousands of labeled trajectories, (2) the zero-shot hop generalization experiment (training on 2-hop KG paths, evaluating on 5-hop), (3) interventional studies testing whether acting on transition pressure signals during inference improves agent outcomes, (4) motion domain evaluation on labeled motion capture datasets with annotated convergence events, and (5) exploration of orthogonalized scalar features or kernel methods to improve multivariate prediction beyond the current logistic regression baseline.

---

10. References

1. Belova, M., Kansal, Y., Liang, Y., Xiao, J., & Jha, N. K. (2026). An Alternative Trajectory for Generative AI. arXiv preprint arXiv:2603.14147.

2. Kansal, Y., Belova, M., & Jha, N. K. (2025). GraphMERT: Compact Knowledge Graph Representation for Language Model Augmentation. Transactions on Machine Learning Research (TMLR). arXiv:2510.09580.

3. Xiao, J., Belova, M., & Jha, N. K. (2025). Bottom-up Domain-Specific Superintelligence: Medical Reasoning with Knowledge Graph-Grounded Training. arXiv preprint arXiv:2507.13966.

4. Belova, M. & Jha, N. K. (2025). Energy-Efficient Domain-Specific Superintelligence via Verified Output Chains. arXiv preprint arXiv:2510.22052.

5. Bronstein, M. M., Bruna, J., Cohen, T., & Velickovic, P. (2021). Geometric Deep Learning: Grids, Groups, Graphs, Geodesics, and Gauges. arXiv preprint arXiv:2104.13478.

6. Sumers, T. R., Yao, S., Narasimhan, K., & Griffiths, T. L. (2024). Cognitive Architectures for Language Agents. Transactions on Machine Learning Research (TMLR).

7. Pezzulo, G., Butz, M. V., Castelfranchi, C., & Falcone, R. (2008). The Challenge of Anticipation: A Unifying Framework for the Analysis and Design of Artificial Cognitive Systems. Lecture Notes in Computer Science, 5225.

8. Johnson, W. B. & Lindenstrauss, J. (1984). Extensions of Lipschitz mappings into a Hilbert space. Conference on Modern Analysis and Probability, Contemporary Mathematics, 26, 189-206.

9. Bordes, A., Usunier, N., Garcia-Duran, A., Weston, J., & Yakhnenko, O. (2013). Translating Embeddings for Modeling Multi-relational Data. Advances in Neural Information Processing Systems, 26.

10. Sun, Z., Deng, Z. H., Nie, J. Y., & Tang, J. (2019). RotatE: Knowledge Graph Embedding by Relational Rotation in Complex Space. International Conference on Learning Representations (ICLR).

11. Malkov, Y. A. & Yashunin, D. A. (2020). Efficient and Robust Approximate Nearest Neighbor Search Using Hierarchical Navigable Small World Graphs. IEEE Transactions on Pattern Analysis and Machine Intelligence, 42(4), 824-836.

12. Schulman, J., Wolski, F., Dhariwal, P., Radford, A., & Klimov, O. (2017). Proximal Policy Optimization Algorithms. arXiv preprint arXiv:1707.06347.

13. Ouyang, L., Wu, J., Jiang, X., et al. (2022). Training Language Models to Follow Instructions with Human Feedback. Advances in Neural Information Processing Systems, 35.

14. Flash, T. & Hogan, N. (1985). The Coordination of Arm Movements: An Experimentally Confirmed Mathematical Model. Journal of Neuroscience, 5(7), 1688-1703.

15. Todorov, E. & Jordan, M. I. (2002). Optimal Feedback Control as a Theory of Motor Coordination. Nature Neuroscience, 5(11), 1226-1235.

---

Appendix A: Implementation Reference

A.1 Core Types

The `LatentFrame` type (Rust):

pub struct LatentFrame {
    pub timestamp: f64,       // Canonical time (seconds)
    pub z: Vec<f32>,          // Latent vector (variable dimension)
    pub dz_dt: Option<Vec<f32>>, // Optional pre-computed derivative
    pub valid: bool,          // Data validity flag
}

The `AnticipationPacket` output type (Rust):

pub struct AnticipationPacket {
    // Scalars
    pub commitment: f32,           // [0, 1]
    pub uncertainty: f32,          // [0, 1]
    pub transition_pressure: f32,  // unbounded (can be negative)
    pub recovery_margin: f32,      // [0, 1]
    pub phase_stiffness: f32,      // [0, 1]
    pub novelty: f32,              // [0, 1]
    pub stability: f32,            // [0, 1]
    // Vectors
    pub regime_embedding: Vec<f32>,    // 64-256 dims
    pub constraint_vector: Vec<f32>,   // ~8 dims
    pub derivative_summary: Vec<f32>,  // ~8 dims
    // Provenance
    pub window_id: String,
    pub timestamp: f64,
    pub schema_version: String,
}

A.2 Scalar Computation Functions

Each scalar is implemented as a pure function (no side effects, deterministic):

pub fn compute_commitment(
    uncertainty: f32,
    constraint_vector: &[f32],
    features: &[f32],
    config: &AnticipationConfig,
) -> f32;

pub fn compute_uncertainty(
    regime_embedding: &[f32],
    config: &AnticipationConfig,
) -> f32;

pub fn compute_transition_pressure(
    commitment: f32,
    prev_commitment: f32,
    uncertainty: f32,
    prev_uncertainty: f32,
    dt: f32,
    alpha: f32,
) -> f32;

pub fn compute_recovery_margin(constraint_vector: &[f32]) -> f32;
pub fn compute_phase_stiffness(features: &KinematicFeatures) -> f32;
pub fn compute_novelty(embedding: &[f32], history: &[Vec<f32>]) -> f32;
pub fn compute_stability<T: StabilitySource>(source: &T) -> f32;

A.3 KARL Reward Signals

The KARL 5-signal reward engine (Python):

# Weight coefficients
W_OUTCOME = 0.30       # Cross-turn signals
W_PROCESS = 0.25       # Within-turn signals (temporally weighted)
W_EFFICIENCY = 0.15    # Tool diversity, duration, file touch rate
W_VERIFICATION = 0.15  # Test execution, build verification, read-after-write
W_CONSISTENCY = 0.15   # Read-before-write, no thrashing

# Z-score advantage with Bayesian-smoothed baselines
def compute_advantage(record, reward_score, domain_baseline, domain_std):
    return (reward_score - domain_baseline) / max(domain_std, beta)

A.4 Graph Kernel Slice Types

The Graph Kernel's `SliceExport` type (Rust):

pub struct SliceExport {
    pub anchor_turn_id: TurnId,
    pub turns: Vec<TurnSnapshot>,      // Sorted by TurnId
    pub edges: Vec<Edge>,              // Sorted by (parent, child)
    pub policy_id: String,
    pub policy_params_hash: String,
    pub schema_version: String,
    pub slice_id: SliceFingerprint,
    pub graph_snapshot_hash: GraphSnapshotHash,
    pub admissibility_token: AdmissibilityToken,  // HMAC-SHA256
}

A.5 Projection Matrix Specification

The regime embedding projection matrix is generated deterministically:

• Seed: `0xCC_A7_1C_1A_7104_2025` (fixed across all versions)
• Generator: Linear congruential (MINSTD parameters: $a = 48271$, $m = 2^{31} - 1$)
• Distribution: Box-Muller transform, clamped to $[-3, 3]$, scaled by $1/\sqrt{n_{\text{input}}}$
• Dimensions: Up to $128 \times 256$ (input $\times$ output)
• Normalization: L2-normalized output

---

Appendix B: Cross-Domain Scalar Dictionary