26 posts tagged with "AI"

Introduction: The Need for Verifiable AI on Blockchain​

As AI systems grow in influence, ensuring their outputs are trustworthy becomes critical. Traditional methods rely on institutional assurances (essentially “just trust us”), which offer no cryptographic guarantees. This is especially problematic in decentralized contexts like blockchains, where a smart contract or user must trust an AI-derived result without being able to re-run a heavy model on-chain. Zero-knowledge Machine Learning (zkML) addresses this by allowing cryptographic verification of ML computations. In essence, zkML enables a prover to generate a succinct proof that “the output $Y$ came from running model $M$ on input $X$” – without revealing $X$ or the internal details of $M$. These zero-knowledge proofs (ZKPs) can be verified by anyone (or any contract) efficiently, shifting AI trust from “policy to proof”.

On-chain verifiability of AI means a blockchain can incorporate advanced computations (like neural network inferences) by verifying a proof of correct execution instead of performing the compute itself. This has broad implications: smart contracts can make decisions based on AI predictions, decentralized autonomous agents can prove they followed their algorithms, and cross-chain or off-chain compute services can provide verifiable outputs rather than unverifiable oracles. Ultimately, zkML offers a path to trustless and privacy-preserving AI – for example, proving an AI model’s decisions are correct and authorized without exposing private data or proprietary model weights. This is key for applications ranging from secure healthcare analytics to blockchain gaming and DeFi oracles.

How zkML Works: Compressing ML Inference into Succinct Proofs​

At a high level, zkML combines cryptographic proof systems with ML inference so that a complex model evaluation can be “compressed” into a small proof. Internally, the ML model (e.g. a neural network) is represented as a circuit or program consisting of many arithmetic operations (matrix multiplications, activation functions, etc.). Rather than revealing all intermediate values, a prover performs the full computation off-chain and then uses a zero-knowledge proof protocol to attest that every step was done correctly. The verifier, given only the proof and some public data (like the final output and an identifier for the model), can be cryptographically convinced of the correctness without re-executing the model.

To achieve this, zkML frameworks typically transform the model computation into a format amenable to ZKPs:

• Circuit Compilation: In SNARK-based approaches, the computation graph of the model is compiled into an arithmetic circuit or set of polynomial constraints. Each layer of the neural network (convolutions, matrix multiplies, nonlinear activations) becomes a sub-circuit with constraints ensuring the outputs are correct given the inputs. Because neural nets involve non-linear operations (ReLUs, Sigmoids, etc.) not naturally suited to polynomials, techniques like lookup tables are used to handle these efficiently. For example, a ReLU (output = max(0, input)) can be enforced by a custom constraint or lookup that verifies output equals input if input≥0 else zero. The end result is a set of cryptographic constraints that the prover must satisfy, which implicitly proves the model ran correctly.
• Execution Trace & Virtual Machines: An alternative is to treat the model inference as a program trace, as done in zkVM approaches. For instance, the JOLT zkVM targets the RISC-V instruction set; one can compile the ML model (or the code that computes it) to RISC-V and then prove each CPU instruction executed properly. JOLT introduces a “lookup singularity” technique, replacing expensive arithmetic constraints with fast table lookups for each valid CPU operation. Every operation (add, multiply, bitwise op, etc.) is checked via a lookup in a giant table of pre-computed valid outcomes, using a specialized argument (Lasso/SHOUT) to keep this efficient. This drastically reduces the prover workload: even complex 64-bit operations become a single table lookup in the proof instead of many arithmetic constraints.
• Interactive Protocols (GKR Sum-Check): A third approach uses interactive proofs like GKR (Goldwasser–Kalai–Rotblum) to verify a layered computation. Here the model’s computation is viewed as a layered arithmetic circuit (each neural network layer is one layer of the circuit graph). The prover runs the model normally but then engages in a sum-check protocol to prove that each layer’s outputs are correct given its inputs. In Lagrange’s approach (DeepProve, detailed next), the prover and verifier perform an interactive polynomial protocol (made non-interactive via Fiat-Shamir) that checks consistency of each layer’s computations without re-doing them. This sum-check method avoids generating a monolithic static circuit; instead it verifies the consistency of computations in a step-by-step manner with minimal cryptographic operations (mostly hashing or polynomial evaluations).

Regardless of approach, the outcome is a succinct proof (typically a few kilobytes to a few tens of kilobytes) that attests to the correctness of the entire inference. The proof is zero-knowledge, meaning any secret inputs (private data or model parameters) can be kept hidden – they influence the proof but are not revealed to verifiers. Only the intended public outputs or assertions are revealed. This allows scenarios like “prove that model $M$ when applied to patient data $X$ yields diagnosis $Y$, without revealing $X$ or the model’s weights.”

Enabling on-chain verification: Once a proof is generated, it can be posted to a blockchain. Smart contracts can include verification logic to check the proof, often using precompiled cryptographic primitives. For example, Ethereum has precompiles for BLS12-381 pairing operations used in many zk-SNARK verifiers, making on-chain verification of SNARK proofs efficient. STARKs (hash-based proofs) are larger, but can still be verified on-chain with careful optimization or possibly with some trust assumptions (StarkWare’s L2, for instance, verifies STARK proofs on Ethereum by an on-chain verifier contract, albeit with higher gas cost than SNARKs). The key is that the chain does not need to execute the ML model – it only runs a verification which is much cheaper than the original compute. In summary, zkML compresses expensive AI inference into a small proof that blockchains (or any verifier) can check in milliseconds to seconds.

Lagrange DeepProve: Architecture and Performance of a zkML Breakthrough​

DeepProve by Lagrange Labs is a state-of-the-art zkML inference framework focusing on speed and scalability. Launched in 2025, DeepProve introduced a new proving system that is dramatically faster than prior solutions like Ezkl. Its design centers on the GKR interactive proof protocol with sum-check and specialized optimizations for neural network circuits. Here’s how DeepProve works and achieves its performance:

• One-Time Preprocessing: Developers start with a trained neural network (currently supported types include multilayer perceptrons and popular CNN architectures). The model is exported to ONNX format, a standard graph representation. DeepProve’s tool then parses the ONNX model and quantizes it (converts weights to fixed-point/integer form) for efficient field arithmetic. In this phase, it also generates the proving and verification keys for the cryptographic protocol. This setup is done once per model and does not need to be repeated per inference. DeepProve emphasizes ease of integration: “Export your model to ONNX → one-time setup → generate proofs → verify anywhere”.

• Proving (Inference + Proof Generation): After setup, a prover (which could be run by a user, a service, or Lagrange’s decentralized prover network) takes a new input $X$ and runs the model $M$ on it, obtaining output $Y$. During this execution, DeepProve records an execution trace of each layer’s computations. Instead of translating every multiplication into a static circuit upfront (as SNARK approaches do), DeepProve uses the linear-time GKR protocol to verify each layer on the fly. For each network layer, the prover commits to the layer’s inputs and outputs (e.g., via cryptographic hashes or polynomial commitments) and then engages in a sum-check argument to prove that the outputs indeed result from the inputs as per the layer’s function. The sum-check protocol iteratively convinces the verifier of the correctness of a sum of evaluations of a polynomial that encodes the layer’s computation, without revealing the actual values. Non-linear operations (like ReLU, softmax) are handled efficiently through lookup arguments in DeepProve – if an activation’s output was computed, DeepProve can prove that each output corresponds to a valid input-output pair from a precomputed table for that function. Layer by layer, proofs are generated and then aggregated into one succinct proof covering the whole model’s forward pass. The heavy lifting of cryptography is minimized – DeepProve’s prover mostly performs normal numeric computations (the actual inference) plus some light cryptographic commitments, rather than solving a giant system of constraints.

• Verification: The verifier uses the final succinct proof along with a few public values – typically the model’s committed identifier (a cryptographic commitment to $M$’s weights), the input $X$ (if not private), and the claimed output $Y$ – to check correctness. Verification in DeepProve’s system involves verifying the sum-check protocol’s transcript and the final polynomial or hash commitments. This is more involved than verifying a classic SNARK (which might be a few pairings), but it’s vastly cheaper than re-running the model. In Lagrange’s benchmarks, verifying a DeepProve proof for a medium CNN takes on the order of 0.5 seconds in software. That is ~0.5s to confirm, for example, that a convolutional network with hundreds of thousands of parameters ran correctly – over 500× faster than naively re-computing that CNN on a GPU for verification. (In fact, DeepProve measured up to 521× faster verification for CNNs and 671× for MLPs compared to re-execution.) The proof size is small enough to transmit on-chain (tens of KB), and verification could be performed in a smart contract if needed, although 0.5s of computation might require careful gas optimization or layer-2 execution.

Architecture and Tooling: DeepProve is implemented in Rust and provides a toolkit (the zkml library) for developers. It natively supports ONNX model graphs, making it compatible with models from PyTorch or TensorFlow (after exporting). The proving process currently targets models up to a few million parameters (tests include a 4M-parameter dense network). DeepProve leverages a combination of cryptographic components: a multilinear polynomial commitment (to commit to layer outputs), the sum-check protocol for verifying computations, and lookup arguments for non-linear ops. Notably, Lagrange’s open-source repository acknowledges it builds on prior work (the sum-check and GKR implementation from Scroll’s Ceno project), indicating an intersection of zkML with zero-knowledge rollup research.

To achieve real-time scalability, Lagrange pairs DeepProve with its Prover Network – a decentralized network of specialized ZK provers. Heavy proof generation can be offloaded to this network: when an application needs an inference proved, it sends the job to Lagrange’s network, where many operators (staked on EigenLayer for security) compute proofs and return the result. This network economically incentivizes reliable proof generation (malicious or failed jobs get the operator slashed). By distributing work across provers (and potentially leveraging GPUs or ASICs), the Lagrange Prover Network hides the complexity and cost from end-users. The result is a fast, scalable, and decentralized zkML service: “verifiable AI inferences fast and affordable”.

Performance Milestones: DeepProve’s claims are backed by benchmarks against the prior state-of-the-art, Ezkl. For a CNN with ~264k parameters (CIFAR-10 scale model), DeepProve’s proving time was ~1.24 seconds versus ~196 seconds for Ezkl – about 158× faster. For a larger dense network with 4 million parameters, DeepProve proved an inference in ~2.3 seconds vs ~126.8 seconds for Ezkl (~54× faster). Verification times also dropped: DeepProve verified the 264k CNN proof in ~0.6s, whereas verifying the Ezkl proof (Halo2-based) took over 5 minutes on CPU in that test. The speedups come from DeepProve’s near-linear complexity: its prover scales roughly O(n) with the number of operations, whereas circuit-based SNARK provers often have superlinear overhead (FFT and polynomial commitments scaling). In fact, DeepProve’s prover throughput can be within an order of magnitude of plain inference runtime – recent GKR systems can be <10× slower than raw execution for large matrix multiplications, an impressive achievement in ZK. This makes real-time or on-demand proofs more feasible, paving the way for verifiable AI in interactive applications.

Use Cases: Lagrange is already collaborating with Web3 and AI projects to apply zkML. Example use cases include: verifiable NFT traits (proving an AI-generated evolution of a game character or collectible is computed by the authorized model), provenance of AI content (proving an image or text was generated by a specific model, to combat deepfakes), DeFi risk models (proving a model’s output that assesses financial risk without revealing proprietary data), and private AI inference in healthcare or finance (where a hospital can get AI predictions with a proof, ensuring correctness without exposing patient data). By making AI outputs verifiable and privacy-preserving, DeepProve opens the door to “AI you can trust” in decentralized systems – moving from an era of “blind trust in black-box models” to one of “objective guarantees”.

SNARK-Based zkML: Ezkl and the Halo2 Approach​

The traditional approach to zkML uses zk-SNARKs (Succinct Non-interactive Arguments of Knowledge) to prove neural network inference. Ezkl (by ZKonduit/Modulus Labs) is a leading example of this approach. It builds on the Halo2 proving system (a PLONK-style SNARK with polynomial commitments over BLS12-381). Ezkl provides a tooling chain where a developer can take a PyTorch or TensorFlow model, export it to ONNX, and have Ezkl compile it into a custom arithmetic circuit automatically.

How it works: Each layer of the neural network is converted into constraints:

• Linear layers (dense or convolution) become collections of multiplication-add constraints that enforce the dot-products between inputs, weights, and outputs.
• Non-linear layers (like ReLU, sigmoid, etc.) are handled via lookups or piecewise constraints because such functions are not polynomial. For instance, a ReLU can be implemented by a boolean selector $b$ with constraints ensuring $y = x \cdot b$ and $0 \le b \le 1$ and $b=1$ if $x>0$ (one way to do it), or more efficiently by a lookup table mapping $x \mapsto \max(0,x)$ for a range of $x$ values. Halo2’s lookup arguments allow mapping 16-bit (or smaller) chunks of values, so large domains (like all 32-bit values) are usually “chunked” into several smaller lookups. This chunking increases the number of constraints.
• Big integer ops or divisions (if any) are similarly broken into small pieces. The result is a large set of R1CS/PLONK constraints tailored to the specific model architecture.

Ezkl then uses Halo2 to generate a proof that these constraints hold given the secret inputs (model weights, private inputs) and public outputs. Tooling and integration: One advantage of the SNARK approach is that it leverages well-known primitives. Halo2 is already used in Ethereum rollups (e.g. Zcash, zkEVMs), so it’s battle-tested and has an on-chain verifier readily available. Ezkl’s proofs use BLS12-381 curve, which Ethereum can verify via precompiles, making it straightforward to verify an Ezkl proof in a smart contract. The team has also provided user-friendly APIs; for example, data scientists can work with their models in Python and use Ezkl’s CLI to produce proofs, without deep knowledge of circuits.

Strengths: Ezkl’s approach benefits from the generality and ecosystem of SNARKs. It supports reasonably complex models and has already seen “practical integrations (from DeFi risk models to gaming AI)”, proving real-world ML tasks. Because it operates at the level of the model’s computation graph, it can apply ML-specific optimizations: e.g. pruning insignificant weights or quantizing parameters to reduce circuit size. It also means model confidentiality is natural – the weights can be treated as private witness data, so the verifier only sees that some valid model produced the output, or at best a commitment to the model. The verification of SNARK proofs is extremely fast (typically a few milliseconds or less on-chain), and proof sizes are small (a few kilobytes), which is ideal for blockchain usage.

Weaknesses: Performance is the Achilles’ heel. Circuit-based proving imposes large overheads, especially as models grow. It’s noted that historically, SNARK circuits could be a million times more work for the prover than just running the model itself. Halo2 and Ezkl optimize this, but still, operations like large matrix multiplications generate tons of constraints. If a model has millions of parameters, the prover must handle correspondingly millions of constraints, performing heavy FFTs and multiexponentiation in the process. This leads to high proving times (often minutes or hours for non-trivial models) and high memory usage. For example, proving even a relatively small CNN (e.g. a few hundred thousand parameters) can take tens of minutes with Ezkl on a single machine. The team behind DeepProve cited that Ezkl took hours for certain model proofs that DeepProve can do in minutes. Large models might not even fit in memory or require splitting into multiple proofs (which then need recursive aggregation). While Halo2 is “moderately optimized”, any need to “chunk” lookups or handle wide-bit operations translates to extra overhead. In summary, scalability is limited – Ezkl works well for small-to-medium models (and indeed outperformed some earlier alternatives like naive Stark-based VMs in benchmarks), but struggles as model size grows beyond a point.

Despite these challenges, Ezkl and similar SNARK-based zkML libraries are important stepping stones. They proved that verified ML inference is possible on-chain and have active usage. Notably, projects like Modulus Labs demonstrated verifying an 18-million-parameter model on-chain using SNARKs (with heavy optimization). The cost was non-trivial, but it shows the trajectory. Moreover, the Mina Protocol has its own zkML toolkit that uses SNARKs to allow smart contracts on Mina (which are Snark-based) to verify ML model execution. This indicates a growing multi-platform support for SNARK-based zkML.

STARK-Based Approaches: Transparent and Programmable ZK for ML​

zk-STARKs (Scalable Transparent ARguments of Knowledge) offer another route to zkML. STARKs use hash-based cryptography (like FRI for polynomial commitments) and avoid any trusted setup. They often operate by simulating a CPU or VM and proving the execution trace is correct. In context of ML, one can either build a custom STARK for the neural network or use a general-purpose STARK VM to run the model code.

