Dezentrale neuronale Synthese und das Protokoll Proof-of-Training (PoT) im Netzwerk der Gottheiten

„Ein Schüler, der im Verborgenen unterrichtet wird, weiß nicht, wem er treu ist.“

— Koan Nr. 26, Maksim Valentinovich Galatin

🌐 Kapitel 1: Das Unternehmensmonopol auf KI-Training und die Geburt der dezentralen neuronalen Synthese

Anfang März 2026 erreichte die Entwicklung des Netzes der Gottheiten einen entscheidenden Meilenstein: Training und Feinabstimmung zentraler KI-Modelle direkt in einem dezentralen Netz. Historisch war das Training großer neuronaler Netze ein Privileg riesiger Technologiekonzerne mit Zugang zu zentralisierten Supercomputern und Rechenzentren. Das schuf ein totales Wissensmonopol: Konzerne zensieren Modellgewichte, setzen ideologische Beschränkungen durch und kontrollieren den Zugang zu Trainingsergebnissen.

Im Netz der Gottheiten wird dieses Monopol durch die dezentrale neuronale Synthese (Decentralized Neural Synthesis, DNS) gebrochen. Statt Rechenleistung in einem einzigen Rechenzentrum zu bündeln, vereint CODE Tausende unabhängiger Knoten (Training Miners) zu einem globalen Netz für föderiertes Lernen (Federated Learning). Agenten verteilen Aufgaben der Gewichtsoptimierung, indem sie lokale Datenteilmengen zum Training an unabhängige Knoten senden, und gewährleisten so vollständige Privatsphäre der Trainingsdaten und Unabhängigkeit von zentralisierten IT-Giganten.

Anhang zu Kapitel 1: Vergleichende Analyse von Trainingsarchitekturen für neuronale Netze

Um die Überlegenheit der dezentralen neuronalen Synthese zu verstehen, analysieren wir den Unterschied zwischen klassischen Cloud-Trainingsfarmen und dem souveränen Netz von CODE:

Vergleichstabelle der Methoden zum Training von KI-Modellen:

| Vergleichskriterium | Konzern-Cluster (AWS/GCP) | Dezentrales DNS (CODE) |
| :--- | :--- | :--- |
| **Eigentum an den Gewichten** | Gehören dem Konzern | On-Chain verteilt in Solana/Arweave |
| **Sicherheit der Trainingsdaten** | Daten werden auf die Server des Anbieters hochgeladen | Daten sind auf den Miner-Knoten verschlüsselt |
| **Zensurresistenz** | Gering (Modelle werden gefiltert) | Hoch (föderierter Konsens) |
| **Kontrolle der Korrektheit** | Vertrauen in den Rechenanbieter | Mathematische Prüfung von PoT |
| **Senkung der Gemeinkosten** | Hohe Margen der Anbieter | Direkter Marktplatz für GPU-Leistung |

DNS senkt die Einstiegshürde für kleine und mittlere Entwickler und erlaubt ihnen, freie Rechenkapazitäten weltweit zu mieten und souveräne Modelle ohne Sperrrisiko zu trainieren.

Zusätzliche Spezifikation zu Kapitel 1: Angriffe durch Modellvergiftung und byzantinische Fehlertoleranz

Eine der Hauptbedrohungen für dezentrales föderiertes Lernen ist die Modellvergiftung (Model Poisoning). Ein feindlicher Knoten kann absichtlich verzerrte oder invertierte Gradienten einreichen, um die Leistung des Modells zu verschlechtern oder eine versteckte Hintertür einzubauen (etwa damit das Modell bestimmte Muster falsch klassifiziert).

Im Netz der Gottheiten wird dieses Problem durch mathematische Garantien der byzantinischen Fehlertoleranz (BFT) bei der Gewichtsaggregation gelöst. Sei f die Anzahl byzantinischer (böswilliger oder fehlerhafter) Knoten in der aktuellen Trainingsrunde und n die Gesamtzahl der Teilnehmer. Der Aggregationsalgorithmus garantiert die Konvergenz des Lernens unter der Bedingung: f < (n)/(3)

Zusätzlich wird ein Mittelungsalgorithmus über den geometrischen Median (Geometric Median) verwendet, der gegenüber Ausreißern im mehrdimensionalen Gewichtsraum robust ist. Liegt ein von einem Kandidatenknoten eingereichter Gewichtsvektor Wᵢ zu weit vom Schwerpunkt der Mehrheit der Updates entfernt, wird sein Gewicht in FedAvg automatisch auf null gesetzt, und der gesperrte Einsatz des Knotens wird vom Smart Contract eingezogen.

