Nillion Comprehensive Research Report: The Leader in Blind Computing Across the AI+ and Privacy Sectors

Author: Messari

Compiled by: Azuma, Odaily Planet Daily

Editor’s Note: Earlier this week, a list of popular projects expected to have their TGE in the first quarter of this year circulated widely in the market, with the privacy computing leader Nillion, which raised $50 million, among them.

In the following text, the research institution Messari provides a detailed analysis of Nillion through various dimensions such as team, narrative, technology, architecture, tokens, ecosystem, and roadmap, which may help you further understand the project's information and dynamics.

The following is the full content from Messari, compiled by Odaily Planet Daily.

Core Content Overview

• Nillion has established partnerships with companies/projects such as Virtuals, NEAR, Aptos, Arbitrum, Ritual, io.net, and Meta.
• A complete set of application tools, including nilAI, nilVM, nilDB, and nilChain, provides developers with resources to create privacy-preserving applications in fields such as artificial intelligence, healthcare, and DeFi.
• Nillion coordinates the use of privacy-enhancing technologies (PETs) such as Multi-Party Computation (MPC), Homomorphic Encryption, and Zero-Knowledge Proofs to achieve secure data computation and storage in its decentralized infrastructure.
• Nillion's validator program has approximately 500,000 validators, processing around 195 million ciphertexts and protecting about 1,050 GB of data security.

Introduction

Handling high-value data (such as passwords, personalized AI, healthcare information, and biometric data) has historically been both insecure and inefficient. While encryption can ensure the security of stored data, it requires decryption during computation, followed by re-encryption, which introduces vulnerabilities and delays. Although blockchain technology can decentralize transaction and data management, it does not fundamentally solve the problem of secure computation on encrypted data. This limitation restricts the types of applications that can be securely built in Web3.

Nillion aims to address these limitations by enabling data transmission, storage, and computation without decryption, ensuring that sensitive information remains private and secure throughout its lifecycle. This approach is known as "Blind Compute," which decentralizes trust and extends the use cases of decentralized networks into previously untapped areas, such as private AI agents, private LLM inference, and other industries requiring secure data. By utilizing advanced privacy technologies (PETs) such as MPC, Fully Homomorphic Encryption (FHE), and Trusted Execution Environments (TEE), Nillion allows data to remain encrypted throughout the entire computation process.

Background

Founded in 2021, Nillion offers a novel approach to handling privacy data in distributed systems without compromising security or efficiency. Supported by application frameworks such as nilVM, nilDB, nilAI, and nilChain, Nillion provides developers with various tools to help them build privacy-focused applications in areas like AI, DeFi, and data storage.

The Nillion team includes:

• Alex Page (CEO), former Hedera SPV General Partner and Goldman Sachs banker;
• Andrew Masanto (CSO), co-founder of Hedera and founding CMO of Reserve;
• Slava Rubin (CBO), founder of Indiegogo;
• Dr. Miguel de Vega (Chief Scientist), PhD advisor and author of over 30 patents;
• Conrad Whelan (Founding CTO), founding engineer at Uber;
• Mark McDermott (COO), former head of innovation at Nike;
• Andrew Yeoh (CMO), early senior partner at Hedera, former UBS and Rothschild banker, among others.

Since its inception, the team has raised $50 million through private placements from investors such as Hack VC, Hashkey Capital, Distributed Global, and Maelstrom.

Technology

The Nillion network is a decentralized infrastructure designed to securely and privately process high-value data.

Nillion consists of two core layers: (i) Coordination Layer, responsible for management and payments; (ii) Orchestration Layer (Petnet), responsible for computation and storage. Nillion's MPC protocol is central to the network's functionality, allowing for private data computation without revealing individual inputs. The Nillion ecosystem is supported by a complete set of application tools (i.e., nilAI, nilVM, nilDB, and nilChain) that help developers build privacy-focused applications. Academic research papers in cryptography and privacy technologies validate the technical feasibility of Nillion.

