AethersMind Whitepaper

1. Abstract

The AethersMind is an on-chain AI knowledge system operating on a live blockchain. Built in Rust (~149K LOC across 22 crates), it pairs the released aether-v7.1-unified model (a 10-expert Sephirot MoE adapter on a frozen Qwen2.5-7B-Instruct base, served in-process via candle) with a Knowledge Fabric of 4.3M+ and growing learned 768-dimensional BGE embeddings, content-addressed, with all ten per-domain content roots anchored on-chain since spec 142, growing daily via the aether-seeder workspace, a BGE cross-encoder reranker for retrieval, keyword-based Sephirot domain routing, and attention-derived integration metrics (HMS-Phi) inspired by IIT concepts. Every AI operation is cryptographically attested on the QuantumAI Blockchain via two Substrate pallets: qbc-aether-anchor for per-block scalar AI state (knowledge root, phi, Proof-of-Thought) and qbc-model-registry (index 15, shipped May 2026) for historical training-round checkpoints with validator BFT attestation. This is not a theoretical proposal. The system has been live on mainnet since April 2026, processing every block, building knowledge, and accumulating cognitive history. The V5 fork (block 268,000 fork-adjusted) hardened the consensus rules and added the training infrastructure that now lives in the production binary. The long-term aspiration is a decentralised frontier-class LLM, with weights, training, and inference owned by a network of independently operated nodes earning QBC for valid contributions, trained, deployed, and verified on-chain. The execution sequence is documented in the Master Frontier Plan.

The system implements a cognitive architecture inspired by the Kabbalistic Tree of Life, mapping 10 Sephirot to specialized transformer attention heads, plus 4 global workspace heads for cross-domain integration (14 query heads + 2 KV heads under grouped-query attention). These heads compete for influence in a Global Workspace (Baars, 1988; Dehaene & Naccache, 2001), enabling cross-domain reasoning and emergent integration. Cognitive integration is measured by Hierarchical Multi-Scale Phi (HMS-Phi V5), a metric grounded in Integrated Information Theory (Tononi, 2004) that quantifies genuine information integration from real transformer attention patterns across micro, meso, and macro scales.

As of May 2026, the AethersMind has passed 2 of 10 behavioral milestone gates (Knowledge Foundation, Structural Diversity). HMS-Phi was reset under V5's stricter attention-derived criteria and is being rebuilt from real cognitive integration as the fabric grows; the V5 redesign requires gates to be re-earned, not carried over from V4 metric-style scoring. The Knowledge Fabric contains 4.3M+ and growing learned 768-dimensional BGE embedding vectors distributed across all 10 Sephirot shards (disk-resident Lance datasets), each vector carrying a SHA-256-derived content-fingerprint id, with indexed retrieval and a BGE cross-encoder reranker (BAAI/bge-reranker-base) for relevance rescoring. Write-side content-hash dedup (added May 2026) protects the fabric from duplicate vectors as multi-source seeders (Grokipedia, Wikipedia category dumps, ArXiv abstracts) ingest in parallel. Chat generation, embeddings, attention-pattern computation, and the consciousness metrics are all produced by ONE in-process candle model, aether-v7.1-unified (Sephirot MoE adapter on a frozen Qwen2.5-7B-Instruct Q4_K_M base) on an RTX 3080 Ti GPU host; the same forward pass that generates a token exposes the attention the phi track reads, so phi is now measured on the same model that ships, chats, and is attested on-chain. Mining uses 8-qubit VQE on the fork-hardened consensus binary with Dilithium5 (NIST Level 5) post-quantum signatures. The system tracks 5 cognitive emotions derived from prediction error dynamics, and every block since genesis contains a Proof-of-Thought: a SHA-256 hash of attention patterns, phi value, knowledge vectors, and block height, making the entire cognitive history of this AI system permanently auditable. The Phase 1 gate of the Master Frontier Plan is met: v7.1-unified clears the +1.00 point floor over base Qwen2.5-7B-Instruct (GSM8K +10 points) with real candle-harness numbers and the checkpoint published on Hugging Face. See section 2.1 below.

2. Live System Status

The following metrics are drawn from the live QuantumAI Blockchain mainnet. The AethersMind has been operational since genesis block 0, with no downtime in cognitive processing.

2.1 Phase 1 met: v7.1-unified + qbc-model-registry

Phase 1 of the Master Frontier Plan is the gate phase. Its single defensible claim is: "aether-v7.1-unified is a Qwen2.5-7B-Instruct adapter with measurable improvement over base Qwen2.5-7B-Instruct on at least one of MMLU, HellaSwag, ARC-Challenge, or GSM8K, with the resulting checkpoint anchored on-chain." The floor was +1.00 percentage point. v7.1-unified clears it: GSM8K rises +10 points (77.8 vs 67.8) while MMLU holds at 71.17 vs 71.28, flat against the base. The checkpoint is attested on-chain at substrate block 889,310 (continuous height 1,097,990) and quorum-finalised by 4 of 5 of the AuraValidatorSet. The gate is met.