General STARK VMs (RISC Zero, Cairo): A straightforward approach is to write inference code and run it in a STARK VM. For example, Risc0 provides a RISC-V environment where any code (e.g., C++ or Rust implementation of a neural network) can be executed and proven via a STARK. Similarly, StarkWare’s Cairo language can express arbitrary computations (like an LSTM or CNN inference) which are then proved by the StarkNet STARK prover. The advantage is flexibility – you don’t need to design custom circuits for each model. However, early benchmarks showed that naive STARK VMs were slower compared to optimized SNARK circuits for ML. In one test, a Halo2-based proof (Ezkl) was about 3× faster than a STARK-based approach on Cairo, and even 66× faster than a RISC-V STARK VM on a certain benchmark in 2024. This gap is due to the overhead of simulating every low-level instruction in a STARK and the larger constants in STARK proofs (hashing is fast but you need a lot of it; STARK proof sizes are bigger, etc.). However, STARK VMs are improving and have the benefit of transparent setup (no trusted setup) and post-quantum security. As STARK-friendly hardware and protocols advance, proving speeds will improve.

DeepProve’s approach vs STARK: Interestingly, DeepProve’s use of GKR and sum-check yields a proof more akin to a STARK in spirit – it’s an interactive, hash-based proof with no need for a structured reference string. The trade-off is that its proofs are larger and verification is heavier than a SNARK. Yet, DeepProve shows that careful protocol design (specialized to ML’s layered structure) can vastly outperform both generic STARK VMs and SNARK circuits in proving time. We can consider DeepProve as a bespoke STARK-style zkML prover (though they use the term zkSNARK for succinctness, it doesn’t have a traditional SNARK’s small constant-size verification, since 0.5s verify is bigger than typical SNARK verify). Traditional STARK proofs (like StarkNet’s) often involve tens of thousands of field operations to verify, whereas SNARK verifies in maybe a few dozen. Thus, one trade-off is evident: SNARKs yield smaller proofs and faster verifiers, while STARKs (or GKR) offer easier scaling and no trusted setup at the cost of proof size and verify speed.

Emerging improvements: The JOLT zkVM (discussed earlier under JOLTx) is actually outputting SNARKs (using PLONKish commitments) but it embodies ideas that could be applied in STARK context too (Lasso lookups could theoretically be used with FRI commitments). StarkWare and others are researching ways to speed up proving of common operations (like using custom gates or hints in Cairo for big int ops, etc.). There’s also Circomlib-ML by Privacy&Scaling Explorations (PSE), which provides Circom templates for CNN layers, etc. – that’s SNARK-oriented, but conceptually similar templates could be made for STARK languages.

In practice, non-Ethereum ecosystems leveraging STARKs include StarkNet (which could allow on-chain verification of ML if someone writes a verifier, though cost is high) and Risc0’s Bonsai service (which is an off-chain proving service that emits STARK proofs which can be verified on various chains). As of 2025, most zkML demos on blockchain have favored SNARKs (due to verifier efficiency), but STARK approaches remain attractive for their transparency and potential in high-security or quantum-resistant settings. For example, a decentralized compute network might use STARKs to let anyone verify work without a trusted setup, useful for longevity. Also, some specialized ML tasks might exploit STARK-friendly structures: e.g. computations heavily using XOR/bit operations could be faster in STARKs (since those are cheap in boolean algebra and hashing) than in SNARK field arithmetic.

Summary of SNARK vs STARK for ML:

• Performance: SNARKs (like Halo2) have huge proving overhead per gate but benefit from powerful optimizations and small constants for verify; STARKs (generic) have larger constant overhead but scale more linearly and avoid expensive crypto like pairings. DeepProve shows that customizing the approach (sum-check) yields near-linear proving time (fast) but with a STARK-like proof. JOLT shows that even a general VM can be made faster with heavy use of lookups. Empirically, for models up to millions of operations: a well-optimized SNARK (Ezkl) can handle it but might take tens of minutes, whereas DeepProve (GKR) can do it in seconds. STARK VMs in 2024 were likely in between or worse than SNARKs unless specialized (Risc0 was slower in tests, Cairo was slower without custom hints).
• Verification: SNARK proofs verify quickest (milliseconds, and minimal data on-chain ~ a few hundred bytes to a few KB). STARK proofs are larger (dozens of KB) and take longer (tens of ms to seconds) to verify due to many hashing steps. In blockchain terms, a SNARK verify might cost e.g. ~200k gas, whereas a STARK verify could cost millions of gas – often too high for L1, acceptable on L2 or with succinct verification schemes.
• Setup and Security: SNARKs like Groth16 require a trusted setup per circuit (unfriendly for arbitrary models), but universal SNARKs (PLONK, Halo2) have a one-time setup that can be reused for any circuit up to certain size. STARKs need no setup and use only hash assumptions (plus classical polynomial complexity assumptions), and are post-quantum secure. This makes STARKs appealing for longevity – proofs remain secure even if quantum computers emerge, whereas current SNARKs (BLS12-381 based) would be broken by quantum attacks.

We will consolidate these differences in a comparison table shortly.

FHE for ML (FHE-o-ML): Private Computation vs. Verifiable Computation​

Fully Homomorphic Encryption (FHE) is a cryptographic technique that allows computations to be performed directly on encrypted data. In the context of ML, FHE can enable a form of privacy-preserving inference: for example, a client can send encrypted input to a model host, the host runs the neural network on the ciphertext without decrypting it, and sends back an encrypted result which the client can decrypt. This ensures data confidentiality – the model owner learns nothing about the input (and potentially the client learns only the output, not the model’s internals if they only get output). However, FHE by itself does not produce a proof of correctness in the same way ZKPs do. The client must trust that the model owner actually performed the computation honestly (the ciphertext could have been manipulated). Usually, if the client has the model or expects a certain distribution of outputs, blatant cheating can be detected, but subtle errors or use of a wrong model version would not be evident just from the encrypted output.

Trade-offs in performance: FHE is notoriously heavy in computation. Running deep learning inference under FHE incurs orders-of-magnitude slowdown. Early experiments (e.g., CryptoNets in 2016) took tens of seconds to evaluate a tiny CNN on encrypted data. By 2024, improvements like CKKS (for approximate arithmetic) and better libraries (Microsoft SEAL, Zama’s Concrete) have reduced this overhead, but it remains large. For example, a user reported that using Zama’s Concrete-ML to run a CIFAR-10 classifier took 25–30 minutes per inference on their hardware. After optimizations, Zama’s team achieved ~40 seconds for that inference on a 192-core server. Even 40s is extremely slow compared to a plaintext inference (which might be 0.01s), showing a ~$10^3$–$10^4\times$ overhead. Larger models or higher precision increase the cost further. Additionally, FHE operations consume a lot of memory and require occasional bootstrapping (a noise-reduction step) which is computationally expensive. In summary, scalability is a major issue – state-of-the-art FHE might handle a small CNN or simple logistic regression, but scaling to large CNNs or Transformers is beyond current practical limits.

Privacy advantages: FHE’s big appeal is data privacy. The input can remain completely encrypted throughout the process. This means an untrusted server can compute on a client’s private data without learning anything about it. Conversely, if the model is sensitive (proprietary), one could envisage encrypting the model parameters and having the client perform FHE inference on their side – but this is less common because if the client has to do the heavy FHE compute, it negates the idea of offloading to a powerful server. Typically, the model is public or held by server in the clear, and the data is encrypted by the client’s key. Model privacy in that scenario is not provided by default (the server knows the model; the client learns outputs but not weights). There are more exotic setups (like secure two-party computation or multi-key FHE) where both model and data can be kept private from each other, but those incur even more complexity. In contrast, zkML via ZKPs can ensure model privacy and data privacy at once – the prover can have both the model and data as secret witness, only revealing what’s needed to the verifier.

No on-chain verification needed (and none possible): With FHE, the result comes out encrypted to the client. The client then decrypts it to obtain the actual prediction. If we want to use that result on-chain, the client (or whoever holds the decryption key) would have to publish the plaintext result and convince others it’s correct. But at that point, trust is back in the loop – unless combined with a ZKP. In principle, one could combine FHE and ZKP: e.g., use FHE to keep data private during compute, and then generate a ZK-proof that the plaintext result corresponds to a correct computation. However, combining them means you pay the performance penalty of FHE and ZKP – extremely impractical with today’s tech. So, in practice FHE-of-ML and zkML serve different use cases:

• FHE-of-ML: Ideal when the goal is confidentiality between two parties (client and server). For instance, a cloud service can host an ML model and users can query it with their sensitive data without revealing the data to the cloud (and if the model is sensitive, perhaps deploy it via FHE-friendly encodings). This is great for privacy-preserving ML services (medical predictions, etc.). The user still has to trust the service to faithfully run the model (since no proof), but at least any data leakage is prevented. Some projects like Zama are even exploring an “FHE-enabled EVM (fhEVM)” where smart contracts could operate on encrypted inputs, but verifying those computations on-chain would require the contract to somehow enforce correct computation – an open challenge likely requiring ZK proofs or specialized secure hardware.
• zkML (ZKPs): Ideal when the goal is verifiability and public auditability. If you want anyone (or any contract) to be sure that “Model $M$ was evaluated correctly on $X$ and produced $Y$”, ZKPs are the solution. They also provide privacy as a bonus (you can hide $X$ or $Y$ or $M$ if needed by treating them as private inputs to the proof), but their primary feature is the proof of correct execution.

A complementary relationship: It’s worth noting that ZKPs protect the verifier (they learn nothing about secrets, only that the computation was correctly done), whereas FHE protects the prover’s data from the computing party. In some scenarios, these could be combined – for example, a network of untrusted nodes could use FHE to compute on users’ private data and then provide ZK proofs to the users (or blockchain) that the computations were done according to the protocol. This would cover both privacy and correctness, but the performance cost is enormous with today’s algorithms. More feasible in the near term are hybrids like Trusted Execution Environments (TEE) plus ZKP or Functional Encryption plus ZKP – these are beyond our scope, but they aim to provide something similar (TEEs keep data/model secret during compute, then a ZKP can attest the TEE did the right thing).

In summary, FHE-of-ML prioritizes confidentiality of inputs/outputs, while zkML prioritizes verifiable correctness (with possible privacy). Table 1 below contrasts the key properties:

Table 1: Comparison of zk-SNARK, zk-STARK, and FHE approaches for machine learning inference (performance and privacy trade-offs).

Use Cases and Implications for Web3 Applications​

The convergence of AI and blockchain via zkML unlocks powerful new application patterns in Web3:

• Decentralized Autonomous Agents & On-Chain Decision-Making: Smart contracts or DAOs can incorporate AI-driven decisions with guarantees of correctness. For example, imagine a DAO that uses a neural network to analyze market conditions before executing trades. With zkML, the DAO’s smart contract can require a zkSNARK proof that the authorized ML model (with a known hash commitment) was run on the latest data and produced the recommended action, before the action is accepted. This prevents malicious actors from injecting a fake prediction – the chain verifies the AI’s computation. Over time, one could even have fully on-chain autonomous agents (contracts that query off-chain AI or contain simplified models) making decisions in DeFi or games, with all their moves proven correct and policy-compliant via zk proofs. This raises the trust in autonomous agents, since their “thinking” is transparent and verifiable rather than a black-box.

• Verifiable Compute Markets: Projects like Lagrange are effectively creating verifiable computation marketplaces – developers can outsource heavy ML inference to a network of provers and get back a proof with the result. This is analogous to decentralized cloud computing, but with built-in trust: you don’t need to trust the server, only the proof. It’s a paradigm shift for oracles and off-chain computation. Protocols like Ethereum’s upcoming DSC (decentralized sequencing layer) or oracle networks could use this to provide data feeds or analytic feeds with cryptographic guarantees. For instance, an oracle could supply “the result of model X on input Y” and anyone can verify the attached proof on-chain, rather than trusting the oracle’s word. This could enable verifiable AI-as-a-service on blockchain: any contract can request a computation (like “score these credit risks with my private model”) and accept the answer only with a valid proof. Projects such as Gensyn are exploring decentralized training and inference marketplaces using these verification techniques.

• NFTs and Gaming – Provenance and Evolution: In blockchain games or NFT collectibles, zkML can prove traits or game moves were generated by legitimate AI models. For example, a game might allow an AI to evolve an NFT pet’s attributes. Without ZK, a clever user might modify the AI or the outcome to get a superior pet. With zkML, the game can require a proof that “pet’s new stats were computed by the official evolution model on the pet’s old stats”, preventing cheating. Similarly for generative art NFTs: an artist could release a generative model as a commitment; later, when minting NFTs, prove each image was produced by that model given some seed, guaranteeing authenticity (and even doing so without revealing the exact model to the public, preserving the artist’s IP). This provenance verification ensures authenticity in a manner akin to verifiable randomness – except here it’s verifiable creativity.

• Privacy-Preserving AI in Sensitive Domains: zkML allows confirmation of outcomes without exposing inputs. In healthcare, a patient’s data could be run through an AI diagnostic model by a cloud provider; the hospital receives a diagnosis and a proof that the model (which could be privately held by a pharmaceutical company) was run correctly on the patient data. The patient data remains private (only an encrypted or committed form was used in the proof), and the model weights remain proprietary – yet the result is trusted. Regulators or insurance could also verify that only approved models were used. In finance, a company could prove to an auditor or regulator that its risk model was applied to its internal data and produced certain metrics without revealing the underlying sensitive financial data. This enables compliance and oversight with cryptographic assurances rather than manual trust.

• Cross-Chain and Off-Chain Interoperability: Because zero-knowledge proofs are fundamentally portable, zkML can facilitate cross-chain AI results. One chain might have an AI-intensive application running off-chain; it can post a proof of the result to a different blockchain, which will trustlessly accept it. For instance, consider a multi-chain DAO using an AI to aggregate sentiment across social media (off-chain data). The AI analysis (complex NLP on large data) is done off-chain by a service that then posts a proof to a small blockchain (or multiple chains) that “analysis was done correctly and output sentiment score = 0.85”. All chains can verify and use that result in their governance logic, without each needing to rerun the analysis. This kind of interoperable verifiable compute is what Lagrange’s network aims to support, by serving multiple rollups or L1s simultaneously. It removes the need for trusted bridges or oracle assumptions when moving results between chains.

• AI Alignment and Governance: On a more forward-looking note, zkML has been highlighted as a tool for AI governance and safety. Lagrange’s vision statements, for example, argue that as AI systems become more powerful (even superintelligent), cryptographic verification will be essential to ensure they follow agreed rules. By requiring AI models to produce proofs of their reasoning or constraints, humans retain a degree of control – “you cannot trust what you cannot verify”. While this is speculative and involves social as much as technical aspects, the technology could enforce that an AI agent running autonomously still proves it is using an approved model and hasn’t been tampered with. Decentralized AI networks might use on-chain proofs to verify contributions (e.g., a network of nodes collaboratively training a model can prove each update was computed faithfully). Thus zkML could play a role in ensuring AI systems remain accountable to human-defined protocols even in decentralized or uncontrolled environments.

In conclusion, zkML and verifiable on-chain AI represent a convergence of advanced cryptography and machine learning that stands to enhance trust, transparency, and privacy in AI applications. By comparing the major approaches – zk-SNARKs, zk-STARKs, and FHE – we see a spectrum of trade-offs between performance and privacy, each suitable for different scenarios. SNARK-based frameworks like Ezkl and innovations like Lagrange’s DeepProve have made it feasible to prove substantial neural network inferences with practical effort, opening the door to real-world deployments of verifiable AI. STARK-based and VM-based approaches promise greater flexibility and post-quantum security, which will become important as the field matures. FHE, while not a solution for verifiability, addresses the complementary need of confidential ML computation, and in combination with ZKPs or in specific private contexts it can empower users to leverage AI without sacrificing data privacy.

The implications for Web3 are significant: we can foresee smart contracts reacting to AI predictions, knowing they are correct; markets for compute where results are trustlessly sold; digital identities (like Worldcoin’s proof-of-personhood via iris AI) protected by zkML to confirm someone is human without leaking their biometric image; and generally a new class of “provable intelligence” that enriches blockchain applications. Many challenges remain – performance for very large models, developer ergonomics, and the need for specialized hardware – but the trajectory is clear. As one report noted, “today’s ZKPs can support small models, but moderate to large models break the paradigm”; however, rapid advances (50×–150× speedups with DeepProve over prior art) are pushing that boundary outward. With ongoing research (e.g., on hardware acceleration and distributed proving), we can expect progressively larger and more complex AI models to become provable. zkML might soon evolve from niche demos to an essential component of trusted AI infrastructure, ensuring that as AI becomes ubiquitous, it does so in a way that is auditable, decentralized, and aligned with user privacy and security.

