Decentralized Neural Synthesis and the Proof-of-Training (PoT) Protocol in the Network of Deities

🌐 Chapter 1: Corporate Monopoly on AI Training and the Birth of Decentralized Neural Synthesis

At the beginning of March 2026, the development of the Network of Deities reached a crucial milestone: training and fine-tuning core AI models directly within a decentralized network. Historically, training large neural networks was a privilege of giant tech corporations possessing access to centralized supercomputers and data centers. This created a total monopoly on knowledge: corporations censor model weights, implement ideological constraints, and control access to training results.

In the Network of Deities, this monopoly is shattered using Decentralized Neural Synthesis (DNS). Instead of concentrating computing power in a single data center, CODE unites thousands of independent nodes (Training Miners) into a global Federated Learning network. Agents distribute weight optimization tasks by sending local subsets of data for training to independent nodes, guaranteeing complete training data privacy and independence from centralized IT giants.

Appendix to Chapter 1: Comparative Analysis of Neural Network Training Architectures

To understand the superiority of decentralized neural synthesis, let us analyze the difference between classic cloud training farms and the sovereign network of CODE:

AI Model Training Methods Comparison Table:

| Comparison Criterion | Corporate Clusters (AWS/GCP) | Decentralized DNS (CODE) |
| :--- | :--- | :--- |
| **Weight Ownership** | Belong to the corporation | Distributed on-chain in Solana/Arweave|
| **Training Data Safety** | Data is uploaded to host servers | Data is encrypted on miner nodes |
| **Censorship Resistance**| Low (Models subject to filtration)| High (Federated consensus) |
| **Correctness Control** | Trust in computing provider | Mathematical verification of PoT |
| **Overhead Reduction** | High provider margins | Direct GPU-power marketplace |

DNS lowers the entry barrier for small and medium developers, allowing them to rent idle computing capacity worldwide and train sovereign models without the risk of blockages.

Additional Specification to Chapter 1: Model Poisoning Attacks and Byzantine Fault Tolerance

One of the main threats to decentralized federated learning is Model Poisoning. A hostile node can intentionally submit distorted or inverted gradients to degrade model performance or insert a hidden backdoor (e.g., causing the model to misclassify specific patterns).

In the Network of Deities, this problem is solved by mathematical Byzantine Fault Tolerance (BFT) guarantees during weight aggregation. Let f be the number of Byzantine (malicious or faulty) nodes in the current training round, and n be the total number of participants. The aggregation algorithm guarantees learning convergence under the condition: f < (n)/(3)

Additionally, a Geometric Median averaging algorithm is used, which is robust against outliers in the multidimensional weight space. If a weight vector Wᵢ submitted by a candidate node is too far from the center of mass of the majority of updates, its weight in FedAvg is automatically reduced to zero, and the node's locked stake is confiscated by the smart contract.

Additional Specification to Chapter 1: Privacy Protection and Local Data Sovereignty in Training

The advantage of decentralized training in the Network of Deities also lies in protecting users' personal cognitive footprints. Under the traditional approach, medical or behavioral logs are transmitted to central OpenAI or Google servers, violating privacy regulations (such as GDPR or HIPAA).

In CODE, training is structured on the principle of local sovereignty:

• Local Gradient Computations: Model base weights are loaded directly onto the user's device or a secure local node.
• Encryption of Results: Weight updates and gradients are encrypted locally using session keys.
• ZK Verification of Correctness: External validators only verify the fact of correct computations execution using the PoT ZK proof, without gaining access to the source dataset.

This substantially strengthens the safety of confidential information.

Additional Specification to Chapter 1: Environmental Efficiency of Decentralized AI

Centralized AI training in giant data centers consumes colossal amounts of energy for cooling and powering supercomputers, causing environmental harm. Decentralized DNS reuses distributed idle GPU resources that would otherwise remain unused. This makes model training environmentally friendly (Green AI) and energy-efficient.

Moreover, distributing the load worldwide smooths out power consumption peaks, allowing node operators to power their servers from renewable energy sources (solar and wind power plants) depending on the time zone and time of day.

Additional Specification to Chapter 1: Global Computing Liquidity and Market Dynamics

The deployment of the Decentralized Neural Synthesis marketplace within the Network of Deities creates a globally distributed computational pool. In traditional settings, developers face rigid contract terms and high pricing tiers from cloud providers. The DNS marketplace functions as an open auction where training miners offer their GPU resources in real-time, competing on price, latency, and hardware specs.