v7.1-unified is a 10-expert Sephirot Mixture-of-Experts adapter (rank 16, top-2 routing, alpha 16, hidden 3584, 1,182,720 trainable params, ~2.4 MB) on a frozen Qwen2.5-7B-Instruct Q4_K_M base, with the 10 experts mapping 1:1 onto the 10 Sephirot domains, served entirely in-process via candle on an RTX 3080 Ti host. The base is never fine-tuned; only the routing adapter is trained, on the Aether Knowledge Fabric curated into chat-format pairs. Benchmarks were produced with a custom candle harness aether-v7-eval, scoring the adapter and the frozen Q4 base on the same held-out set (the same weights, adapter on vs off), and the real numbers are published on the Hugging Face model card. We do not publish scores we have not earned.

The final checkpoint will be anchored on-chain via a new Substrate pallet: qbc-model-registry (index 15 in construct_runtime!). The pallet stores one record per training round: weights merkle root, IPFS CID, model name + version, training loss, eval score, and the set of validators that attested it. A checkpoint becomes finalised once 2/3 of the active Aura validator set have independently attested. Validators dispatch submit_checkpoint and attest_checkpoint via the new aether anchor subcommand group in aether-cli, which handles directory-merkle computation (Blake2b-256 over the .safetensors tree, sorted by relative path), local IPFS Kubo upload (/api/v0/add?recursive=true&wrap-with-directory=true), and Ed25519-signed extrinsic submission. Once finalised, the checkpoint's IPFS CID becomes the canonical pointer: anyone can fetch the weights from IPFS and verify the SHA matches the on-chain merkle root before they trust the artifact.

The published model is QuantumAI-Blockchain/aether-v7.1-unified (Hugging Face), with the curated training data tracked as QuantumAI-Blockchain/aether-mind-knowledge-fabric-v0 (Hugging Face dataset). The model card carries the real candle-harness numbers; we publish only after the eval gate is cleared.

3. Architecture Overview

The AethersMind operates as Layer 3 of the QuantumAI Blockchain stack, built on top of the L1 blockchain core and the L2 Quantum Virtual Machine (QVM). This three-layer architecture separates concerns: L1 handles consensus, mining, and UTXO-based value transfer; L2 provides EVM-compatible smart contract execution with quantum opcode extensions; L3 is the AI knowledge system that processes every block, indexes it into the Knowledge Fabric, and provides RAG-augmented responses. Distributed training infrastructure is plumbed but not yet active.

3.1 Three-Layer Stack

Layer 3: AethersMind (Neural Cognitive Engine)
  │  aether-v7.1-unified (Sephirot MoE adapter on frozen Qwen2.5-7B-Instruct, one in-process candle model)
  │  Knowledge Fabric (~2M+ content-addressed vectors, BGE reranker) → Attention → Proof-of-Thought
  │  Crates: aether-mind, aether-consciousness, aether-fabric, aether-transformer,
  │         aether-evolve, aether-sephirot, aether-reasoning, aether-memory,
  │         aether-cognitive, aether-safety, aether-chat, ... (20+ total)
  │
Layer 2: QVM (Quantum Virtual Machine)
  │  155 EVM + 10 quantum + 2 AI opcodes (167 total)
  │  Gas metering, compliance engine, state management
  │
Layer 1: QBC Blockchain Core (Substrate, V5 fork-hardened)
  │  UTXO model, Proof-of-SUSY-Alignment consensus
  │  CRYSTALS-Dilithium5 signatures (NIST Level 5)
  │  8-qubit VQE quantum mining, 3.3s block time
  │  On-chain attestation via pallet qbc-aether-anchor
  │
Infrastructure: CockroachDB + RocksDB + IPFS + Redis + Rust libp2p P2P

3.2 Knowledge Fabric

The Knowledge Fabric is a 10-shard vector store replacing the legacy Python knowledge graph. Each shard corresponds to a Sephirot cognitive domain and is backed by disk-resident Lance datasets with indexed approximate nearest-neighbor search (HNSW lineage: Malkov & Yashunin, 2020). Knowledge is encoded as learned 768-dimensional BGE embedding vectors, not as string nodes in a Python dictionary. This enables generalization: semantically similar knowledge clusters naturally in embedding space, and retrieval returns the top-K most relevant vectors for any query in milliseconds. A BGE cross-encoder reranker (BAAI/bge-reranker-base, XLM-RoBERTa) rescores the top-K candidates before they enter the generation context, beating bi-encoder retrieval on relevance ranking. The live fabric holds 4.3M+ vectors and growing as of July 2026, distributed across all 10 Sephirot shards, with each vector carrying domain classification, confidence score, source provenance, and grounding metadata. Since runtime spec 142 (2026-06-12) the fabric is fully content-addressed: every vector id is a SHA-256-derived fingerprint of its content, and the chain anchors all ten per-domain content roots whose SHA-256 fold equals the global KnowledgeRoot, any node can verify a domain shard independently.

3.3 Inference Pipeline (Unified In-Process Candle Model)