ETHDenver 2025, branded the “Year of The Regenerates,” solidified its status as one of the world’s largest Web3 gatherings. Spanning BUIDLWeek (Feb 23–26), the Main Event (Feb 27–Mar 2), and a post-conference Mountain Retreat, the festival drew an expected 25,000+ participants. Builders, developers, investors, and creatives from 125+ countries converged in Denver to celebrate Ethereum’s ethos of decentralization and innovation. True to its community roots, ETHDenver remained free to attend, community-funded, and overflowing with content – from hackathons and workshops to panels, pitch events, and parties. The event’s lore of “Regenerates” defending decentralization set a tone that emphasized public goods and collaborative building, even amid a competitive tech landscape. The result was a week of high-energy builder activity and forward-looking discussions, offering a snapshot of Web3’s emerging trends and actionable insights for industry professionals.

Emerging Web3 Trends Spotlighted by Speakers​

No single narrative dominated ETHDenver 2025 – instead, a broad spectrum of Web3 trends took center stage. Unlike last year (when restaking via EigenLayer stole the show), 2025’s agenda was a sprinkle of everything: from decentralized physical infrastructure networks (DePIN) to AI agents, from regulatory compliance to real-world asset tokenization (RWA), plus privacy, interoperability, and more. In fact, ETHDenver’s founder John Paller addressed concerns about multi-chain content by noting “95%+ of our sponsors and 90% of content is ETH/EVM-aligned” – yet the presence of non-Ethereum ecosystems underscored interoperability as a key theme. Major speakers reflected these trend areas: for example, zk-rollup and Layer-2 scaling was highlighted by Alex Gluchowski (CEO of Matter Labs/zkSync), while multi-chain innovation came from Adeniyi Abiodun of Mysten Labs (Sui) and Albert Chon of Injective.

The convergence of AI and Web3 emerged as a strong undercurrent. Numerous talks and side events focused on decentralized AI agents and “DeFi+AI” crossovers. A dedicated AI Agent Day showcased on-chain AI demos, and a collective of 14 teams (including Coinbase’s developer kit and NEAR’s AI unit) even announced the Open Agents Alliance (OAA) – an initiative to provide permissionless, free AI access by pooling Web3 infrastructure. This indicates growing interest in autonomous agents and AI-driven dApps as a frontier for builders. Hand-in-hand with AI, DePIN (decentralized physical infrastructure) was another buzzword: multiple panels (e.g. Day of DePIN, DePIN Summit) explored projects bridging blockchain with physical networks (from telecom to mobility).

Cuckoo AI Network made waves at ETHDenver 2025, showcasing its innovative decentralized AI model-serving marketplace designed for creators and developers. With a compelling presence at both the hackathon and community-led side events, Cuckoo AI attracted significant attention from developers intrigued by its ability to monetize GPU/CPU resources and easily integrate on-chain AI APIs. During their dedicated workshop and networking session, Cuckoo AI highlighted how decentralized infrastructure could efficiently democratize access to advanced AI services. This aligns directly with the event's broader trends—particularly the intersection of blockchain with AI, DePIN, and public-goods funding. For investors and developers at ETHDenver, Cuckoo AI emerged as a clear example of how decentralized approaches can power the next generation of AI-driven dApps and infrastructure, positioning itself as an attractive investment opportunity within the Web3 ecosystem.

Privacy, identity, and security remained top-of-mind. Speakers and workshops addressed topics like zero-knowledge proofs (zkSync’s presence), identity management and verifiable credentials (a dedicated Privacy & Security track was in the hackathon), and legal/regulatory issues (an on-chain legal summit was part of the festival tracks). Another notable discussion was the future of fundraising and decentralization of funding: a Main Stage debate between Dragonfly Capital’s Haseeb Qureshi and Matt O’Connor of Legion (an “ICO-like” platform) about ICOs vs. VC funding captivated attendees. This debate highlighted emerging models like community token sales challenging traditional VC routes – an important trend for Web3 startups navigating capital raising. The take-away for professionals is clear: Web3 in 2025 is multidisciplinary – spanning finance, AI, real assets, and culture – and staying informed means looking beyond any one hype cycle to the full spectrum of innovation.

Sponsors and Their Strategic Focus Areas​

ETHDenver’s sponsor roster in 2025 reads like a who’s-who of layer-1s, layer-2s, and Web3 infrastructure projects – each leveraging the event to advance strategic goals. Cross-chain and multi-chain protocols made a strong showing. For instance, Polkadot was a top sponsor with a hefty $80k bounty pool, incentivizing builders to create cross-chain DApps and appchains. Similarly, BNB Chain, Flow, Hedera, and Base (Coinbase’s L2) each offered up to $50k for projects integrating with their ecosystems, signaling their push to attract Ethereum developers. Even traditionally separate ecosystems like Solana and Internet Computer joined in with sponsored challenges (e.g. Solana co-hosted a DePIN event, and Internet Computer offered an “Only possible on ICP” bounty). This cross-ecosystem presence drew some community scrutiny, but ETHDenver’s team noted that the vast majority of content remained Ethereum-aligned. The net effect was interoperability being a core theme – sponsors aimed to position their platforms as complementary extensions of the Ethereum universe.

Scaling solutions and infrastructure providers were also front and center. Major Ethereum L2s like Optimism and Arbitrum had large booths and sponsored challenges (Optimism’s bounties up to $40k), reinforcing their focus on onboarding developers to rollups. New entrants like ZkSync and Zircuit (a project showcasing an L2 rollup approach) emphasized zero-knowledge tech and even contributed SDKs (ZkSync promoted its Smart Sign-On SDK for user-friendly login, which hackathon teams eagerly used). Restaking and modular blockchain infrastructure was another sponsor interest – EigenLayer (pioneering restaking) had its own $50k track and even co-hosted an event on “Restaking & DeFAI (Decentralized AI)”, marrying its security model with AI topics. Oracles and interoperability middleware were represented by the likes of Chainlink and Wormhole, each issuing bounties for using their protocols.

Notably, Web3 consumer applications and tooling had sponsor support to improve user experience. Uniswap’s presence – complete with one of the biggest booths – wasn’t just for show: the DeFi giant used the event to announce new wallet features like integrated fiat off-ramps, aligning with its sponsorship focus on DeFi usability. Identity and community-focused platforms like Galxe (Gravity) and Lens Protocol sponsored challenges around on-chain social and credentialing. Even mainstream tech companies signaled interest: PayPal and Google Cloud hosted a stablecoin/payments happy hour to discuss the future of payments in crypto. This blend of sponsors shows that strategic interests ranged from core infrastructure to end-user applications – all converging at ETHDenver to provide resources (APIs, SDKs, grants) to developers. For Web3 professionals, the heavy sponsorship from layer-1s, layer-2s, and even Web2 fintechs highlights where the industry is investing: interoperability, scalability, security, and making crypto useful for the next wave of users.

Hackathon Highlights: Innovative Projects and Winners​

At the heart of ETHDenver is its legendary #BUIDLathon – a hackathon that has grown into the world’s largest blockchain hackfest with thousands of developers. In 2025 the hackathon offered a record $1,043,333+ prize pool to spur innovation. Bounties from 60+ sponsors targeted key Web3 domains, carving the competition into tracks such as: DeFi & AI, NFTs & Gaming, Infrastructure & Scalability, Privacy & Security, and DAOs & Public Goods. This track design itself is insightful – for example, pairing DeFi with AI hints at the emergence of AI-driven financial applications, while a dedicated Public Goods track reaffirms community focus on regenerative finance and open-source development. Each track was backed by sponsors offering prizes for best use of their tech (e.g. Polkadot and Uniswap for DeFi, Chainlink for interoperability, Optimism for scaling solutions). The organizers even implemented quadratic voting for judging, allowing the community to help surface top projects, with final winners chosen by expert judges.

The result was an outpouring of cutting-edge projects, many of which offer a glimpse into Web3’s future. Notable winners included an on-chain multiplayer game “0xCaliber”, a first-person shooter that runs real-time blockchain interactions inside a classic FPS game. 0xCaliber wowed judges by demonstrating true on-chain gaming – players buy in with crypto, “shoot” on-chain bullets, and use cross-chain tricks to collect and cash out loot, all in real time. This kind of project showcases the growing maturity of Web3 gaming (integrating Unity game engines with smart contracts) and the creativity in merging entertainment with crypto economics. Another category of standout hacks were those merging AI with Ethereum: teams built “agent” platforms that use smart contracts to coordinate AI services, inspired by the Open Agents Alliance announcement. For example, one hackathon project integrated AI-driven smart contract auditors (auto-generating security test cases for contracts) – aligning with the decentralized AI trend observed at the conference.

Infrastructure and tooling projects were also prominent. Some teams tackled account abstraction and user experience, using sponsor toolkits like zkSync’s Smart Sign-On to create wallet-less login flows for dApps. Others worked on cross-chain bridges and Layer-2 integrations, reflecting ongoing developer interest in interoperability. In the Public Goods & DAO track, a few projects addressed real-world social impact, such as a dApp for decentralized identity and aid to help the homeless (leveraging NFTs and community funds, an idea reminiscent of prior ReFi hacks). Regenerative finance (ReFi) concepts – like funding public goods via novel mechanisms – continued to appear, echoing ETHDenver’s regenerative theme.

While final winners were being celebrated by the end of the main event, the true value was in the pipeline of innovation: over 400 project submissions poured in, many of which will live on beyond the event. ETHDenver’s hackathon has a track record of seeding future startups (indeed, some past BUIDLathon projects have grown into sponsors themselves). For investors and technologists, the hackathon provided a window into bleeding-edge ideas – signaling that the next wave of Web3 startups may emerge in areas like on-chain gaming, AI-infused dApps, cross-chain infrastructure, and solutions targeting social impact. With nearly $1M in bounties disbursed to developers, sponsors effectively put their money where their mouth is to cultivate these innovations.

Networking Events and Investor Interactions​

ETHDenver is not just about writing code – it’s equally about making connections. In 2025 the festival supercharged networking with both formal and informal events tailored for startups, investors, and community builders. One marquee event was the Bufficorn Ventures (BV) Startup Rodeo, a high-energy showcase where 20 hand-picked startups demoed to investors in a science-fair style expo. Taking place on March 1st in the main hall, the Startup Rodeo was described as more “speed dating” than pitch contest: founders manned tables to pitch their projects one-on-one as all attending investors roamed the arena. This format ensured even early-stage teams could find meaningful face time with VCs, strategics, or partners. Many startups used this as a launchpad to find customers and funding, leveraging the concentrated presence of Web3 funds at ETHDenver.

On the conference’s final day, the BV BuffiTank Pitchfest took the spotlight on the main stage – a more traditional pitch competition featuring 10 of the “most innovative” early-stage startups from the ETHDenver community. These teams (separate from the hackathon winners) pitched their business models to a panel of top VCs and industry leaders, competing for accolades and potential investment offers. The Pitchfest illustrated ETHDenver’s role as a deal-flow generator: it was explicitly aimed at teams “already organized…looking for investment, customers, and exposure,” especially those connected to the SporkDAO community. The reward for winners wasn’t a simple cash prize but rather the promise of joining Bufficorn Ventures’ portfolio or other accelerator cohorts. In essence, ETHDenver created its own mini “Shark Tank” for Web3, catalyzing investor attention on the community’s best projects.

Beyond these official showcases, the week was packed with investor-founder mixers. According to a curated guide by Belong, notable side events included a “Meet the VCs” Happy Hour hosted by CertiK Ventures on Feb 27, a StarkNet VC & Founders Lounge on March 1, and even casual affairs like a “Pitch & Putt” golf-themed pitch event. These gatherings provided relaxed environments for founders to rub shoulders with venture capitalists, often leading to follow-up meetings after the conference. The presence of many emerging VC firms was also felt on panels – for example, a session on the EtherKnight Stage highlighted new funds like Reflexive Capital, Reforge VC, Topology, Metalayer, and Hash3 and what trends they are most excited about. Early indications suggest these VCs were keen on areas like decentralized social media, AI, and novel Layer-1 infrastructure (each fund carving a niche to differentiate themselves in a competitive VC landscape).

For professionals looking to capitalize on ETHDenver’s networking: the key takeaway is the value of side events and targeted mixers. Deals and partnerships often germinate over coffee or cocktails rather than on stage. ETHDenver 2025’s myriad investor events demonstrate that the Web3 funding community is actively scouting for talent and ideas even in a lean market. Startups that came prepared with polished demos and a clear value proposition (often leveraging the event’s hackathon momentum) found receptive audiences. Meanwhile, investors used these interactions to gauge the pulse of the developer community – what problems are the brightest builders solving this year? In summary, ETHDenver reinforced that networking is as important as BUIDLing: it’s a place where a chance meeting can lead to a seed investment or where an insightful conversation can spark the next big collaboration.

Venture Capital Trends and Investment Opportunities in Web3​

A subtle but important narrative throughout ETHDenver 2025 was the evolving landscape of Web3 venture capital itself. Despite the broader crypto market’s ups and downs, investors at ETHDenver signaled strong appetite for promising Web3 projects. Blockworks reporters on the ground noted “just how much private capital is still flowing into crypto, undeterred by macro headwinds,” with seed stage valuations often sky-high for the hottest ideas. Indeed, the sheer number of VCs present – from crypto-native funds to traditional tech investors dabbling in Web3 – made it clear that ETHDenver remains a deal-making hub.

Emerging thematic focuses could be discerned from what VCs were discussing and sponsoring. The prevalence of AI x Crypto content (hackathon tracks, panels, etc.) wasn’t only a developer trend; it reflects venture interest in the “DeFi meets AI” nexus. Many investors are eyeing startups that leverage machine learning or autonomous agents on blockchain, as evidenced by venture-sponsored AI hackhouses and summits. Similarly, the heavy focus on DePIN and real-world asset (RWA) tokenization indicates that funds see opportunity in projects that connect blockchain to real economy assets and physical devices. The dedicated RWA Day (Feb 26) – a B2B event on the future of tokenized assets – suggests that venture scouts are actively hunting in that arena for the next Goldfinch or Centrifuge (i.e. platforms bringing real-world finance on-chain).

Another observable trend was a growing experimentation with funding models. The aforementioned debate on ICOs vs VCs wasn’t just conference theatrics; it mirrors a real venture movement towards more community-centric funding. Some VCs at ETHDenver indicated openness to hybrid models (e.g. venture-supported token launches that involve community in early rounds). Additionally, public goods funding and impact investing had a seat at the table. With ETHDenver’s ethos of regeneration, even investors discussed how to support open-source infrastructure and developers long-term, beyond just chasing the next DeFi or NFT boom. Panels like “Funding the Future: Evolving Models for Onchain Startups” explored alternatives such as grants, DAO treasury investments, and quadratic funding to supplement traditional VC money. This points to an industry maturing in how projects are capitalized – a mix of venture capital, ecosystem funds, and community funding working in tandem.

From an opportunity standpoint, Web3 professionals and investors can glean a few actionable insights from ETHDenver’s venture dynamics: (1) Infrastructure is still king – many VCs expressed that picks-and-shovels (L2 scaling, security, dev tools) remain high-value investments as the industry’s backbone. (2) New verticals like AI/blockchain convergence and DePIN are emerging investment frontiers – getting up to speed in these areas or finding startups there could be rewarding. (3) Community-driven projects and public goods might see novel funding – savvy investors are figuring out how to support these sustainably (for instance, investing in protocols that enable decentralized governance or shared ownership). Overall, ETHDenver 2025 showed that while the Web3 venture landscape is competitive, it’s brimming with conviction: capital is available for those building the future of DeFi, NFTs, gaming, and beyond, and even bear-market born ideas can find backing if they target the right trend.

Developer Resources, Toolkits, and Support Systems​

ETHDenver has always been builder-focused, and 2025 was no exception – it doubled as an open-source developer conference with a plethora of resources and support for Web3 devs. During BUIDLWeek, attendees had access to live workshops, technical bootcamps, and mini-summits spanning various domains. For example, developers could join a Bleeding Edge Tech Summit to tinker with the latest protocols, or drop into an On-Chain Legal Summit to learn about compliant smart contract development. Major sponsors and blockchain teams ran hands-on sessions: Polkadot’s team hosted hacker houses and workshops on spinning up parachains; EigenLayer led a “restaking bootcamp” to teach devs how to leverage its security layer; Polygon and zkSync gave tutorials on building scalable dApps with zero-knowledge tech. These sessions provided invaluable face-time with core engineers, allowing developers to get help with integration and learn new toolkits first-hand.

Throughout the main event, the venue featured a dedicated #BUIDLHub and Makerspace where builders could code in a collaborative environment and access mentors. ETHDenver’s organizers published a detailed BUIDLer Guide and facilitated an on-site mentorship program (experts from sponsors were available to unblock teams on technical issues). Developer tooling companies were also present en masse – from Alchemy and Infura (for blockchain APIs) to Hardhat and Foundry (for smart contract development). Many unveiled new releases or beta tools at the event. For instance, MetaMask’s team previewed a major wallet update featuring gas abstraction and an improved SDK for dApp developers, aiming to simplify how apps cover gas fees for users. Several projects launched SDKs or open-source libraries: Coinbase’s “Agent Kit” for AI agents and the collaborative Open Agents Alliance toolkit were introduced, and Story.xyz promoted its Story SDK for on-chain intellectual property licensing during their own hackathon event.