Nillion Network

Nillion Network is a decentralized infrastructure designed to support private high-value data storage and computation. The scalability of Nillion Network is achieved through clusters, which can be configured to meet specific performance, security, and cost requirements. Unlike traditional blockchains, Nillion Network does not rely on a globally shared state for operation, achieving vertical scalability (by upgrading individual nodes or clusters) and horizontal scalability (by adding new nodes or clusters), effectively distributing workloads. Below are the contributions of each layer (i.e., Coordination Layer and Orchestration Layer) to the network architecture.

Coordination Layer

The Coordination Layer of the Nillion Network (referred to as nilChain) is responsible for: (i) managing rewards; (ii) payments; (iii) cryptoeconomic security; (iv) coordination between network clusters.

Specifically, nilChain coordinates the payments for storage operations and the blind computations executed on the network without directly handling the computations. The Coordination Layer is built using the Cosmos SDK and supports IBC for interoperability; however, given that the core focus of the network is on storage and computation, it currently does not support the execution of smart contracts. While applications built on cooperative blockchains can be accessed directly via Keplr or Leap wallets, they will be fully abstracted. nilChain has been operational on the testnet since June 2024.

Orchestration Layer (Petnet)

Petnet aims to integrate cryptographic technologies such as MPC, Fully Homomorphic Encryption (FHE), and Zero-Knowledge Proofs (ZKPs) for private computation and data management. This integration is achieved through two key components: (i) a compiler and (ii) a computing network. Specifically, the compiler simplifies the use of privacy-enhancing technologies (PETs) by providing different levels of abstraction, while the computing network executes secure computations and manages encrypted data.

Nillion Network is implementing this approach through its Nada language compiler and nilVM, with elements of all four abstraction levels currently in development. The four abstraction levels are as follows:

• Each PET protocol operates independently within its own Blind Module, similar to an isolated black box. There is no built-in unified interface or abstraction; all orchestration occurs on the client side; thus, developers can use application programming interfaces to perform specific tasks but cannot integrate or customize them.
• Each SDK integrates various Blind Modules, providing developers with a direct unified way to manage multiple PET protocols without requiring cryptographic expertise. Although these modules have not yet been fully optimized, as they currently rely on a single PET protocol, they can already be seamlessly and readily used in combinations of PET protocols.
• Blind Modules begin to support multiple PET protocols within a single Blind Module. This provides developers with the ability to make various trade-offs between performance and security, further simplifying decision-making for developers with limited cryptographic knowledge.
• Blind Modules are deployed on loosely independent networks (referred to as clusters) managed by NilChain. As Nillion's blind computing matures, the same Blind Module can be replicated across multiple clusters, each with different configurations. These configurations vary based on various factors such as the number of nodes, node locations, reputation, hardware specifications, and security thresholds. This versatility allows developers to use the same functionality across different cluster settings, enabling solutions to be customized based on specific needs (such as security, cost, hardware, regulatory compliance, etc.).

Nillion's PET is introduced in phases, with each phase going through the aforementioned four abstraction levels. Phase 1 (i.e., HE, LSSS MPC) and Phase 2 (i.e., DWT+LSSS, TEE) are progressing faster and have been integrated into the Nillion Network. Technologies in Phase 3 (i.e., FHE-MPC, DWT+TEE, public computation, ZKP) have begun to make progress at the abstract level.

Operation Process

Here is a detailed breakdown of how the components of the Nillion Network operate:

• Users/developers submit data for storage or initiate blind computation requests through front-end applications built using JavaScript or Python clients.
• Applications using the JavaScript client interact with Petnet for secure computation and encrypted data management. In contrast, applications based on the Python client interact with the Coordination Layer for payments, routing, and multi-chain communication.

The Coordination Layer processes payments using the native gas tokens of the respective blockchains or NIL tokens.