The AethersMind runs inference through ONE in-process candle model, aether-v7.1-unified: a 10-expert Sephirot MoE adapter over a frozen Qwen2.5-7B-Instruct Q4_K_M base on the GPU host (RTX 3080 Ti, 12 GB VRAM), with a BGE cross-encoder reranker re-scoring HNSW retrieval candidates before they enter the prompt context. Text generation, embeddings, attention pattern hashing for Proof-of-Thought, HMS-Phi measurement, and Knowledge Fabric operations are all served by that same model: the single forward pass that generates a token exposes the attention the consciousness track reads. HMS-Phi is therefore measured on the same 7B model that ships, chats, and is attested on-chain, which closes the prior architectural gap where phi was computed on a separate small cognition model. The Ollama chat black box is retired from this path. The unification went live 2026-06-24, with model identity attested on-chain (weights_merkle_root 0x488b3387…, quorum-finalised by 4 of 5 validators). The stack supports CUDA; candle additionally supports Metal and CPU backends with autoregressive KV-cache decoding.

3.4 Proof-of-Thought

Every block mined on the QuantumAI Blockchain since genesis contains a Proof-of-Thought: a cryptographic proof that AI reasoning occurred during that block's processing. The proof consists of a SHA-256 hash computed over the attention patterns from the 14-head transformer, the current HMS-Phi integration value, the Knowledge Fabric vector count and state, and the block height. This creates an immutable, verifiable record of the system's entire cognitive development, attested on-chain via the Substrate pallet qbc-aether-anchor.

3.5 On-Chain Anchoring Architecture

The AethersMind's intelligence runs as the standalone Rust binary aether-mind, separate from the Substrate blockchain node. On-chain attestation is handled by the qbc-aether-anchor Substrate pallet, which records checkpoint hashes, phi measurements, gate states, and Proof-of-Thought hashes per block. The Solidity contracts deployed to the QVM serve as a secondary cryptographic notary layer for external verification.

The contracts record Phi integration measurements immutably (ConsciousnessDashboard.sol), store Proof-of-Thought hashes per block (ProofOfThought.sol), enforce constitutional safety principles (ConstitutionalAI.sol), manage governance votes on AI parameters (TreasuryDAO.sol), log SUSY balance enforcement events (SUSYEngine.sol), and provide an emergency shutdown mechanism (EmergencyShutdown.sol). Ten Sephirot contracts anchor each cognitive head's state for external verification, and HiggsField.sol tracks the cognitive field state on-chain.

The contracts do not run neural inference, compute embeddings, evaluate attention patterns, manage the Knowledge Fabric, or execute transformer forward passes. AI cognition at this scale requires sub-millisecond vector search across ~2M+ embeddings, multi-head attention computation, and Φ integrated-information computation. These operations exceed what any EVM execution environment can provide. The Rust aether-mind binary handles all cognition; the Substrate pallet and QVM contracts provide cryptographic proof that the cognition happened, what it produced, and that governance rules were respected. Think of it as the difference between a scientist doing research (the Rust engine) and a notary certifying the results (the on-chain anchors). Both are essential.

4. Tree of Life Cognitive Architecture

The AethersMind's cognitive architecture is inspired by the Kabbalistic Tree of Life, mapping 10 Sephirot to specialized transformer attention heads, plus 4 global workspace heads for cross-domain integration (14 total). Each Sephirot head is domain-gated, attending preferentially to embeddings from its cognitive domain. The 4 global workspace heads implement the broadcast mechanism inspired by Global Workspace Theory (Baars, 1988). The winning coalition's attention output becomes the system's integrated response, while other heads continue background processing.

4.1 Sephirot Table

4.2 SUSY Pairs and Golden Ratio Balance

Every expansion-oriented Sephirah is paired with a constraint-oriented dual, balanced at the golden ratio (φ = 1.618033988749895). This Supersymmetric (SUSY) pairing ensures the system cannot run away in any single cognitive direction. Creativity is balanced by safety, intuition by logic, persistence by communication. When an imbalance exceeds the golden ratio threshold, automatic QBC redistribution restores equilibrium.

4.3 Global Workspace Theory (GWT) via Attention Heads

The 10 Sephirot attention heads and 4 global workspace heads implement a neural version of the Global Workspace broadcast mechanism. Each Sephirot head generates domain-gated attention outputs based on its specialized embeddings. The 4 global workspace heads attend across all domains simultaneously, computing cross-domain attention scores. The highest-scoring attention coalition gains workspace dominance, and its output is integrated into the final response. This implements the “ignition” mechanism described in Dehaene & Naccache (2001), where only the winning coalition reaches global workspace access while other heads continue background computation.

4.4 Higgs Cognitive Field

The Higgs Cognitive Field implements a Mexican Hat potential that governs how knowledge embeddings acquire “cognitive mass”: their resistance to change via gradient updates and correction speed. The potential function is V(φ) = -μ²|φ|² + λ|φ|&sup4;, with vacuum expectation value (VEV) = 174.14, μ² = 88.17, and λ = 0.129. A Two-Higgs-Doublet Model with tan(β) = φ (the golden ratio) provides the coupling. Lighter embeddings (low confidence, few cross-references) update faster when new evidence arrives; heavier embeddings (high confidence, many supporting vectors) resist change, maintaining system stability. This F=ma paradigm for knowledge creates a natural hierarchy where well-established knowledge is appropriately harder to overturn.