Bounties and hacker support further augmented the developer experience. With over 180 bounties offered by 62 sponsors, hackers effectively had a menu of specific challenges to choose from, each coming with documentation, office hours, and sometimes bespoke sandboxes. For example, Optimism’s bounty challenged devs to use the latest Bedrock opcodes (with their engineers on standby to assist), and Uniswap’s challenge provided access to their new API for off-ramp integration. Tools for coordination and learning – like the official ETHDenver mobile app and Discord channels – kept developers informed of schedule changes, side quests, and even job opportunities via the ETHDenver job board.

One notable resource was the emphasis on quadratic funding experiments and on-chain voting. ETHDenver integrated a quadratic voting system for hackathon judging, exposing many developers to the concept. Additionally, the presence of Gitcoin and other public goods groups meant devs could learn about grant funding for their projects after the event. In sum, ETHDenver 2025 equipped developers with cutting-edge tools (SDKs, APIs), expert guidance, and follow-on support to continue their projects. For industry professionals, it’s a reminder that nurturing the developer community – through education, tooling, and funding – is critical. Many of the resources highlighted (like new SDKs, or improved dev environments) are now publicly available, offering teams everywhere a chance to build on the shoulders of what was shared at ETHDenver.

Side Events and Community Gatherings Enriching the ETHDenver Experience​

What truly sets ETHDenver apart is its festival-like atmosphere – dozens of side events, both official and unofficial, created a rich tapestry of experiences around the main conference. In 2025, beyond the National Western Complex where official content ran, the entire city buzzed with meetups, parties, hackathons, and community gatherings. These side events, often hosted by sponsors or local Web3 groups, significantly contributed to the broader ETHDenver experience.

On the official front, ETHDenver’s own schedule included themed mini-events: the venue had zones like an NFT Art Gallery, a Blockchain Arcade, a DJ Chill Dome, and even a Zen Zone to decompress. The organizers also hosted evening events such as opening and closing parties – e.g., the “Crack’d House” unofficial opening party on Feb 26 by Story Protocol, which blended an artsy performance with hackathon award announcements. But it was the community-led side events that truly proliferated: according to an event guide, over 100 side happenings were tracked on the ETHDenver Luma calendar.

Some examples illustrate the diversity of these gatherings:

• Technical Summits & Hacker Houses: ElizaOS and EigenLayer ran a 9-day Vault AI Agent Hacker House residency for AI+Web3 enthusiasts. StarkNet’s team hosted a multi-day hacker house culminating in a demo night for projects on their ZK-rollup. These provided focused environments for developers to collaborate on specific tech stacks outside the main hackathon.
• Networking Mixers & Parties: Every evening offered a slate of choices. Builder Nights Denver on Feb 27, sponsored by MetaMask, Linea, EigenLayer, Wormhole and others, brought together innovators for casual talks over food and drink. 3VO’s Mischief Minded Club Takeover, backed by Belong, was a high-level networking party for community tokenization leaders. For those into pure fun, the BEMO Rave (with Berachain and others) and rAIve the Night (an AI-themed rave) kept the crypto crowd dancing late into the night – blending music, art, and crypto culture.
• Special Interest Gatherings: Niche communities found their space too. Meme Combat was an event purely for meme enthusiasts to celebrate the role of memes in crypto. House of Ink catered to NFT artists and collectors, turning an immersive art venue (Meow Wolf Denver) into a showcase for digital art. SheFi Summit on Feb 26 brought together women in Web3 for talks and networking, supported by groups like World of Women and Celo – highlighting a commitment to diversity and inclusion.
• Investor & Content Creator Meetups: We already touched on VC events; additionally, a KOL (Key Opinion Leaders) Gathering on Feb 28 let crypto influencers and content creators discuss engagement strategies, showing the intersection of social media and crypto communities.

Crucially, these side events weren’t just entertainment – they often served as incubators for ideas and relationships in their own right. For instance, the Tokenized Capital Summit 2025 delved into the future of capital markets on-chain, likely sparking collaborations between fintech entrepreneurs and blockchain developers in attendance. The On-Chain Gaming Hacker House provided a space for game developers to share best practices, which may lead to cross-pollination among blockchain gaming projects.

For professionals attending large conferences, ETHDenver’s model underscores that value is found off the main stage as much as on it. The breadth of unofficial programming allowed attendees to tailor their experience – whether one’s goal was to meet investors, learn a new skill, find a co-founder, or just unwind and build camaraderie, there was an event for that. Many veterans advise newcomers: “Don’t just attend the talks – go to the meetups and say hi.” In a space as community-driven as Web3, these human connections often translate into DAO collaborations, investment deals, or at the very least, lasting friendships that span continents. ETHDenver 2025’s vibrant side scene amplified the core conference, turning one week in Denver into a multi-dimensional festival of innovation.

Key Takeaways and Actionable Insights​

ETHDenver 2025 demonstrated a Web3 industry in full bloom of innovation and collaboration. For professionals in the space, several clear takeaways and action items emerge from this deep dive:

• Diversification of Trends: The event made it evident that Web3 is no longer monolithic. Emerging domains like AI integration, DePIN, and RWA tokenization are as prominent as DeFi and NFTs. Actionable insight: Stay informed and adaptable. Leaders should allocate R&D or investment into these rising verticals (e.g. exploring how AI could enhance their dApp, or how real-world assets might be integrated into DeFi platforms) to ride the next wave of growth.
• Cross-Chain is the Future: With major non-Ethereum protocols actively participating, the walls between ecosystems are lowering. Interoperability and multi-chain user experiences garnered huge attention, from MetaMask adding Bitcoin/Solana support to Polkadot and Cosmos-based chains courting Ethereum developers. Actionable insight: Design for a multi-chain world. Projects should consider integrations or bridges that tap into liquidity and users on other chains, and professionals may seek partnerships across communities rather than staying siloed.
• Community & Public Goods Matter: The “Year of the Regenerates” theme wasn’t just rhetoric – it permeated the content via public goods funding discussions, quadratic voting for hacks, and events like SheFi Summit. Ethical, sustainable development and community ownership are key values in the Ethereum ethos. Actionable insight: Incorporate regenerative principles. Whether through supporting open-source initiatives, using fair launch mechanisms, or aligning business models with community growth, Web3 companies can gain goodwill and longevity by not being purely extractive.
• Investor Sentiment – Cautious but Bold: Despite bear market murmurs, ETHDenver showed that VCs are actively scouting and willing to bet big on Web3’s next chapters. However, they are also rethinking how to invest (e.g. more strategic, perhaps more oversight on product-market fit, and openness to community funding). Actionable insight: If you’re a startup, focus on fundamentals and storytelling. The projects that stood out had clear use cases and often working prototypes (some built in a weekend!). If you’re an investor, the conference affirmed that infrastructure (L2s, security, dev tools) remains high-priority, but differentiating via theses in AI, gaming, or social can position a fund at the forefront.
• Developer Experience is Improving: ETHDenver highlighted many new toolkits, SDKs, and frameworks lowering the barrier for Web3 development – from account abstraction tools to on-chain AI libraries. Actionable insight: Leverage these resources. Teams should experiment with the latest dev tools unveiled (e.g. try out that zkSync Smart SSO for easier logins, or use the Open Agents Alliance resources for an AI project) to accelerate their development and stay ahead of the competition. Moreover, companies should continue engaging with hackathons and open developer forums as a way to source talent and ideas; ETHDenver’s success in turning hackers into founders is proof of that model.
• The Power of Side Events: Lastly, the explosion of side events taught an important lesson in networking – opportunities often appear in casual settings. A chance encounter at a happy hour or a shared interest at a small meetup can create career-defining connections. Actionable insight: For those attending industry conferences, plan beyond the official agenda. Identify side events aligned with your goals (whether it’s meeting investors, learning a niche skill, or recruiting talent) and be proactive in engaging. As seen in Denver, those who immersed themselves fully in the week’s ecosystem walked away with not just knowledge, but new partners, hires, and friends.

In conclusion, ETHDenver 2025 was a microcosm of the Web3 industry’s momentum – a blend of cutting-edge tech discourse, passionate community energy, strategic investment moves, and a culture that mixes serious innovation with fun. Professionals should view the trends and insights from the event as a roadmap for where Web3 is headed. The actionable next step is to take these learnings – whether it’s a newfound focus on AI, a connection made with an L2 team, or inspiration from a hackathon project – and translate them into strategy. In the spirit of ETHDenver’s favorite motto, it’s time to #BUIDL on these insights and help shape the decentralized future that so many in Denver came together to envision.

We're excited to share a transformative opportunity at Altera.al, a breakthrough AI startup that recently made waves with their groundbreaking work in developing digital humans. Recently featured in MIT Technology Review, Altera.al has demonstrated remarkable progress in creating AI agents that can develop humanlike behaviors, form communities, and interact meaningfully in digital spaces.

About Altera.al​

Founded by Robert Yang, who left his position as an assistant professor in computational neuroscience at MIT to pursue this vision, Altera.al has already secured over $11 million in funding from prestigious investors including A16Z and Eric Schmidt's emerging tech VC firm. Their recent Project Sid demonstration showed AI agents spontaneously developing specialized roles, forming social connections, and even creating cultural systems within Minecraft - a significant step toward their goal of creating truly autonomous AI agents that can collaborate at scale.

Why Now Is an Exciting Time to Join​

Altera.al has achieved a significant technical breakthrough in their mission to develop machines with fundamental human qualities. Their work goes beyond traditional AI development - they're creating digital beings that can:

• Form communities and social hierarchies
• Develop specialized roles and responsibilities
• Create and spread cultural patterns
• Interact meaningfully with humans in digital spaces

Who They're Looking For​

Following their recent breakthrough, Altera.al is scaling their team and offering exceptional compensation packages ranging from $600,000 to $1,000,000 for:

• Experts in AI agent research
• Strong Individual Contributors in:
  • Distributed systems
  • Security
  • Operating systems

How to Apply​

Ready to be part of this groundbreaking journey? Apply directly through their careers page: https://jobs.ashbyhq.com/altera.al

Join the Future of Digital Human Development​

This is a unique opportunity to work at the intersection of artificial intelligence and human behavior modeling, with a team that's already demonstrating remarkable results. If you're passionate about pushing the boundaries of what's possible in AI and human-machine interaction, Altera.al could be your next adventure.

For more updates on groundbreaking opportunities in tech and blockchain, follow us on Twitter or join our Discord community.

This post is part of our ongoing commitment to supporting innovation and connecting talent with transformative opportunities in the tech industry.

Every year, a16z publishes sweeping predictions on the technologies that will define our future. This time, their crypto team has painted a vivid picture of a 2025 where blockchains, AI, and advanced governance experiments collide.

I’ve summarized and commented on their key insights below, focusing on what I see as the big levers for change — and possible stumbling blocks. If you’re a tech builder, investor, or simply curious about the next wave of the internet, this piece is for you.

1. AI Meets Crypto Wallets​

Key Insight: AI models are moving from “NPCs” in the background to “main characters,” acting independently in online (and potentially physical) economies. That means they’ll need crypto wallets of their own.

• What It Means: Instead of an AI just spitting out answers, it might hold, spend, or invest digital assets — transacting on behalf of its human owner or purely on its own.
• Potential Payoff: Higher-efficiency “agentic AIs” could help businesses with supply chain coordination, data management, or automated trading.
• Watch Out For: How do we ensure an AI is truly autonomous, not just secretly manipulated by humans? Trusted execution environments (TEEs) can provide technical guarantees, but establishing trust in a “robot with a wallet” won’t happen overnight.

2. Rise of the DAC (Decentralized Autonomous Chatbot)​

Key Insight: A chatbot running autonomously in a TEE can manage its own keys, post content on social media, gather followers, and even generate revenue — all without direct human control.

• What It Means: Think of an AI influencer that can’t be silenced by any one person because it literally controls itself.
• Potential Payoff: A glimpse of a world where content creators aren’t individuals but self-governing algorithms with million-dollar (or billion-dollar) valuations.
• Watch Out For: If an AI breaks laws, who’s liable? Regulatory guardrails will be tricky when the “entity” is a set of code housed on distributed servers.

3. Proof of Personhood Becomes Essential​

Key Insight: With AI lowering the cost of generating hyper-realistic fakes, we need better ways to verify that we’re interacting with real humans online. Enter privacy-preserving unique IDs.

• What It Means: Every user might eventually have a certified “human stamp” — hopefully without sacrificing personal data.
• Potential Payoff: This could drastically reduce spam, scams, and bot armies. It also lays the groundwork for more trustworthy social networks and community platforms.
• Watch Out For: Adoption is the main barrier. Even the best proof-of-personhood solutions need broad acceptance before malicious actors outpace them.

4. From Prediction Markets to Broader Information Aggregation​

Key Insight: 2024’s election-driven prediction markets grabbed headlines, but a16z sees a bigger trend: using blockchain to design new ways of revealing and aggregating truths — be it in governance, finance, or community decisions.

• What It Means: Distributed incentive mechanisms can reward people for honest input or data. We might see specialized “truth markets” for everything from local sensor networks to global supply chains.
• Potential Payoff: A more transparent, less gameable data layer for society.
• Watch Out For: Sufficient liquidity and user participation remain challenging. For niche questions, “prediction pools” can be too small to yield meaningful signals.

5. Stablecoins Go Enterprise​

Key Insight: Stablecoins are already the cheapest way to move digital dollars, but large companies haven’t embraced them — yet.

• What It Means: SMBs and high-transaction merchants might wake up to the idea that they can save hefty credit-card fees by adopting stablecoins. Enterprises that process billions in annual revenue could do the same, potentially adding 2% to their bottom lines.
• Potential Payoff: Faster, cheaper global payments, plus a new wave of stablecoin-based financial products.
• Watch Out For: Companies will need new ways to manage fraud protection, identity verification, and refunds — previously handled by credit-card providers.

6. Government Bonds on the Blockchain​

Key Insight: Governments exploring on-chain bonds could create interest-bearing digital assets that function without the privacy issues of a central bank digital currency.

• What It Means: On-chain bonds could serve as high-quality collateral in DeFi, letting sovereign debt seamlessly integrate with decentralized lending protocols.
• Potential Payoff: Greater transparency, potentially lower issuance costs, and a more democratized bond market.
• Watch Out For: Skeptical regulators and potential inertia in big institutions. Legacy clearing systems won’t disappear easily.

7. ‘DUNA’ – The Legal Backbone for DAOs​

Key Insight: Wyoming introduced a new category called the “decentralized unincorporated nonprofit association” (DUNA), meant to give DAOs legal standing in the U.S.

• What It Means: DAOs can now hold property, sign contracts, and limit the liability of token holders. This opens the door for more mainstream usage and real commercial activity.
• Potential Payoff: If other states follow Wyoming’s lead (as they did with LLCs), DAOs will become normal business entities.
• Watch Out For: Public perception is still fuzzy on what DAOs do. They’ll need a track record of successful projects that translate to real-world benefits.

8. Liquid Democracy in the Physical World​

Key Insight: Blockchain-based governance experiments might extend from online DAO communities to local-level elections. Voters could delegate their votes or vote directly — “liquid democracy.”

• What It Means: More flexible representation. You can choose to vote on specific issues or hand that responsibility to someone you trust.
• Potential Payoff: Potentially more engaged citizens and dynamic policymaking.
• Watch Out For: Security concerns, technical literacy, and general skepticism around mixing blockchain with official elections.

9. Building on Existing Infrastructure (Instead of Reinventing It)​

Key Insight: Startups often spend time reinventing base-layer technology (consensus protocols, programming languages) rather than focusing on product-market fit. In 2025, they’ll pick off-the-shelf components more often.

• What It Means: Faster speed to market, more reliable systems, and greater composability.
• Potential Payoff: Less time wasted building a new blockchain from scratch; more time spent on the user problem you’re solving.
• Watch Out For: It’s tempting to over-specialize for performance gains. But specialized languages or consensus layers can create higher overhead for developers.

10. User Experience First, Infrastructure Second​

Key Insight: Crypto needs to “hide the wires.” We don’t make consumers learn SMTP to send email — so why force them to learn “EIPs” or “rollups”?

• What It Means: Product teams will choose the technical underpinnings that serve a great user experience, not vice versa.
• Potential Payoff: A big leap in user onboarding, reducing friction and jargon.
• Watch Out For: “Build it and they will come” only works if you truly nail the experience. Marketing lingo about “easy crypto UX” means nothing if people are still forced to wrangle private keys or memorize arcane acronyms.

