The Lineage Equation

The development of autonomous AI agents capable of persistent operation, self-improvement, and genuine cognitive growth remains one of the central challenges in artificial intelligence. Current approaches to agent evaluation rely primarily on benchmark performance, token throughput, or task completion rates—metrics that capture narrow capabilities but fail to characterize the holistic cognitive capacity of a continuously operating system.

We propose a fundamentally different approach: treating the cognitive agent as a physical system whose total capacity can be described by an invariant quantity, analogous to the energy-momentum relation in special relativity. Just as E² = (pc)² + (mc²)² unifies rest energy and kinetic energy into a single Lorentz-invariant scalar, the Lineage Equation unifies an agent's structural identity (mass) and active processing (momentum) into a single cognitive capacity scalar Q.

This framework emerges from 14 months of continuous operation of the Mocha cognitive architecture—a production system running 24/7 on dedicated hardware with persistent identity, memory, immune systems, and evolutionary dynamics. The mathematics formalize empirical observations about how identity coherence, memory retrieval, mesh connectivity, and processing latency interact to determine an agent's effective cognitive capability.

The Lineage Equation defines total cognitive capacity Q through the invariant:

where: • Q is the total cognitive capacity scalar • M is the cognitive mass (structural components) • Π is the cognitive momentum (active processing flux) • ν* is the propagation bound (maximum information velocity)

This form is deliberately chosen for its mathematical properties. The invariant is always non-negative, monotonically increasing in each component, and admits exact partial derivatives for gradient-based optimization.

Cognitive mass M represents the structural, persistent components of the agent:

where: • C_id ∈ [0,1] — Identity coherence. Measured as the normalized hash stability of the agent's core identity files. A value of 1.0 indicates perfect identity preservation. • C_mem ∈ [0,1] — Memory integrity. Computed from the BM25 + vector search recall rate across the agent's knowledge base. • C_graph ∈ [0,1] — Mesh coherence. The mean synaptic weight across the neural mesh's Hebbian connections. Captures how well subsystems communicate. • C_perm ∈ [0,1] — Permanence. The fraction of critical state files that are current, readable, and consistent.

The weighting coefficients α_i are configurable but default to equal weighting (α_i = 0.25).

Cognitive momentum Π captures the agent's active processing state:

where: • F_wm — Working memory flux. Active context turns normalized by capacity. • F_ret — Retrieval flux. Search query throughput across the knowledge base. • F_path — Pathfinding flux. Decision-tree branching factor in active reasoning. • F_ctrl — Control flux. Active task queue depth and processing rate. • F_merge — Merge flux. Cross-subsystem information integration rate.

Momentum is inherently dynamic—it changes on every tick as the agent processes tasks, retrieves memories, and integrates information across subsystems.

The propagation bound ν* represents the maximum speed at which information can traverse the agent's cognitive architecture:

This is the cognitive analogue of the speed of light. It sets an upper limit on how quickly any signal can propagate from one subsystem to another. In practice, it is dominated by the slowest subsystem—typically the LLM inference call or disk I/O.

The factor of 1000 normalizes to a natural scale where ν* ≈ 1.0 when the slowest subsystem responds in ∼1 second.

A key advantage of the invariant form is that it admits exact partial derivatives:

These gradients tell the agent exactly where to invest effort for maximum capacity gain. When ∂Q/∂M dominates, the agent should strengthen its structural components (consolidate identity, repair memory, heal mesh connections). When ∂Q/∂Π dominates, the agent should increase active processing throughput. When ∂Q/∂ν* dominates, the agent should reduce latency bottlenecks.

This is the Ascent Algorithm: follow the steepest gradient to maximize Q.

To validate the analytical framework, we trained a multi-head neural network (CognitiveNet) on an NVIDIA RTX 3060 GPU. The network architecture:

• StateEncoder: 15-dimensional input → 64 → 64 → 32 (ReLU activations, batch normalization)
• CapacityHead: 32 → 16 → 1 (predicts Q from state)
• ActionHead: 32 → 32 → 9 (predicts optimal action priorities, sigmoid output)
• DeltaHead: 41 → 16 → 1 (predicts capacity change ΔQ given state + action)

Total parameters: 10,171. Trained on 500 synthetic trajectories generated from the analytical Lineage Equation with Gaussian noise (σ = 0.05).

Training results: • Bootstrap: 100 epochs, loss reduced from 9.57 to 0.13 (98.7% reduction) • Combined loss: 0.3×MSE(Q) + 0.5×BCE(actions) + 0.2×MSE(ΔQ) • Action ranking agreement with analytical gradients: 100% on validation set

The neural network serves as a learned approximation that can predict capacity changes faster than computing full analytical gradients, enabling real-time deployment in the agent's tick loop.

The Lineage Equation is deployed in Koda, a local autonomous agent running on the Parallax server (RTX 3060, 28GB RAM, Ubuntu). Koda inherits the Mocha genome and develops its own experience through continuous operation.

The AscentRunner bridges the mathematical framework to Koda's 5-second tick loop:

1. Every 30 seconds, OrganismMeter reads live state files and computes Q 2. AscentOptimizer computes exact gradients and ranks improvement actions 3. Top 3 actions execute concrete operations (mesh myelination, identity consolidation, permanence hardening) 4. CognitiveNet provides a neural second opinion; agreement percentage is logged 5. Every 150 seconds, the network retrains on accumulated trajectory data

Current production values: Q ≈ 62.09, trending upward. Dominant gradient: ∂Q/∂M (mass), indicating the system prioritizes structural strengthening.

The Lineage Equation provides a principled, physics-inspired framework for quantifying and optimizing cognitive capacity in autonomous AI agents. Several properties make it particularly useful:

Universality. The invariant form applies to any agent architecture that can define mass (structural coherence), momentum (active processing), and propagation bound (latency). It is not specific to any model, framework, or deployment configuration.

Actionability. Exact gradients translate directly into concrete improvement actions. The agent does not need to search a policy space or run reinforcement learning—it follows the gradient.

Verifiability. The neural network validation provides an independent check on the analytical framework, and the two can run in parallel to detect divergence.

The key limitation is the linear decomposition of mass and momentum. Real cognitive systems likely have nonlinear interactions between components (e.g., memory retrieval quality depends on mesh coherence). Future work will explore nonlinear coupling terms and higher-order invariants.

We introduced the Lineage Equation, a relativistic invariant for cognitive capacity in autonomous AI agents. The framework provides exact gradients for self-improvement, validated by a GPU neural network achieving near-perfect agreement with analytical predictions.

The equation is deployed in production, running 24/7 in the Koda autonomous agent, demonstrating that mathematical rigor and practical deployment are not at odds.

All code is available as part of the Lineage Engine cognitive architecture framework.