• After the Coordination Layer processes the request, it forwards the computation tasks to Petnet, which includes PET.
• Petnet processes the data according to the task requirements using PETs such as linear secret sharing schemes, obfuscated circuits, and/or homomorphic encryption.

These computations will be executed on node clusters.

Each node in Petnet manages only a fragment (share) of the encrypted data.

• Nodes perform specified computations (such as addition, multiplication, or secure comparison) on the masked data and generate partial outputs.
• Petnet aggregates these partial outputs to generate the final computation result securely and confidentially.
• The final result is routed back as follows:

If using the JavaScript client, Petnet sends the result directly to the application for user/developer access.

If using the Python client, the Coordination Layer retrieves the result from Petnet and routes it to the application or relevant blockchain for further use.

• For blockchain-integrated use cases, the Coordination Layer passes the result to the original smart contract or decentralized application, allowing for multi-chain functionality without requiring users to download new wallets.

Nillion's MPC Complex Computation Protocol

Multi-Party Computation (MPC) is a subfield of cryptography that allows individuals to collaboratively compute the result of their combined data without revealing their individual inputs. Nillion has developed an MPC protocol called Curl, which is based on linear secret sharing schemes (LSSS) but extends its capabilities to efficiently handle complex computations (such as division, square roots, trigonometric functions, and logarithms). This makes Curl highly scalable and well-suited for real-world problems, such as privacy-focused AI agents, where the output is not a linear function of the input. Curl employs a structured two-phase workflow:

Phase 1 (Preprocessing to Create Shares): This phase generates random shares and allocates them to participants (computing entities) before using MPC techniques to process the actual data. Notably, the operations in the preprocessing phase are independent of the input values and rely solely on the number of inputs to create the appropriate number of shares before computation occurs. It can be viewed as an abstraction layer—creating placeholders in advance, which are then combined with the actual input data provided by users in Phase 2.

Phase 2 (Efficient Computation of Complex Operations): The computation phase involves the actual computation of the private input data through the following three stages: (i) Input; (ii) Evaluation; (iii) Output.

• Input: Each party allocates its input to participants, ensuring information-theoretic security (ITS). Each input value from every participant receives a share, and the entire process remains confidential.
• Evaluation: Each party efficiently computes complex operations on the input shares using Nillion's Curl protocol.
• Output: The locally computed results are disclosed and aggregated to produce the final result.

For more information about Nillion's MPC mechanism, click here to read the original academic paper.

Application Tools

Built on the Nillion Network, application tools (i.e., nilVM, nilDB, nilAI, and Nada integration package) provide developers with a modular framework and utilities to quickly build privacy-preserving high-value data applications.

nilAI

nilAI is Nillion's privacy technology suite focused on artificial intelligence (i.e., AIVM, nada-AI, and nilTEE). Here’s how each technology works:

• AI Virtual Machine (AIVM): This is a secure AI inference platform based on Nillion's MPC technology and Meta's CrypTen framework. It utilizes the Discrete Wavelet Transform (DWT), developed in collaboration with Meta's AI research team, to accelerate inference. AIVM ensures data privacy by keeping individual nodes blind to user prompts and model outputs, thereby ensuring private deep learning model inference and deployment.
• nada-AI: A library of nilVM designed for AI applications, providing a PyTorch-like interface for running small models (such as Neural Networks "NN", Convolutional Neural Networks "CNN", linear regression, etc.). Developers can also quickly bootstrap their projects using Google Colab.
• nilTEE: This solution uses Trusted Execution Environments (TEE) to run large language models (LLMs) at high performance during inference. Nillion recommends limiting the use of TEE to inference time rather than long-term data storage. Currently, Nillion is conducting research to enhance nilTEE and AIVM by separating inference settings, further improving security and performance.

nilVM, Nada, and Their Libraries