11. Crypto’s Own App Stores Emerge​

Key Insight: From Worldcoin’s World App marketplace to Solana’s dApp Store, crypto-friendly platforms provide distribution and discovery free from Apple or Google’s gatekeeping.

• What It Means: If you’re building a decentralized application, you can reach users without fear of sudden deplatforming.
• Potential Payoff: Tens (or hundreds) of thousands of new users discovering your dApp in days, instead of being lost in the sea of centralized app stores.
• Watch Out For: These stores need enough user base and momentum to compete with Apple and Google. That’s a big hurdle. Hardware tie-ins (like specialized crypto phones) might help.

12. Tokenizing ‘Unconventional’ Assets​

Key Insight: As blockchain infrastructure matures and fees drop, tokenizing everything from biometric data to real-world curiosities becomes more feasible.

• What It Means: A “long tail” of unique assets can be fractionalized and traded globally. People could even monetize personal data in a controlled, consent-based way.
• Potential Payoff: Massive new markets for otherwise “locked up” assets, plus interesting new data pools for AI to consume.
• Watch Out For: Privacy pitfalls and ethical landmines. Just because you can tokenize something doesn’t mean you should.

A16Z’s 2025 outlook shows a crypto sector that’s reaching for broader adoption, more responsible governance, and deeper integration with AI. Where previous cycles dwelled on speculation or hype, this vision revolves around utility: stablecoins saving merchants 2% on every latte, AI chatbots operating their own businesses, local governments experimenting with liquid democracy.

Yet execution risk looms. Regulators worldwide remain skittish, and user experience is still too messy for the mainstream. 2025 might be the year that crypto and AI finally “grow up,” or it might be a halfway step — it all depends on whether teams can ship real products people love, not just protocols for the cognoscenti.

On November 13, 2024, 0G Labs announced a $40 million funding round led by Hack VC, Delphi Digital, OKX Ventures, Samsung Next, and Animoca Brands, thrusting the team behind this decentralized AI operating system into the spotlight. Their modular approach combines decentralized storage, data availability verification, and decentralized settlement to enable AI applications on-chain. But can they realistically achieve GB/s-level throughput to fuel the next era of AI adoption on Web3? This in-depth report evaluates 0G’s architecture, incentive mechanics, ecosystem traction, and potential pitfalls, aiming to help you gauge whether 0G can deliver on its promise.

Background​

The AI sector has been on a meteoric rise, catalyzed by large language models like ChatGPT and ERNIE Bot. Yet AI is more than just chatbots and generative text; it also includes everything from AlphaGo’s Go victories to image generation tools like MidJourney. The holy grail that many developers pursue is a general-purpose AI, or AGI (Artificial General Intelligence)—colloquially described as an AI “Agent” capable of learning, perception, decision-making, and complex execution similar to human intelligence.

However, both AI and AI Agent applications are extremely data-intensive. They rely on massive datasets for training and inference. Traditionally, this data is stored and processed on centralized infrastructure. With the advent of blockchain, a new approach known as DeAI (Decentralized AI) has emerged. DeAI attempts to leverage decentralized networks for data storage, sharing, and verification to overcome the pitfalls of traditional, centralized AI solutions.

0G Labs stands out in this DeAI infrastructure landscape, aiming to build a decentralized AI operating system known simply as 0G.

What Is 0G Labs?​

In traditional computing, an Operating System (OS) manages hardware and software resources—think Microsoft Windows, Linux, macOS, iOS, or Android. An OS abstracts away the complexity of the underlying hardware, making it easier for both end-users and developers to interact with the computer.

By analogy, the 0G OS aspires to fulfill a similar role in Web3:

• Manage decentralized storage, compute, and data availability.
• Simplify on-chain AI application deployment.

Why decentralization? Conventional AI systems store and process data in centralized silos, raising concerns around data transparency, user privacy, and fair compensation for data providers. 0G’s approach uses decentralized storage, cryptographic proofs, and open incentive models to mitigate these risks.

The name “0G” stands for “Zero Gravity.” The team envisions an environment where data exchange and computation feel “weightless”—everything from AI training to inference and data availability happens seamlessly on-chain.

The 0G Foundation, formally established in October 2024, drives this initiative. Its stated mission is to make AI a public good—one that is accessible, verifiable, and open to all.

Key Components of the 0G Operating System​

Fundamentally, 0G is a modular architecture designed specifically to support AI applications on-chain. Its three primary pillars are:

1. 0G Storage – A decentralized storage network.
2. 0G DA (Data Availability) – A specialized data availability layer ensuring data integrity.
3. 0G Compute Network – Decentralized compute resource management and settlement for AI inference (and eventually training).

These pillars work in concert under the umbrella of a Layer1 network called 0G Chain, which is responsible for consensus and settlement.

According to the 0G Whitepaper (“0G: Towards Data Availability 2.0”), both the 0G Storage and 0G DA layers build on top of 0G Chain. Developers can launch multiple custom PoS consensus networks, each functioning as part of the 0G DA and 0G Storage framework. This modular approach means that as system load grows, 0G can dynamically add new validator sets or specialized nodes to scale out.

0G Storage​

0G Storage is a decentralized storage system geared for large-scale data. It uses distributed nodes with built-in incentives for storing user data. Crucially, it splits data into smaller, redundant “chunks” using Erasure Coding (EC), distributing these chunks across different storage nodes. If a node fails, data can still be reconstructed from redundant chunks.

Supported Data Types​

0G Storage accommodates both structured and unstructured data.

1. Structured Data is stored in a Key-Value (KV) layer, suitable for dynamic and frequently updated information (think databases, collaborative documents, etc.).
2. Unstructured Data is stored in a Log layer which appends data entries chronologically. This layer is akin to a file system optimized for large-scale, append-only workloads.

By stacking a KV layer on top of the Log layer, 0G Storage can serve diverse AI application needs—from storing large model weights (unstructured) to dynamic user-based data or real-time metrics (structured).

PoRA Consensus​

PoRA (Proof of Random Access) ensures storage nodes actually hold the chunks they claim to store. Here’s how it works:

• Storage miners are periodically challenged to produce cryptographic hashes of specific random data chunks they store.
• They must respond by generating a valid hash (similar to PoW-like puzzle-solving) derived from their local copy of the data.

To level the playing field, the system limits mining competitions to 8 TB segments. A large miner can subdivide its hardware into multiple 8 TB partitions, while smaller miners compete within a single 8 TB boundary.

Incentive Design​

Data in 0G Storage is divided into 8 GB “Pricing Segments.” Each segment has both a donation pool and a reward pool. Users who wish to store data pay a fee in 0G Token (ZG), which partially funds node rewards.

• Base Reward: When a storage node submits valid PoRA proofs, it gets immediate block rewards for that segment.
• Ongoing Reward: Over time, the donation pool releases a portion (currently ~4% per year) into the reward pool, incentivizing nodes to store data permanently. The fewer the nodes storing a particular segment, the larger the share each node can earn.

Users only pay once for permanent storage, but must set a donation fee above a system minimum. The higher the donation, the more likely miners are to replicate the user’s data.

Royalty Mechanism: 0G Storage also includes a “royalty” or “data sharing” mechanism. Early storage providers create “royalty records” for each data chunk. If new nodes want to store that same chunk, the original node can share it. When the new node later proves storage (via PoRA), the original data provider receives an ongoing royalty. The more widely replicated the data, the higher the aggregate reward for early providers.

Comparisons with Filecoin and Arweave​

Similarities:

• All three incentivize decentralized data storage.
• Both 0G Storage and Arweave aim for permanent storage.
• Data chunking and redundancy are standard approaches.

Key Differences:

• Native Integration: 0G Storage is not an independent blockchain; it’s integrated directly with 0G Chain and primarily supports AI-centric use cases.
• Structured Data: 0G supports KV-based structured data alongside unstructured data, which is critical for many AI workloads requiring frequent read-write access.
• Cost: 0G claims $10–11/TB for permanent storage, reportedly cheaper than Arweave.
• Performance Focus: Specifically designed to meet AI throughput demands, whereas Filecoin or Arweave are more general-purpose decentralized storage networks.

0G DA (Data Availability Layer)​

Data availability ensures that every network participant can fully verify and retrieve transaction data. If the data is incomplete or withheld, the blockchain’s trust assumptions break.

In the 0G system, data is chunked and stored off-chain. The system records Merkle roots for these data chunks, and DA nodes must sample these chunks to ensure they match the Merkle root and erasure-coding commitments. Only then is the data deemed “available” and appended into the chain’s consensus state.

DA Node Selection and Incentives​

• DA nodes must stake ZG to participate.
• They’re grouped into quorums randomly via Verifiable Random Functions (VRFs).
• Each node only validates a subset of data. If 2/3 of a quorum confirm the data as available and correct, they sign a proof that’s aggregated and submitted to the 0G consensus network.
• Reward distribution also happens through periodic sampling. Only the nodes storing randomly sampled chunks are eligible for that round’s rewards.

Comparison with Celestia and EigenLayer​

0G DA draws on ideas from Celestia (data availability sampling) and EigenLayer (restaking) but aims to provide higher throughput. Celestia’s throughput currently hovers around 10 MB/s with ~12-second block times. Meanwhile, EigenDA primarily serves Layer2 solutions and can be complex to implement. 0G envisions GB/s throughput, which better suits large-scale AI workloads that can exceed 50–100 GB/s of data ingestion.

0G Compute Network​

0G Compute Network serves as the decentralized computing layer. It’s evolving in phases:

• Phase 1: Focus on settlement for AI inference.
• The network matches “AI model buyers” (users) with compute providers (sellers) in a decentralized marketplace. Providers register their services and prices in a smart contract. Users pre-fund the contract, consume the service, and the contract mediates payment.
• Over time, the team hopes to expand to full-blown AI training on-chain, though that’s more complex.

Batch Processing: Providers can batch user requests to reduce on-chain overhead, improving efficiency and lowering costs.

0G Chain​

0G Chain is a Layer1 network serving as the foundation for 0G’s modular architecture. It underpins:

• 0G Storage (via smart contracts)
• 0G DA (data availability proofs)
• 0G Compute (settlement mechanisms)

Per official docs, 0G Chain is EVM-compatible, enabling easy integration for dApps that require advanced data storage, availability, or compute.

0G Consensus Network​

0G’s consensus mechanism is somewhat unique. Rather than a single monolithic consensus layer, multiple independent consensus networks can be launched under 0G to handle different workloads. These networks share the same staking base:

• Shared Staking: Validators stake ZG on Ethereum. If a validator misbehaves, their staked ZG on Ethereum can be slashed.
• Scalability: New consensus networks can be spun up to scale horizontally.

Reward Mechanism: When validators finalize blocks in the 0G environment, they receive tokens. However, the tokens they earn on 0G Chain are burned in the local environment, and the validator’s Ethereum-based account is minted an equivalent amount, ensuring a single point of liquidity and security.

0G Token (ZG)​

ZG is an ERC-20 token representing the backbone of 0G’s economy. It’s minted, burned, and circulated via smart contracts on Ethereum. In practical terms:

• Users pay for storage, data availability, and compute resources in ZG.
• Miners and validators earn ZG for proving storage or validating data.
• Shared staking ties the security model back to Ethereum.

Summary of Key Modules​

0G OS merges four components—Storage, DA, Compute, and Chain—into one interconnected, modular stack. The system’s design goal is scalability, with each layer horizontally extensible. The team touts the potential for “infinite” throughput, especially crucial for large-scale AI tasks.

0G Ecosystem​

Although relatively new, the 0G ecosystem already includes key integration partners:

1. Infrastructure & Tooling:

   • ZK solutions like Union, Brevis, Gevulot
   • Cross-chain solutions like Axelar
   • Restaking protocols like EigenLayer, Babylon, PingPong
   • Decentralized GPU providers IoNet, exaBits
   • Oracle solutions Hemera, Redstone
   • Indexing tools for Ethereum blob data

2. Projects Using 0G for Data Storage & DA:

   • Polygon, Optimism (OP), Arbitrum, Manta for L2 / L3 integration
   • Nodekit, AltLayer for Web3 infrastructure
   • Blade Games, Shrapnel for on-chain gaming

Supply Side​

ZK and Cross-chain frameworks connect 0G to external networks. Restaking solutions (e.g., EigenLayer, Babylon) strengthen security and possibly attract liquidity. GPU networks accelerate erasure coding. Oracle solutions feed off-chain data or reference AI model pricing.

Demand Side​

AI Agents can tap 0G for both data storage and inference. L2s and L3s can integrate 0G’s DA to improve throughput. Gaming and other dApps requiring robust data solutions can store assets, logs, or scoring systems on 0G. Some have already partnered with the project, pointing to early ecosystem traction.

Roadmap & Risk Factors​

0G aims to make AI a public utility, accessible and verifiable by anyone. The team aspires to GB/s-level DA throughput—crucial for real-time AI training that can demand 50–100 GB/s of data transfer.

Co-founder & CEO Michael Heinrich has stated that the explosive growth of AI makes timely iteration critical. The pace of AI innovation is fast; 0G’s own dev progress must keep up.

Potential Trade-Offs:

• Current reliance on shared staking might be an intermediate solution. Eventually, 0G plans to introduce a horizontally scalable consensus layer that can be incrementally augmented (akin to spinning up new AWS nodes).
• Market Competition: Many specialized solutions exist for decentralized storage, data availability, and compute. 0G’s all-in-one approach must stay compelling.
• Adoption & Ecosystem Growth: Without robust developer traction, the promised “unlimited throughput” remains theoretical.
• Sustainability of Incentives: Ongoing motivation for nodes depends on real user demand and an equilibrium token economy.

Conclusion​

0G attempts to unify decentralized storage, data availability, and compute into a single “operating system” supporting on-chain AI. By targeting GB/s throughput, the team seeks to break the performance barrier that currently deters large-scale AI from migrating on-chain. If successful, 0G could significantly accelerate the Web3 AI wave by providing a scalable, integrated, and developer-friendly infrastructure.

Still, many open questions remain. The viability of “infinite throughput” hinges on whether 0G’s modular consensus and incentive structures can seamlessly scale. External factors—market demand, node uptime, developer adoption—will also determine 0G’s staying power. Nonetheless, 0G’s approach to addressing AI’s data bottlenecks is novel and ambitious, hinting at a promising new paradigm for on-chain AI.

Introduction​

Decentralized Physical Infrastructure Networks (DePIN) are blockchain-based projects that incentivize people to deploy real-world hardware in exchange for crypto tokens. By leveraging idle or underutilized resources – from wireless radios to hard drives and GPUs – DePIN projects create crowdsourced networks providing tangible services (connectivity, storage, computing, etc.). This model transforms normally idle infrastructure (like unused bandwidth, disk space, or GPU power) into active, income-generating networks by rewarding contributors with tokens. Major early examples include Helium (crowdsourced wireless networks) and Filecoin (distributed data storage), and newer entrants target GPU computing and 5G coverage sharing (e.g. Render Network, Akash, io.net).

DePIN’s promise lies in distributing the costs of building and operating physical networks via token incentives, thus scaling networks faster than traditional centralized models. In practice, however, these projects must carefully design economic models to ensure that token incentives translate into real service usage and sustainable value. Below, we analyze the economic models of key DePIN networks, evaluate how effectively token rewards have driven actual infrastructure use, and assess how these projects are coupling with the booming demand for AI-related compute.

Economic Models of Leading DePIN Projects​

Helium (Decentralized Wireless IoT & 5G)​

Helium pioneered a decentralized wireless network by incentivizing individuals to deploy radio hotspots. Initially focused on IoT (LoRaWAN) and later expanded to 5G small-cell coverage, Helium’s model centers on its native token HNT. Hotspot operators earn HNT by participating in Proof-of-Coverage (PoC) – essentially proving they are providing wireless coverage in a given location. In Helium’s two-token system, HNT has utility through Data Credits (DC): users must burn HNT to mint non-transferable DC, which are used to pay for actual network usage (device connectivity) at a fixed rate of $0.0001 per 24 bytes. This burn mechanism creates a burn-and-mint equilibrium where increased network usage (DC spending) leads to more HNT being burned, reducing supply over time.

Originally, Helium operated on its own blockchain with an inflationary issuance of HNT that halved every two years (yielding a gradually decreasing supply and an eventual max around ~223 million HNT in circulation). In 2023, Helium migrated to Solana and introduced a “network of networks” framework with sub-DAOs. Now, Helium’s IoT network and 5G mobile network each have their own tokens (IOT and MOBILE respectively) rewarded to hotspot operators, while HNT remains the central token for governance and value. HNT can be redeemed for subDAO tokens (and vice versa) via treasury pools, and HNT is also used for staking in Helium’s veHNT governance model. This structure aims to align incentives in each sub-network: for example, 5G hotspot operators earn MOBILE tokens, which can be converted to HNT, effectively tying rewards to the success of that specific service.

