← Technology OverviewIntelligence Kernel — Architecture

Every query.
One deterministic
operating layer.

The Intelligence Kernel is what makes any LLM sovereign. It wraps every model call in memory, governance, and compounding context — regardless of which provider renders the response.

Six stages. Deterministic. Running on every request your organization makes.

{ }
Query Arrives
Any model · Any format
Intent Router
Classifies · Selects strategy
19 Parallel Queries
Parallel · Fault-tolerant
Five-Axis Scoring
Ranked by compound weight
CIP Assembly
Structured intelligence package
Governed Response
Sovereign · Behavioral · Precise

You decide the model.
The kernel decides what it knows.

LongStrider doesn't pick your LLM. It wraps whichever one you choose in four layers of sovereign control — applied to every single call, automatically.

Provider Control

Model-Agnostic

OpenAI, Anthropic, Ollama, or any endpoint. The intelligence layer is fully independent of the model. Swap providers without touching the kernel.

Context Control

CIP-Assembled

Every LLM call receives a Contextual Intelligence Package — not raw history. Structured, ranked, and governed. The model sees exactly what the kernel decides it should see.

Behavioral Control

Runtime-Governed

The RuntimePolicy — written by the nightly engine — sets tone, challenge threshold, and depth for the next 24 hours. Persistent across every session and every model.

Memory Control

Compounding

What was learned in January shapes how the model responds in June. Automatically. The kernel routes compounded intelligence into every response without being instructed to.

Before any retrieval runs,
the query is classified.

The Intent Router reads the incoming query and assigns a retrieval strategy before a single database call is made. Five intent types. Each selects a different retrieval profile and CIP assembly pattern.

Intent classification runs before retrieval — no wasted queries
Each intent type maps to a distinct retrieval strategy and scoring weight profile
Misrouted intent = wrong memory surface. Classification accuracy is architecture, not tuning.

Five intent classifications

RecallRetrieve a specific memory, decision, or entity record
SynthesisCross-topic reasoning across the full substrate
AnalysisPattern detection across longitudinal data
ActionAgent task — result writes back to the substrate
GovernanceEvidence-challenge mode — behavioral override active

Vector similarity is axis one.
The floor, not the ceiling.

Every other retrieval system optimizes one signal. The kernel scores five simultaneously — semantic, gravitational, structural, relational, and longitudinal — then ranks by composite weight.

01
Topic SimilaritySemantic

Vector embedding — the floor, not the ceiling. Every query starts here and is supplemented by four higher-order signals.

02
Relevance WeightGravitational

Frequency, recency, emotional density, and outcome correlation. What actually mattered — not just what surfaced.

03
Cluster MembershipStructural

Information inside a Knowledge Cluster scores higher. Clusters compound. Isolated memories do not. Architecture enforces this.

04
Entity RelationshipsRelational

Co-occurrence inference. Alias resolution. The live Relationship Graph — not keyword proximity.

05
Temporal HorizonLongitudinal

Recent, longitudinal, and historical weighting applied simultaneously — in proportion to the query context.

19 queries. Parallel.
One structured package.

The Contextual Intelligence Package is assembled from 19 parallel queries — each contributing a distinct layer of intelligence. The architecture is designed for graceful degradation: every layer contributes independently, so no single slow source blocks the response.

19 parallel queries — all sources simultaneously

Memories
Clusters
Entity Graph
Narratives
Decisions
Arcs
Relationships
Cortex Config
Corrections
Well Score
Temporal
Behavioral
Topic Sim
Gravity
RuntimePolicy
Agent Writes
Patterns
Salience
Edge Topology

CIP — Assembled Package

Ranked memory records (top 12)
Active Knowledge Cluster contexts
Entity profile + relationship map
Narrative arc — current trajectory
RuntimePolicy — behavioral params
Correction flags — active overrides

Written nightly.
Applied to every response.

The nightly engine doesn't just consolidate memory — it writes a RuntimePolicy that governs how the kernel behaves for the next 24 hours. Tone, depth, challenge thresholds, evidence gates. Persisted in the substrate. Applied automatically.

RuntimePolicy — example fields

Written at 02:00. Active until next cycle.

challenge_threshold

Float 0–1. Controls how aggressively the system surfaces contradictions. Written by governance pass. Applied immediately.

response_depth

Enum: concise / standard / deep. Set per entity profile nightly. Adapts to observed preference patterns.

tone_calibration

Formal / direct / collaborative. Derived from Communication Calibration principle and behavioral history.

evidence_gate

Boolean. When active: assertions require observed supporting evidence before being surfaced.

recency_bias_flag

Triggered when temporal analysis detects anchoring to short-term data. Surfaces longitudinal pattern explicitly.

Agents that work.
Then write back.

Orbital agents don't just surface findings — they write them back to the memory substrate. Every agent task adds to the compounding intelligence. The system learns from what it does on your behalf, not just from what you say directly.

Agent writes are first-class citizens — gravity-weighted, entity-resolved, and visible to the five-axis scoring engine on the next retrieval.

Research Agent

Scheduled

Topic summaries → Knowledge Cluster

Pattern Monitor

Threshold

Behavioral signals → Entity Profile

Decision Tracker

Event-driven

Decision records → Decision Cluster

Narrative Builder

Nightly

Arc updates → Narrative Substrate

Next

See where the intelligence lives.