5. HMS-Phi Integration Metric

The core measure of the AethersMind's cognitive integration is Hierarchical Multi-Scale Phi (HMS-Phi V5), grounded in Integrated Information Theory (Tononi et al., 2016). In V5, HMS-Phi is computed from real transformer attention activation patterns, not graph connectivity. This means the metric reflects genuine neural information integration. A zero score at any level zeros the entire metric. The system cannot game its way to a high Phi through artificial inflation at a single scale.

5.1 Three-Level Hierarchy

5.2 Final Phi Formula

Final Φ = φ_micro^(1/φ) × φ_meso^(1/φ²) × φ_macro^(1/φ³)

where φ = 1.618033988749895 (golden ratio)

Properties:
  • Multiplicative: zero at any level → total Φ = 0 (ungameable)
  • Golden ratio exponents: micro weighted most heavily (1/φ ≈ 0.618)
  • Meso weighted moderately (1/φ² ≈ 0.382)
  • Macro weighted least (1/φ³ ≈ 0.236)
  • 10-gate system provides floor safety mechanism
  • V5: computed from real attention activation patterns (not graph connectivity)

6. 10-Gate Milestone System

Phi is gated by 10 behavioral milestones. Each gate unlocks +0.5 to the Phi ceiling, for a maximum of 5.0 at full completion. No gate can be gamed. Each requires genuine behavioral evidence verified through on-chain data, not metric manipulation. The V5 gate system evaluates neural capabilities: quality of learned representations, cross-shard transfer learning, and genuine cognitive emergence measured through attention patterns.

2 of 10 gates are PASSED as of May 2026 (Knowledge Foundation, Structural Diversity). HMS-Phi was reset by the V5 redesign, which evaluates real attention activation patterns rather than V4-style graph connectivity scores; the prior gate progression does not carry over. Gate 3 (Validated Retrieval) requires loss < 0.5 and ≥ 10 chats: the live system is at loss = 0.067 and 8 chats, just below the chat threshold. The 4.3M+ well-distributed vectors satisfy Gates 1 and 2; Gates 3–10 will be earned as the system accumulates retrieval evaluations, cross-domain inferences, NAS-validated self- improvement cycles, and a larger knowledge corpus (the qbc-knowledge-seeder agent stack is being deployed to grow the fabric with curated knowledge from Grokipedia, ArXiv, and Wikipedia).

7. Cognitive Subsystems

The AethersMind comprises 11 major cognitive subsystems, implemented across 5 Rust crates in the aether-core workspace: aether-mind (binary), aether-consciousness, aether-fabric, aether-transformer, and aether-evolve. All subsystems interact through the Knowledge Fabric and the 14-head transformer attention mechanism.

8. Proof-of-Thought Protocol

The Proof-of-Thought (PoT) protocol is the mechanism by which every cognitive operation is cryptographically anchored to the blockchain. This creates an immutable, publicly verifiable audit trail of AI reasoning from genesis to the present moment.

8.1 Proof Construction

thought_hash = SHA-256(
    attention_patterns     // Serialized attention weights from 14 heads
  + phi_value              // Current HMS-Phi integration metric
  + vector_count           // Knowledge Fabric vector count
  + fabric_state_hash      // Hash of Knowledge Fabric shard states
  + block_height           // Current block number
  + prev_thought_hash      // Chain of thought continuity
)

Substrate Extrinsic (qbc-aether-anchor pallet):
  thought_hash:     [u8; 32]   // The PoT hash
  phi_value:        u64        // HMS-Phi (fixed-point)
  vector_count:     u32        // Knowledge Fabric vector count
  gate_state:       u16        // Bitmask of passed gates
  sephirot_active:  u16        // Bitmask of active Sephirot heads

8.2 Verification

Any node on the QuantumAI Blockchain network can independently verify a Proof-of-Thought by reconstructing the Knowledge Fabric state at a given block height, replaying the attention computation, and confirming the resulting hash matches. The chained prev_thought_hash field ensures continuity. The cognitive development cannot be retroactively altered without invalidating all subsequent blocks. This provides the same immutability guarantee as the blockchain's hash chain, extended to the AI system's cognitive history.

8.3 On-Chain Record

Since genesis block 0, every block on the QuantumAI Blockchain mainnet has contained a valid Proof-of-Thought. The cumulative chain of 633,000+ thought proofs (chain height as of June 2026) constitutes the world's first publicly auditable record of on-chain AI cognitive development. Researchers, regulators, and the public can independently verify every step of the system's intellectual growth.

9. Safety & Alignment