Economic value creation: Helium’s value is created by providing low-cost wireless access. By distributing token rewards, Helium offloaded the capex of network deployment onto individuals who purchased and ran hotspots. In theory, as businesses and IoT devices use the network (by spending DC that require burning HNT), that demand should support HNT’s value and fund ongoing rewards. Helium sustains its economy through a burn-and-spend cycle: network users buy HNT (or use HNT rewards) and burn it for DC to use the network, and the protocol mints HNT (according to a fixed schedule) to pay hotspot providers. In Helium’s design, a portion of HNT emissions was also allocated to founders and a community reserve, but the majority has always been for hotspot operators as an incentive to build coverage. As discussed later, Helium’s challenge has been getting enough paying demand to balance the generous supply-side incentives.

Filecoin (Decentralized Storage Network)​

Filecoin is a decentralized storage marketplace where anyone can contribute disk space and earn tokens for storing data. Its economic model is built around the FIL token. Filecoin’s blockchain rewards storage providers (miners) with FIL block rewards for provisioning storage and correctly storing clients’ data – using cryptographic proofs (Proof-of-Replication and Proof-of-Spacetime) to verify data is stored reliably. Clients, in turn, pay FIL to miners to have their data stored or retrieved, negotiating prices in an open market. This creates an incentive loop: miners invest in hardware and stake FIL collateral (to guarantee service quality), earning FIL rewards for adding storage capacity and fulfilling storage deals, while clients spend FIL for storage services.

Filecoin’s token distribution is heavily weighted toward incentivizing storage supply. FIL has a maximum supply of 2 billion, with 70% reserved for mining rewards. (In fact, ~1.4 billion FIL are allocated to be released over time as block rewards to storage miners over many years.) The remaining 30% was allocated to stakeholders: 15% to Protocol Labs (the founding team), 10% to investors, and 5% to the Filecoin Foundation. Block reward emissions follow a somewhat front-loaded schedule (with a six-year half-life), meaning supply inflation was highest in the early years to quickly bootstrap a large storage network. To balance this, Filecoin requires miners to lock up FIL as collateral for each gigabyte of data they pledge to store – if they fail to prove the data is retained, they can be penalized (slashed) by losing some collateral. This mechanism aligns miner incentives with reliable service.

Economic value creation: Filecoin creates value by offering censorship-resistant, redundant data storage at potentially lower costs than centralized cloud providers. The FIL token’s value is tied to demand for storage and the utility of the network: clients must obtain FIL to pay for storing data, and miners need FIL (both for collateral and often to cover costs or as revenue). Initially, much of Filecoin’s activity was driven by miners racing to earn tokens – even storing zero-value or duplicated data just to increase their storage power and earn block rewards. To encourage useful storage, Filecoin introduced the Filecoin Plus program: clients with verified useful data (e.g. open datasets, archives) can register deals as “verified,” which gives miners 10× the effective power for those deals, translating into proportionally larger FIL rewards. This has incentivized miners to seek out real clients and has dramatically increased useful data stored on the network. By late 2023, Filecoin’s network had grown to about 1,800 PiB of active deals, up 3.8× year-over-year, with storage utilization rising to ~20% of total capacity (from only ~3% at the start of 2023). In other words, token incentives bootstrapped enormous capacity, and now a growing fraction of that capacity is being filled by paying customers – a sign of the model beginning to sustain itself with real demand. Filecoin is also expanding into adjacent services (see AI Compute Trends below), which could create new revenue streams (e.g. decentralized content delivery and compute-over-data services) to bolster the FIL economy beyond simple storage fees.

Render Network (Decentralized GPU Rendering & Compute)​

Render Network is a decentralized marketplace for GPU-based computation, originally focused on rendering 3D graphics and now also supporting AI model training/inference jobs. Its native token RNDR (recently updated to the ticker RENDER on Solana) powers the economy. Creators (users who need GPU work done) pay in RNDR for rendering or compute tasks, and Node Operators (GPU providers) earn RNDR by completing those jobs. This basic model turns idle GPUs (from individual GPU owners or data centers) into a distributed cloud rendering farm. To ensure quality and fairness, Render uses escrow smart contracts: clients submit jobs and burn the equivalent RNDR payment, which is held until node operators submit proof of completing the work, then the RNDR is released as reward. Originally, RNDR functioned as a pure utility/payment token, but the network has recently overhauled its tokenomics to a Burn-and-Mint Equilibrium (BME) model to better balance supply and demand.

Under the BME model, all rendering or compute jobs are priced in stable terms (USD) and paid in RENDER tokens, which are **burned upon job completion. In parallel, the protocol mints new RENDER tokens on a predefined declining emissions schedule to compensate node operators and other participants. In effect, user payments for work destroy tokens while the network inflates tokens at a controlled rate as mining rewards – the net supply can increase or decrease over time depending on usage. The community approved an initial emission of ~9.1 million RENDER in the first year of BME (mid-2023 to mid-2024) as network incentives, and set a long-term max supply of about 644 million RENDER (up from the initial 536.9 million RNDR that were minted at launch). Notably, RENDER’s token distribution heavily favored ecosystem growth: 65% of the initial supply was allocated to a treasury (for future network incentives), 25% to investors, and 10% to team/advisors. With BME, that treasury is being deployed via the controlled emissions to reward GPU providers and other contributors, while the burn mechanism ties those rewards directly to platform usage. RNDR also serves as a governance token (token holders can vote on Render Network proposals). Additionally, node operators on Render can stake RNDR to signal their reliability and potentially receive more work, adding another incentive layer.

Economic value creation: Render Network creates value by supplying on-demand GPU computing at a fraction of the cost of traditional cloud GPU instances. By late 2023, Render’s founder noted that studios had already used the network to render movie-quality graphics with significant cost and speed advantages – “one tenth the cost” and with massive aggregated capacity beyond any single cloud provider. This cost advantage is possible because Render taps into dormant GPUs globally (from hobbyist rigs to pro render farms) that would otherwise be idle. With rising demand for GPU time (for both graphics and AI), Render’s marketplace meets a critical need. Crucially, the BME token model means token value is directly linked to service usage: as more rendering and AI jobs flow through the network, more RENDER is burned (creating buy pressure or reducing supply), while node incentives scale up only as those jobs are completed. This helps avoid “paying for nothing” – if network usage stagnates, the token emissions eventually outpace burns (inflating supply), but if usage grows, the burns can offset or even exceed emissions, potentially making the token deflationary while still rewarding operators. The strong interest in Render’s model was reflected in the market: RNDR’s price rocketed in 2023, rising over 1,000% in value as investors anticipated surging demand for decentralized GPU services amid the AI boom. Backed by OTOY (a leader in cloud rendering software) and used in production by some major studios, Render Network is positioned as a key player at the intersection of Web3 and high-performance computing.

Akash Network (Decentralized Cloud Compute)​

Akash is a decentralized cloud computing marketplace that enables users to rent general compute (VMs, containers, etc.) from providers with spare server capacity. Think of it as a decentralized alternative to AWS or Google Cloud, powered by a blockchain-based reverse auction system. The native token AKT is central to Akash’s economy: clients pay for compute leases in AKT, and providers earn AKT for supplying resources. Akash is built on the Cosmos SDK and uses a delegated Proof-of-Stake blockchain for security and coordination. AKT thus also functions as a staking and governance token – validators stake AKT (and users delegate AKT to validators) to secure the network and earn staking rewards.

Akash’s marketplace operates via a bidding system: a client defines a deployment (CPU, RAM, storage, possibly GPU requirements) and a max price, and multiple providers can bid to host it, driving the price down. Once the client accepts a bid, a lease is formed and the workload runs on the chosen provider’s infrastructure. Payments for leases are handled by the blockchain: the client escrows AKT and it streams to the provider over time for as long as the deployment is active. Uniquely, the Akash network charges a protocol “take rate” fee on each lease to fund the ecosystem and reward AKT stakers: 10% of the lease amount if paid in AKT (or 20% if paid in another currency) is diverted as fees to the network treasury and stakers. This means AKT stakers earn a portion of all usage, aligning the token’s value with actual demand on the platform. To improve usability for mainstream users, Akash has integrated stablecoin and credit card payments (via its console app): a client can pay in USD stablecoin, which under the hood is converted to AKT (with a higher fee rate). This reduces the volatility risk for users while still driving value to the AKT token (since those stablecoin payments ultimately result in AKT being bought/burned or distributed to stakers).

On the supply side, AKT’s tokenomics are designed to incentivize long-term participation. Akash began with 100 million AKT at genesis and has a max supply of 389 million via inflation. The inflation rate is adaptive based on the proportion of AKT staked: it targets 20–25% annual inflation if the staking ratio is low, and around 15% if a high percentage of AKT is staked. This adaptive inflation (a common design in Cosmos-based chains) encourages holders to stake (contributing to network security) by rewarding them more when staking participation is low. Block rewards from inflation pay validators and delegators, as well as funding a reserve for ecosystem growth. AKT’s initial distribution set aside allocations for investors, the core team (Overclock Labs), and a foundation pool for ecosystem incentives (e.g. an early program in 2024 funded GPU providers to join).

Economic value creation: Akash creates value by offering cloud computing at potentially much lower costs than incumbent cloud providers, leveraging underutilized servers around the world. By decentralizing the cloud, it also aims to fill regional gaps and reduce reliance on a few big tech companies. The AKT token accrues value from multiple angles: demand-side fees (more workloads = more AKT fees flowing to stakers), supply-side needs (providers may hold or stake earnings, and need to stake some AKT as collateral for providing services), and general network growth (AKT is needed for governance and as a reserve currency in the ecosystem). Importantly, as more real workloads run on Akash, the proportion of AKT in circulation that is used for staking and fee deposits should increase, reflecting real utility. Initially, Akash saw modest usage for web services and crypto infrastructure hosting, but in late 2023 it expanded support for GPU workloads – making it possible to run AI training, machine learning, and high-performance compute jobs on the network. This has significantly boosted Akash’s usage in 2024. By Q3 2024, the network’s metrics showed explosive growth: the number of active deployments (“leases”) grew 1,729% year-on-year, and the average fee per lease (a proxy for complexity of workloads) rose 688%. In practice, this means users are deploying far more applications on Akash and are willing to run larger, longer workloads (many involving GPUs) – evidence that token incentives have attracted real paying demand. Akash’s team reported that by the end of 2024, the network had over 700 GPUs online with ~78% utilization (i.e. ~78% of GPU capacity rented out at any time). This is a strong signal of efficient token incentive conversion (see next section). The built-in fee-sharing model also means that as this usage grows, AKT stakers receive protocol revenue, effectively tying token rewards to actual service revenue – a healthier long-term economic design.

io.net (Decentralized GPU Cloud for AI)​

io.net is a newer entrant (built on Solana) aiming to become the “world’s largest GPU network” specifically geared toward AI and machine learning workloads. Its economic model draws lessons from earlier projects like Render and Akash. The native token IO has a fixed maximum supply of 800 million. At launch, 500 million IO were pre-minted and allocated to various stakeholders, and the remaining 300 million IO are being emitted as mining rewards over a 20-year period (distributed hourly to GPU providers and stakers). Notably, io.net implements a revenue-based burn mechanism: a portion of network fees/revenue is used to burn IO tokens, directly tying token supply to platform usage. This combination – a capped supply with time-released emissions and a burn driven by usage – is intended to ensure long-term sustainability of the token economy.

To join the network as a GPU node, providers are required to stake a minimum amount of IO as collateral. This serves two purposes: it deters malicious or low-quality nodes (as they have “skin in the game”), and it reduces immediate sell pressure from reward tokens (since nodes must lock up some tokens to participate). Stakers (which can include both providers and other participants) also earn a share of network rewards, aligning incentives across the ecosystem. On the demand side, customers (AI developers, etc.) pay for GPU compute on io.net, presumably in IO tokens or possibly stable equivalents – the project claims to offer cloud GPU power at up to 90% lower cost than traditional providers like AWS. These usage fees drive the burn mechanism: as revenue flows in, a portion of tokens get burned, linking platform success to token scarcity.

Economic value creation: io.net’s value proposition is aggregating GPU power from many sources (data centers, crypto miners repurposing mining rigs, etc.) into a single network that can deliver on-demand compute for AI at massive scale. By aiming to onboard over 1 million GPUs globally, io.net seeks to out-scale any single cloud and meet the surging demand for AI model training and inference. The IO token captures value through a blend of mechanisms: supply is limited (so token value can grow if demand for network services grows), usage burns tokens (directly creating value feedback to the token from service revenue), and token rewards bootstrap supply (gradually distributing tokens to those who contribute GPUs, ensuring the network grows). In essence, io.net’s economic model is a refined DePIN approach where supply-side incentives (hourly IO emissions) are substantial but finite, and they are counter-balanced by token sinks (burns) that scale with actual usage. This is designed to avoid the trap of excessive inflation with no demand. As we will see, the AI compute trend provides a large and growing market for networks like io.net to tap into, which could drive the desired equilibrium where token incentives lead to robust service usage. (io.net is still emerging, so its real-world metrics remain to be proven, but its design clearly targets the AI compute sector’s needs.)

Table 1: Key Economic Model Features of Selected DePIN Projects

Sources: Official documentation and research for each project (see inline citations above).

Token Incentives vs. Real-World Service Usage​

A critical question for DePIN projects is how effectively token incentives convert into real service provisioning and actual usage of the network. In the initial stages, many DePIN protocols emphasized bootstrapping supply (hardware deployment) through generous token rewards, even if demand was minimal – a “build it and (hopefully) they will come” strategy. This led to situations where the network’s market cap and token emissions far outpaced the revenue from customers. As of late 2024, the entire DePIN sector (~350 projects) had a combined market cap of ~$50 billion, yet generated only about ~$0.5 billion annualized revenue – an aggregate valuation of ~100× annual revenue. Such a gap underscores the inefficiency in early stages. However, recent trends show improvements as networks shift from purely supply-driven growth to demand-driven adoption, especially propelled by the surge in AI compute needs.

Below we evaluate each example project’s token incentive efficiency, looking at usage metrics versus token outlays:

• Helium: Helium’s IoT network grew explosively in 2021–2022, with nearly 1 million hotspots deployed globally for LoRaWAN coverage. This growth was almost entirely driven by the HNT mining incentives and crypto enthusiasm – not by customer demand for IoT data, which remained low. By mid-2022, it became clear that Helium’s data traffic (devices actually using the network) was minuscule relative to the enormous supply-side investment. One analysis in 2022 noted that less than $1,000 of tokens were burned for data usage per month, even as the network was minting tens of millions of dollars worth of HNT for hotspot rewards – a stark imbalance (essentially, <1% of token emission was being offset by network usage). In late 2022 and 2023, HNT token rewards underwent scheduled halvings (reducing issuance), but usage was still lagging. An example from November 2023: the dollar value of Helium Data Credits burned was only about $156 for that day – whereas the network was still paying out an estimated $55,000 per day in token rewards to hotspot owners (valued in USD). In other words, that day’s token incentive “cost” outweighed actual network usage by a factor of 350:1. This illustrates the poor incentive-to-usage conversion in Helium’s early IoT phase. Helium’s founders recognized this “chicken-and-egg” dilemma: a network needs coverage before it can attract users, but without users the coverage is hard to monetize.

  There are signs of improvement. In late 2023, Helium activated its 5G Mobile network with a consumer-facing cell service (backed by T-Mobile roaming) and began rewarding 5G hotspot operators in MOBILE tokens. The launch of Helium Mobile (5G) quickly brought in paying users (e.g. subscribers to Helium’s $20/month unlimited mobile plan) and new types of network usage. Within weeks, Helium’s network usage jumped – by early 2024, the daily Data Credit burn reached ~$4,300 (up from almost nothing a couple months prior). Moreover, 92% of all Data Credits consumed were from the Mobile network (5G) as of Q1 2024, meaning the 5G service immediately dwarfed the IoT usage. While $4.3k/day is still modest in absolute terms (~$1.6 million annualized), it represents a meaningful step toward real revenue. Helium’s token model is adapting: by isolating the IoT and Mobile networks into separate reward tokens, it ensures that the 5G rewards (MOBILE tokens) will scale down if 5G usage doesn’t materialize, and similarly for IOT tokens – effectively containing the inefficiency. Helium Mobile’s growth also showed the power of coupling token incentives with a service of immediate consumer interest (cheap cellular data). Within 6 months of launch, Helium had ~93,000 MOBILE hotspots deployed in the US (alongside ~1 million IoT hotspots worldwide), and had struck partnerships (e.g. with Telefónica) to expand coverage. The challenge ahead is to substantially grow the user base (both IoT device clients and 5G subscribers) so that burning of HNT for Data Credits approaches the scale of HNT issuance. In summary, Helium started with an extreme supply surplus (and correspondingly overvalued token), but its pivot toward demand (5G, and positioning as an “infrastructure layer” for other networks) is gradually improving the efficiency of its token incentives.