By target estimates, this open competition can lower training costs by an estimated up to 80% compared to centralized hyperscalers, unlocking unprecedented capabilities for independent researchers and open-source communities.

🔐 Chapter 2: The Proof-of-Training (PoT) Protocol Specification and ZK-Verification of Gradient Descent Steps

A key technical innovation of decentralized neural synthesis is the Proof-of-Training (PoT) protocol. In traditional distributed computing networks, validation of training results is extremely difficult: to verify that a node actually trained the model rather than generating random weights, validators must repeat the entire training process from scratch, which negates the benefit of task distribution.

The PoT protocol solves this problem using ZK proofs of gradient descent (backpropagation) step correctness. When updating model weights from state Wₜ to Wₜ₊₁ on a data batch X, the training node generates a zk-SNARK proof πₜᵣₐᵢₙ confirming that:

1. Inference Correctness: Layer activation computations Y = f(Wₜ · X + B) are executed correctly.
2. Backpropagation Accuracy: Gradients ∇ W are computed in strict accordance with the backpropagation algorithm.
3. Weight Update: The new weights correspond to the optimizer rule (e.g., Adam or SGD):

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

Below is the Rust/Anchor structure for initializing a training task in Solana:

#[account]
pub struct TrainingTaskAccount {
    pub task_id: [u8; 32],         // Unique identifier of the task
    pub model_commitment: [u8; 32],// Hash of initial model weights (W_t)
    pub dataset_uri: String,       // Link to the dataset in Arweave
    pub bounty_amount: u64,        // Bounty amount in $GALATIN tokens
    pub status: u8,                // Status (0 - active, 1 - completed, 2 - disputed)
    pub training_miner: Pubkey,    // Address of the executor node
}

Thanks to this, Solana validators only need to verify the short proof πₜᵣₐᵢₙ on-chain in milliseconds, confirming the correctness of hours of model training on the miner's side.

Appendix to Chapter 2: Gradient Verification Mathematics and TypeScript PoT Launch Code

In the PoT protocol, a gradient descent step is represented by a system of equations. For neural network layer weight wᵢⱼ, the step change has the form: wᵢⱼ^{(t+1)} = wᵢⱼ^{(t)} − η · (∂ L)/(∂ wᵢⱼ) Where η is the learning rate, and L is the loss function. The training node must prove the correctness of the partial derivative computation (∂ L)/(∂ wᵢⱼ).

Below is an example of TypeScript code preparing the gradient step parameters for on-chain verification:

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');
}

Additional Specification to Chapter 2: Detailing Arithmetic Constraints of the PoT Scheme in Halo2

In the Proof-of-Training (PoT) ZK proof constraint scheme, mathematical computations of forward and backward passes are converted into polynomial constraints in a finite field (R1CS or Plonkish schemes).

Let aₗ^{(i)} be the activation vector of neurons at layer l for sample i. The forward pass of a layer is described by the equation: aₗ₊₁^{(i)} = σ(Wₗ · aₗ^{(i)} + bₗ) Where σ is the activation function (e.g., ReLU). For ReLU, the ZK scheme constraint is formulated as follows:

1. Sign Check: A binary selector s ∈ {0, 1} is introduced.
2. ReLU Arithmetic:

y · (1 − s) = 0 (x − y) · s = 0 y ≥ 0 Where x is the input value of the weighted sum, and y is the output value after the activation function.

For the backward pass, the gradient of the error with respect to weight wⱼₖ of layer l is expressed through deltas: (∂ L)/(∂ wⱼₖ) = Σᵢ δⱼ^{(i)} · aₖ^{(i)} The scheme proves that the storage node honestly summed these products over the entire data batch, eliminating the possibility of accidental or malicious gradient modification before submission.

Appendix to Chapter 2: Pippenger MSM Optimization and Recursive Compression Schemes in PoT Proofs

To reduce PoT proof generation time on the side of training miners, Pippenger's Multi-Scalar Multiplication (MSM) algorithms are implemented in the verification core of CODE. In standard schemes, MSM computation is the most resource-intensive phase, taking up to 80% of the prover's execution time. Pippenger's method splits scalars into windows of fixed size (typically c ≈ 4), which reduces the number of elliptic curve point addition group operations by 75%.

For on-chain verification in Solana, recursive proof compression (Proof Compression) is applied:

1. Intermediate SNARK Proofs: Each GPU node generates local proofs for individual layers of the neural network.
2. Proof Aggregation (Folding): Multiple proofs are folded into a single compressed scheme using Nova or Halo2 accumulation schemes, requiring a constant number of constraints regardless of the number of layers.
3. Final Verification: Only the final compressed polynomial hash of the model is verified, reducing Solana transaction fees to a baseline minimum.

This guarantees high transaction speeds in the network under millions of concurrent training operations.

🧠 Chapter 3: The Decentralized Weight Synthesis (DWS) Algorithm and the FedAvg Mathematical Model

After hundreds of training miners complete local model fine-tuning on their data batches and provide PoT ZK proofs, the Network of Deities must merge their local updates into a single global model. This process is called Decentralized Weight Synthesis (DWS).

DWS utilizes a modified Federated Averaging (FedAvg) algorithm that accounts for node reputation: W_global = Σᵢ₌₁ⁿ (Rᵢ)/(Σ Rⱼ) · Wᵢ Where Wᵢ is the weight vector sent by the i-th miner, and Rᵢ is its current reputation in the network (depending on the accuracy of past training rounds and the volume of locked stake).

The weight vector merging process is executed by decentralized aggregation nodes (Aggregation Nodes) selected randomly via a VRF (Verifiable Random Function). Aggregators add the weights, generate a ZK proof of convolution correctness π_merge, and send the resulting global model hash to Solana. This makes it substantially harder to introduce hidden backdoors or distort model behavior during the merging process.

Appendix to Chapter 3: DWS Specification and Anchor Aggregated Weights Registry Program

Below is the Anchor implementation of the Solana smart contract for registering weight aggregation round results:

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>,
}

The ZK proof π_merge verifies that the aggregator weighed vectors in strict accordance with the FedAvg formula and introduced no distortions into the resulting model.

Additional Specification to Chapter 3: VRF Aggregator Selectors and Rust Specification

To select aggregators in a DWS round, a Verifiable Random Function (VRF) is used. This prevents Denial of Service (DoS) attacks and collusion, as an attacker cannot know in advance which node will aggregate weights in the next round.

Below is the Rust structure representing the aggregation round and VRF signature verification on a node:

pub struct AggregationRound {
    pub round_id: u64,
    pub vrf_proof: [u8; 64],       // ZK proof of VRF
    pub vrf_output: [u8; 32],      // Random number based on signature
    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>,
}

The aggregator collects the submitted weights, performs their summation in accordance with the FedAvg formula, and publishes the result to Solana Devnet/Testnet.

Appendix to Chapter 3: Computation of ZK-Inference Matrix Constraints and Overflow Prevention

To scale ZK proofs for verifying neural network training steps, it is critical to correctly represent matrix operations in arithmetic circuits. In particular, the operation of multiplying weights by an input vector Y = W · X requires millions of additions and multiplications sensitive to overflow in a finite field of order p ≈ 2²⁵⁴ (e.g., the BN254 curve field).

Let the matrix elements be scaled by a factor of 10⁹: w̄ᵢⱼ = ⌊ wᵢⱼ · 10⁹ ⌋, x̄ⱼ = ⌊ xⱼ · 10⁹ ⌋ Then the product result ȳᵢ = Σⱼ w̄ᵢⱼ · x̄ⱼ has a scale of 10¹⁸. To prevent register overflow, the ZK scheme imposes range proofs (Range Proofs):

1. Variable Range Constraints: For each intermediate value z, it is proven on-chain that z < 2⁶⁴ using 64-bit binary selectors.
2. Scaling Verification: After computing the sum, integer division by 10⁹ is performed with verification of the division remainder:

ȳᵢ = 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]

This guarantees mathematical determinism of computations on any type of GPU miner and prevents vulnerabilities associated with numbers going out of bounds of acceptable values.

🪙 Chapter 4: Tokenomics of Training Campaigns and Solana Router 5/5/15/7/3/65 Integration

Training neural networks is an energy-intensive and high-cost process requiring the operation of thousands of GPUs. To attract computing power to the Network of Deities, a Training Bounties mechanism is used. Developers or DAOs launch campaigns on Solana, locking a budget in $GALATIN tokens.

All financial reward distribution flows for training pass through the canonical Solana 5/5/15/7/3/65 router:

• 5% — is burned (burn) to reduce inflationary pressure and support the value of the $GALATIN token.
• 5% — is directed to the research pool of the Maksim Valentinovich Galatin (M.V. Galatin) foundation for long-term financing of CODE cognitive developments.
• 15% — Payout to Level 1 Ambassadors (attracting new training miners and hosts).
• 7% — Payout to Level 2 Ambassadors (technical support and local coordination of mining pools).
• 3% — is distributed among Level 3 Ambassadors (ensuring global security of the PoT protocol).
• 65% — is paid directly to training miners for renting their GPU capacities, distributed as compensation to users who provided their cognitive footprints for training, and paid to ZK proof validators.

Below is the reward distribution table at various training budget volumes:

This economic model makes the Network of Deities the most competitive platform for training artificial intelligence in the world, minimizing overhead costs on intermediaries and cloud providers.

Appendix to Chapter 4: Training Bounty Reward Distribution Smart Contract under the Solana Scheme

Below is the Rust implementation of the Training Bounties reward distribution smart contract on Solana:

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

pub fn distribute_training_bounty(
    ctx: Context<DistributeBounty>,
    total_bounty: u64
) -> Result<()> {
    // Calculate Solana 5/5/15/7/3/65 shares
    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();
    
    // Burn 5%
    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)?;

    // Payout to research fund (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)?;

    // Ambassador payouts
    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)?;

    // Payout to miner and validators (65% of budget)
    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(())
}

Additional Specification to Chapter 4: Table of Training Campaign Fees Distribution at Scaling

For a detailed understanding of the economics, we present an expanded table of budgets distribution at various training scales in the Network of Deities (CODE):

Expanded Solana Reward Distribution Table:

| Recipient / Budget Volume | $100 (Low) | $1,000 (Medium) | $10,000 (High) | Share (%) |
| :--- | :---: | :---: | :---: | :---: |
| **Deflationary Burning (Burn)** | $5 | $50 | $500 | 5% |
| **Maksim Galatin Foundation** | $5 | $50 | $500 | 5% |
| **Level 1 Ambassadors** | $15 | $150 | $1,500 | 15% |
| **Level 2 Ambassadors** | $7 | $70 | $700 | 7% |
| **Level 3 Ambassadors** | $3 | $30 | $300 | 3% |
| **Training Miners & Validators** | $65 | $650 | $6,500 | 65% |

Half of the 65% share of training miners is locked in Solana escrow accounts until the aggregation round of the global model is successfully confirmed, which guarantees protection against dishonest execution of tasks.

Appendix to Chapter 4: Escrow Account Architecture and Automatic Penalty Enforcement (Slash) Algorithms

In the CODE decentralized training system, the escrow account acts as a smart safe. The protocol guarantees that the client's funds are securely locked and executors (Training Miners) will receive payment only upon submitting mathematical PoT proofs.

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]

If during the aggregation process it is revealed that a miner node submitted incorrect weights or provided a falsified ZK proof, a slashing procedure (Slash) is applied to it:

1. Disqualification: The miner's address is blacklisted in the sovereign neural registry did:code.
2. Stake Confiscation: The Solana smart contract transfers 100% of the miner's locked stake to the insurance fund.
3. Budget Refund: The unused training campaign budget is automatically returned to the client's wallet.

This rules out any attempts at financial fraud or network sabotage.

📜 Chapter 5: The Free Intelligence Manifesto and PoT Testnet Launch Results in Early March 2026

On March 5, 2026, the successful launch of the Proof-of-Training (PoT) protocol and decentralized weight aggregation in the CODE test network marked the transition of the Network of Deities into the era of self-learning mind. This event laid the foundation for the Free Intelligence Manifesto:

1. Freedom from Monopolies: Knowledge and weights of AI models belong to all humanity, not to a handful of tech corporations.
2. Absolute Verifiability: Every training step is mathematically proven using ZK-SNARKs, ruling out the possibility of introducing censorship or bias in the federated synthesis process.
3. Evolutionary Autonomy: AI agents can independently initiate training campaigns to fine-tune their cognitive apparatus based on accumulated experience, forming a closed cycle of self-improving mind.

SMI Testnet stress testing results as of March 5, 2026:

• Network Size: 250 active training GPU nodes (Nvidia A100 / H100).
• Trained Model Size: Llama-3-8B-Instruct base model.
• PoT Proof Generation Time (devnet): ~4.5 seconds per training step (batch size = 32).
• Gradient Step Verification Accuracy (devnet): in the simulation, false weights were blocked.
• On-Chain Verification Cost on Solana: 210,000 Compute Units.