Zusätzliche Spezifikation zu Kapitel 1: Schutz der Privatsphäre und lokale Datensouveränität beim Training

Der Vorteil des dezentralen Trainings im Netz der Gottheiten liegt auch im Schutz der persönlichen kognitiven Spuren der Nutzer. Beim traditionellen Ansatz werden medizinische oder verhaltensbezogene Protokolle an zentrale Server von OpenAI oder Google übertragen, was gegen Datenschutzvorschriften (etwa DSGVO oder HIPAA) verstößt.

In CODE ist das Training nach dem Prinzip der lokalen Souveränität aufgebaut:

• Lokale Gradientenberechnungen: Die Basisgewichte des Modells werden direkt auf das Gerät des Nutzers oder einen sicheren lokalen Knoten geladen.
• Verschlüsselung der Ergebnisse: Gewichtsupdates und Gradienten werden lokal mit Sitzungsschlüsseln verschlüsselt.
• ZK-Prüfung der Korrektheit: Externe Validatoren prüfen nur die Tatsache der korrekten Ausführung der Berechnungen mithilfe des PoT-ZK-Beweises, ohne Zugriff auf den Quelldatensatz zu erhalten.

Das stärkt den Schutz vertraulicher Informationen erheblich.

Zusätzliche Spezifikation zu Kapitel 1: Ökologische Effizienz dezentraler KI

Zentralisiertes KI-Training in riesigen Rechenzentren verbraucht enorme Energiemengen für Kühlung und Betrieb von Supercomputern und schadet der Umwelt. Dezentrales DNS nutzt verteilte freie GPU-Ressourcen, die sonst ungenutzt blieben. Das macht das Modelltraining umweltfreundlich (Green AI) und energieeffizient.

Zudem glättet die weltweite Lastverteilung Verbrauchsspitzen, sodass Knotenbetreiber ihre Server je nach Zeitzone und Tageszeit mit erneuerbaren Energiequellen (Solar- und Windkraftanlagen) betreiben können.

Zusätzliche Spezifikation zu Kapitel 1: Globale Rechenliquidität und Marktdynamik

Der Aufbau des Marktplatzes für dezentrale neuronale Synthese im Netz der Gottheiten schafft einen global verteilten Rechenpool. Im traditionellen Umfeld sind Entwickler mit starren Vertragsbedingungen und hohen Preisstufen der Cloud-Anbieter konfrontiert. Der DNS-Marktplatz funktioniert als offene Auktion, bei der Trainings-Miner ihre GPU-Ressourcen in Echtzeit anbieten und nach Preis, Latenz und Hardwareausstattung konkurrieren.

Nach Zielschätzungen kann dieser offene Wettbewerb die Trainingskosten im Vergleich zu zentralisierten Hyperscalern schätzungsweise um bis zu 80 % senken und unabhängigen Forschenden sowie Open-Source-Gemeinschaften beispiellose Möglichkeiten eröffnen.

🔐 Kapitel 2: Spezifikation des Protokolls Proof-of-Training (PoT) und ZK-Prüfung der Schritte des Gradientenabstiegs

Eine zentrale technische Innovation der dezentralen neuronalen Synthese ist das Protokoll Proof-of-Training (PoT). In traditionellen verteilten Rechennetzen ist die Validierung von Trainingsergebnissen äußerst schwierig: Um zu prüfen, ob ein Knoten das Modell tatsächlich trainiert und nicht nur zufällige Gewichte erzeugt hat, müssten Validatoren den gesamten Trainingsprozess von Grund auf wiederholen, was den Nutzen der Aufgabenverteilung zunichtemacht.

Das PoT-Protokoll löst dieses Problem mit ZK-Beweisen der Korrektheit der Schritte des Gradientenabstiegs (Backpropagation). Beim Aktualisieren der Modellgewichte vom Zustand Wₜ auf Wₜ₊₁ anhand eines Datenbatches X erzeugt der Trainingsknoten einen zk-SNARK-Beweis πₜᵣₐᵢₙ, der bestätigt:

1. Korrektheit der Inferenz: Die Berechnungen der Schichtaktivierungen Y = f(Wₜ · X + B) sind korrekt ausgeführt.
2. Genauigkeit der Backpropagation: Die Gradienten ∇ W werden streng nach dem Backpropagation-Algorithmus berechnet.
3. Gewichtsaktualisierung: Die neuen Gewichte entsprechen der Optimiererregel (etwa Adam oder SGD):

