HadAgent: Harness-Aware Decentralized Agentic AI Serving with Proof-of-Inference Blockchain Consensus

1. Problem Statement

The paper addresses two converging challenges in modern computing:

• Inefficiency of Traditional Consensus: Proof-of-Work (PoW) blockchains consume vast computational resources (e.g., Bitcoin uses >100 TWh annually) to solve cryptographic puzzles that yield no useful output.
• Scalability of AI Agents: The rapid growth of Large Language Model (LLM) agents has created an unprecedented demand for GPU computation that outpaces supply.
• Limitations of Existing "Proof-of-Useful-Work" (PoUW): Previous attempts to replace PoW with machine learning tasks (e.g., Proof of Learning) focus on model training. These approaches are ill-suited for real-time AI serving because:
  1. Training takes hours or days, whereas inference requires seconds.
  2. Consensus is defined at the model level (who trained the best model) rather than the request level (is this specific output correct?).
  3. They lack mechanisms to isolate unreliable nodes or differentiate between trusted and untrusted participants, leading to high verification latency.

2. Methodology: HadAgent Architecture

HadAgent proposes a decentralized agentic AI serving system that replaces hash-based mining with Proof-of-Inference (PoI). The system is built on four key design pillars:

A. Proof-of-Inference (PoI) Consensus

Instead of training models, nodes earn block-creation rights by executing deterministic LLM inference tasks.

• Determinism: Given identical model weights, input data, and decoding parameters, every compliant node must produce bit-identical output.
• Verification: Verifying a result requires only a single forward pass (re-execution) rather than a full training run, making cross-node verification efficient and fast.
• Process: Nodes submit results as cryptographic proofs. Consensus is reached by verifying that the output matches the deterministic expectation.

B. Three-Lane Block Structure

To support fine-grained tamper detection and auditable provenance, the block body is divided into three independent lanes, each protected by its own Merkle root:

1. DATA Lane: Records dataset commitments and audit hashes.
2. MODEL Lane: Records model hashes, versions, and configuration metadata.
3. PROOF Lane: Records input/output hashes, validation scores, and execution proofs.
   Only cryptographic hashes and metadata are stored on-chain; raw data and model weights remain off-chain.

C. Two-Tier Node Architecture

The system classifies secondary nodes based on historical behavior to optimize latency:

• Trusted Nodes: Have a history of correct proofs. They serve inference results in real-time via "optimistic execution" (results are delivered immediately without waiting for full consensus).
• Non-Trusted Nodes: New or previously unreliable nodes. Their results must undergo full consensus verification (master evaluation and cross-node voting) before being delivered to the user.
• Dynamic Trust: Nodes can be promoted to "Trusted" or demoted to "Non-Trusted/Excluded" based on performance.

D. Harness Engineering (Self-Correction Loop)

A dedicated "Harness Layer" monitors node behavior to ensure system stability and security. It operates in three phases after every consensus round:

1. Heartbeat Monitoring: Detects unresponsive nodes and triggers failover.
2. Anomaly Detection: Re-executes the inference task deterministically to verify submitted proofs. Any deviation (beyond numerical tolerance) flags the node as malicious.
3. Trust Management: Automatically updates node tiers. Malicious nodes are isolated within two rounds; honest nodes are promoted within five rounds.

3. Key Contributions

1. Proof-of-Inference (PoI): A novel consensus mechanism where the useful work is the AI service itself. It couples consensus participation directly with real-time inference serving, ensuring every unit of computation contributes to network security and end-user value.
2. Three-Lane Block Design: A structured block format (DATA, MODEL, PROOF) with independent Merkle roots, enabling efficient, granular verification and tamper detection.
3. Harness-Aware Two-Tier Architecture: A system that balances security and speed by allowing trusted nodes to bypass full consensus for real-time serving while maintaining rigorous verification for new/untrusted nodes.
4. Self-Correcting Feedback Loop: An automated trust management system that isolates adversarial nodes and promotes honest ones without human intervention.

4. Experimental Results

The authors implemented a prototype in Python and conducted experiments focusing on correctness, scale, and latency.

• Tamper Detection:
  • Detection Rate: 100% (Successfully identified all tampered records, invalid signatures, and schema violations).
  • False Positive Rate: 0% (No valid records were incorrectly rejected).
• Latency:
  • Validation Latency: Sub-millisecond (<1 ms) for record and hub operations.
  • Block Validation: Higher latency due to structural checks but remained stable under load.
• Harness Convergence:
  • Adversarial Isolation: Malicious nodes were successfully excluded from the network within 2 rounds.
  • Trust Promotion: Honest nodes were promoted to "Trusted" status within 5 rounds.
• Scalability: The system maintained consistent performance and low variance in latency even when processing over 2,000 validation operations.

5. Significance and Future Work

Significance:
HadAgent demonstrates that blockchain consensus can be redirected from wasteful hashing to productive AI inference. By leveraging the cost asymmetry between execution (inference) and verification (single forward pass), it enables a decentralized network that is both secure and capable of real-time AI serving. The "Harness" concept introduces a critical layer of observability and automated governance often missing in decentralized AI networks.

Limitations & Future Work:

• Networking: The current prototype uses direct TCP connections. Future work aims to integrate production-grade P2P gossip protocols (e.g., libp2p) for NAT traversal and resilience against network attacks (e.g., eclipse attacks).
• Hardware Determinism: Achieving bit-level deterministic inference across heterogeneous GPU hardware may require software-emulated floating-point arithmetic.
• Dynamic Membership: The current design assumes a fixed node set; future iterations will address dynamic node membership and clock drift issues.

In conclusion, HadAgent provides a foundational blueprint for a scalable, trustworthy, and efficient decentralized AI infrastructure where security and utility are intrinsically linked.