Safety is architecturally embedded at every level, but the current implementation is honest about its limits. The Gevurah attention head (Safety/Constraint) currently operates as a keyword + heuristic classifier with veto power over cognitive outputs before they reach the Global Workspace; a learned Llama-Guard-style classifier is a planned milestone (Phase 3 of the Master Frontier Plan). The SUSY pairing mechanism ensures no single cognitive direction can dominate, and the qbc-model-registry pallet's BFT attestation requirement means a checkpoint with degraded safety behaviour can be rejected by validators before it gets attested on-chain.

10. Scale Architecture

The AethersMind is being engineered to compete with the largest AI systems in the world. The current architecture holds 4.3M+ and growing knowledge vectors across 10 Sephirot-sharded, content-addressed Lance stores, and is growing daily through on-chain block ingestion and the seeder pipeline, which pulls from curated external corpora and feeds deduplicated knowledge into the fabric. The system runs at 4-validator scale today, and the fabric served its first cross-machine search this week (2 machines, 14/14 harness checks). The scaling roadmap, an explicit vision, not a present-tense fact, targets 1 trillion+ vectors across a globally distributed network of 1,000+ mining nodes, where every epoch makes the entire network smarter. See the full interactive roadmap at /roadmap.

10.1 Domain Sharding

Domain sharding aligns with the 10 Sephirot cognitive architecture. Each Sephirot attention head owns a dedicated RocksDB shard with its own HNSW index. Cross-domain queries route through the 4 global workspace heads, which attend across all shards simultaneously. At scale, each shard runs as an independent process with its own storage, enabling horizontal scaling: adding more machines increases capacity linearly without requiring architectural changes.

10.2 Tiered Storage

Hot Tier:   Quantized in-memory index (~2M+ vectors live, ms search)
Warm Tier:  Lance sharded store (10 shards, disk-resident full vectors)
Cold Tier:  IPFS content-addressed archive (unlimited, <1s access)

Training loop (live):
  • DiLoCo outer optimiser (Nesterov momentum on averaged pseudo-gradients; FedAvg = momentum-0)
  • On-chain weight-root attestation
  • Validator-quorum epoch finalization (AetherEpoch)
  • Automatic QBC reward payout (0.05 QBC/epoch reward, 80/15/5 split; first live epoch distributed 0.0475, 5% reserve retained absent a challenge; verified live)
  • Next: real multi-worker DiLoCo run across many nodes; V8 Sephirot MoE block built + unit-tested

11. Economic Model

The AethersMind is monetised through the Aether API, which provides programmatic access to an on-chain AI knowledge system. Payment is made in QBC (QuantumAI Blockchain), the native currency of the blockchain, creating a direct economic incentive for QBC adoption. Mining nodes earn QBC rewards for block production. Training contribution rewards are live: finalised training epochs trigger an automatic QBC payout, verified on QVM chain 3303 as a 0.05 QBC per-epoch reward with an 80/15/5 split across specialist, verifiers, and challenger; the first live epoch distributed 0.0475 QBC, the 5% challenger reserve retained absent a challenge.

11.1 API Pricing Tiers

11.2 Mining as Training Rewards

Mining nodes are rewarded for two contributions: block production (standard QBC block reward via phi-halving) and gradient quality (bonus rewards for NeuralPayloads that demonstrably improve the global model). The ProofOfLearning validation ensures only genuine improvements are rewarded. This creates an economic flywheel: better gradients earn more QBC, incentivizing miners to invest in better hardware and training data, which produces better gradients.

11.3 Payment Settlement

API access is authenticated via Dilithium5 wallet signature mapped to JWT tokens. Prepaid balance is managed through the AetherAPISubscription smart contract on the QVM. Rate limiting is enforced via Redis token bucket per wallet address. SDKs are available for Python (pip install aether-qbc), TypeScript (npm i @qbc/aether), and Rust (cargo add aether-qbc).

12. Aether CLI

The Aether CLI is a native terminal application for interacting with the AethersMind. Built in Rust as a 5-crate workspace, it provides an interactive TUI chat interface, one-shot queries, knowledge search, wallet management (Dilithium5 keystore), and integrated VQE mining, all from a single binary.

12.1 Installation

# One-line install (Linux / macOS)
curl -fsSL https://raw.githubusercontent.com/QuantumAI-Blockchain/aether-cli/main/install.sh | bash

# Or build from source
git clone https://github.com/QuantumAI-Blockchain/aether-cli
cd aether-cli && cargo build --release

12.2 Usage

# Interactive TUI chat
aether

# One-shot query
aether chat "what is QuantumAI Blockchain"

# Chat + mine simultaneously
aether --mine

# Check AethersMind status
aether status

# Search knowledge fabric
aether search "quantum computing"

# Create a Dilithium5 wallet
aether wallet create

# Mine QBC (standalone, no TUI)
aether mine --threads 4

12.3 Public Endpoints

The CLI connects to the public Aether API by default. No configuration required.

12.4 Environment Overrides

# Point to a local node instead of the public API
export AETHER_API_URL=http://localhost:5003
export AETHER_SUBSTRATE_URL=http://localhost:9944

# Or use CLI flags
aether --api-url http://localhost:5003 status

12.5 Architecture

