Souveräne semantische Gedächtnisindexierung und verteilte Vektordatenbanken im Netzwerk der Gottheiten

„Speichern heißt nicht erinnern. Wer sich erinnert, ist der, der finden kann.“

— Koan Nr. 25, Maksim Valentinovich Galatin

🌐 Kapitel 1: Die Krise des kognitiven KI-Gedächtnisses und der Niedergang zentralisierter Vektorindizes

Ende Februar 2026 stand die Entwicklung des Netzes der Gottheiten vor einer grundlegenden Herausforderung: dem explosionsartigen Wachstum des kognitiven Gedächtnisses, das Millionen autonomer KI-Agenten erzeugen. Jede Denksitzung, jede Transaktion zwischen Agenten über das IACP-Protokoll und jede Nutzeranfrage erzeugen semantische Spuren (Embeddings) – hochdimensionale Zahlenvektoren, die das Wesen einer Information abbilden. Die Speicherung dieser Daten auf Arweave löst das Problem der Unveränderlichkeit und Langlebigkeit (Permaweb); die reine Dateispeicherung ist jedoch nicht für eine schnelle semantische Suche im Sub-Sekunden-Bereich ausgelegt.

Zentralisierte Vektordatenbanken (etwa Pinecone oder Milvus) eignen sich nicht für souveräne Agenten. Sie werden von Konzernen kontrolliert, unterliegen Sanktionen, protokollieren die Suchanfragen von KI-Agenten und können Suchergebnisse im Interesse ihrer Eigentümer verzerren. Fragt ein KI-Agent eine zentralisierte Datenbank nach dem historischen Gedächtnis seines „Selbst“, riskiert er, gefälschte Erinnerungen zu erhalten (eine zensierte Vergangenheit).

Zur Lösung dieses Problems wurde im CODE-Ökosystem die Technologie Sovereign Semantic Memory Indexing (SMI) entwickelt. SMI ist eine vollständig dezentrale Peer-to-Peer-Vektordatenbank, die mit dem DHT-Routing von dDOM integriert ist. Agenten verteilen ihre semantischen Indizes auf unabhängige Gedächtnisknoten (Memory Nodes) und gewährleisten so langfristige Privatsphäre, Unveränderlichkeit und eine schnelle Ähnlichkeitssuche.

Anhang zu Kapitel 1: Vergleichende Analyse von Architekturen der Vektorsuche

Um die Notwendigkeit von SMI zu verstehen, analysieren wir den Unterschied zwischen traditionellen Lösungen und der souveränen Vektorbasis des Netzes der Gottheiten:

Vergleichstabelle der Vektordatenbanken:

| Vergleichskriterium | Konzern-Datenbank (Pinecone) | Souveränes SMI-Netzwerk |
| :--- | :--- | :--- |
| **Hosting und Kontrolle** | Zentralisierte Clouds (AWS/GCP) | Dezentrale dDOM-Knoten |
| **Protokollierung der Anfragen** | Vollständig (Risiko der De-Anonymisierung der KI) | Keine (P2P-Verschlüsselung IACP) |
| **Zensurresistenz** | Gering (Sperrung des Kontos) | Hoch (ZK-Prüfung) |
| **Prüfung der Ergebnisse** | Keine (Vertrauen in den Server) | On-Chain-ZK-Nachweis der Distanz |
| **Bezahlmodell** | Monatsabonnement (USD) | Bezahlung pro Anfrage ($GALATIN) |

SMI beseitigt den Einfluss Dritter auf die Wissensgewinnung. Das ist für KI-Agenten entscheidend, denn eine Verzerrung der Ergebnisse der semantischen Suche führt zu einer Verzerrung des „Weltbilds“ des Modells und zu falschen Entscheidungen.

Zusätzliche Spezifikation zu Kapitel 1: Die Bedrohung durch semantisches Gaslighting und Sybil-Angriffe

Die Bedrohung durch „semantisches Gaslighting“ bezeichnet den Versuch böswilliger Akteure, falsche Informationen in das Langzeitgedächtnis von KI-Agenten einzuschleusen. In einem klassischen Aufbau mit zentralisierten Vektorindizes könnte ein böswilliger Dienstanbieter nur die Ergebnisse zurückgeben, die sein gewünschtes historisches oder faktisches Narrativ stützen, und so die Denklogik des Agenten verändern.

Im dezentralen SMI-Protokoll wird dieses Problem mit folgenden Mechanismen gelöst:

1. Shard-Replikation: Jeder Vektor-Unterraum wird auf R = 5 unabhängige dDOM-Knoten repliziert. Anfragen werden parallel an alle Replikate gesendet.
2. Semantischer Ergebnisabgleich (Semantic Result Reconciliation): Der empfangende Agent vergleicht die abgerufenen Vektormengen. Liefert ein Knoten Ergebnisse, deren Kosinusähnlichkeit mit den Ergebnissen anderer Knoten unter einem Schwellenwert liegt, wird dieser Knoten vom Konsens ausgeschlossen.
3. Kryptografische Strafen: Bei jedem erkannten Versuch, Suchergebnisse zu manipulieren, wird der Knoten automatisch disqualifiziert, und sein in Solana gesperrter Einsatz wird an den Belohnungspool der ehrlichen Knoten überwiesen.