nilVM is a virtual machine that allows developers to create programs using PETs. Programs are written in Nillion's open-source DSL Nada, based on Python, and developed using the Nillion SDK. Nada also includes libraries such as nada-ai (similar to PyTorch and scikit-learn), nada-numpy, nada-data, and nada-test to simplify program development. Developers can integrate nilVM into their applications using Python, Typescript, or CLI clients and utilize storage APIs for secure data storage and retrieval on the Nillion Network. Examples include federated learning programs, community development projects, and interactive demo use cases.

nilDB

nilDB is an encrypted distributed NoSQL database designed for privacy-preserving data storage and computation. Unlike ordinary NoSQL databases, nilDB distributes encrypted data as secret shares across multiple nodes, eliminating reliance on a central authority. Furthermore, data owners can grant access to others to run SQL-like queries, computations, and privacy-preserving aggregations on the stored data.

The specific operation is as follows:

• Users encrypt sensitive data on their local devices.
• Users securely upload the encrypted data through a Nillion-based front-end application. The application securely uploads the encrypted data to nilDB via an integrated backend RESTful API.
• The encrypted data is split into secret shares using Nillion's MPC protocol and distributed across the node clusters of the nilDB network. Notably, no single node possesses the complete dataset.
• Users provide explicit consent for the use or query of specific data and can withdraw consent at any time through the application.
• Authorized entities (such as companies or third parties) submit SQL-like query requests (such as lookups, range filters, or aggregate computations) through Nillion's RESTful API.
• Nodes in the nilDB cluster collaboratively execute computations on the encrypted data without exposing sensitive information.
• Query results (such as averages, sums, or filtered datasets) are generated while maintaining data confidentiality.
• Only the final query results are returned to the requesting user via the RESTful API.
• For more information on the technical architecture, click here.

Nada Integration Package

The Nada language includes various integration packages, including nada-AI (discussed earlier), nada-numpy, and nada-test, with use cases as follows:

• nada-numpy: A NumPy-adapted package tailored for the Nada DSL. Compared to ordinary NumPy, nada-numpy allows efficient manipulation of array structures and imposes strong typing requirements on data types, ensuring compatibility with the strong typing characteristics of MPC.
• nada-test: A testing framework for Nada programs that supports dynamic tests generated at runtime. Developers can write test cases in Python, integrate the framework into pytest workflows, and define flexible input and output specifications.

Other tools (such as Nada DSL, Nada Sandbox, etc.) and SDKs can be viewed on GitHub.

NIL Token

Token Utility

NIL tokens will serve multiple functions within the Nillion Network, including:

• Payment for computation services, data storage, AI inference, and transaction fees for Petnet and the Coordination Layer. Specifically, developers can use NIL to access privacy-preserving computation services provided by Nillion for their applications.
• Staking to support network security and earn rewards.

Validators stake NIL to validate transactions and computations, ensuring the security of the Coordination Layer.

Petnet nodes stake NIL to enhance the security of their clusters, attracting developers and applications.

• Participation in decentralized governance, proposing and voting on various network decisions (such as protocol upgrades, resource allocation, and community grant programs).

Governance

Governance decisions are made through an on-chain voting mechanism. Specifically, any NIL token holder who meets the minimum token holding requirements can propose conceptual suggestions to the network. Community committees or working groups established through previous governance actions can also submit proposals.

Voting rights apply to key decisions such as:

• Introducing new features or updates.
• Allocating reward pools for grants, developer incentives, and community-driven projects.
• Adjusting network pricing, validator requirements, or authorization limits.
• Modifying governance structures, such as quorum requirements or proposal thresholds.
• Expanding interoperability, establishing strategic partnerships, or implementing transparency and audit mechanisms.
• Voting rights are proportional to the amount of NIL staked, with stakers delegating their voting rights to validators while retaining their ability to vote on proposals.

Nillion Ecosystem

Nillion can create new opportunities in the following industries:

• Artificial Intelligence: Nillion can process data and inference without exposing sensitive information, bridging the gap between secure local AI processing and the scalability of centralized non-private AI systems.
• Personalized Agents: AI agents can store, compute, and process private data.
• Privacy Model Inference: AI models can securely handle private data, minimizing the risk of exposure to third parties and enabling private LLMs.
• Privacy Knowledge Bases and Search: Data can be stored in encrypted form while still providing search capabilities for AI agents and other AI use cases.
• Data Ownership: Nillion's encrypted infrastructure supports secure data markets, allowing users to control and sell their data to buyers.
• Blockchain: Nillion allows blockchain applications to send blind storage and computation requests to the Nillion Network, complementing the public data functionality of blockchains. It also supports on-chain settlement, allowing applications to decrypt relevant data on the blockchain.
• Healthcare: Nillion supports privacy-preserving analysis of healthcare data across institutions and users.
• DePIN: After integration with Nillion, DePIN projects can securely store and process sensitive operational data.

Key Projects

• Virtuals Protocol: A platform for building AI agents that has developed a multimodal AI agent library, allowing for private training and inference of its AI models using Nillion to establish personalized AI agents.
• Aptos/NEAR/Arbitrum/Sei: Layer 1 and Layer 2 blockchains that integrate blind data storage and computation to enhance data processing within smart contracts.
• Ritual: An AI platform building a decentralized AI inference network that integrates Nillion in its backend for private inference.
• Zap: A data platform that aggregates user data into Nillion, providing secure insights through blind computation and zero-knowledge transmission layer security (zkTLS).
• Reclaim Protocol: A zkTLS infrastructure platform that allows users to prove identity and reputation through trusted off-chain platforms, with Nillion serving as the storage and processing platform for the generated proofs.
• Healthblocks: A fitness application that uses Nillion to maintain user ownership and control over data while allowing third parties to gain insights without exposing personal details.
• MonadicDNA: A genomics platform that uses Nillion to encrypt data throughout its lifecycle, providing an alternative to centralized service providers like 23andMe.

Roadmap

Nillion's roadmap was released on May 31, 2024, divided into four key phases:

• Phase 1 ------ Genesis Sprint (Completed). This phase established: (i) the foundational Coordination Layer during the testnet launch; (ii) tested core functionalities such as Keplr wallet creation, token transfers, staking, and management; (iii) provided developers access to the Nillion SDK, which includes telemetry for early application development; (iv) conducted load testing to assess transaction throughput and network scalability.
• Phase 2 ------ Catalyst Integration (Ongoing). This phase: (i) integrates Petnet with the Coordination Layer; (ii) adds external nodes for complete decentralization; (iii) introduces "blind applications" for secure data processing; (iv) supports cross-chain functionality, expanding Nillion into a multi-chain ecosystem.
• Phase 3 ------ Fortification. This phase will: (i) include the mainnet launch and token generation event (TGE); (ii) operate external nodes; (iii) achieve real-world interactions through blind computation; (iv) validate previously built applications on the network under real-time conditions.
• Phase 4 ------ The Future of Multi-Clusters. This phase will: (i) achieve horizontal scalability by adding public node clusters; (ii) enhance computational capabilities; (iii) optimize the network for applications targeting specific markets; (iv) achieve scalability while maintaining security and privacy.

Conclusion

Nillion is a decentralized infrastructure designed to handle high-value, privacy-sensitive data across various applications, from AI agents to privacy DeFi. Nillion combines advanced PETs (such as MPC, FHE, TEE) to expand the usability of decentralized networks and the possibilities of decentralized applications. The architecture of Nillion—Coordination Layer and Petnet—supports scalability through clusters while ensuring data confidentiality and decentralized trust.

The Nillion ecosystem is continuously expanding, with milestone events including: (i) the Nucleus Builder Program (supporting about 50 projects across multiple verticals) and (ii) approximately 500,000 validators participating, processing around 195 million ciphertexts, and protecting about 1,050 GB of data. Collaborations with Virtuals, NEAR, Meta, and Aptos, along with ongoing mainnet launches and multi-cluster scalability roadmap development, highlight Nillion's progress in advancing privacy-focused data management and secure computation.