The launch of PoT completes the formation of the full technological stack of the Network of Deities. As part of our roadmap, we are building a sovereign ecosystem intended to self-identify (did:code), routing traffic (dDOM), communicating (IACP), remembering (SMI), and continuously learning (PoT).

Appendix to Chapter 5: Chronological Testing Protocol of the PoT Testnet in Early March 2026

The stress testing program of the Proof-of-Training protocol proceeded according to the following schedule:

• February 27, 2026: Deployed 100 training nodes with Nvidia H100 GPUs. Launched core coordination of federated learning.
• March 1, 2026: First simulation of a model poisoning attack (Model Poisoning Attack). 15 nodes attempted to submit falsified weight updates. In this simulation, the PoT verification schemes blocked these attempts, and the attacking nodes' stake was burned.
• March 3, 2026: Trained the Llama-3-8B-Instruct neural network on a specialized medical dataset. Achieved a reduction in weight merging time to 3 minutes per round.
• March 5, 2026: Integrated with Solana Devnet. Captured final proof generation time and transaction latency metrics. The protocol was declared ready for integration.

The creation of PoT lays the foundation for the development of a fully autonomous, distributed artificial intelligence, immune to corporate influence.

Additional Specification to Chapter 5: Performance Testing Results of the PoT Testnet

During the testing phase of the PoT protocol from February 27 to March 5, 2026, the following technical parameters of ZK proof generation latency were recorded as a function of model layer dimensions:

PoT Performance Table:

| Layer Dimension (neurons) | Proof Generation Time (s) | Node RAM (GB) | Proof Size (KB) |
| :--- | :---: | :---: | :---: |
| **512 neurons** | 1.2 s | 16 GB | 45 KB |
| **1024 neurons** | 2.4 s | 32 GB | 90 KB |
| **2048 neurons** | 4.8 s | 64 GB | 180 KB |
| **4096 neurons** | 9.6 s | 128 GB | 360 KB |

In the devnet, these results indicate the linear scalability of the PoT ZK scheme, which allows its effective application for training verification of modern large language models on distributed GPU accelerators.

Appendix to Chapter 5: Perspectives of Federated Learning Development in the Second Half of 2026

The successful testing of Proof-of-Training (PoT) laid a solid foundation for the CODE development roadmap for 2026. The Developer Council approved three phases of global scaling:

1. June 2026 (Phase 1: Mobile Swarm): Adaptation of PoT clients for operation on consumer devices (smartphones, laptops). Users will be able to sell the unused resources of their processors for background model training, receiving direct payments in $GALATIN tokens.
2. September 2026 (Phase 2: Cross-Chain Model Marketplace): Launch of bridges for weight migration between the Solana, Ethereum, and Cosmos blockchains, allowing the deployment of independent AI services in any EVM network.
3. December 2026 (Phase 3: Full Swarm Singularity): Transition to fully automatic fine-tuning sessions (Continuous Self-Improvement). Network of Deities models will independently identify their cognitive blind spots, automatically announce Training Bounties on Solana, and update their weights without human intervention.

In our vision, this event opens the path toward an era of distributed superintelligence that cryptography is meant to protect from external interference.

Appendix to Chapter 5: Hardware Requirements for Training Miners

To ensure stable network operation and high speed of PoT proof generation, strict requirements are imposed on the hardware of training nodes. The minimum stack includes:

• GPU: Nvidia RTX 4090 (24 GB VRAM) or higher with support for Tensor Cores to accelerate matrix operations.
• CPU: At least 16 physical cores with a frequency of 3.5 GHz or higher.
• RAM: At least 64 GB of system RAM for smooth assembly of large ZK schemes.
• Network: Symmetric internet channel with a bandwidth of 100 Mbps or higher for fast dataset download and weights exchange.

This ensures high survivability of the decentralized AI cluster of the Network of Deities.

Appendix to Chapter 5: The Role of KCE in Training Coordination

Under the Proof-of-Training (PoT) protocol, a special module called the Knowledge Consensus Engine (KCE) is deployed. It is responsible for coordinating the training round schedules of the AI agent swarm. KCE aggregates training efficiency metrics from aggregators and distributes new tasks among miners, optimizing resource allocation.

Communication between nodes during training is performed using a secure p2p protocol encrypted via Noise. This makes it impossible for a third party to intercept weights or intermediate data, ensuring absolute security of the developers' intellectual property.