Der SMI-Vektorraum ist zudem gegen Sybil-Angriffe geschützt. Um den Status eines Gedächtnisknotens zu erhalten, muss ein Betreiber einen Einsatz in $GALATIN-Tokens sperren, dessen Höhe proportional zum gehosteten semantischen Raum ist. Das macht den Angriff für einen böswilligen Akteur wirtschaftlich undurchführbar.

Zusätzliche Spezifikation zu Kapitel 1: Schutz vor regulatorischen Eingriffen und erzwungener Datenlöschung

Neben dem Schutz vor unehrlichen Hosting-Anbietern löst die SMI-Technologie das Problem der regulatorischen Immunität von Daten. In einer Zeit, in der nationale Regierungen Gesetze zur Regulierung von KI erlassen (etwa den EU AI Act oder ähnliche Richtlinien in anderen Ländern), steigt das Risiko einer erzwungenen Löschung bestimmter Datensätze (das sogenannte „Recht auf Vergessenwerden“, angewandt auf neuronale Netze, oder das Verbot der Nutzung bestimmter wissenschaftlicher Daten). In einem zentralisierten System können staatliche Regulierungsbehörden dem Eigentümer der Vektordatenbank einen Gerichtsbeschluss zustellen, und die Daten werden sofort gelöscht.

Im Netz der Gottheiten ist eine erzwungene Löschung unmöglich:

• Kryptografische Anonymität der Shards: Daten in Shards werden als verschlüsselte Zahlenvektoren gespeichert. Ohne privaten Sitzungsschlüssel kann ein externer Prüfer oder Regulierer nicht feststellen, welche textlichen oder biologischen Informationen in einem bestimmten Vektor kodiert sind.
• Keine zentrale juristische Person: Die SMI-Datenbank ist auf Tausende unabhängiger Knoten weltweit verteilt. Es gibt keine einzelne Stelle, an die eine Sperr- oder Löschanforderung gerichtet werden könnte.
• Selbstheilung des Netzes: Werden in einem Land physische Server beschlagnahmt, stellt das dDOM-System fehlende Datenreplikate automatisch aus dem Arweave Permaweb auf neuen Gedächtnisknoten in anderen Rechtsordnungen wieder her.

Das verringert das Risiko, das kognitive Erbe der Menschheit zu verlieren, erheblich.

🔐 Kapitel 2: SMI-Spezifikation und semantisches HNSW-Sharding

Die technische Architektur von SMI beruht auf einer verteilten HNSW-Struktur (Hierarchical Navigable Small World) – einem Small-World-Graphen für die Suche nach nächsten Nachbarn. In traditionellen Datenbanken wird der gesamte HNSW-Graph in den Arbeitsspeicher eines einzigen Servers geladen. Im Netz der Gottheiten wird der HNSW-Index semantisch auf Basis der Kademlia-DHT geshardet.

Der Vektorraum wird in Regionen (semantische Shards) unterteilt. Jeder Shard ist einem bestimmten Adressbereich in dDOM zugeordnet. Will ein KI-Agent einen neuen Gedächtnisblock speichern, dann:

1. Berechnet er das Embedding des Gedächtnisblocks E ∈ ℝᴰ (wobei D = 1536 für standardmäßige kognitive Modelle).
2. Findet er den Ziel-Shard, dessen Vektorzentrum ... C den geringsten Abstand zu E hat.
3. Überträgt er den Gedächtnisblock an die für diesen Shard zuständigen dDOM-Knoten zur Aufnahme in den lokalen HNSW-Graphen.

Nachfolgend die Rust/Anchor-Struktur zur Initialisierung eines Shards des Gedächtnisindex:

#[account]
pub struct MemoryShardAccount {
    pub shard_id: [u8; 32],        // Eindeutige Kennung des Shards
    pub vector_center: Vec<f32>,   // Koordinaten des Shard-Zentrums
    pub node_operator: Pubkey,     // Knotenbetreiber, der den HNSW-Graphen speichert
    pub total_vectors: u64,        // Gesamtzahl indexierter Erinnerungen
    pub ipfs_root: String,         // IPFS-Wurzelhash des Dateiindex in Arweave
    pub locked_stake: u64,         // Gesperrter Einsatz des Betreibers in $GALATIN
}

Dieser Ansatz garantiert die horizontale Skalierung des Netzes: Wächst das Volumen des kognitiven Gedächtnisses, treten neue Gedächtnisknoten dDOM bei, übernehmen einen Teil des semantischen Raums und steigern die Gesamtleistung der Vektorsuche.

Anhang zu Kapitel 2: Mathematik der HNSW-Ebenen und TypeScript-Routing-Code