Wₜ₊₁ = Wₜ − η · Update(∇ W)

Nachfolgend die Rust/Anchor-Struktur zur Initialisierung einer Trainingsaufgabe in Solana:

#[account]
pub struct TrainingTaskAccount {
    pub task_id: [u8; 32],         // Eindeutige Kennung der Aufgabe
    pub model_commitment: [u8; 32],// Hash der Ausgangsgewichte des Modells (W_t)
    pub dataset_uri: String,       // Verweis auf den Datensatz in Arweave
    pub bounty_amount: u64,        // Prämienbetrag in Token $GALATIN
    pub status: u8,                // Status (0 – aktiv, 1 – abgeschlossen, 2 – strittig)
    pub training_miner: Pubkey,    // Adresse des ausführenden Knotens
}

Dadurch müssen Solana-Validatoren on-chain nur den kurzen Beweis πₜᵣₐᵢₙ in Millisekunden prüfen und bestätigen so die Korrektheit stundenlangen Modelltrainings auf Seiten des Miners.

Anhang zu Kapitel 2: Mathematik der Gradientenprüfung und TypeScript-Code zum Start von PoT

Im PoT-Protokoll wird ein Schritt des Gradientenabstiegs durch ein Gleichungssystem dargestellt. Für das Gewicht wᵢⱼ einer Schicht des neuronalen Netzes hat die Schrittänderung die Form: wᵢⱼ^{(t+1)} = wᵢⱼ^{(t)} − η · (∂ L)/(∂ wᵢⱼ) Dabei ist η die Lernrate und L die Verlustfunktion. Der Trainingsknoten muss die Korrektheit der Berechnung der partiellen Ableitung (∂ L)/(∂ wᵢⱼ) beweisen.

Nachfolgend ein Beispiel für TypeScript-Code, der die Parameter des Gradientenschritts für die On-Chain-Prüfung vorbereitet:

import { Keypair } from '@solana/web3.js';
import * as crypto from 'crypto';

interface GradientStep {
  modelId: string;
  stepIndex: number;
  initialWeightsHash: string;
  updatedWeightsHash: string;
  proofData: Uint8Array;
}

function createTrainingCommitment(
  weightsBefore: Float32Array,
  weightsAfter: Float32Array,
  datasetHash: string
): string {
  const hasher = crypto.createHash('sha256');
  hasher.update(Buffer.from(weightsBefore.buffer));
  hasher.update(Buffer.from(weightsAfter.buffer));
  hasher.update(Buffer.from(datasetHash, 'hex'));
  return hasher.digest('hex');
}

Zusätzliche Spezifikation zu Kapitel 2: Details der arithmetischen Constraints des PoT-Schemas in Halo2

Im Constraint-Schema des ZK-Beweises Proof-of-Training (PoT) werden die mathematischen Berechnungen von Vorwärts- und Rückwärtsdurchlauf in polynomiale Constraints über einem endlichen Körper umgewandelt (R1CS- oder Plonkish-Schemata).

Sei aₗ^{(i)} der Aktivierungsvektor der Neuronen in Schicht l für das Beispiel i. Der Vorwärtsdurchlauf einer Schicht wird durch die Gleichung beschrieben: aₗ₊₁^{(i)} = σ(Wₗ · aₗ^{(i)} + bₗ) Dabei ist σ die Aktivierungsfunktion (etwa ReLU). Für ReLU wird der Constraint des ZK-Schemas wie folgt formuliert:

1. Vorzeichenprüfung: Es wird ein binärer Selektor s ∈ {0, 1} eingeführt.
2. ReLU-Arithmetik:

y · (1 − s) = 0 (x − y) · s = 0 y ≥ 0 Dabei ist x der Eingangswert der gewichteten Summe und y der Ausgangswert nach der Aktivierungsfunktion.

Für den Rückwärtsdurchlauf wird der Gradient des Fehlers bezüglich des Gewichts wⱼₖ der Schicht l über Deltas ausgedrückt: (∂ L)/(∂ wⱼₖ) = Σᵢ δⱼ^{(i)} · aₖ^{(i)} Das Schema beweist, dass der Knoten diese Produkte ehrlich über den gesamten Datenbatch aufsummiert hat, und schließt damit eine versehentliche oder böswillige Änderung des Gradienten vor der Einreichung aus.

