Skip to content

Index

Components
Section FrontThe Axonis Ledger82 specifications

← Front Page

component.prism.universal-lens-parser

Universal Lens Parser

Parse YAML lens specifications into frozen, validated LensSpec dataclasses. This is the cost-lens engine's parser: one parser handles the four cost lens types (traversal, threat, observation, temporal) — domain-specific config liv…

component.parallax.lens-parser

Lens Parser

Parse a Semantic Lens YAML file into a structured Python object that drives the rest of the fusion pipeline. The parser output feeds two consumers:

component.parallax.scoring-engine

Scoring Engine

The scoring engine is the core math. It takes two records and a lens config, computes per-field similarity scores, and produces a weighted aggregate confidence value in [0, 1]. This is where fusion lives or dies.

component.cortex.intelligence

Cortex — Intelligence Service

Domain: Intelligence objects (insights, signals, blocks, profiles, editions, tasks, workflows) + AI-assisted

component.prism.cost-primitives

Cost Primitives as Athena-Compatible Ops

Restructure the 10 scoring primitives and 6 transforms as LensCommand subclasses that mirror athena's Command interface. This enables drop-in integration when migrating to the platform — swap import path, same math.

component.prism.scoring-engine

Scoring Engine (Orchestrator)

Execute a parsed LensSpec against input data: resolve sources → compute cost per layer → weighted composite → threshold evaluation → evidence block + optional signal. This is the function that becomes execute_lens_block in Cortex.

component.prism.evidence-model

Evidence Model

Frozen evidence blocks with deterministic SHA-256 hashes, and threshold-driven signal generation. Enforces Invariants #3 (blocks are evidence), #4 (frozen means frozen), and #5 (editions require frozen evidence).

component.parallax.blocking-engine

Blocking Engine

Reduce the comparison space from N×M (all pairs) to a manageable set of candidate pairs. Without blocking, 25×25 = 625 comparisons. With blocking, ~60-100 candidate pairs.

component.cortex.pack-reference

Cortex — Pack Reference

Pack schemas, inheritance model, authoring rules, and change management. The YAML files in the pack bundle directory (loaded into Elasticsearch by the loader) ARE the system; this spec describes it.

component.parallax.local-persistence-adapter

Local Persistence Adapter

Parallax has no local persistence. CorrelationRecord, FusionRun, and LineageEvent dataclasses are produced in-memory by the fusion pipeline and disappear after a run.

component.parallax.attestation-rationale

Attestation Rationale + Correction

Attestation captures what an analyst decided, not why. The LineageEvent carries the action (ATTESTED, INVALIDATED, RECONFIRMED), actor, timestamp, and scoring context — but no field for the analyst's reasoning.

component.parallax.feature-extraction

Feature Extraction Operations

Convert raw records into feature vectors using lens-defined transforms. Feature extraction runs as a sequence of existing parallax operations in the add_operations() chain — not as custom code.

component.prism.source-adapters

Source Adapters

Resolve layer source names to data. The lens.yaml references sources by logical name (e.g., satellite_coverage). The domain.yaml defines what that source is and where it lives. The adapter knows how to fetch it.

component.parallax.derived-features

Derived Features & Privacy Boundary

Raw PII must never cross a federation boundary. The EU AI Act (Articles 10, 12, 15), GDPR Article 25 (data protection by design and by default), and the data minimisation principle all require that entity resolution operates on th…

component.parallax.quorum

Federated Quorum

The three-phase protocol (SPEC-16) and run_multi_fusion (SPEC-16 §13) produce a

component.prism.packaging

Packaging (pyproject.toml)