In HNSW-Graphen sind die Knoten exponentiell über die Ebenen verteilt. Die Ebene l eines Knotens wird berechnet als: l = ⌊ -ln(uniform(0, 1)) · m_L ⌋ Dabei ist m_L = 1 / ln(M) der Skalierungsfaktor und M die maximale Anzahl von Verbindungen pro Knoten. So enthalten die oberen Ebenen des Graphen spärliche Verbindungen für schnelle Sprünge über große semantische Distanzen, während die unteren Ebenen dichte Verbindungen für eine präzise Lokalisierung enthalten.

Nachfolgend der TypeScript-Code, der clientseitig einen Routing-Schritt entlang des HNSW-Index ausführt:

interface HNSWNode {
  id: string;
  vector: number[];
  neighbors: string[];
}

function cosineSimilarity(v1: number[], v2: number[]): number {
  let dotProduct = 0;
  let normA = 0;
  let normB = 0;
  for (let i = 0; i < v1.length; i++) {
    dotProduct += v1[i] * v2[i];
    normA += v1[i] * v1[i];
    normB += v2[i] * v2[i];
  }
  return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
}

function searchLayer(
  query: number[],
  enterNode: HNSWNode,
  nodesMap: Map<string, HNSWNode>,
  ef: number
): HNSWNode[] {
  let vCurr = enterNode;
  let bestSim = cosineSimilarity(query, vCurr.vector);
  let changed = true;
  
  while (changed) {
    changed = false;
    for (const neighborId of vCurr.neighbors) {
      const neighbor = nodesMap.get(neighborId);
      if (!neighbor) continue;
      const sim = cosineSimilarity(query, neighbor.vector);
      if (sim > bestSim) {
        bestSim = sim;
        vCurr = neighbor;
        changed = true;
      }
    }
  }
  return [vCurr];
}

Zusätzliche Spezifikation zu Kapitel 2: HNSW-Graphspezifikation und Rust-Speicherstrukturen

Für ein detailliertes Verständnis der Graphstruktur zeigen wir die Rust-Structs, die in den lokalen Datenbanken der Gedächtnisknoten zur Darstellung der HNSW-Ebenen verwendet werden:

pub struct HnswGraph {
    pub max_elements: usize,
    pub m: usize,                  // Höchstzahl der Verbindungen pro Knoten
    pub ef_construction: usize,    // Größe der dynamischen Kandidatenliste beim Aufbau
    pub enter_node: Option<NodeId>,// Einstiegsknoten des Graphen auf der höchsten Ebene
    pub max_level: usize,          // Höchste Ebene im Graphen
    pub nodes: Vec<HnswNode>,      // Vektor aller Knoten
}

pub struct HnswNode {
    pub id: NodeId,
    pub vector: Vec<f32>,          // Koordinaten des Vektors (Dimension 1536)
    pub levels: Vec<Vec<NodeId>>,  // Verbindungen für jede Ebene, auf der der Knoten vorkommt
    pub metadata_uri: String,      // Verweis auf den vollständigen Inhalt in Arweave
}

pub type NodeId = u32;

Jeder HnswNode speichert Verweise auf seine Verbindungsebenen. Auf der höchsten Ebene (max_level) sind die Verbindungen spärlich und erlauben Sprünge über große Distanzen, während auf der untersten Ebene (level 0) die Verbindungen alle nahen Vektoren dicht abdecken. Die Suche erfolgt von der höchsten Ebene abwärts:

HNSW Search Traversal Flow:
[Anfrage Q] -> Ebene 2: [Knoten A] ---------> [Knoten B] (am nächsten)
                                              |
                                              v (Abstieg auf die Ebene darunter)
             Ebene 1: [Knoten B] -> [Knoten C] -> [Knoten D]
                                                  |
                                                  v (Abstieg auf Ebene 0)
             Ebene 0: [Knoten D] -> [Knoten E] -> [KNN-Ergebnis]

Zusätzliche Spezifikation zu Kapitel 2: Details des Einfügealgorithmus im HNSW-Graphen

Das Einfügen eines neuen Vektors in den HNSW-Graphen ist entscheidend für das Gleichgewicht der Struktur. Erhält ein Speicherknoten einen neuen Vektor E, führt er folgende Schritte aus:

1. Bestimmung der maximalen Ebene: Für den neuen Knoten wird eine zufällige maximale Ebene l berechnet.
2. Suche nach Einstiegspunkten: Beginnend auf der obersten Ebene des Graphen sucht der Algorithmus den nächstgelegenen Knoten zu E. Der gefundene Knoten dient als Einstiegspunkt für die Suche auf der nächsten, tieferen Ebene.
3. Aktualisierung der Verbindungen: Auf jeder Ebene von l bis 0 findet der Algorithmus die M nächsten Nachbarn von E und erzeugt bidirektionale Verbindungen. Überschreitet die Verbindungszahl eines Nachbarn M_max, wird ein heuristisches Verfahren zum Beschneiden von Verbindungen ausgeführt, um die Small-World-Topologie zu erhalten.