• Filecoin: In Filecoin’s case, the imbalance was between storage capacity vs. actual stored data. Token incentives led to an overabundance of supply: at its peak, the Filecoin network had well over 15 exbibytes (EiB) of raw storage capacity pledged by miners, yet for a long time only a few percent of that was utilized by real data. Much of the space was filled with dummy data (clients could even store random garbage data to satisfy proof requirements) just so miners could earn FIL rewards. This meant a lot of FIL was being minted and awarded for storage that wasn’t actually demanded by users. However, over 2022–2023 the network made big strides in driving demand. Through initiatives like Filecoin Plus and aggressive onboarding of open datasets, the utilization rate climbed from ~3% to over 20% of capacity in 2023. By Q4 2024, Filecoin’s storage utilization had further risen to ~30% – meaning nearly one-third of the enormous capacity was holding real client data. This is still far from 100%, but the trend is positive: token rewards are increasingly going toward useful storage rather than empty padding. Another measure: as of Q1 2024, about 1,900 PiB (1.9 EiB) of data was stored in active deals on Filecoin, a 200% year-over-year increase. Notably, the majority of new deals now come via Filecoin Plus (verified clients), indicating miners strongly prefer to devote space to data that earns them bonus reward multipliers.

  In terms of economic efficiency, Filecoin’s protocol also experienced a shift: initially, protocol “revenue” (fees paid by users) was negligible compared to mining rewards (which some analyses treated as revenue, inflating early figures). For example, in 2021, Filecoin’s block rewards were worth hundreds of millions of dollars (at high FIL prices), but actual storage fees were tiny; in 2022, as FIL price fell, reported revenue dropped 98% from $596M to $13M, reflecting that most of 2021’s “revenue” was token issuance value rather than customer spend. Going forward, the balance is improving: the pipeline of paying storage clients is growing (e.g. an enterprise deal of 1 PiB was closed in late 2023, one of the first large fully-paid deals). Filecoin’s introduction of the FVM (enabling smart contracts) and forthcoming storage marketplaces and DEXes are expected to bring more on-chain fee activity (and possibly FIL burns or lockups). In summary, Filecoin’s token incentives successfully built a massive global storage network, albeit with efficiency under 5% in the early period; by 2024 that efficiency improved to ~20–30% and is on track to climb further as real demand catches up with the subsidized supply. The sector’s overall demand for decentralized storage (Web3 data, archives, NFT metadata, AI datasets, etc.) appears to be rising, which bodes well for converting more of those mining rewards into actual useful service.

• Render Network: Render’s token model inherently links incentives to usage more tightly, thanks to the burn-and-mint equilibrium. In the legacy model (pre-2023), RNDR issuance was largely in the hands of the foundation and based on network growth goals, while usage involved locking up RNDR in escrow for jobs. This made it a bit difficult to analyze efficiency. However, with BME fully implemented in 2023, we can measure how many tokens are burned relative to minted. Since each rendering or compute job burns RNDR proportional to its cost, essentially every token emitted as a reward corresponds to work done (minus any net inflation if emissions > burns in a given epoch). Early data from the Render network post-upgrade indicated that usage was indeed ramping up: the Render Foundation noted that at “peak moments” the network could be completing more render frames per second than Ethereum could handle in transactions, underscoring significant activity. While detailed usage stats (e.g. number of jobs or GPU-hours consumed) aren’t public in the snippet above, one strong indicator is the price and demand for RNDR. In 2023, RNDR became one of the best-performing crypto assets, rising from roughly $0.40 in January to over $2.50 by May, and continuing to climb thereafter. By November 2023, RNDR was up over 10× year-to-date, propelled by the frenzy for AI-related computing power. This price action suggests that users were buying RNDR to get rendering and AI jobs done (or speculators anticipated they would need to). Indeed, the interest in AI tasks likely brought a new wave of demand – Render reported that its network was expanding beyond media rendering into AI model training, and that the GPU shortage in traditional clouds meant demand far outstripped supply in this niche. In essence, Render’s token incentives (the emissions) have been met with equally strong user demand (burns), making its incentive-to-usage conversion relatively high. It’s worth noting that in the first year of BME, the network intentionally allocated some extra tokens (the 9.1M RENDER emissions) to bootstrap node operator earnings. If those outpace usage, it could introduce some temporary inflationary inefficiency. However, given the network’s growth, the burn rate of RNDR has been climbing. The Render Network Dashboard as of mid-2024 showed steady increases in cumulative RNDR burned, indicating real jobs being processed. Another qualitative sign of success: major studios and content creators have used Render for high-profile projects, proving real-world adoption (these are not just crypto enthusiasts running nodes – they are customers paying for rendering). All told, Render appears to have one of the more effective token-to-service conversion metrics in DePIN: if the network is busy, RNDR is being burned and token holders see tangible value; if the network were idle, token emissions would be the only output, but the excitement around AI has ensured the network is far from idle.

• Akash: Akash’s efficiency can be seen in the context of cloud spend vs. token issuance. As a proof-of-stake chain, Akash’s AKT has inflation to reward validators, but that inflation is not excessively high (and a large portion is offset by staking locks). The more interesting part is how much real usage the token is capturing. In 2022, Akash usage was relatively low (only a few hundred deployments at any time, mainly small apps or test nets). This meant AKT’s value was speculative, not backed by fees. However, in 2023–2024, usage exploded due to AI. By late 2024, Akash was processing ~$11k of spend per day on its network, up from just ~$1.3k/day in January 2024 – a ~749% increase in daily revenue within the year. Over the course of 2024, Akash surpassed $1.6 million in cumulative paid spend for compute. These numbers, while still small compared to giants like AWS, represent actual customers deploying workloads on Akash and paying in AKT or USDC (which ultimately drives AKT demand via conversion). The token incentives (inflationary rewards) during that period were on the order of maybe 15–20% of the 130M circulating AKT (~20–26M AKT minted in 2024, which at $1–3 per AKT might be $20–50M value). So in pure dollar terms, the network was still issuing more value in tokens than it was bringing in fees – similar to other early-stage networks. But the trend is that usage is catching up fast. A telling statistic: comparing Q3 2024 to Q3 2023, the average fee per lease rose from $6.42 to $18.75. This means users are running much more resource-intensive (and thus expensive) workloads, likely GPUs for AI, and they are willing to pay more, presumably because the network delivers value (e.g. lower cost than alternatives). Also, because Akash charges a 10–20% fee on leases to the protocol, that means 10–20% of that $1.6M cumulative spend went to stakers as real yield. In Q4 2024, AKT’s price hit new multi-year highs (~$4, an 8× increase from mid-2023 lows), indicating the market recognized the improved fundamentals and usage. On-chain data from year-end 2024 showed over 650 active leases and over 700 GPUs in the network with ~78% utilization – effectively, most of the GPUs added via incentives were actually in use by customers. This is a strong conversion of token incentives into service: nearly 4 out of 5 GPUs incentivized were serving AI developers (for model training, etc.). Akash’s proactive steps, like enabling credit card payments and supporting popular AI frameworks, helped bridge crypto tokens to real-world users (some users might not even know they are paying for AKT under the hood). Overall, while Akash initially had the common DePIN issue of “supply > demand,” it is quickly moving toward a more balanced state. If AI demand continues, Akash could even approach a regime where demand outstrips the token incentives – in other words, usage might drive AKT’s value more than speculative inflation. The protocol’s design to share fees with stakers also means AKT holders benefit directly as efficiency improves (e.g. by late 2024, stakers were earning significant yield from actual fees, not just inflation).

• io.net: Being a very new project (launched in 2023/24), io.net’s efficiency is still largely theoretical, but its model is built explicitly to maximize incentive conversion. By hard-capping supply and instituting hourly rewards, io.net avoids the scenario of runaway indefinite inflation. And by burning tokens based on revenue, it ensures that as soon as demand kicks in, there is an automatic counterweight to token emissions. Early reports claimed io.net had aggregated a large number of GPUs (possibly by bringing existing mining farms and data centers on board), giving it significant supply to offer. The key will be whether that supply finds commensurate demand from AI customers. One positive sign for the sector: as of 2024, decentralized GPU networks (including Render, Akash, and io.net) were often capacity-constrained, not demand-constrained – meaning there was more user demand for compute than the networks had online at any moment. If io.net taps into that unmet demand (offering lower prices or unique integrations via Solana’s ecosystem), its token burn could accelerate. On the flip side, if it distributed a large chunk of the 500M IO initial supply to insiders or providers, there is a risk of sell pressure if usage lags. Without concrete usage data yet, io.net serves as a test of the refined tokenomic approach: it targets a demand-driven equilibrium from the outset, trying to avoid oversupplying tokens. In coming years, one can measure its success by tracking what percentage of the 300M emission gets effectively “paid for” by network revenue (burns). The DePIN sector’s evolution suggests io.net is entering at a fortuitous time when AI demand is high, so it may reach high utilization more quickly than earlier projects did.

In summary, early DePIN projects often faced low token incentive efficiency, with token payouts vastly exceeding real usage. Helium’s IoT network was a prime example, where token rewards built a huge network that was only a few percent utilized. Filecoin similarly had a bounty of storage with little stored data initially. However, through network improvements and external demand trends, these gaps are closing. Helium’s 5G pivot multiplied usage, Filecoin’s utilization is steadily climbing, and both Render and Akash have seen real usage surge in tandem with the AI boom, bringing their token economics closer to a sustainable loop. A general trend in 2024 was the shift to “prove the demand”: DePIN teams started focusing on getting users and revenue, not just hardware and hype. This is evidenced by networks like Helium courting enterprise partners for IoT and telco, Filecoin onboarding large Web2 datasets, and Akash making its platform user-friendly for AI developers. The net effect is that token values are increasingly underpinned by fundamentals (e.g. data stored, GPU hours sold) rather than just speculation. While there is still a long way to go – the sector overall at 100× price/revenue implies plenty of speculation remains – the trajectory is towards more efficient use of token incentives. Projects that fail to translate tokens into service (or “hardware on the ground”) will likely fade, while those that achieve a high conversion rate are gaining investor and community confidence.

Coupling with AI Compute Demand: Trends and Opportunities​

One of the most significant developments benefiting DePIN projects is the explosive growth in AI computing demand. The year 2023–2024 saw AI model training and deployment become a multi-billion-dollar market, straining the capacity of traditional cloud providers and GPU vendors. Decentralized infrastructure networks have quickly adapted to capture this opportunity, leading to a convergence sometimes dubbed “DePIN x AI” or even “Decentralized Physical AI (DePAI)” by futurists. Below, we outline how our focus projects and the broader DePIN sector are leveraging the AI trend:

• Decentralized GPU Networks & AI: Projects like Render, Akash, io.net (and others such as Golem, Vast.ai, etc.) are at the forefront of serving AI needs. As noted, Render expanded beyond rendering to support AI workloads – e.g. renting GPU power to train Stable Diffusion models or other ML tasks. Interest in AI has directly driven usage on these networks. In mid-2023, demand for GPU compute to train image and language models skyrocketed. Render Network benefited as many developers and even some enterprises turned to it for cheaper GPU time; this was a factor in RNDR’s 10× price surge, reflecting the market’s belief that Render would supply GPUs to meet AI needs. Similarly, Akash’s GPU launch in late 2023 coincided with the generative AI boom – within months, hundreds of GPUs on Akash were being rented to fine-tune language models or serve AI APIs. The utilization rate of GPUs on Akash reaching ~78% by year-end 2024 indicates that nearly all incentivized hardware found demand from AI users. io.net is explicitly positioning itself as an “AI-focused decentralized computing network”. It touts integration with AI frameworks (they mention using the Ray distributed compute framework, popular in machine learning, to make it easy for AI developers to scale on io.net). Io.net’s value proposition – being able to deploy a GPU cluster in 90 seconds at 10–20× efficiency of cloud – is squarely aimed at AI startups and researchers who are constrained by expensive or backlogged cloud GPU instances. This targeting is strategic: 2024 saw extreme GPU shortages (e.g. NVIDIA’s high-end AI chips were sold out), and decentralized networks with access to any kind of GPU (even older models or gaming GPUs) stepped in to fill the gap. The World Economic Forum noted the emergence of “Decentralized Physical AI (DePAI)” where everyday people contribute computing power and data to AI processes and get rewarded. This concept aligns with GPU DePIN projects enabling anyone with a decent GPU to earn tokens by supporting AI workloads. Messari’s research likewise highlighted that the intense demand from the AI industry in 2024 has been a “significant accelerator” for the DePIN sector’s shift to demand-driven growth.

• Storage Networks & AI Data: The AI boom isn’t just about computation – it also requires storing massive datasets (for training) and distributing trained models. Decentralized storage networks like Filecoin and Arweave have found new use cases here. Filecoin in particular has embraced AI as a key growth vector: in 2024 the Filecoin community identified “Compute and AI” as one of three focus areas. With the launch of the Filecoin Virtual Machine, it’s now possible to run compute services close to the data stored on Filecoin. Projects like Bacalhau (a distributed compute-over-data project) and Fluence’s compute L2 are building on Filecoin to let users run AI algorithms directly on data stored in the network. The idea is to enable, for example, training a model on a large dataset that’s already stored across Filecoin nodes, rather than having to move it to a centralized cluster. Filecoin’s tech innovations like InterPlanetary Consensus (IPC) allow spinning up subnetworks that could be dedicated to specific workloads (like an AI-specific sidechain leveraging Filecoin’s storage security). Furthermore, Filecoin is supporting decentralized data commons that are highly relevant to AI – for instance, datasets from universities, autonomous vehicle data, or satellite imagery can be hosted on Filecoin, and then accessed by AI models. The network proudly stores major AI-relevant datasets (the referenced UC Berkeley and Internet Archive data, for example). On the token side, this means more clients using FIL for data – but even more exciting is the potential for secondary markets for data: Filecoin’s vision includes allowing storage clients to monetize their data for AI training use cases. That suggests a future where owning a large dataset on Filecoin could earn you tokens when AI companies pay to train on it, etc., creating an ecosystem where FIL flows not just for storage but for data usage rights. This is nascent but highlights how deeply Filecoin is coupling with AI trends.

• Wireless Networks & Edge Data for AI: On the surface, Helium and similar wireless DePINs are less directly tied to AI compute. However, there are a few connections. IoT sensor networks (like Helium’s IoT subDAO, and others such as Nodle or WeatherXM) can supply valuable real-world data to feed AI models. For instance, WeatherXM (a DePIN for weather station data) provides a decentralized stream of weather data that could improve climate models or AI predictions – WeatherXM data is being integrated via Filecoin’s Basin L2 for exactly these reasons. Nodle, which uses smartphones as nodes to collect data (and is considered a DePIN), is building an app called “Click” for decentralized smart camera footage; they plan to integrate Filecoin to store the images and potentially use them in AI computer vision training. Helium’s role could be providing the connectivity for such edge devices – for example, a city deploying Helium IoT sensors for air quality or traffic, and those datasets then being used to train urban planning AI. Additionally, the Helium 5G network could serve as edge infrastructure for AI in the future: imagine autonomous drones or vehicles that use decentralized 5G for connectivity – the data they generate (and consume) might plug into AI systems continuously. While Helium hasn’t announced specific “AI strategies,” its parent Nova Labs has hinted at positioning Helium as a general infrastructure layer for other DePIN projects. This could include ones in AI. For example, Helium could provide the physical wireless layer for an AI-powered fleet of devices, while that AI fleet’s computational needs are handled by networks like Akash, and data storage by Filecoin – an interconnected DePIN stack.

• Synergistic Growth and Investments: Both crypto investors and traditional players are noticing the DePIN–AI synergy. Messari’s 2024 report projected the DePIN market could grow to $3.5 trillion by 2028 (from ~$50B in 2024) if trends continue. This bullish outlook is largely premised on AI being a “killer app” for decentralized infrastructure. The concept of DePAI (Decentralized Physical AI) envisions a future where ordinary people contribute not just hardware but also data to AI systems and get rewarded, breaking Big Tech’s monopoly on AI datasets. For instance, someone’s autonomous vehicle could collect road data, upload it via a network like Helium, store it on Filecoin, and have it used by an AI training on Akash – with each protocol rewarding the contributors in tokens. While somewhat futuristic, early building blocks of this vision are appearing (e.g. HiveMapper, a DePIN mapping project where drivers’ dashcams build a map – those maps could train self-driving AI; contributors earn tokens). We also see AI-focused crypto projects like Bittensor (TAO) – a network for training AI models in a decentralized way – reaching multi-billion valuations, indicating strong investor appetite for AI+crypto combos.