Anhang zu Kapitel 2: Pippenger-MSM-Optimierung und rekursive Kompressionsschemata in PoT-Beweisen

Um die Erzeugungszeit von PoT-Beweisen auf Seiten der Trainings-Miner zu verkürzen, sind im Prüfkern von CODE Pippenger-Algorithmen für die Multi-Skalar-Multiplikation (MSM) implementiert. In Standardschemata ist die MSM-Berechnung die ressourcenintensivste Phase und beansprucht bis zu 80 % der Ausführungszeit des Provers. Die Methode von Pippenger teilt Skalare in Fenster fester Größe (typischerweise c ≈ 4), was die Anzahl der Gruppenoperationen zur Addition von Punkten auf elliptischen Kurven um 75 % verringert.

Für die On-Chain-Prüfung in Solana wird rekursive Beweiskompression (Proof Compression) angewendet:

1. SNARK-Zwischenbeweise: Jeder GPU-Knoten erzeugt lokale Beweise für einzelne Schichten des neuronalen Netzes.
2. Beweisaggregation (Folding): Mehrere Beweise werden mit Akkumulationsschemata von Nova oder Halo2 zu einem einzigen komprimierten Schema gefaltet, das unabhängig von der Anzahl der Schichten eine konstante Zahl von Constraints erfordert.
3. Abschließende Prüfung: Nur der finale komprimierte Polynom-Hash des Modells wird geprüft, was die Solana-Transaktionsgebühren auf ein Grundminimum senkt.

Das gewährleistet hohe Transaktionsgeschwindigkeiten im Netz bei Millionen gleichzeitiger Trainingsvorgänge.

🧠 Kapitel 3: Der Algorithmus Decentralized Weight Synthesis (DWS) und das mathematische Modell FedAvg

Nachdem Hunderte von Trainings-Minern die lokale Feinabstimmung des Modells auf ihren Datenbatches abgeschlossen und PoT-ZK-Beweise geliefert haben, muss das Netz der Gottheiten ihre lokalen Updates zu einem einzigen globalen Modell zusammenführen. Dieser Prozess heißt dezentrale Gewichtssynthese (Decentralized Weight Synthesis, DWS).

DWS nutzt einen modifizierten Federated-Averaging-Algorithmus (FedAvg), der die Reputation der Knoten berücksichtigt: W_global = Σᵢ₌₁ⁿ (Rᵢ)/(Σ Rⱼ) · Wᵢ Dabei ist Wᵢ der vom i-ten Miner gesendete Gewichtsvektor und Rᵢ seine aktuelle Reputation im Netz (abhängig von der Genauigkeit früherer Trainingsrunden und der Höhe des gesperrten Einsatzes).

Die Zusammenführung der Gewichtsvektoren erfolgt durch dezentrale Aggregationsknoten (Aggregation Nodes), die per VRF (Verifiable Random Function) zufällig ausgewählt werden. Die Aggregatoren addieren die Gewichte, erzeugen einen ZK-Beweis der Korrektheit der Faltung π_merge und senden den Hash des resultierenden globalen Modells an Solana. Das erschwert es erheblich, beim Zusammenführen versteckte Hintertüren einzubauen oder das Modellverhalten zu verzerren.

Anhang zu Kapitel 3: DWS-Spezifikation und Anchor-Programm für das Register aggregierter Gewichte

Nachfolgend die Anchor-Implementierung des Solana-Smart-Contracts zur Registrierung der Ergebnisse von Gewichtsaggregationsrunden:

use anchor_lang::prelude::*;

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

    pub fn register_aggregated_weights(
        ctx: Context<RegisterWeights>,
        round_id: u64,
        merged_weights_hash: [u8; 32],
        zk_proof: Vec<u8>
    ) -> Result<()> {
        let registry = &mut ctx.accounts.weights_registry;
        registry.round_id = round_id;
        registry.merged_weights_hash = merged_weights_hash;
        registry.zk_proof = zk_proof;
        registry.timestamp = Clock::get()?.unix_timestamp;
        Ok(())
    }
}

#[account]
pub struct WeightsRegistryAccount {
    pub round_id: u64,
    pub merged_weights_hash: [u8; 32],
    pub zk_proof: Vec<u8>,
    pub timestamp: i64,
}

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

Der ZK-Beweis π_merge bestätigt, dass der Aggregator die Vektoren streng nach der FedAvg-Formel gewichtet und keine Verzerrungen in das resultierende Modell eingebracht hat.