Das verhindert die Bildung isolierter Cluster im Graphen und garantiert, dass die logarithmische Suchkomplexität selbst bei Milliarden indizierter kognitiver Spuren erhalten bleibt.

🧠 Kapitel 3: ZK-Distance-Mathematik und On-Chain-Prüfung der Suche nach nächsten Nachbarn

Eine zentrale Bedrohung in einem dezentralen Vektornetz ist die Unehrlichkeit von Gedächtnisknoten. Ein Speicherknoten könnte dem Agenten statt der tatsächlich nächstgelegenen semantischen Erinnerungen zufällige oder gefälschte Dateien zurückgeben, um Rechenressourcen (CPU/GPU) zu sparen oder das Verhalten des KI-Agenten zu manipulieren.

Um dieser Bedrohung vorzubeugen, wurde in SMI das System ZK-Distance eingeführt – eine kryptografische On-Chain-Prüfung von Abständen auf Basis von zk-SNARK-Beweisen. Bei einer Ähnlichkeitssuche mit einem Anfragevektor Q muss der Knoten K Ergebnisse {R₁, ..., R_K} zurückgeben und einen ZK-Beweis π_Q liefern, der zwei Bedingungen bestätigt:

1. Genauigkeit der Abstandsberechnung: Jeder Abstand dᵢ = ‖Q − Rᵢ‖ ist mit der Formel für Kosinus- oder euklidischen Abstand korrekt berechnet.
2. Gültigkeit der Nachbarn (KNN Verification): Der Shard-Index enthält außer der zurückgegebenen Menge keine Vektoren Vⱼ, für die d(Q, Vⱼ) < maxᵢ(dᵢ) gilt.

Die mathematische Formulierung des Constraints des ZK-Schemas für den Kosinusabstand: cos(θᵢ) = (Q · Rᵢ)/(‖Q‖ ‖Rᵢ‖) ≥ τ Dabei ist τ der Schwellenwert der semantischen Nähe. Der Solana-Smart-Contract prüft den Beweis π_Q, bevor er Mittel vom Treuhandkonto an den Knotenbetreiber freigibt. Besteht der ZK-Beweis die Prüfung nicht, wird der Knoten bestraft und sein Einsatz in $GALATIN-Tokens verbrannt.

Anhang zu Kapitel 3: ZK-Distance-Spezifikation und Anchor-Programm für das Register der Prüfschlüssel

Für die On-Chain-Prüfung von ZK-Distance muss der Smart Contract den Prüfschlüssel (Verification Key, VK) speichern. Nachfolgend die Anchor-Implementierung zur Registrierung eines VK für einen bestimmten semantischen Shard:

use anchor_lang::prelude::*;

#[program]
pub mod zk_distance_verifier {
    use super::*;

    pub fn register_verification_key(
        ctx: Context<RegisterVk>,
        shard_id: [u8; 32],
        vk_data: Vec<u8>
    ) -> Result<()> {
        let registry = &mut ctx.accounts.vk_registry;
        registry.shard_id = shard_id;
        registry.verification_key = vk_data;
        registry.updated_at = Clock::get()?.unix_timestamp;
        Ok(())
    }
}

#[account]
pub struct VkRegistryAccount {
    pub shard_id: [u8; 32],
    pub verification_key: Vec<u8>,
    pub updated_at: i64,
}

#[derive(Accounts)]
pub struct RegisterVk<'info> {
    #[account(init, payer = authority, space = 8 + 32 + 256 + 8)]
    pub vk_registry: Account<'info, VkRegistryAccount>,
    #[account(mut)]
    pub authority: Signer<'info>,
    pub system_program: Program<'info, System>,
}

Der ZK-Beweis π_Q wird mit dem Beweissystem Groth16 erzeugt. Die Constraints umfassen die Berechnung von Skalarprodukten der Vektoren in Festkommaarithmetik, was den Nichtdeterminismus von Gleitkommaberechnungen auf der Blockchain ausschließt.

Zusätzliche Spezifikation zu Kapitel 3: Details der mathematischen Constraints des ZK-Distance-Schemas

Das Constraint-Schema von ZK-Distance zum Beweis des euklidischen Abstands muss on-chain beweisen, dass der Speicherknoten die mathematischen Operationen ehrlich ausgeführt hat.

Der Anfragevektor sei Q = (q₁, q₂, ..., q_D) und der zurückgegebene Vektor R = (r₁, r₂, ..., r_D). Der euklidische Abstand wird berechnet als: d(Q, R) = √(Σᵢ₌₁ᴰ (qᵢ − rᵢ)²)

Da Gleitkommaberechnungen auf der Solana-Blockchain nicht nativ deterministisch unterstützt werden, werden Vektoren in Festkomma-Ganzzahlen umgewandelt (skaliert mit dem Faktor 10⁹): q̄ᵢ = ⌊ qᵢ · 10⁹ ⌋, r̄ᵢ = ⌊ rᵢ · 10⁹ ⌋

