Proof of Useful Intelligence Work

Introduction: Evolving "Work" on Kaspa

Kaspa's BlockDAG (GHOSTDAG → DAGKnight) already solved the scalability trilemma with 10+ BPS post-Crescendo. The next frontier is making the "work" useful. PoUIW evolves Kaspa's kHeavyHash into an optional/hybrid useful matrix-multiplication puzzle. Miners solve real high-order machine learning puzzles — such as optimizing neural weights or processing complex sequential datasets on decentralized datasets — while the protocol enforces cryptographic hardness and verifiability. No TEEs, no hardware IDs.

Anti-Sybil Architecture: Economic Permissionlessness

Kaspa's strength is that anyone with electricity and a GPU can mine. PoUIW keeps this intact:

• No TEEs or Hardware IDs — gated only by computational cost.
• Economic Sybil Resistance — fake nodes still require real hashrate.
• Physical Decentralization — control requires global energy, not silicon supply chains.

The Engine: Useful Logic & ZK-Verification

High-speed BlockDAGs demand instant verification. PoUIW delivers it with the 2025 PoUW construction + Kaspa's native ZK precompiles (Groth16/RISC0 via KIP-16).

Security: 51% Nakamoto + GHOSTDAG

Security remains identical: 51% hashrate resistance, GHOSTDAG ordering, DAGKnight finality. The PoUW construction preserves all classic PoW properties while the useful work is performed.

Autonomous Uptime Incentives (Covenant-Native)

Using the May 5 2026 Covenant++ hardfork, PoUIW adds lightweight incentives without hurting decentralized miners.

5.1 — Attested Uptime Heartbeats

Nodes broadcast signed presence packets every 60s via existing P2P. These are tracked on-chain via covenants, proving the hardware is online and synchronized.

5.2 — Latency-Sensitive Micro-Puzzles

To prevent ghost nodes, the network issues spot-checks. A node receives a micro-puzzle (ZK-verified matrix task) and must return the logic result. Only a node with the AI model actively loaded can respond fast enough. Failure triggers covenant penalties — but verification is instant on-chain, so global latency is never punished.

• A node receives a micro-puzzle and must return the logic result.
• ZK-verified in milliseconds; failure results in immediate network penalties via covenants.

Mathematical Economics: Reward & Recovery Engine

Reward = (Logic Difficulty) × U × T

6.2 — Soft-Slashing Mechanism

If a node fails a Micro-Puzzle or submits an invalid ZK-Proof, it faces a covenant-enforced "Soft-Slash":

1. 1-Hour Reward Lockout: Future rewards are reduced for 3,600 seconds (no principal seizure).
2. Reputation Reset: The Trust Multiplier T immediately resets to 1.0.
3. Principal Persistence: Previously mined coins are never seized — only future earning potential is reduced.

6.3 — The Recovery Curve

Technical Implementation: Kaspa Core Node Logic

// PoUIW Miner Loop (rusty-kaspa + KIP-16 + Covenants)
fn start_pouw_miner() {
    loop {
        // 1. Fetch useful matrix task (neural weights / decentralized dataset)
        let puzzle = network::get_next_matmul_task();

        // 2. Perform Useful Intelligence Work (2025 PoUW)
        let (solution, trace) = ai_engine::matmul_pouw_solve(puzzle);

        // 3. ZK-Proof (Groth16 via KIP-16)
        let zk_proof = groth16::generate_proof(trace, solution);

        // 4. Package & Broadcast (hybrid kHeavyHash optional)
        let block = Block::new(solution, zk_proof, pow_hash);
        dag_network::broadcast(block);

        // 5. GHOSTDAG acceptance + covenant reward (U × T + micro-puzzle checks)
        if dag_network::accept_block(&block) {
            covenants::apply_reward_multiplier();
        }
    }
}

Conclusion: Kaspa's Permanent Supercomputer