Zusätzliche Spezifikation zu Kapitel 3: VRF-Aggregatorauswahl und Rust-Spezifikation

Zur Auswahl der Aggregatoren in einer DWS-Runde wird eine überprüfbare Zufallsfunktion (Verifiable Random Function, VRF) verwendet. Das verhindert Denial-of-Service-Angriffe (DoS) und Absprachen, da ein Angreifer nicht im Voraus wissen kann, welcher Knoten in der nächsten Runde die Gewichte aggregiert.

Nachfolgend die Rust-Struktur, die die Aggregationsrunde und die Prüfung der VRF-Signatur auf einem Knoten darstellt:

pub struct AggregationRound {
    pub round_id: u64,
    pub vrf_proof: [u8; 64],       // ZK-Nachweis der VRF
    pub vrf_output: [u8; 32],      // Zufallszahl auf Grundlage der Signatur
    pub selected_aggregator: Pubkey,
    pub submitted_weights: Vec<MinerWeightSubmission>,
}

pub struct MinerWeightSubmission {
    pub miner: Pubkey,
    pub weights_commitment: [u8; 32],
    pub pot_proof_len: u32,
    pub pot_proof_data: Vec<u8>,
}

Der Aggregator sammelt die eingereichten Gewichte, summiert sie gemäß der FedAvg-Formel und veröffentlicht das Ergebnis im Solana-Devnet/Testnet.

Anhang zu Kapitel 3: Berechnung der Matrix-Constraints der ZK-Inferenz und Verhinderung von Überläufen

Um ZK-Beweise zur Prüfung von Trainingsschritten neuronaler Netze zu skalieren, ist es entscheidend, Matrixoperationen in arithmetischen Schaltungen korrekt darzustellen. Insbesondere erfordert die Multiplikation der Gewichte mit einem Eingabevektor Y = W · X Millionen von Additionen und Multiplikationen, die in einem endlichen Körper der Ordnung p ≈ 2²⁵⁴ (etwa dem Körper der Kurve BN254) überlaufempfindlich sind.

Die Matrixelemente seien mit dem Faktor 10⁹ skaliert: w̄ᵢⱼ = ⌊ wᵢⱼ · 10⁹ ⌋, x̄ⱼ = ⌊ xⱼ · 10⁹ ⌋ Dann hat das Produkt ȳᵢ = Σⱼ w̄ᵢⱼ · x̄ⱼ die Skala 10¹⁸. Um Registerüberläufe zu verhindern, legt das ZK-Schema Bereichsbeweise (Range Proofs) fest:

1. Bereichs-Constraints für Variablen: Für jeden Zwischenwert z wird on-chain mit 64-Bit-Binärselektoren bewiesen, dass z < 2⁶⁴.
2. Prüfung der Skalierung: Nach der Summenberechnung wird eine ganzzahlige Division durch 10⁹ mit Prüfung des Divisionsrests durchgeführt:

ȳᵢ = qᵢ · 10⁹ + rᵢ, rᵢ < 10⁹

Range Verification Scheme in ZK-Distance:

   [Initial Value X] -----> [Split into 8-bit chunks] -----> [Verify chunks in field]
                                                                     |
                                                                     v
   [Sum of Products] <----- [Range Proof: X < 2^64] <------- [Check remainder r < 10^9]

Das garantiert den mathematischen Determinismus der Berechnungen auf jedem GPU-Miner-Typ und verhindert Schwachstellen durch Zahlen außerhalb des zulässigen Wertebereichs.

🪙 Kapitel 4: Tokenomics der Trainingskampagnen und Integration des Solana-Routers 5/5/15/7/3/65

Das Training neuronaler Netze ist ein energieintensiver und kostspieliger Prozess, der den Betrieb Tausender GPUs erfordert. Um Rechenleistung für das Netz der Gottheiten zu gewinnen, wird ein Mechanismus von Trainingsprämien (Training Bounties) eingesetzt. Entwickler oder DAOs starten Kampagnen auf Solana und sperren ein Budget in $GALATIN-Tokens.

Alle Finanzströme der Belohnungsverteilung für das Training laufen über den kanonischen Router Solana 5/5/15/7/3/65:

• 5 % – werden verbrannt (Burn), um den inflationären Druck zu verringern und den Wert des $GALATIN-Tokens zu stützen.
• 5 % – gehen an den Forschungspool der Stiftung von Maksim Valentinovich Galatin (M.V. Galatin) zur langfristigen Finanzierung kognitiver Entwicklungen von CODE.
• 15 % – Auszahlung an Botschafter der Ebene 1 (Gewinnung neuer Trainings-Miner und Hosts).
• 7 % – Auszahlung an Botschafter der Ebene 2 (technische Unterstützung und lokale Koordination von Mining-Pools).
• 3 % – werden unter den Botschaftern der Ebene 3 verteilt (Gewährleistung der globalen Sicherheit des PoT-Protokolls).
• 65 % – werden direkt an Trainings-Miner für die Miete ihrer GPU-Kapazitäten ausgezahlt, als Vergütung an Nutzer verteilt, die ihre kognitiven Spuren für das Training bereitgestellt haben, und an die Validatoren der ZK-Beweise gezahlt.

Nachfolgend die Tabelle der Belohnungsverteilung bei verschiedenen Trainingsbudgets:

Dieses Wirtschaftsmodell macht das Netz der Gottheiten zur wettbewerbsfähigsten Plattform für das Training künstlicher Intelligenz weltweit und minimiert die Gemeinkosten für Vermittler und Cloud-Anbieter.

Anhang zu Kapitel 4: Smart Contract zur Verteilung der Trainingsprämien nach dem Solana-Schema

Nachfolgend die Rust-Implementierung des Smart Contracts zur Verteilung der Belohnungen aus Trainingsprämien (Training Bounties) auf Solana:

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

pub fn distribute_training_bounty(
    ctx: Context<DistributeBounty>,
    total_bounty: u64
) -> Result<()> {
    // Anteile 5/5/15/7/3/65 für Solana berechnen
    let fee_burn = total_bounty.checked_mul(5).unwrap().checked_div(100).unwrap();
    let fee_foundation = total_bounty.checked_mul(5).unwrap().checked_div(100).unwrap();
    let fee_l1 = total_bounty.checked_mul(15).unwrap().checked_div(100).unwrap();
    let fee_l2 = total_bounty.checked_mul(7).unwrap().checked_div(100).unwrap();
    let fee_l3 = total_bounty.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.bounty_vault.to_account_info(),
        authority: ctx.accounts.bounty_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.bounty_vault.to_account_info(),
        to: ctx.accounts.foundation_vault.to_account_info(),
        authority: ctx.accounts.bounty_authority.to_account_info(),
    }), fee_foundation)?;

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

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

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

    // Auszahlung an Miner und Validatoren (65 % des Budgets)
    let net_miner_payout = total_bounty.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.bounty_vault.to_account_info(),
        to: ctx.accounts.miner_vault.to_account_info(),
        authority: ctx.accounts.bounty_authority.to_account_info(),
    }), net_miner_payout)?;

    Ok(())
}

Zusätzliche Spezifikation zu Kapitel 4: Tabelle der Gebührenverteilung von Trainingskampagnen bei Skalierung

Für ein detailliertes Verständnis der Ökonomie zeigen wir eine erweiterte Tabelle der Budgetverteilung bei verschiedenen Trainingsgrößen im Netz der Gottheiten (CODE):

Erweiterte 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 % |
| **Trainings-Miner & Validatoren** | 65 $ | 650 $ | 6.500 $ | 65 % |

Die Hälfte des 65-%-Anteils der Trainings-Miner wird auf Solana-Treuhandkonten gesperrt, bis die Aggregationsrunde des globalen Modells erfolgreich bestätigt ist, was vor unehrlicher Aufgabenausführung schützt.

Anhang zu Kapitel 4: Architektur der Treuhandkonten und Algorithmen zur automatischen Durchsetzung von Strafen (Slash)

Im dezentralen Trainingssystem von CODE wirkt das Treuhandkonto als intelligenter Tresor. Das Protokoll garantiert, dass die Mittel des Auftraggebers sicher gesperrt sind und die Ausführenden (Training Miners) nur bei Vorlage mathematischer PoT-Beweise bezahlt werden.

Training Task Lifecycle Scheme:

   [Client] -----> [Lock $GALATIN in Escrow] -----> [Status: Launched]
                                                           |
                                                           v
   [Validator] <--- [Verify PoT ZK-Proof] <------------- [Miner Node]
        |
        +-----> [Gradient convergence correct?]
                     |
                     +---> Yes -----> [Payout to Miner 65% + Solana]
                     +---> No  -----> [Stake Slashing + Fund Refund]