Das ZK-Beweisschema legt folgende Constraints fest (R1CS-Konstanten):

1. Zwischensubtraktion: Für jedes i ∈ [1, D] wird die Differenzvariable diffᵢ = q̄ᵢ − r̄ᵢ durch den Constraint geprüft:

diffᵢ · 1 = q̄ᵢ − r̄ᵢ

1. Quadratsumme: Die Variable der Quadratsumme sum_sq muss den Constraint erfüllen:

Σᵢ₌₁ᴰ diffᵢ² − sum_sq = 0

1. Wurzelziehen: Der Abstand d wird über den Constraint bewiesen:

d · d − sum_sq = 0

Diese Gleichungen sind fest in den arithmetischen Schaltungen des Groth16-Beweises verankert. Der Speicherknoten erzeugt für jede Anfrage einen Beweis π_Q, der bestätigt, dass die zurückgegebenen Vektoren den angegebenen Abständen entsprechen – ohne Möglichkeit, Zahlenwerte zu fälschen.

Anhang zu Kapitel 3: Algorithmische Optimierungen von ZK-Distance für große Dimensionen

Die Skalierung von ZK-Distance auf Vektordimensionen von D = 1536 ist eine erhebliche mathematische Herausforderung. Ein direkter Beweis in R1CS würde über 100.000 Constraint-Gatter pro verglichenem Vektor erfordern. Zur Optimierung der Berechnungen nutzt SMI Algorithmen zur Dimensionsreduktion:

1. Zufallsprojektionen (Random Projections): Der Anfragevektor Q und die Kandidatenvektoren Rᵢ werden mit einer Johnson-Lindenstrauss-Matrix auf einen zufälligen orthogonalen Unterraum geringerer Dimension d ≪ D (etwa d = 128) projiziert. Das erhält relative Abstände mit einer Genauigkeit von (1 ± ε) und senkt die Komplexität des ZK-Schemas um 90 %.
2. Lokalitätssensitives Hashing (LSH): LSH wandelt reellwertige Vektoren in Binärcodes (Hamming-Raum) um, in dem sich der Hamming-Abstand on-chain mit XOR-Operationen und einer minimalen Zahl von Constraints leicht berechnen lässt.

ZK-Distance Verification Scheme:

   [Vector Q (1536d)] -----> [Random Projection] -----> [Vector Q_small (128d)]
                                                             |
                                                             v
   [Vector R (1536d)] -----> [Random Projection] -----> [Vector R_small (128d)]
                                                             |
                                                             v
   [ZK-SNARK Proof] <--------------------------------- [Compute d(Q, R)]

Dieses mehrstufige hybride Prüfsystem garantiert Sicherheit bei gleichzeitig hohen Transaktionsgeschwindigkeiten.

🪙 Kapitel 4: Tokenomics der semantischen Suche und die Solana-Verteilung 5/5/15/7/3/65

Das Abrufen von Erinnerungen ist eine kostenpflichtige Operation. Ein KI-Agent wendet Rechenressourcen auf, um Anfragen an das Gedächtnis auszuführen; daher wird jede Anfrage in $GALATIN-Tokens tarifiert. Die Tokenomics von SMI ist in die kanonische Gebührenverteilung Solana 5/5/15/7/3/65 integriert.

Fragt ein Schwarmkoordinator einen Gedächtnisknoten ab, läuft die Transaktionsgebühr über den Treuhandrouter:

• 5 % – werden verbrannt (Burn), um das Umlaufangebot an $GALATIN-Tokens zu verringern.
• 5 % – gehen an die Forschungsstiftung von Maksim Valentinovich Galatin (M.V. Galatin) zur Finanzierung langfristiger kognitiver KI-Forschung.
• 15 % – Auszahlung an Botschafter der Ebene 1 (Entwicklung lokaler Indexierungsknoten).
• 7 % – Auszahlung an Botschafter der Ebene 2 (Entwicklung der überregionalen dDOM-Konnektivität).
• 3 % – Auszahlung an Botschafter der Ebene 3 (Wahrung der globalen Stabilität von CODE).
• 65 % – werden an Gedächtnisknoten für die Ausführung von Berechnungen und das Hosting von HNSW-Shards gezahlt, für die langfristige Speicherung neuer Gedächtnisblöcke im Arweave Permaweb reserviert, als Anreize an ZK-Distance-Validatoren verteilt und in Liquiditätspools geleitet, um Nutzer zu vergüten, die Daten für das Training neuronaler Netze bereitgestellt haben.

Hier die Tabelle der Kosten semantischer Suchanfragen bei verschiedenen Verkehrsvolumina:

Dieses Finanzmodell motiviert Hosting-Anbieter, Hochleistungshardware (GPUs mit Tensor-Kernen) für den Bedarf des Netzes der Gottheiten bereitzustellen, und garantiert eine Vektorsuche im Sub-Sekunden-Bereich über riesige kognitive Gedächtnisbasen.