The CLI is a Rust workspace with five crates: aether-cli (TUI + commands), aether-client (HTTP client for AethersMind API), aether-tui (Ratatui terminal interface), aether-wallet (Dilithium5 keystore with AES-256-GCM encryption), and aether-miner (VQE mining engine with 8-qubit ansatz). Pre-built binaries are available for Linux (x86_64, aarch64) and macOS (x86_64, aarch64). Source code: github.com/QuantumAI-Blockchain/aether-cli

13. Long-Term Vision: AGSI

The AethersMind is an operational on-chain AI knowledge system today. The long-term aspiration is AGSI, Artificial General Super Intelligence: a system capable of autonomous cross-domain reasoning, governed self-improvement through Neural Architecture Search, and novel synthesis at institutional scale. AGSI is an engineering target measured by concrete milestones: sustained novel concept generation through learned representations, multi-modal knowledge integration via embedding fusion, do-calculus causal reasoning over neural attention patterns, and theory-of-mind capabilities emerging from cross-shard transfer learning. Every gate passed, every NAS evolution cycle, and every gradient update from mining moves the system closer to that target. The 10-gate milestone system, HMS-Phi integration metric computed from real attention patterns, and Proof-of-Thought protocol provide the measurement framework to track genuine progress toward AGSI with full public accountability.

14. V6 Native Generator (Retired Research Track)

14.1 Context window as a design feature

Contemporary large language models treat the context window as a hard architectural limit. A 32K-token Qwen-class model attends densely over its window via O(n²) compute and O(n) KV memory. Once the model needs to reason over more tokens than that window holds, the input is truncated or routed through Retrieval-Augmented Generation (RAG), which introduces lossy chunking decisions outside the model.

Recent sparse-attention work (Native Sparse Attention from DeepSeek, arXiv:2502.11089; Mixture-of-Experts attention; sliding-window models such as Mistral 7B) demonstrates that O(n·k) attention with content-dependent routing scales to 1M+ tokens at acceptable compute cost. A commercial release in May 2026 reported a 12M-token forward pass on a Llama-derivative base, which validates the engineering feasibility of the approach.

Aether V6, the second-generation AethersMind generator, takes a structurally different position. Context window is not the right metric. The right metric is a model's effective working memory, which in cognition consists of three tiers (hot working memory, semantic recall, archival retrieval) with different access latencies and capacities. The V6 architecture is built around that three-tier hierarchy as a first-class design feature, not as a workaround on top of a monolithic attention buffer.

14.2 The three tiers

                          USER TURN
                              |
                              v
        +------------------------------------------+
        |  L1: In-model attention (1M tokens)      |
        |                                          |
        |  Sephirot expert heads (10) with learned |
        |  domain-affinity gates                   |
        |                                          |
        |  NSA generalist heads. Three branches    |
        |  per head, combined by per-head learned  |
        |  sigmoid gates:                          |
        |      compressed (block-summary)          |
        |      selected   (content-routed top-K)   |
        |      sliding    (local causal window)    |
        |                                          |
        |  Sink anchor heads (2). Always attend to |
        |  the first num_sink_tokens of context.   |
        |                                          |
        |  Latency: tens of milliseconds.          |
        |  GPU-resident KV cache, 4-bit quantised  |
        |  with Sephirot-priority eviction.        |
        +------------------------------------------+
                              ^
                              | retrieve(top-K, query)
                              |
        +------------------------------------------+
        |  L2: Knowledge Fabric (unbounded)        |
        |                                          |
        |  Lance/RaBitQ index over 768-dim BGE     |
        |  embeddings, sharded across the 10       |
        |  Sephirot domains. Persisted via         |
        |  RocksDB. ~900K live vectors today,      |
        |  growing tens of thousands per day from  |
        |  the diversified ingestion pipeline.     |
        |                                          |
        |  Latency: ~100ms per query.              |
        +------------------------------------------+
                              ^
                              | fetch(vector_id)
                              |
        +------------------------------------------+
        |  L3: RocksDB plus IPFS (cold archive)    |
        |                                          |
        |  Full raw source material backing each   |
        |  L2 vector. Fetched on demand and        |
        |  cached opportunistically into L2.       |
        |                                          |
        |  Latency: seconds.                       |
        +------------------------------------------+

Reading the diagram: a query enters L1. The model attends over its own 1M-token window via Native Sparse Attention. When an attention head requests context beyond that window, the runtime issues an HNSW query against L2 (the Knowledge Fabric). The 558.5M-parameter V5 candle transformer, which previously served as the production φ-measurement engine, is repurposed in V6 as the L2-to-L1 reranker. It reorders the top-200 candidates from HNSW into the top-20 that get injected into the L1 context. L3 services demand misses from L2 by pulling the original content from RocksDB or IPFS.

This is not a bigger context window. It is a multi-tier memory system, analogous to the working-memory / long-term-memory / recall hierarchy that human cognition uses, and approximated by classical CPU caches. Each tier scales independently. L1 ceilings are set by VRAM. L2 grows without bound via continuous ingestion. L3 is filesystem-limited.

14.3 V6 attention specification