Prism started as a standalone library axonis-lens (per the original draft of

component.beacon.workbench

Beacon — Investigation Workbench

Beacon is the investigation workbench: an Angular frontend served by a Python/FastAPI backend. The backend is a first-class Axonis service (conforms to platform.service-contract), not a simple proxy. It provides:

component.oracle.apollo

Apollo — System-Wide Observation, Learning, and Guidance Layer

Apollo is the reasoning and memory layer over the platform's LLM activity. It sits inside oracle, observes every LLM and tool interaction across a three-layer system, distills durable artifacts from those observations, and exposes…

component.parallax.primitives-framework

Fusion Primitives Framework

The fusion pipeline requires 94 distinct primitives across 6 categories (Canonical Attributes, Normalization, Matching Features, Matching Algorithms, Tracking, Configuration).

component.parallax.fusion-binding

Fusion Binding as Project + Dataset

SCHEMA-BINDING.md (§132-151) argued against using the existing Dataset object for fusion because the POC operates on CSV files with no platform infrastructure. That was correct for the POC.

component.parallax.observation-reverse-index

Observation Reverse Index

An observation (a single record at a federate) may contribute to many correlations over its lifetime. Today the link is one-way only:

component.parallax.decay-scheduler

Decay Scheduler + Retention

apply_decay() exists in parallax/ops/fusion/correlation.py as a primitive — but nothing calls it on a clock.

component.parallax.wire-message-families

Wire Message Families

The Axonis platform has a real, working wire-protocol contract — what flows between Edge Nodes, between contributors in a fusion run, between the fusion engine and the decision substrate, between operators and the audit replayer.

component.prism.operational-lifecycle

Operational Lifecycle — Init → Execute → Sync

Define how the lens framework operates across three phases: connected initialization (data staging), disconnected crisis execution (off-network compute), and reconnection (evidence sync).

component.prism.composition

Lens Composition

Resolve lens://type/name references between lenses. A traversal lens consumes threat and observation outputs as cost layers — declared in YAML, resolved by the composer. Dependency ordering with circular reference detection.

component.conduit.effect-engine

Conduit — Effect DAG Engine

The Effect engine is Conduit's second DAG engine, alongside the ingest engine. Where the ingest

component.cortex.block-card

Cortex — Block and Card Contract

The Block/Card data contract between Cortex (data layer) and Beacon (presentation layer), following MVC principles: the Model is Cards (rows + column_meta, source-agnostic data), the View is Beacon rendering Cards with compatible…

component.cortex.task-and-effect

Cortex — Task and Decision Effect Lifecycle

This spec adds lifecycle semantics, template governance, and completion validation to Tasks, and pack-level implementation guidance to Decision Effects.

component.parallax.fusionmatch-model

FusionMatch Model (FATE Pipeline Integration)

FusionMatch is a new model type that registers in the existing FATE pipeline alongside HomoLR, HomoNN, HomoSecureBoost, HeteroKmeans, etc. It performs entity matching instead of training a statistical model.

component.parallax.fusion-governance-lifecycle

Fusion Governance Lifecycle & Operational Execution

parallax solves how to run fusion — the compute layer is complete with 944 passing tests and F1=0.973 on VRS POC (0.967 on Febrl4). component.parallax.fusion-binding defines how data flows into the fusion engine.

component.parallax.fusion-adi-integration

Fusion-to-ADI Integration Pattern

Define the integration pattern by which any lens engine — Parallax (Identity Lens / entity resolution), Prism (Cost Lens / Decision Lens / source-localization), or future engines — emits results into the ADI workflow (Monitor → In…

component.prism.mobility-surface

Cross-Country Mobility Surface (Layered Cost Grid)

A generic raster-based mobility surface where each cell has a composite traversal cost from stacked layers — roads, rivers, slope, vegetation, threat, satellite coverage, flooding. Routes via A on the 8-connected grid.

component.prism.threat-engine

Threat Engine

Risk surface computation: weighted combination of threat layers into a spatiotemporal grid. Flood prediction via D8 flow accumulation. Bio-threat modeling via SIR epidemic simulation.

component.prism.serialization

Serialization

Convert frozen dataclasses to/from JSON-safe dicts. Required for REST transport, evidence block storage, and Beacon rendering.

component.prism.integration-test

Platform Integration Test

End-to-end test proving prism (the cost-lens engine; axonis-prism, ex-axonis-lens) runs through the platform stack. Stubbed ES replaces UDS.

component.titan.runtime

Titan — ML Runtime + Federated Fusion Node

Titan is the platform's per-node ML runtime. It is not an external-facing service; it executes work on behalf of other services (cortex, oracle, parallax) and participates in cross-node federated runs.

component.xanadu.messaging

Xanadu — Federation Messaging

Xanadu is the platform's federation messaging layer. It transports messages between Axonis nodes over RabbitMQ (aio-pika, TLS) and provides peer discovery, heartbeating, and lifecycle management.

component.cortex.data-shape

Cortex — Data Shape Contract

Eliminate frontend guessing by making Cortex emit stable, render-ready data shapes while keeping (1) ABAC safety, (2) dataspace types sacred, and (3) visualization choice in Beacon's ViewerController.

component.cortex.developer-rules

Cortex — Axonis Developer Rules

System invariants — what code MUST and MUST NOT do across the Axonis Decision Intelligence platform. Normative for all engineers and Claude Code agents.

component.cortex.domain-loading

Cortex — Domain Loading

Cortex loads domain configuration from YAML schema files at startup. Domains define data models, user roles, governance rules, and UI behavior. A separate loader configuration controls which domains and demo data are active.

component.cortex.investigation-lifecycle

Cortex — Investigation Lifecycle

This spec adds lifecycle semantics and implementation guidance to the Investigation (InsightRoot) object: status semantics and transitions, entry-context requirements per mode, evidence lifecycle within an investigation, edition c…

component.cortex.signal-lifecycle

Cortex — Signal Lifecycle

This spec adds lifecycle semantics and implementation guidance to the Signal object: transition rules, signal policy mechanics, accountability pack filtering, the signal→investigation triggering contract, and disposition semantics…

component.geodex.operations

Geodex — Geospatial Operations

Geodex is the geospatial op-provider in the Axonis feature-engineering platform. It contributes raster and vector transforms to the shared /userspace/operation dispatch surface (alongside local UDS ops, Parallax fusion ops, Prism…

component.parallax.adi-integration

ADI Integration (Signals + Evidence)

Connect fusion output to the existing ADI decision workflow. Confirmed matches become Signals that enter the investigation → decision → attestation flow.

component.parallax.tracking-integration

Tracking Integration & Advanced Matching

The tracking primitives (TR-01 through TR-07) are already implemented as standalone algorithms in parallax/ops/fusion/tracking.py — staypoint detection, trip extraction, kinematic gating, Kalman smoothing, and ST-DBSCAN all work.

component.parallax.island-robustness

Island Fusion Robustness Tests

Prove the island fusion wire protocol is robust under realistic tactical conditions: concurrent access, large payloads, partial failures, repeated cycles, and mid-flight network disruption.

component.parallax.local-quickstart

Local Quickstart + OSS Docker Path

A curious engineer evaluating Athena must have it producing useful matches on their own data within 15 minutes of docker run. Today that's impossible without Titan, ES, and Xanadu — a multi-day setup.

component.parallax.consensus-mission-service

Consensus Mission Service

SPEC-28 / SPEC-36 / SPEC-30 define combiner math, session state machine, and machine dissent.

component.parallax.coordination-ledger

Coordination Ledger Options for Composable Architecture

Composable architectures pay a recurring audit-quality tax: silent schema drift between services, diffuse audit trails that make cross-service workflow reconstruction forensic rather than mechanical, and undefined workflow states…

component.parallax.signal-queue-contract

Signal Queue Contract

This spec defines a contract, not an implementation. It captures the capability requirements that close the gaps surfaced by the Signal-Flow Ground Truth review (May 2026).

component.prism.traversal-engine

Traversal Engine

Multi-modal routing engine: road graphs (OSM), terrain meshes (DEM), ocean grids. A with composite cost from lens layers. Produces Route artifacts with per-segment cost breakdown.

component.prism.observation-engine

Observation Engine

Satellite propagation (SGP4), coverage surface computation, and collection window analysis. Real TLE data from CelesTrak. Two coverage modes: elevation-angle (wide-area sensors) and ground-track swath (optical imaging).

component.prism.temporal-engine

Temporal Engine

Action window optimization: intersect time-varying constraints, find optimal departure time, detect constraint conflicts. Answers "when should we move?"

component.prism.scenario-runner

Scenario Runner (YAML → Execution)

Generic executor: scenario YAML in → lens execution → evidence + HTML out. The LLM generates the YAML, the framework executes it. No custom demo code per scenario.

component.prism.cost-lens-governance

Cost-Lens Governance Lifecycle

from prism's pre-split code (git show 8099b68^:lens/governance/{lens,_helpers}.py), which was

component.prism.lens-families

Lens Families — Identity + Decision

Two families of governed computation share one lifecycle, one evidence model, and one platform. This spec names them, fixes the boundary between them, and defines how they compose.

component.prism.platform-integration

Platform Integration & Scale

A lens is a governed, versioned, federated computation primitive: a YAML spec (auditable, version-pinned), an input hash (reproducible), an output hash (tamper-evident SHA-256 evidence block — component.prism.evidence-model), a go…

component.sentinel.alerting

Sentinel — Alerting and Monitoring Service

Trigger: As an operator monitoring federated sites, I want a dedicated alerting service that ingests alert events from any source, evaluates thresholds, and routes notifications, so that the alert lifecycle (acknowledge → resolve…