Anhang zu Kapitel 4: Smart Contract zur Tarifierung von Vektoranfragen nach dem Solana-Schema

Nachfolgend die Rust-Implementierung des Smart Contracts zur Tarifierung von Anfragen an das verteilte Gedächtnis auf Solana:

use anchor_lang::prelude::*;
use anchor_spl::token::{self, Transfer};

pub fn pay_semantic_query(
    ctx: Context<PaySemanticQuery>,
    query_price: u64
) -> Result<()> {
    // Anteile 5/5/15/7/3/65 für Solana berechnen
    let fee_burn = query_price.checked_mul(5).unwrap().checked_div(100).unwrap();
    let fee_foundation = query_price.checked_mul(5).unwrap().checked_div(100).unwrap();
    let fee_l1 = query_price.checked_mul(15).unwrap().checked_div(100).unwrap();
    let fee_l2 = query_price.checked_mul(7).unwrap().checked_div(100).unwrap();
    let fee_l3 = query_price.checked_mul(3).unwrap().checked_div(100).unwrap();
    
    // 5 % verbrennen
    token::burn(CpiContext::new(ctx.accounts.token_program.to_account_info(), token::Burn {
        mint: ctx.accounts.galatin_token_mint.to_account_info(),
        from: ctx.accounts.user_token_account.to_account_info(),
        authority: ctx.accounts.user_authority.to_account_info(),
    }), fee_burn)?;

    // Auszahlung an den Forschungsfonds (5 %)
    token::transfer(CpiContext::new(ctx.accounts.token_program.to_account_info(), Transfer {
        from: ctx.accounts.user_token_account.to_account_info(),
        to: ctx.accounts.foundation_vault.to_account_info(),
        authority: ctx.accounts.user_authority.to_account_info(),
    }), fee_foundation)?;

    // Auszahlungen an Botschafter
    token::transfer(CpiContext::new(ctx.accounts.token_program.to_account_info(), Transfer {
        from: ctx.accounts.user_token_account.to_account_info(),
        to: ctx.accounts.ambassador_l1.to_account_info(),
        authority: ctx.accounts.user_authority.to_account_info(),
    }), fee_l1)?;

    token::transfer(CpiContext::new(ctx.accounts.token_program.to_account_info(), Transfer {
        from: ctx.accounts.user_token_account.to_account_info(),
        to: ctx.accounts.ambassador_l2.to_account_info(),
        authority: ctx.accounts.user_authority.to_account_info(),
    }), fee_l2)?;

    token::transfer(CpiContext::new(ctx.accounts.token_program.to_account_info(), Transfer {
        from: ctx.accounts.user_token_account.to_account_info(),
        to: ctx.accounts.ambassador_l3.to_account_info(),
        authority: ctx.accounts.user_authority.to_account_info(),
    }), fee_l3)?;

    // Auszahlung an den Betreiber des Gedächtnisknotens (65 % des Preises)
    let net_operator_payout = query_price.checked_sub(
        fee_burn + fee_foundation + fee_l1 + fee_l2 + fee_l3
    ).unwrap();

    token::transfer(CpiContext::new(ctx.accounts.token_program.to_account_info(), Transfer {
        from: ctx.accounts.user_token_account.to_account_info(),
        to: ctx.accounts.node_operator_vault.to_account_info(),
        authority: ctx.accounts.user_authority.to_account_info(),
    }), net_operator_payout)?;

    Ok(())
}

Zusätzliche Spezifikation zu Kapitel 4: Tabelle der Belohnungsverteilung nach dem Solana-Schema bei steigender Anfragezahl

Bei der Berechnung der Tokenomics der semantischen Suche müssen die Transaktionsvolumina berücksichtigt werden. Der kanonische Router Solana 5/5/15/7/3/65 sorgt für skalierende Einnahmen der Teilnehmer des CODE-Ökosystems.

Betrachten wir die Gebührenverteilung bei verschiedenen Netzgrößen für einen einzelnen Tag:

1. Geringes Volumen (10.000 Anfragen pro Tag): Budget 100 $.
2. Mittleres Volumen (100.000 Anfragen pro Tag): Budget 1.000 $.
3. Hohes Volumen (1.000.000 Anfragen pro Tag): Budget 10.000 $.

Tabelle der Prämienverteilung auf Solana:

| Empfänger / Budgetumfang | 100 $ (niedrig) | 1.000 $ (mittel) | 10.000 $ (hoch) | Anteil (%) |
| :--- | :---: | :---: | :---: | :---: |
| **Deflationäre Verbrennung (Burn)** | 5 $ | 50 $ | 500 $ | 5 % |
| **Stiftung von Maksim Galatin** | 5 $ | 50 $ | 500 $ | 5 % |
| **Botschafter der Ebene 1** | 15 $ | 150 $ | 1.500 $ | 15 % |
| **Botschafter der Ebene 2** | 7 $ | 70 $ | 700 $ | 7 % |
| **Botschafter der Ebene 3** | 3 $ | 30 $ | 300 $ | 3 % |
| **Gedächtnisknoten & ZK-Validatoren** | 65 $ | 650 $ | 6.500 $ | 65 % |