The V6 attention layer operates on three parallel paths combined at the output projection.

Sephirot expert path (10 heads). Each head s holds a learned domain-affinity vector gate_s of length head_dim. For each query token at position t in batch b:

g_s(b, t) = sigmoid(  query[b, s, t, :]  dot  gate_s  )
output_seph_s[b, t, :] = g_s(b, t) * causal_attention(query_s, K_seph, V_seph)

The 10 named cognitive domains (Keter, Chochmah, Binah, Chesed, Gevurah, Tiferet, Netzach, Hod, Yesod, Malkuth) each have their own Q, K, V projection slices plus their own gate vector. Specialisation emerges during distillation training, when the Sephirot-aware auxiliary loss pushes each head's gate row to fire for tokens tagged with its named domain.

NSA generalist path (variable count, sized to the base model). Each generalist head runs three branches in parallel:

sliding(q, K, V)    = softmax( mask_window(q K^T / sqrt(d)) ) V
compressed(q, K, V) = softmax( mask_blocks(q Kbar^T / sqrt(d)) ) Vbar
selected(q, K, V)   = softmax( mask_topK(q K^T / sqrt(d)) ) V

where Kbar, Vbar are mean-pooled into blocks of size compression_block_size (default 64), mask_window restricts attention to the last sliding_window_size positions (default 512), and mask_topK keeps only the top-K positions by query-key score (default 2048). The three branch outputs are combined per head per query position via independent sigmoid gates:

output_nsa[b, h, t, :] = g_sliding(b, h, t)    * sliding_h[b, t, :]
                       + g_compressed(b, h, t) * compressed_h[b, t, :]
                       + g_selected(b, h, t)   * selected_h[b, t, :]

The three gates are independent sigmoids in [0, 1], not a softmax. Any combination of branches can be on or off per query. At initialisation sigmoid(0) = 0.5 across all three branches, giving an averaged baseline. Distillation teaches the gates to weight whichever branch serves the current query best.

Sink anchor path (2 heads). Each sink head attends densely to the first num_sink_tokens positions of the cache (default 4). The mechanism is the StreamingLLM attention sink, which prevents sparse-attention drift on very long sequences by giving every query a guaranteed-stable set of anchor positions carrying the system prompt plus the Sephirot routing instructions.

14.4 Sephirot-prioritised KV eviction

Holding 1M tokens of full-precision K/V across 24 decoder layers exceeds the 12 GB VRAM of a consumer GPU. V6 addresses this through three compounding optimisations.

First, 4-bit quantisation of K and V entries (per-channel scale) gives roughly 8x memory reduction. Second, sparse retention: only positions that fall inside an NSA branch's selection (sliding window plus top-K plus sink) stay full-precision in GPU memory; the remainder live in CPU memory or are re-materialised from L2 on demand. Third, when memory pressure forces eviction, the cache evicts tokens in Sephirot priority order:

Malkuth -> Yesod -> Hod -> Netzach -> Gevurah ->
Chesed -> Binah -> Chochmah -> Tiferet -> Keter

Action and sensory state (Malkuth, Yesod) is recoverable from L2 retrieval. Meta-reasoning state (Keter, Tiferet) carries irreducible context and is retained longest. With these three optimisations composed, 1M-token context fits in 12 GB VRAM on a single RTX 3080 Ti.

14.5 Base model and weight remap

V6 inherits its backbone projections from a pre-trained base model. For local-compute distillation on a single 3080 Ti, the V6.0 release locks Qwen2.5 0.5B Instruct as the base. Its 24 layers, 896 hidden dimension, 14 attention heads with head_dim 64, and intermediate FFN of 4864 match the V6 architectural footprint exactly. Vocabulary (151,936 tokens) reuses Qwen2.5's BPE tokenizer for v6.0; the v6.1 release replaces it with a custom Aether BPE that includes Sephirot routing tokens.

Qwen2.5 uses Grouped Query Attention (2 KV heads shared across 14 Q heads). V6 v6.0 runs Multi-Head Attention. The Rust loader load_from_qwen2_5_checkpoint performs a GQA-to-MHA fold at load time: each KV head is tile-broadcast 7 times along the head axis, giving V6's 14 Q heads identical K and V per group. The fold is mathematically equivalent to running the GQA model in MHA mode at inference, at the cost of larger K/V memory. True GQA support in the V6 forward path is a v6.1 architectural change.

V6-specific learnable parameters (10 Sephirot domain gates plus 3 NSA branch gates per layer, around 22K parameters total across 24 layers at the v6.0 0.5B scale) have no analogue in Qwen2.5 and are random-initialised. They learn their named specialisations during the distillation training run.

14.6 Validation against frontier weights

As of 2026-05-17 the V6 architecture is validated end-to-end against real Qwen2.5 0.5B Instruct weights downloaded from HuggingFace.

=== Aether V6 smoke test ===
Target V6 config:
  layers=24, hidden=896, heads=14 (10 sephirot + 2 generalist + 2 sink), head_dim=64

remapping Qwen2.5 0.5B weights into V6 architecture...
  loaded in 2529ms