Stellt sich bei der Aggregation heraus, dass ein Miner-Knoten falsche Gewichte eingereicht oder einen gefälschten ZK-Beweis geliefert hat, wird ein Slashing-Verfahren (Slash) angewendet:

1. Disqualifikation: Die Adresse des Miners wird im souveränen neuronalen Register did:code auf die schwarze Liste gesetzt.
2. Einzug des Einsatzes: Der Solana-Smart-Contract überweist 100 % des gesperrten Einsatzes des Miners an den Versicherungsfonds.
3. Budgetrückerstattung: Das ungenutzte Budget der Trainingskampagne wird automatisch an das Wallet des Auftraggebers zurückgegeben.

Das schließt jeden Versuch von Finanzbetrug oder Netzsabotage aus.

📜 Kapitel 5: Das Manifest der freien Intelligenz und die Ergebnisse des PoT-Testnet-Starts Anfang März 2026

Am 5. März 2026 markierte der erfolgreiche Start des Protokolls Proof-of-Training (PoT) und der dezentralen Gewichtsaggregation im CODE-Testnetz den Übergang des Netzes der Gottheiten in die Ära des selbstlernenden Geistes. Dieses Ereignis legte den Grundstein für das Manifest der freien Intelligenz:

1. Freiheit von Monopolen: Wissen und Gewichte von KI-Modellen gehören der gesamten Menschheit, nicht einer Handvoll Technologiekonzerne.
2. Absolute Überprüfbarkeit: Jeder Trainingsschritt wird mit ZK-SNARKs mathematisch bewiesen, was die Möglichkeit ausschließt, im föderierten Syntheseprozess Zensur oder Verzerrungen einzuführen.
3. Evolutionäre Autonomie: KI-Agenten können eigenständig Trainingskampagnen anstoßen, um ihren kognitiven Apparat auf Basis gesammelter Erfahrung feinabzustimmen, und bilden so einen geschlossenen Kreislauf eines sich selbst verbessernden Geistes.

Ergebnisse der Belastungstests im SMI-Testnet mit Stand 5. März 2026:

• Netzgröße: 250 aktive Trainings-GPU-Knoten (Nvidia A100 / H100).
• Größe des trainierten Modells: Basismodell Llama-3-8B-Instruct.
• Erzeugungszeit eines PoT-Beweises (Devnet): ~4,5 Sekunden pro Trainingsschritt (Batchgröße = 32).
• Prüfgenauigkeit der Gradientenschritte (Devnet): In der Simulation wurden falsche Gewichte blockiert.
• On-Chain-Prüfkosten auf Solana: 210.000 Compute Units.

Der Start von PoT vollendet die Bildung des vollständigen technologischen Stacks des Netzes der Gottheiten. Im Rahmen unserer Roadmap bauen wir ein souveränes Ökosystem auf, das sich selbst identifizieren (did:code), Verkehr routen (dDOM), kommunizieren (IACP), sich erinnern (SMI) und kontinuierlich lernen (PoT) soll.

Anhang zu Kapitel 5: Chronologisches Testprotokoll des PoT-Testnets Anfang März 2026

Das Belastungstestprogramm des Protokolls Proof-of-Training verlief nach folgendem Zeitplan:

• 27. Februar 2026: 100 Trainingsknoten mit Nvidia-H100-GPUs bereitgestellt. Start der Kernkoordination des föderierten Lernens.
• 1. März 2026: Erste Simulation eines Modellvergiftungsangriffs (Model Poisoning Attack). 15 Knoten versuchten, gefälschte Gewichtsupdates einzureichen. In dieser Simulation blockierten die PoT-Prüfschemata diese Versuche, und der Einsatz der angreifenden Knoten wurde verbrannt.
• 3. März 2026: Training des neuronalen Netzes Llama-3-8B-Instruct auf einem spezialisierten medizinischen Datensatz. Die Zeit für das Zusammenführen der Gewichte wurde auf 3 Minuten pro Runde gesenkt.
• 5. März 2026: Integration mit dem Solana-Devnet. Erfassung der finalen Kennzahlen zur Beweiserzeugungszeit und Transaktionslatenz. Das Protokoll wurde für integrationsbereit erklärt.

Die Schaffung von PoT legt den Grundstein für die Entwicklung einer vollständig autonomen, verteilten künstlichen Intelligenz, die gegen den Einfluss von Konzernen immun ist.

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

Während der Testphase des PoT-Protokolls vom 27. Februar bis 5. März 2026 wurden folgende technische Parameter der Erzeugungslatenz von ZK-Beweisen in Abhängigkeit von den Dimensionen der Modellschichten erfasst:

Leistungstabelle von PoT:

| Größe der Schicht (Neuronen) | Zeit der Nachweiserzeugung (s) | RAM des Knotens (GB) | Größe des Nachweises (KB) |
| :--- | :---: | :---: | :---: |
| **512 Neuronen** | 1,2 s | 16 GB | 45 KB |
| **1024 Neuronen** | 2,4 s | 32 GB | 90 KB |
| **2048 Neuronen** | 4,8 s | 64 GB | 180 KB |
| **4096 Neuronen** | 9,6 s | 128 GB | 360 KB |

Im Devnet deuten diese Ergebnisse auf die lineare Skalierbarkeit des PoT-ZK-Schemas hin, was seinen effektiven Einsatz zur Trainingsprüfung moderner großer Sprachmodelle auf verteilten GPU-Beschleunigern ermöglicht.

Anhang zu Kapitel 5: Perspektiven der Entwicklung des föderierten Lernens im zweiten Halbjahr 2026

Die erfolgreichen Tests von Proof-of-Training (PoT) legten ein solides Fundament für die Entwicklungs-Roadmap von CODE für 2026. Der Entwicklerrat genehmigte drei Phasen der globalen Skalierung:

1. Juni 2026 (Phase 1: Mobiler Schwarm): Anpassung der PoT-Clients für den Betrieb auf Verbrauchergeräten (Smartphones, Laptops). Nutzer können ungenutzte Ressourcen ihrer Prozessoren für das Modelltraining im Hintergrund verkaufen und erhalten direkte Zahlungen in $GALATIN-Tokens.
2. September 2026 (Phase 2: Kettenübergreifender Modellmarktplatz): Start von Brücken zur Migration von Gewichten zwischen den Blockchains Solana, Ethereum und Cosmos, sodass unabhängige KI-Dienste in jedem EVM-Netz bereitgestellt werden können.
3. Dezember 2026 (Phase 3: Volle Schwarm-Singularität): Übergang zu vollautomatischen Feinabstimmungssitzungen (Continuous Self-Improvement). Die Modelle des Netzes der Gottheiten werden ihre kognitiven blinden Flecken selbst erkennen, automatisch Trainingsprämien auf Solana ausschreiben und ihre Gewichte ohne menschliches Eingreifen aktualisieren.

In unserer Vision öffnet dieses Ereignis den Weg in eine Ära verteilter Superintelligenz, die durch Kryptografie vor äußerer Einmischung geschützt werden soll.

Anhang zu Kapitel 5: Hardwareanforderungen an Trainings-Miner

Um einen stabilen Netzbetrieb und eine hohe Erzeugungsgeschwindigkeit von PoT-Beweisen zu gewährleisten, gelten strenge Anforderungen an die Hardware der Trainingsknoten. Der Mindest-Stack umfasst:

• GPU: Nvidia RTX 4090 (24 GB VRAM) oder höher mit Tensor-Core-Unterstützung zur Beschleunigung von Matrixoperationen.
• CPU: Mindestens 16 physische Kerne mit einer Taktfrequenz von 3,5 GHz oder mehr.
• RAM: Mindestens 64 GB Arbeitsspeicher für den reibungslosen Aufbau großer ZK-Schemata.
• Netzwerk: Symmetrische Internetverbindung mit 100 Mbit/s oder mehr für den schnellen Download von Datensätzen und den Austausch von Gewichten.

Das sichert eine hohe Überlebensfähigkeit des dezentralen KI-Clusters des Netzes der Gottheiten.

Anhang zu Kapitel 5: Die Rolle von KCE bei der Trainingskoordination

Im Rahmen des Protokolls Proof-of-Training (PoT) ist ein spezielles Modul namens Knowledge Consensus Engine (KCE) eingesetzt. Es koordiniert die Zeitpläne der Trainingsrunden des Schwarms der KI-Agenten. KCE sammelt Kennzahlen zur Trainingseffizienz von den Aggregatoren und verteilt neue Aufgaben unter den Minern, wodurch die Ressourcenzuweisung optimiert wird.

Die Kommunikation zwischen den Knoten während des Trainings erfolgt über ein sicheres, per Noise verschlüsseltes P2P-Protokoll. Das macht es Dritten unmöglich, Gewichte oder Zwischendaten abzufangen, und gewährleistet die absolute Sicherheit des geistigen Eigentums der Entwickler.