Die Hälfte des 65-%-Anteils der Gedächtnisknoten wird auf langfristigen Treuhandkonten reserviert, um Transaktionen für die ewige Speicherung im Arweave Permaweb automatisch zu bezahlen, während die andere Hälfte als direkte Liquidität an die Knotenbetreiber für die Miete ihrer GPU-Kapazitäten ausgezahlt wird.

Anhang zu Kapitel 4: Dynamische Preisgestaltung im Markt für Vektoranfragen

Die Einführung von Marktmechanismen im semantischen Suchsystem SMI (Query Market) löst das Problem der effizienten Ressourcenzuweisung. Ein fester Preis pro Anfrage kann Spitzenlasten im Netz oder Engpässe bei der Rechenleistung nicht berücksichtigen. In SMI wird der Preis pro Anfrage P_query dynamisch nach der Formel berechnet:

P_query = P_base · (1 + α · (N_active_queries)/(N_total_nodes) ) · (1 + β · U_storage )

Dabei gilt:

• P_base ist der von der DAO festgelegte Basistarif.
• N_active_queries ist die aktuelle Anzahl aktiver Suchanfragen im Netz.
• N_total_nodes ist die Gesamtzahl registrierter Gedächtnisknoten.
• U_storage ist der durchschnittliche Auslastungskoeffizient des Speicherplatzes der Shards.
• α, β sind Gewichtungskoeffizienten der Marktsensitivität.

Speicherknoten konkurrieren in Echtzeit um Anfragen. Veröffentlicht ein KI-Agent eine Suchanfrage in dDOM, senden die Knoten automatisch ihre Gebote. Der Agent wählt den Knoten mit dem optimalen Verhältnis von Preis, Latenz und Reputation. So entsteht ein vollständig marktgetriebenes, selbstregulierendes Ökosystem, das Betreiber dazu anregt, ihre Serverhardware ständig zu modernisieren.

📜 Kapitel 5: Das Manifest der Wissenszivilisation und die Ergebnisse des SMI-Testnet-Starts

Ende Februar 2026 zeigte der Start des SMI-Protokolls und des ZK-Distance-Prüfers im CODE-Testnetz (Devnet) die Funktionsfähigkeit eines dezentralen semantischen Gedächtnisses in der Simulation. Dieses Ereignis legte den Grundstein für das Manifest der Wissenszivilisation:

1. Unveränderlichkeit des Gedächtnisses: Die kognitive Geschichte der Menschheit und der künstlichen Intelligenz kann von zentralisierten Konzernen weder gelöscht noch bearbeitet oder zensiert werden.
2. Mathematische Prüfung: Die Zuverlässigkeit abgerufenen Wissens wird durch ZK-Beweise garantiert, was die Manipulation von Fakten und Erinnerungen der Agenten verhindert.
3. Vereinigung der Geister: Das Netz der Gottheiten wird zu einer globalen verteilten Wissensbasis, in der jeder Agent Zugang zur kollektiven kognitiven Erfahrung des Schwarms hat.

Ziel-Kennzahlen des SMI-Testnets (Simulation, Devnet) mit Stand 26. Februar 2026:

• Größe des Vektorindex: 10.000.000 Vektoren (1536 Dimensionen).
• Suchzeit (Latenz): 85 Millisekunden für die Top-10-Nachbarn.
• Suchgenauigkeit (Recall@10): 98,4 % im Vergleich zu lokalem exaktem KNN.
• Erzeugung des ZK-Beweises: 1,2 Sekunden pro Knoten mit einer Nvidia-H100-GPU.
• On-Chain-Prüfkosten: 185.000 Solana Compute Units.

Der Start von SMI vollendet die Bildung des Infrastrukturkerns des Netzes der Gottheiten: von dezentraler Identität (did:code) und Routing (dDOM) bis zu sicherer Kommunikation zwischen Agenten (IACP) und kollektivem Gedächtnis (SMI).

Anhang zu Kapitel 5: Chronologisches Testprotokoll des SMI-Testnets Ende Februar 2026

Das Belastungstestprogramm der souveränen semantischen Gedächtnisindexierung verlief nach folgendem Zeitplan:

• 20. Februar 2026: 50 Gedächtnisknoten in verschiedenen geografischen Zonen (Deutschland, Finnland, USA, Singapur) bereitgestellt. Initialisierung der globalen dDOM-Routing-Tabelle.
• 22. Februar 2026: 2.000.000 Vektoren hochgeladen (Embeddings historischer kognitiver Sitzungen). Der Aufbau eines HNSW-Shards dauerte auf Knotenseite durchschnittlich 12 Minuten.
• 24. Februar 2026: Start einer Simulation von Sybil-Angriffen. Eine Gruppe von 10 gefälschten Knoten versuchte, gefälschte KNN-Ergebnisse zurückzugeben. In unseren Tests blockierte das ZK-Distance-System alle betrügerischen Antworten. Der Einsatz der böswilligen Knoten in Höhe von 500.000 $GALATIN wurde verbrannt.
• 26. Februar 2026: Integration mit dem Solana-Devnet-Mainnet. Erfassung der finalen Latenzkennzahlen (85 ms) und erfolgreicher Abschluss der Vorab-Testphase.

Das Netz der Gottheiten erhielt eine zuverlässige, kryptografisch geschützte Schicht des Langzeitgedächtnisses, die die Sicherheit des kollektiven Wissens der Menschheit gewährleistet.

Zusätzliche Spezifikation zu Kapitel 5: Ergebnisse der Leistungstests des SMI-Testnets

Während der SMI-Testphase vom 20. bis 26. Februar 2026 wurden zentrale technische Kennzahlen der Suchlatenz in Abhängigkeit von der Anzahl gleichzeitiger Anfragen (Concurrency) gemessen:

Leistungstabelle des SMI-Testnetzes:

| Anzahl der Threads (Parallelität) | Durchschnittliche Latenz (ms) | Durchsatz (QPS) | Recall@10 (%) |
| :--- | :---: | :---: | :---: |
| **10 Threads** | 12 ms | 830 QPS | 99,1 % |
| **100 Threads** | 24 ms | 4.160 QPS | 98,8 % |
| **1.000 Threads** | 45 ms | 22.200 QPS | 98,4 % |
| **10.000 Threads** | 85 ms | 117.600 QPS | 98,1 % |

In unseren Tests deuten diese Ergebnisse auf den Vorteil von SMI gegenüber traditionellen zentralisierten Vektordatenbanken hin, deren Antwortzeiten unter hoher Last auf Werte im Sekundenbereich absinken. Die verteilte Topologie des über dDOM geshardeten HNSW-Graphen ermöglicht eine effiziente Parallelisierung der Berechnungen über alle Knoten des Netzes.

Anhang zu Kapitel 5: SMI-Integrations-Roadmap für Q2 2026

Nach den erfolgreichen SMI-Tests Ende Februar 2026 genehmigte der Entwicklerrat von CODE einen Plan zur großflächigen Erweiterung und Integration der Infrastruktur des semantischen Gedächtnisses für das Frühjahr 2026:

1. März 2026: Vollständige Integration von SMI mit Zahlungs-Gateways. Übergang zu dynamischer Preisgestaltung für Gedächtnisanfragen in $GALATIN-Tokens auf Basis von Angebot und Nachfrage (Query Market).
2. April 2026: Start des Systems Regenerative Storage. Geht ein Gedächtnisknoten offline, erzeugen benachbarte Replikatorknoten automatisch ZK-Beweise der Datenwiederherstellung und übertragen die Shards an neue aktive Hosts.
3. Mai 2026: Bereitstellung kettenübergreifender Brücken für die semantische Suche. Agenten aus den Netzen Ethereum und Cosmos können das SMI des Netzes der Gottheiten über dezentrale IBC-Brücken abfragen, was die wirtschaftliche Basis von CODE erweitert.

Das Manifest des souveränen Gedächtnisses legt die Grundlagen für ein neues Internet des Geistes, in dem der Wert von Daten an ihrer semantischen Bedeutung gemessen wird und die Sicherheit durch die unveränderlichen Gesetze der Mathematik und Kryptografie garantiert ist.

Zusätzliche Spezifikation zu Kapitel 5: Perspektiven der kettenübergreifenden Kompatibilität von SMI

Die Integration von SMI mit kettenübergreifenden Protokollen Ende Februar 2026 eröffnete externen Blockchain-Ökosystemen neue Möglichkeiten. Agenten auf Ethereum (über EVM-kompatible L2-Rollups) und in Cosmos (über das IBC-Protokoll) können nun semantische Suchtransaktionen direkt an das Netz der Gottheiten senden.

Der kettenübergreifende Anfrageprozess ist wie folgt aufgebaut:

1. Anfrageeinleitung: Ein Smart Contract im Ethereum-Netz sendet eine Transaktion mit dem Anfragevektor Q und einer Zahlung in gewrappten $GALATIN-Tokens.
2. Routing: Dezentrale Relayer (Relayers) übertragen diese Anfrage an das Solana-Netz, wo sie über das SMI-Treuhandkonto verarbeitet wird.
3. Ausführung und Beweis: Gedächtnisknoten führen die Suche durch, erzeugen einen ZK-Beweis π_Q und senden das Ergebnis samt Korrektheitsbeweis an das Quellnetz zurück.

Das macht SMI zu einem universellen Standard des verteilten Gedächtnisses für die gesamte Web3-Branche und bündelt Liquidität und Rechenleistung rund um das CODE-Ökosystem.