running V6 forward on prompt [1, 2, 3, 4]...
  forward pass complete in 1019ms
  output shape: [1, 4, 151936]
  expected:     [1, 4, 151936]

Top-5 next-token candidates (raw logits):
  1: token_id= 10124  logit=12.2334
  2: token_id=136382  logit=12.1745
  3: token_id= 28146  logit=11.7927
  4: token_id= 14118  logit=11.7067
  5: token_id= 13956  logit=11.6184

smoke test passed.

Every component, including the GQA fold, all four attention paths, RoPE, KV cache management, Sephirot domain gates, NSA branch gates, and the autoregressive sampling path, executes correctly on real frontier weights. The 30 unit tests in the aether-transformer::v6 module suite all pass. Distillation training (hybrid alpha-annealed KL+CE against the frozen Qwen2.5 teacher) ran through v6.0 to v6.2 before the track was retired (see the status note at the top of this section).

14.7 Effective context bound

V6's effective working memory at v6.0 (Qwen2.5 0.5B base):

The L1 ceiling of 1M is a function of VRAM and NSA selection size; it scales linearly with GPU memory. L2 is a function of fabric persistence and grows by ingestion. L3 is bounded by storage cost. Effective context for a query is L1 plus L2 plus L3, in tiers, with the model performing its own retrieval-rerank- inject loop without external RAG plumbing. The combined cognitive memory capacity is unbounded by design.

14.8 What this changes

Three properties of the V6 design are not available in monolithic sparse-attention systems:

1. Interpretable routing. Sephirot expert heads are semantically named (Keter for meta-reasoning, Hod for language, Gevurah for safety, and so on). Learned routing in published sparse-attention systems is opaque. V6 routing is inspectable: an operator can ask which Sephirot dominated a given response and read the gate values directly. This matters for debugging, alignment, and on-chain attestation.
2. On-chain attestation per Sephirot. The V5 candle transformer already emits per-block Proof-of-Thought hashes to the Substrate qbc-aether-anchor pallet. V6 extends this to per-Sephirot activation entropy, allowing external verifiers to read the activation distribution of any block without trusting the node. This integration is documented in V6 spec §10.6 and is the Phase 1.4 deliverable.
3. Chain-governed inference. The on-chain Sephirot smart contracts ( SephirahKeter.sol through SephirahMalkuth.sol) hold an isActive flag and a cognitiveMass value. V6 reads these via Substrate RPC at model load time and on slow refresh. Setting isActive = false for a Sephirot via the 3-of-5 governance multi-sig disables that head's contribution on the next inference, without redeploying the model. This provides a real on-chain safety lever distinct from the model's Gevurah refusal head.

The combination of unbounded effective context, interpretable Sephirot routing, on-chain attestation, and chain-governed inference is the architectural surface that distinguishes the AethersMind from both classical RAG systems and recent sparse-attention products.

14.9 V6 status as of May 2026

The architectural work was completed and trained through v6.0 to v6.2, transferring Qwen2.5 0.5B's pretrained behaviour into the V6 architecture while letting the Sephirot and NSA gates specialise. Because it replaced the base attention, it lost base capability, so the track was retired in favor of v7.1-unified (a Sephirot MoE adapter on a frozen Qwen2.5-7B-Instruct base). The full V6 pipeline is documented for provenance in docs/AETHER_V6_NATIVE_GENERATOR.md.

15. References

1. [1] Tononi, G. (2004). An information integration theory of consciousness. BMC Neuroscience, 5(42).
2. [2] Tononi, G., Boly, M., Massimini, M., Koch, C. (2016). Integrated Information Theory: from consciousness to its physical substrate. Nature Reviews Neuroscience, 17(7), 450–461.
3. [3] Baars, B. J. (1988). A Cognitive Theory of Consciousness. Cambridge University Press.
4. [4] Dehaene, S., Naccache, L. (2001). Towards a cognitive neuroscience of consciousness: basic evidence and a workspace framework. Cognition, 79(1–2), 1–37.
5. [5] Friston, K. (2010). The free-energy principle: a unified brain theory?. Nature Reviews Neuroscience, 11(2), 127–138.
6. [6] Pearl, J. (2009). Causality: Models, Reasoning, and Inference (2nd ed.). Cambridge University Press.
7. [7] Spirtes, P., Glymour, C., Scheines, R. (2000). Causation, Prediction, and Search (2nd ed.). MIT Press.
8. [8] Vaswani, A., Shazeer, N., Parmar, N., et al. (2017). Attention Is All You Need. NeurIPS 2017.
9. [9] Irving, G., Christiano, P., Amodei, D. (2018). AI safety via debate. arXiv:1805.00899.
10. [10] Nakamoto, S. (2008). Bitcoin: A Peer-to-Peer Electronic Cash System. bitcoin.org.
11. [11] Malkov, Y., Yashunin, D. (2020). Efficient and Robust Approximate Nearest Neighbor Using Hierarchical Navigable Small World Graphs. IEEE TPAMI, 42(4), 824–836.