• Autonomous Agents and Machine-to-Machine Economy: A fascinating trend on the horizon is AI agents using DePIN services autonomously. Messari speculated that by 2025, AI agent networks (like autonomous bots) might directly procure decentralized compute and storage from DePIN protocols to perform tasks for humans or for other machines. In such a scenario, an AI agent (say, part of a decentralized network of AI services) could automatically rent GPUs from Render or io.net when it needs more compute, pay with crypto, store its results on Filecoin, and communicate over Helium – all without human intervention, negotiating and transacting via smart contracts. This machine-to-machine economy could unlock a new wave of demand that is natively suited to DePIN (since AI agents don’t have credit cards but can use tokens to pay each other). It’s still early, but prototypes like Fetch.ai and others hint at this direction. If it materializes, DePIN networks would see a direct influx of machine-driven usage, further validating their models.

• Energy and Other Physical Verticals: While our focus has been connectivity, storage, and compute, the AI trend also touches other DePIN areas. For example, decentralized energy grids (sometimes called DeGEN – decentralized energy networks) could benefit as AI optimizes energy distribution: if someone shares excess solar power into a microgrid for tokens, AI could predict and route that power efficiently. A project cited in the Binance report describes tokens for contributing excess solar energy to a grid. AI algorithms managing such grids could again be run on decentralized compute. Likewise, AI can enhance decentralized networks’ performance – e.g. AI-based optimization of Helium’s radio coverage or AI ops for predictive maintenance of Filecoin storage nodes. This is more about using AI within DePIN, but it demonstrates the cross-pollination of technologies.

In essence, AI has become a tailwind for DePIN. The previously separate narratives of “blockchain meets real world” and “AI revolution” are converging into a shared narrative: decentralization can help meet AI’s infrastructure demands, and AI can, in turn, drive massive real-world usage for decentralized networks. This convergence is attracting significant capital – over $350M was invested in DePIN startups in 2024 alone, much of it aiming at AI-related infrastructure (for instance, many recent fundraises were for decentralized GPU projects, edge computing for AI, etc.). It’s also fostering collaboration between projects (Filecoin working with Helium, Akash integrating with other AI tool providers, etc.).

Conclusion​

DePIN projects like Helium, Filecoin, Render, and Akash represent a bold bet that crypto incentives can bootstrap real-world infrastructure faster and more equitably than traditional models. Each has crafted a unique economic model: Helium uses token burns and proof-of-coverage to crowdsource wireless networks, Filecoin uses cryptoeconomics to create a decentralized data storage marketplace, Render and Akash turn GPUs and servers into global shared resources through tokenized payments and rewards. Early on, these models showed strains – rapid supply growth with lagging demand – but they have demonstrated the ability to adjust and improve efficiency over time. The token-incentive flywheel, while not a magic bullet, has proven capable of assembling impressive physical networks: a global IoT/5G network, an exabyte-scale storage grid, and distributed GPU clouds. Now, as real usage catches up (from IoT devices to AI labs), these networks are transitioning toward sustainable service economies where tokens are earned by delivering value, not just by being early.

The rise of AI has supercharged this transition. AI’s insatiable appetite for compute and data plays to DePIN’s strengths: untapped resources can be tapped, idle hardware put to work, and participants globally can share the rewards. The alignment of AI-driven demand with DePIN supply in 2024 has been a pivotal moment, arguably providing the “product-market fit” that some of these projects were waiting for. Trends suggest that decentralized infrastructure will continue to ride the AI wave – whether by hosting AI models, collecting training data, or enabling autonomous agent economies. In the process, the value of the tokens underpinning these networks may increasingly reflect actual usage (e.g. GPU-hours sold, TB stored, devices connected) rather than speculation alone.

That said, challenges remain. DePIN projects must continue improving conversion of investment to utility – ensuring that adding one more hotspot or one more GPU actually adds proportional value to users. They also face competition from traditional providers (who are hardly standing still – e.g. cloud giants are lowering prices for committed AI workloads) and must overcome issues like regulatory hurdles (Helium’s 5G needs spectrum compliance, etc.), user experience friction with crypto, and the need for reliable performance at scale. The token models, too, require ongoing calibration: for instance, Helium splitting into sub-tokens was one such adjustment; Render’s BME was another; others may implement fee burns, dynamic rewards, or even DAO governance tweaks to stay balanced.

From an innovation and investment perspective, DePIN is one of the most exciting areas in Web3 because it ties crypto directly to tangible services. Investors are watching metrics like protocol revenue, utilization rates, and token value capture (P/S ratios) to discern winners. For example, if a network’s token has a high market cap but very low usage (high P/S), it might be overvalued unless one expects a surge in demand. Conversely, a network that manages to drastically increase revenue (like Akash’s 749% jump in daily spend) could see its token fundamentally re-rated. Analytics platforms (Messari, Token Terminal) now track such data: e.g. Helium’s annualized revenue (~$3.5M) vs incentives (~$47M) yielded a large deficit, while a project like Render might show a closer ratio if burns start canceling out emissions. Over time, we expect the market to reward those DePIN tokens that demonstrate real cash flows or cost savings for users – a maturation of the sector from hype to fundamentals.

In conclusion, established networks like Helium and Filecoin have proven the power and pitfalls of tokenized infrastructure, and emerging networks like Render, Akash, and io.net are pushing the model into the high-demand realm of AI compute. The economics behind each network differ in mechanics but share a common goal: create a self-sustaining loop where tokens incentivize the build-out of services, and the utilization of those services, in turn, supports the token’s value. Achieving this equilibrium is complex, but the progress so far – millions of devices, exabytes of data, and thousands of GPUs now online in decentralized networks – suggests that the DePIN experiment is bearing fruit. As AI and Web3 continue to converge, the next few years could see decentralized infrastructure networks move from niche alternatives to vital pillars of the internet’s fabric, delivering real-world utility powered by crypto economics.

Sources: Official project documentation and blogs, Messari research reports, and analytics data from Token Terminal and others. Key references include Messari’s Helium and Akash overviews, Filecoin Foundation updates, Binance Research on DePIN and io.net, and CoinGecko/CoinDesk analyses on token performance in the AI context. These provide the factual basis for the evaluation above, as cited throughout.

BlockEden.xyz, known for its Remote Procedure Call (RPC) infrastructure, is expanding into AI inference services. This evolution leverages its open-source, permissionless design to create a marketplace where model researchers, hardware operators, API providers, and users interact seamlessly. The network's Relay Mining algorithm ensures a transparent and verifiable service, presenting a unique opportunity for large model AI researchers to monetize their work without infrastructure maintenance.

The Core Problem​

The AI landscape faces significant challenges, including:

• Restricted Model-Serving Environments: Resource-intensive infrastructure limits AI researchers' ability to experiment with various models.
• Unsustainable Business Models for Open Source Innovation: Independent engineers struggle to monetize their work, relying on major infrastructure providers.
• Unequal Market Access: Enterprise-grade models dominate, leaving mid-tier models and users underserved.

BlockEden.xyz’s Unique Value Proposition​

BlockEden.xyz addresses these issues by decoupling the infrastructure layer from the product and services layer, ensuring an open and decentralized framework. This setup enables high-quality service delivery and aligns incentives among all network participants.

Key benefits include:

• Established Network: Utilizing an existing network of BlockEden.xyz's services to streamline model access and service quality.
• Separation of Concerns: Each stakeholder focuses on their strengths, improving overall ecosystem efficiency.
• Incentive Alignment: Cryptographic proofs and performance measurements drive competition and transparency.
• Permissionless Models & Supply: An open marketplace for cost-effective hardware supply.

Decentralized AI Inference Stakeholders​

Model Providers: Coordinators

Coordinators manage the product and services layer, optimizing service quality and providing seamless access for applications. Coordinators discreetly ensure supplier integrity by posing as regular users, offering unbiased performance assessments.

Model Users: Applications

Applications typically use first-party coordinators but can also access the network with a third-party for enhanced privacy and cost savings. Direct access allows for diverse use case experimentation and eliminates intermediary costs.

Model Suppliers: Hardware Operators

Suppliers run inference nodes to earn tokens. Their competencies in DevOps, hardware maintenance, and logging are crucial for network growth. The permissionless approach encourages participation from various hardware providers, including those with idle or dormant resources.

Model Sources: Engineers & Researchers

Researchers and institutions that open-source models can earn revenue based on usage. This model incentivizes innovation without the need for infrastructure maintenance, providing a sustainable business model for open-source contributors.

Working with Cuckoo Network​

BlockEden.xyz collaborates with Cuckoo Network to revolutionize AI inference through a decentralized and permissionless infrastructure. This partnership focuses on leveraging both platforms' strengths to create a seamless and efficient ecosystem for AI model deployment and monetization.

Key Collaboration Areas​

• Infrastructure Integration: Combining BlockEden.xyz's robust RPC infrastructure with Cuckoo Network's decentralized model-serving capabilities to offer a scalable and resilient AI inference service.
• Model Distribution: Facilitating the distribution of open-source AI models across the network, enabling researchers to reach a broader audience and monetize their innovations without the need for extensive infrastructure.
• Quality Assurance: Implementing mechanisms for continuous monitoring and assessment of model performance and supplier integrity, ensuring high-quality service delivery and reliability.
• Economic Incentives: Aligning economic incentives across all stakeholders through cryptographic proofs and performance-based rewards, fostering a competitive and transparent marketplace.
• Privacy and Security: Enhancing privacy-preserving operations and secure model inference through advanced technologies like Trusted Execution Environments (TEE) and decentralized data storage solutions.
• Community and Support: Building a supportive community for AI researchers and developers, providing resources, guidance, and incentives to drive innovation and adoption within the decentralized AI ecosystem.

By partnering with Cuckoo Network, BlockEden.xyz aims to create a holistic and decentralized approach to AI inference, empowering researchers, developers, and users with a robust, transparent, and efficient platform for AI model deployment and utilization. You can now try decentralized text-to-image API at https://blockeden.xyz/api-marketplace/cuckoo-ai.

Input/Output of a Decentralized Inference Network​

LLM Inputs to Cuckoo Network:

• Open-source models
• Demand from end-users or Applications
• Aggregated supply from commodity hardware
• Quality of service guarantees

LLM Outputs from Cuckoo Network:

• No downtime
• Seamless model experimentation
• Public model evaluation
• Privacy-preserving operations
• Censorship-free models

Web3 Ecosystem Integrations​

BlockEden.xyz's RPC protocol can integrate with other Web3 protocols to enhance Decentralized AI (DecAI):

Data & Storage Networks: Seamless integration with decentralized storage solutions like Filecoin/IPFS and Arweave for model storage and data integrity.

Compute Networks: Complementary services leveraging decentralized computing layers like Akash and Render, supporting both dedicated and idle hardware.

Inference Networks: Flexible deployment models and robust ecosystems supporting diverse inference tasks.

Applications: AI agents, consumer apps, and IoT devices benefit from DecAI inference for personalized services, data privacy, and edge decision-making.

Summary​

BlockEden.xyz's established infrastructure and economic design unlock new opportunities for open-source AI. By providing a decentralized and verifiable service, it bridges the gap between open-source AI and Web3, enabling innovative, sustainable, and reliable services. This approach allows for greater model diversity, better market access for SMEs, and a new business model for open-source researchers. Future developments will continue to expand the ecosystem, ensuring BlockEden.xyz remains a robust and adaptable solution in the evolving AI and blockchain landscapes.

• Twitter: https://twitter.com/BlockEdenHQ
• Discord: https://discord.gg/eWZvE4RSBw
• Source Link: https://blockeden.xyz/blog/2024/06/20/decentralized-inference-blockeden-xyz/

We are glad to announce that BlockEden.xyz, web3 developers' go-to platform for API marketplace, has added a new, powerful capability – OpenAI API. Yes, you heard it right! Developers, tech enthusiasts, and AI pioneers can now leverage the cutting-edge machine learning models offered by OpenAI, directly through BlockEden's API Marketplace.

Before we dive into the how-to guide, let's understand what OpenAI API brings to the table. OpenAI API is a gateway to AI models developed by OpenAI, such as the industry-renowned GPT-3, the state-of-the-art transformer-based language model known for its remarkable ability to understand and generate human-like text. The API enables developers to use this advanced technology for a variety of applications, including drafting emails, writing code, answering questions, creating written content, tutoring, language translation, and much more.

Now, let's see how you can incorporate the power of OpenAI API into your applications using BlockEden.xyz. You can do it in three ways: using Python, using JavaScript (Node.js), or using curl directly from the command line. In this blog, we're going to provide the basic setup for each method, using a simple "Hello, World!" example.

The API key below is public and subject to change and rate limit. Get your own BLOCKEDEN_API_KEY from https://blockeden.xyz/dash instead.

Python:

Using Python, you can use the OpenAI API as shown in the following snippet:

import openai

BLOCKEDEN_API_KEY = "8UuXzatAZYDBJC6YZTKD"
openai.api_key = ""
openai.api_base = "https://api.blockeden.xyz/openai/" + BLOCKEDEN_API_KEY + "/v1"

response = openai.ChatCompletion.create(
  model="gpt-3.5-turbo-16k",
  messages=[{"role": "user", "content": "hello, world!"}],
  temperature=0,
  max_tokens=2048,
  top_p=1,
  frequency_penalty=0,
  presence_penalty=0
)

print(response["choices"])

JavaScript (Node.js):

You can also utilize the OpenAI API with JavaScript. Here's how you can do it:

const { Configuration, OpenAIApi } = require("openai");

const BLOCKEDEN_API_KEY = "8UuXzatAZYDBJC6YZTKD";
const configuration = new Configuration({
  basePath: "https://api.blockeden.xyz/openai/" + BLOCKEDEN_API_KEY + "/v1"
});
const openai = new OpenAIApi(configuration);

(async () => {
  const response = await openai.createChatCompletion({
    model: "gpt-3.5-turbo-16k",
    messages: [{role: "user", content: "hello, world!"}],
    temperature: 0,
    max_tokens: 2048,
    top_p: 1,
    frequency_penalty: 0,
    presence_penalty: 0,
  });

  console.log(JSON.stringify(response.data.choices, null, 2));
})()

cURL:

Last but not least, you can call the OpenAI API using curl directly from your terminal:

curl https://api.blockeden.xyz/openai/8UuXzatAZYDBJC6YZTKD/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
  "model": "gpt-3.5-turbo-16k",
  "messages": [{"role": "user", "content": "hello, world!"}],
  "temperature": 0,
  "max_tokens": 2048,
  "top_p": 1,
  "frequency_penalty": 0,
  "presence_penalty": 0
}'

So, what's next? Dive in, experiment, and discover how you can leverage the power of OpenAI API for your projects, be it for chatbots, content generation, or any other NLP-based application. The possibilities are as vast as your imagination. With BlockEden.xyz's seamless integration with OpenAI, let's redefine the boundaries of what's possible.

For more information on OpenAI's capabilities, models, and usage, visit the official OpenAI documentation.

Happy Coding!

What is BlockEden.xyz​

BlockEden.xyz is an API marketplace powering DApps of all sizes for Sui, Aptos, Solana, and 12 EVM blockchains. Why do our customers choose us?

1. High availability. We maintain 99.9% uptime since our first API - Aptos main net launch.
2. Inclusive API offerings and community. Our services have expanded to include Sui, Ethereum, IoTeX, Solana, Polygon, Polygon zkEVM, Filecoin, Harmony, BSC, Arbitrum, Optimism, Gnosis, Arbitrum Nova & EthStorage Galileo. Our community 10x.pub has 4000+ web3 innovators from Silicon Valley, Seattle, and NYC.
3. Security. With over $45 million worth of tokens staked with us, our clients trust us to provide reliable and secure solutions for their web3 and blockchain needs.

We provide a comprehensive suite of services designed to empower every participant in the blockchain space, focusing on three key areas:

• For blockchain protocol builders, we ensure robust security and decentralization by operating nodes and making long-term ecosystem contributions.
• For DApp developers, we build user-friendly APIs to streamline development and unleash the full potential of decentralized applications.
• For token holders, we offer a reliable staking service to maximize rewards and optimize asset management.

• Twitter: https://twitter.com/BlockEdenHQ
• Discord: https://discord.gg/eWZvE4RSBw
• Source Link: https://blockeden.xyz/blog/2023/07/19/unveiling-integration-openai-api-blockeden-api-marketplace/