# Autonomi Docs Understanding and getting started with the world's first autonomous data and communications network. Critical infrastructure of the next web. Assembled from everyday devices and owned by us all.
Cover image

Start a Node

Add your spare hard drive space to the Network and start earning/files/Bk80z4NODdTamOzhjGa3https://docs.autonomi.com/node

Learn more

Dig into the detail. Understand how it works./files/O6Gr1Llqhvs2bIkz60i1/pages/4m2nnBtiUXBkV24NRBLi

ANT Token

Using, holding & earning the currency of the Network/files/8fyCr25VndAYM9dp5HcJ/spaces/yZv1zkASl6hUNUmP3ypg

Developers

Start building on Autonomi with our developer guides/files/WqGttNOuWDFpvIsh2IMxhttps://docs.autonomi.com/developers
# What is Autonomi? **Autonomi combines the spare capacity of everyday devices to form a new, autonomous, permanent data storage layer of the Internet**. Real-time communication, mutable shared state, and collaboration are handled by x0x — a complementary post-quantum gossip network that shares the same transport and cryptography. It allows you to securely store data, build businesses, run services, and create new futures without the intervention of any middlemen or gatekeepers. It's designed to give people complete sovereignty over their personal data, yet still allow rich and scalable software platforms and user experiences to be built on top. ## Key features…
The Internet's Crowd Storage Layer/pages/mknqLcF7eInd5dDPQFy0/files/CFa5ogB8Xtx9Djl7HuSQ
Everything's Encrypted/pages/vi6V23KkCiBVEKcbd6Lz/files/kFfECVN7mnBiVXg34V1G
Lifetime Storage; One-Time Fee/pages/8wt0zh537IxEC5ZJk5kT/files/egqyMxRAO2R0u1Qtw3o4
Built From Everyday Devices/pages/EnmpxnTC0gYbMn4s8RTW/files/XkLibFJ4aLNqZI4sAPxY
Private By Design/pages/lNWgumSoedsLg0oSNAR1/files/wlC7uyLxKYSlYQISOjyx
No Blockchain/pages/be2hGLrKdFlf1EeYQivD/files/1q4GTlq4Jby8U4EJbspu
Post-Quantum Secure/pages/JcBEWWn81riWcyU9dQaa/files/c4SRTcvozfdxXZ4Qw8SZ
Secure & Efficient/pages/Ns0qVEDX3RRukf2xmDYf/files/a569jeUQEJs5VWt2ltbE
## What it means… Decentralized, distributed, self-encrypted, and protected by post-quantum networking; it means security, privacy, and lifetime storage of the world's most precious data—including yours. The Network will give people autonomy over their digital lives, allowing them to participate in the connected economy, regardless of their location, status, or access to capital. It's designed for mass collaboration between humans, between machines, and between humans and machines—critically, without the distorting effects of endemic data insecurity, siloing of knowledge, inefficient markets, and limited accessibility. In order to do this, and accomplish it in a way suitable for human-scale use, Autonomi has been built from the first principle of secure and private data, and in such a way that the performance of the network scales with size. Not only is data de-duplicated and redundantly replicated, but it is self-encrypted on an end user's computer before upload, while the connections that move it across the network use NIST-standardised post-quantum cryptography (ML-KEM-768 for key exchange, ML-DSA-65 for signatures). That means the network never sees readable content, and the transport layer does not rely on classical cryptography. # The Internet's Crowd Storage Layer Autonomi takes the idle capacity of everyday devices to form the Internet's crowd storage layer. Private, secure, decentralized infrastructure that's powered by us all. ## Strength in Numbers *Amazon, Microsoft, Apple, Google… they reign supreme. Walled gardens encircling a vast proportion of the world's data. Yet we've lost sight of the power on our desks and in our pockets.* The empty storage of internet-connected devices dwarfs what the tech giants can serve. We've all got underutilised assets laying dormant while corporations continue to pour concrete, lay cables, and rack servers. It's time to harness that spare capacity and make a global resource that's owned by everyone. # Everything's Encrypted Anything stored on the Network is encrypted in a way that not even a quantum computer can break it. And it is end-to-end encrypted in transit too. This means you get all the benefits of the cloud, but without your data hitting the Internet. That also means no one can watch or track your use of the Network either. Autonomi uses a novel approach called [Self-Encryption](/how-it-works/encryption-and-authentication/self-encryption). Not only does this mean that your data is secure and private, it means your personal information never needs to touch the Internet. It's securely reassembled for you *only* within your own device when you are ready to use it, and then leaves no trace when you are done.
# Lifetime Storage; One Time Fee A one-time payment provides long-term security and no ongoing charges. You pay once when you upload a file and it's stored for the lifetime of the Network. No contract re-negotiations, no losing access if you miss a payment. Simple, secure, perpetual storage. Not only does this allow you to escape the cloud and its spiralling costs, it's vital for giving you true sovereignty over your own data, your digital life, and legacy. # Built From Everyday Devices Autonomi is assembled from a multitude of connected devices, of all shapes and sizes. It's deliberately designed to allow even the smallest computers to be able to contribute, rather than just relying on enterprise data centres. It runs on commodity hardware. Not only does this make the most of humanity's spare resources—which is better for the planet—but it means it’s inherently more decentralized and secure, thanks to the millions of devices able to participate. And it's a breeze to get involved. Thanks to the nature of its design, with all data broken into chunks, encrypted, and randomly distributed, it means there's no red tape, no complicated setup, no paperwork, and no prohibitive capital requirements. Just allocate your spare storage space and be rewarded directly by the Network. # Private by Design **Zero-knowledge**: The Network's protocol employs multilayered encryption, protecting the privacy of users data both during storage and during transit. Nodes cannot determine the content, nor origin of data they hold or transmit, even if it is their own, **No tracking**: Thanks to its various encryption schemes, tracking and surveillance of browsing and data usage patterns—commonplace business practice on the incumbent web—is no longer possible. Privacy is by default. **Self-Sovereign**: Users of the Network have sovereignty over their personal data, and can maintain and control access to it, while still making use of rich and accessible services and software. **No Password Hacks**: Passwords and credentials never leave your computer when accessing and decrypting data. You only need a single set of credentials while interacting with an unlimited number of services, businesses, identities, or contexts of use. # Blockchainless Data Autonomi's core data network is a form of Decentralized Ledger Technology (DLT) that doesn't utilise nor require a blockchain to function, so it's able to sidestep many of the obstacles to scaling inherent in other solutions. It's designed from the ground up for data, and serving people's needs at a global scale, without the bottlenecks. The bigger it gets, the more it can do. # Post-Quantum Secure Autonomi is designed for a post-quantum threat model, but it does not use the same cryptography for everything. Stored data is protected by self-encryption on your own device, while node identity and network connections use explicitly post-quantum cryptography. ## What this means Post-quantum security means the network does not rely only on classical public-key cryptography for node identity and connection security. That matters because large quantum computers would weaken some cryptographic systems that are still used widely on today's Internet. For you, that means: 1. Your files are protected by self-encryption before they leave your device. 2. The connections between clients and nodes are protected by post-quantum cryptography. This means Autonomi is designed to protect your data against quantum-era threats, both at rest and while it moves across the network. ## Why Autonomi separates these layers Stored data and live network connections face different risks, so they are protected differently. Self-encryption keeps uploaded content unreadable to the network itself using modern symmetric encryption and hashing. Post-quantum transport security protects node identity and the secure connections used to move data around. That means the network can verify who is participating and establish secure connections without exposing readable content in transit or at rest. ## Under the hood Autonomi's transport layer uses `ML-KEM-768` for key exchange and `ML-DSA-65` for signatures, with no classical fallback. Content protection follows a different path. Files are self-encrypted on the client using `ChaCha20-Poly1305`, with keys and addresses derived using `BLAKE3`. These are not the same as the network's explicit post-quantum identity and transport algorithms, but they are also not vulnerable in the same way as classical public-key cryptography. ## Related pages * [Everything's Encrypted](/introduction/what-is-autonomi/everythings-encrypted) * [Self-Encryption](/how-it-works/encryption-and-authentication/self-encryption) * [Post-Quantum Identity & Credentials](/how-it-works/encryption-and-authentication/multisig-credentials) # Secure & Efficient Autonomi is designed to make use of under-utilized and otherwise squandered resources of everyday connected devices; creating a common data storage resource that can be put to work serving individuals and communities regardless of location. Thanks to the protocol’s design, all files uploaded to the Network are automatically de-duplicated, yet still benefit from the security and performance benefits of redundant replication since a number of copies of each data chunk are always maintained. Security for everyone's vital data, *and* the best use of precious resources. # Background Decentralized or peer-to-peer (P2P) networks are not new. Since the release of Napster in 1999 they have been very widely used, particularly for file sharing. These networks allow users from all over the world to connect directly to each other and share data such as movies, books and music. In 2010 more than half of all Internet traffic was attributed to P2P. But the use of these technologies is not limited to simple file sharing. Freenet was launched in 2000 allowing people to publish decentralized websites (Freesites) distributed across the machines of the network's users. A little after that, the BitTorrent protocol was created by Bram Cohen. BitTorrent was and still is particularly well suited to transferring large files in a P2P fashion, allowing simultaneous downloads from multiple peers. The next notable development arrived after the financial crash, which very nearly brought the global economy to its knees. In 2009 Satoshi Nakamoto released Bitcoin and gave the world a 'trustless' decentralized digital currency that is not controlled by bank, government or institution. The blockchain—the immutable ledger that records all Bitcoin transactions—was something very new, solving at a stroke the difficult and long-standing problem of creating a trustless source of the truth for transactions. The ownership of 'addresses' in the network can be proven by the usage of private cryptographic keys in a Public Key Infrastructure (PKI) — hence the term cryptocurrency. It should be noted, however, that connections between Bitcoin nodes are not fully encrypted. {% hint style="success" %} **Autonomi is the next big step in the evolution of P2P networks, combining the vision of decentralized file sharing and decentralized services together with an internal currency and several additional innovations to enhance security, privacy, performance and stability.** {% endhint %} MaidSafe, a Scottish company with developers around the world, has been researching and developing this project since 2006. Since that time, many more people have come to recognize the vital importance of a global, secure and private decentralized platform for storage and communication. # A Self-Organizing System Simplicity is strength. From basic elements and a simple set of rules, sophisticated structures with integral security, adaptability and resilience can emerge, thanks entirely to the simplicity of their building blocks. Examples are all around us, if we care to look. Ants are not, as far as we know, mathematicians, engineers, doctors, epidemiologists or military tacticians, but by following a few biochemical rules and role specialisations, these simple creatures organise themselves into sophisticated colonies of thousands or even millions of individuals. They build elaborate nests, solve complex problems such as fording rivers, guard against disease and enemies, and colonise new territories. Present in almost every country on Earth, the humble ant is one of the world's most successful creatures. We can learn a great deal from ants, bees, fungi and other self-organizing systems in nature. The key lesson is that, given the right conditions, robust, resilient and highly complex systems can evolve naturally from individuals grouped into small units that know nothing of the big picture. Unfortunately, this lesson has not always been learned by technologists and engineers, who are too often attracted to grand ‘theories of everything’ and total control, and who have to resort to kludges when, inevitably, reality doesn't conform to their equations. They build complex systems based on complex elements and the layers of fixes make them more complex still. The result: insecurity, incompatibility, instability, inefficiency and incomprehensibility, not to mention expense. ## The Autonomous Network Inspired by the self-organisational prowess of ants, Autonomi creates a secure, resilient network of devices, connected and governed by simple rules yet capable of storing, protecting and delivering humanity's data in perpetuity without any human involvement at all. Autonomi is the vision of MaidSafe, a Scottish software company with two decades of experience in the field of decentralized computer networking. It is an autonomous peer-to-peer network created by linking together users' computers and smartphones. It's designed to address many of the current technical, managerial and societal problems exacerbated by the centralization of control of the web by a few powerful actors, namely intrusions into privacy, poor data security and censorship. Anyone with a connected device can use the Network anonymously to store data, and anyone can supply their spare storage and computer resources *to* the Network. It's a globally accessible infrastructure assembled from everyday things. Autonomi is a surface on which new digital worlds can be constructed. This guide outlines how it's is constructed to achieve these aims. While it is somewhat technical in places, it's intended very much as an overview, and even those with very little technical knowledge should be able to gain a good working understanding of Autonomi. For those requiring more depth, there are plenty of pointers as to where they can find the relevant information. # Fundamental Principles There are a number of core ideas that have driven each stage of the design of Autonomi. These can be distilled into the following 20 fundamental principles. ### Autonomi will:
1. Allow anyone to use the Network without intervention Browsing, accessing, downloading, and utilizing Autonomi will never require a third party.
2. Enable users to securely share information without intermediaries By design, Autonomi doesn't allow third parties to either read or store the information sent by a user without that user’s consent.
3. Allow the transfer of the Network currency to any user free of transaction costs Transfers between users will not have any transaction fees. However should any associated data be stored to the Network, a [Data Payment](broken://pages/ehWRJe7UX0mDtQaEdnaO) may still be required.
4. Enable users to anonymously create and share data worldwide The Network ensures that the user has the ability to send messages, posts, and data without the need to link it to any known identity on the Network.
5. Let anyone browse content anonymously and free of charge …and without the need to create an account
6. Allow users to associate multiple identities with their account You can choose any combination of pseudonym, real persona, or composable, decentralized identity that suits their needs, goals and context of use. Or utilize the Network without any identity at all, it's up to you.
7. Let users utilize any of their identities to send and receive payments Each individual must be able to use any of their identities as a wallet address to send and receive Autonomi Network Tokens.
8. Store data in perpetuity All data uploaded will be available to its owner for the lifetime of the Network. You'll pay once to upload, but downloads are always free.
9. Never store passwords on the Network nor on machines used to access it
10. Allow anyone to access the Network and leave no trace of their activity on the machine
11. Obfuscate IP addresses as far as underlying technology allows
12. Allow nodes to join at any time, with any payouts subject to the laws of supply and demand
13. Increase operator rewards when it needs more resources (e.g. more nodes to increase storage capacity) and decrease rewards when resources are plentiful. This is the primary mechanism for balancing supply and demand.
14. Ensure unreliable or malicious nodes are incapable of performing meaningful actions
15. Not have servers! Autonomi will never rely on servers (as the term is traditionally understood) as to do so introduces a third-party weakness that would undermine the entire Network.
16. Digitally sign all transactions To ensure that the transactions have been authorized in accordance with the rules of the Network.
17. Ensure that client-to-client direct messages are free i.e. those not transmitted via other nodes in the Network.
18. Never use time as a network tool There can be no concept of time in a truly decentralized network, as this would require reaching out to centralized servers and services.
19. Only use encrypted services and encrypted traffic
20. Allow real-time upgrades in a secure manner The Network will refuse upgrades that could break it. We expand on these fundamental principles in the chapters that follow. Combined they aim to give all users the freedom to safely store data on the Network, to share information with others securely, to publish data cheaply and easily and to communicate using secure channels and apps.
# Key Features ### An **Autonomous** Network Autonomi goes a step beyond typical decentralized systems. It is a network that can act both as a global market for computer capacity, but also turn that capacity into usable capability that's native to the Internet itself, not just a pointer to existing cloud services. It's a self-healing, course-correcting system; a huge resource layer that anyone can utilize with no permission required. ### **Blockchainless Data** Data storage on the Network use is a Decentralized Ledger Technology (DLT) that doesn't utilize blockchain, so it's able to sidestep many of the obstacles to scale inherent typical decentralized storage solutions. The bigger it gets, the more it can do. ### **Post-Quantum Security** Anything stored on the Network is self-encrypted on your own device before upload, and every connection between nodes uses NIST-standardised post-quantum cryptography. The transport layer is quantum-resistant from the very first byte, not just the application layer on top. This means Autonomi combines client-side encrypted storage with connections designed for the quantum era, while keeping your data out of plain sight on the network. ### **Commodity Devices** The Network is assembled from a multitude of connected devices, of all shapes and sizes. It's deliberately designed to allow even the smallest computers to be able to contribute, rather than just relying on enterprise data centres. Not only does this make the most of humanity's spare resources—which is better for the planet—but it means it’s inherently more decentralized and secure, thanks to the millions of devices able to participate. ### Privacy Zero-knowledge: The Network's protocol employs multilayered encryption, protecting the privacy of users data both during storage and during transit. Nodes cannot determine the content, nor origin of data they hold or transmit, even if it is their own. No tracking: thanks to its various encryption schemes, tracking and surveillance of browsing and data usage patterns—commonplace business practice on the incumbent web—is no longer possible. Privacy is by default. Users of the Network have sovereignty over their personal data, and can maintain and control access to it, while still making use of rich and accessible services and software. Cryptographic keys replace passwords and accounts. Users need only a single secret key while interacting with an unlimited number of services, businesses, identities, or contexts of use.
# Overview When you use the Network to store some data it is split into ‘chunks’. Each chunk is securely encrypted with a set of credentials that are only known by the creator—who has the keys to unlock the data and reassemble it into information again. These credentials never touch the Internet. Data ‘chunks’ are then sent to the Network, duplicated several times for extra security, and dispersed evenly and randomly across the globe, along with a map of where they are and how to reassemble them. Once again this is securely encrypted and only accessible to the holder of the keys. The encrypted data chunks are held by a multitude of everyday devices, called nodes, these all offer a small portion of their spare, under-utilized capacity, to securely hold a small collection of encrypted data chunks, serving them back to their owner when asked. Nodes in the Network are independent but work together in cooperation. Each has a randomly determined location in the Network, and from this location, monitors the health and behaviour of neighbouring nodes it connects to. Nodes check and double-check each other's ability to keep on holding and serving data. They cooperate based on a set of rules and incentives that reward good behaviour but shun the bad; quickly dropping uncooperative nodes from the Network Each piece of data stored is looked after by a small number of nodes called a close group, a group which only exists for that specific data. This allows nodes to act independently, but together to form a strong autonomous global network, capable of storing and retaining data in perpetuity. As nodes come and go, as devices are turned on or off, this redundant data is replicated again and shuffled to new nodes that must perform the same task. Nodes are rewarded for holding data, and offering their spare capacity for the collective good, by payment in Autonomi Network Tokens (ANT) — an ERC-20 token on the Arbitrum One network with a fixed total supply of 1.2 billion tokens. ANT acts as a medium of exchange for these resources, and allows the autonomous market to function. When someone (a person or a collective) uploads data they pay a one-time fee at point of upload and then the data is stored for the lifetime of the Network. It will always be free for the owner to access and download, it is perpetual data. While perpetual data is an attractive proposition in an age of spiralling ongoing costs, it is also essential if the data owner is to have true sovereignty, autonomy, and control over the data they own: you cannot be blocked from it and you cannot lose access to it. That frees owners of data—whether they’re individuals, collectives or organisations—from ongoing charges by cloud providers as well as on-going contract renegotiations, truth of source, and terms of access (and use). # Fully Autonomous Data Network **Autonomi can be seen as a secure, encrypted, intelligent layer that sits on top of the current Internet, complementing the top three layers in the OSI model and adding resources in the application layer.** Going a little deeper, Autonomi introduces some changes to the networking and application layers as shown below.

Autonomi compliments three of the seven networking layers in the OSI model for improved security, privacy and autonomy

Many features of Autonomi are genuine innovations, but there is no intention to reinvent the wheel. It builds on existing decentralized technologies such as Kademlia and is based on the physical and data infrastructure of the Internet. Early development of Autonomi (formerly the SAFE Network) happened in parallel with blockchain, but it has taken an alternative route to solve the decentralization puzzle. Autonomi can be seen as a secure, encrypted, intelligent layer that sits on top of the current Internet, complementing the top three layers in the OSI model and adding resources in the application layer. This enables secure, anonymous, decentralized data storage and networking. Its core libraries are written in the Rust programming language. The diagram below shows the basic hierarchy. **NOTE: The stack diagram below is outdated and will be replaced. The v2 stack is: ant-client / ant-sdk (developer interfaces) → saorsa-transport (shared transport abstraction with QUIC NAT traversal) → saorsa-core (Kademlia DHT routing, trust) → saorsa-pqc (post-quantum cryptography).**

The Autonomi Network Stack (to be updated for v2)

Autonomi 2.0 is a permanent, immutable data store. Data integrity is guaranteed by the content-addressing of self-encrypted chunks and cryptographic verification by close group nodes at upload time. Client connections are managed via a custom QUIC transport layer (saorsa-transport) with native NAT traversal, and are mediated via the client API. There is a command line interface (CLI) for this purpose, and apps written in Rust can access network functions directly via the API. Apps written in other languages do the same via the ant-sdk daemon and its REST/gRPC endpoints, with bindings available for 15 languages. Nodes and clients provide the main means for users to interact with the Network, either by providing resources in return for payment by running a node or by storing data and interacting with data as a client. # A Serverless Web The existing Web is formed of servers and clients. Clients request data and servers provide it. The Autonomi Protocol does not use this client-server model. Instead stored data is spread across a network that’s made up of the spare computing resources of contributing users. When a request for some content is made, a message goes out across the Network and machines that hold the constituent parts of that content—the nodes—return them to the requester, the client {% hint style="info" %} #### **Keeping it Simple** Autonomi is comprised of its users' machines (nodes) linked together by node software which routes data and messages securely between them. These machines provide the Network's storage by allocating a portion of their hard drives for this purpose—and earning the Network's token currency in return. {% endhint %} So, the Protocol considers two basic components: [nodes](/how-it-works/fully-autonomous-data-network/nodes) and [clients](/how-it-works/fully-autonomous-data-network/clients).\ \ You don't have to run a node to use the Network any more than you have to run a web server to use the Web. Client software allows users to create a secure, private data store, and browse the Network securely and anonymously without being part of the Network. A single computer can run both node and client software at the same time. *** {% hint style="info" %} #### Tell me more! [Autonomous Network (MaidSafe white paper, 2010)](http://docs.maidsafe.net/Whitepapers/pdf/AutonomousNetwork.pdf) {% endhint %} \
# Nodes The Autonomi Network is formed of interconnected machines running node software. This software connects the devices to each other using the [QUIC](/learn-more/glossary#quic) protocol with native [NAT traversal](/learn-more/glossary#nat-traversal), manages data and routes it around the Network. It allows users to offer computer resources, like hard drive space, to the Network, and earn Autonomi Network Tokens (ANT) in return. This process of providing a service in return for a reward is analogous to Bitcoin mining, but is designed to work on everyday consumer hardware. The node software is a small executable file that connects the user’s machine to the Network, turns it into a routing node and also allocates some disk space for storage. It manages the storage of data chunks on the user’s computer and in that way provides storage capacity to the Network. It also routes and caches data chunks (these are encrypted) over the Network via post-quantum encrypted QUIC connections to other nodes. Each node maintains a list of its ‘close group’, other nodes with IDs (XOR addresses) close to its own. Data stored at a node will also be replicated to members of its close group for redundancy. Nodes fulfil several functions. They route and store chunks of data; they cryptographically check messages; they cluster into temporary close groups, and thus manage a certain portion of the Network; and they store replicas of data chunks for redundancy. Every node has an identity based on post-quantum cryptographic keys (ML-DSA-65). Its [PeerId](/learn-more/glossary#peerid), the network identifier other nodes use to recognize it, is derived from that identity as the BLAKE3 hash of its public key. When nodes connect to each other, they authenticate through a quantum-resistant handshake built into the [QUIC](/learn-more/glossary#quic) transport layer. No certificates or central authorities are needed. Importantly, nodes can run from any home internet connection without port forwarding or manual configuration. NAT traversal is handled natively — the network tries a direct connection first, then coordinated hole punching, with a relay fallback for the most restrictive firewalls. This is what makes it possible for everyday home computers to participate. # Clients Just as you don’t need to run a web server to use the Web, so you don’t have to run a node to access the Autonomi Network. Ordinary users interact with the Network via the client. Clients includes things like browsers, apps, wallets, and file systems—any software that interacts with the Network to perform operations such as data retrieval, storage, or management.\ \ Browsing, and accessing data on Autonomi is end-to-end encrypted. Data is only reconstructed into readable information on the client device, greatly enhancing security and building in privacy by design.\ \ It's worth noting that you don't need an 'account' to access data on Autonomi, nor do you need to pay to access data downloading is always free. You only [pay when you store ](broken://pages/ehWRJe7UX0mDtQaEdnaO)or edit data—and there are no recurring fees either, data uploaded is stored for the lifetime of the Network: Perpetual Data. # Network Architecture Storing data and eventually using applications on the Autonomi Network will be as simple as on the current Web but with greatly enhanced privacy, security and control. Autonomi is designed with ease of use in mind for app developers, too. Developing simple apps is just a short step from what developers are familiar with in terms of APIs and methodologies. However, those wishing to perform more complex system-level tasks will need to go deeper into its architecture—there are some big differences between traditional client-server systems and decentralized architectures. This section provides a brief introduction to the underlying technical architecture of the Network, including its Kademlia-based DHT, QUIC transport layer with native NAT traversal, and post-quantum cryptographic identity system… # Building on Kademlia The first step in understanding the architecture of Autonomi is to take a look at distributed hash tables. These are structures that map a unique ID to something on the distributed network, be that data, a device or a service. Kademlia is a distributed hash table (DHT) protocol which provides a way for millions of computers to self-organize into a network, communicate with other computers on the network, and share resources between devices, all without a central controlling entity. Petar Maymounkov and David Mazières released the Kademlia distributed hash table in 2002. The idea is that nodes form a network overlay, and are identified with a different node identification system. So a node with an IP address of 96.251.182.97 might have a 256-bit XOR address that looks like this: `17846cb8a4b53c9e44c616d2415a15984283eee975a1dac8f488dd91d0aed1cd`. Bitwise Exclusive OR (XOR) has the feature that each address is a unique distance from any other address in the address range. XOR distance bears no relation to physical distance. Indeed, two pieces of data on the network may be very close XOR-wise but be sitting on machines located on opposite sides of the world. With potentially millions of devices on a network, there's no way a single node could keep track of them all without running out of resources. Instead it keeps a record (a routing table) containing information about a small number of other nodes and lets the magical uniqueness of XOR distances do the rest. Each node is a unique distance from every XOR address in the space, which means its routing table is also unique. The address space is enormous: 2^256 is more than the number of atoms in the universe. To make this space manageable it is broken into k-buckets. The furthest away bucket (in terms of XOR distance) contains half the network, the next furthest away represents a quarter of the network, the next furthest an eighth, and so on. Autonomi is based on Kademlia. Each node's routing table contains information on up to 20 nodes in each k-bucket. This means it knows everything about the nodes in the address space close to it, but very little about space furthest away—but crucially it does know some nodes in that space, and those nodes, of course, know everything about other nodes close to them and can pass messages on. The bigger the Network becomes, the more secure it will get because an individual node will have influence over a decreasing range of addresses. Every piece of data has a unique address; in the jargon it is ‘[content-addressable](/how-it-works/network-architecture/content-addressable-storage)’—its content defines where it is stored. When a node wants to retrieve a piece of data, it checks its address, then asks the node closest to that address whether it's holding the data. That node in turn checks the address and sees whether it knows a node that's closer. If it does, it passes the message on to that node, and so on, until it reaches the node that's actually holding the data. The same messaging process happens when saving data too. It is very fast and efficient, with the enormous address space being traversable in just a few hops. In the Autonomi Network, a node's closest neighbours (again, in XOR terms) are called its ‘close group’. Data stored at a node is automatically replicated to the nodes in its close group for redundancy. As nodes leave and others join (a process known as churn) the node's close group will change. The size of the close group is defined by a tuneable parameter, currently it is set at 5. So, nodes must constantly update their routing tables. They do this by observing which nodes are alive, dead and newly arrived during the course of their day-to-day operations. # Connectivity and NAT Traversal Autonomi is designed so ordinary devices can join the network from home or office internet connections, even when they sit behind routers and firewalls. To make that work, the network needs a reliable way to discover peers, establish secure connections, and stay reachable without asking most people to configure ports manually. ## Why this matters Many decentralized networks work best on publicly reachable servers or require manual setup. Autonomi is designed so most nodes can connect from ordinary internet connections instead. For you, that means: 1. Most nodes can run without manual port forwarding. 2. The network first tries to connect peers directly. 3. If that does not work, it tries hole punching, then falls back to a relay. ## How peers connect Autonomi uses [QUIC](/learn-more/glossary#quic), a modern transport protocol built on UDP, as the basis for peer connections. QUIC allows fast connection setup, multiple data streams over one connection, and built-in TLS 1.3 encryption. To get peers talking across routers and firewalls, the network uses [NAT traversal](/learn-more/glossary#nat-traversal). In practice, that means a three-step strategy: 1. **Direct connection** — peers connect directly where possible. 2. **Hole punching** — the network coordinates a connection between peers behind NAT. 3. [**MASQUE relay**](/learn-more/glossary#masque-relay) — if direct connection and hole punching both fail, traffic is relayed as a last resort. This keeps the network reachable in restrictive environments while keeping direct peer-to-peer connections as the default. ## Connection security Every connection uses post-quantum cryptography from the first byte, so peers can establish secure connections without falling back to classical public-key cryptography. ## Peer identity Each node has a [PeerId](/learn-more/glossary#peerid), the network identifier other nodes use to recognize it. That identifier is derived from the node's cryptographic identity, so a node cannot choose its own position in the network arbitrarily. This helps the network identify peers consistently, coordinate connections, and measure which nodes are closest to each other and to a given piece of data. ## Under the hood The shared transport layer is [`saorsa-transport`](/learn-more/glossary#saorsa-transport). It handles connection setup, address discovery, NAT traversal, and relay fallback. The same transport is also used by [x0x](/learn-more/glossary#x0x), though Autonomi and x0x use it for different higher-level purposes. Autonomi's transport layer uses `ML-KEM-768` for key exchange and `ML-DSA-65` for signatures, with no classical fallback. Each `PeerId` is the `BLAKE3` hash of the node's `ML-DSA-65` public key. ## Related pages * [Nodes](/how-it-works/fully-autonomous-data-network/nodes) * [Post-Quantum Identity & Credentials](/how-it-works/encryption-and-authentication/multisig-credentials) * [Glossary](/learn-more/glossary) # Content-Addressable Storage Content stored on Autonomi is first broken into chunks, hashed and then encrypted, in a unique process known as [Self-Encryption](/how-it-works/encryption-and-authentication/self-encryption). Those chunks are run through a hashing algorithm to create a unique 256-bit hash for each chunk. Only chunks that are exactly identical will have the same hash value. This hash serves as the XOR address on the Network where that chunk will be stored, which in turn determines the nodes that will manage it. Chunks with hashes that lie within a certain address range (say 000010... to 000011...) will be secured, stored and managed by the nodes whose IDs are closest (in XOR terms) to that address. These will change over time as new nodes join and others leave. {% hint style="info" %} The hash of a chunk of data serves as the XOR address on the Network where it will be stored, which in turn determines which nodes will manage it {% endhint %} Nodes are paid for data chunks they hold, but not for replicated data. They are expected to hold replicated data as a condition of participating in the network and having the chance to earn. As nodes fill up, the [price of storing a chunk of data rises](broken://pages/f28SMy5nhNUhU9OtLWKf). All nodes on the Network fill up at more or less the same rate although there will be some local variations and hence a range of prices. Nodes cache data when a new close node appears and they share some of their primary data store with that node. This cache isn't included in the fullness calculations. It is just something they are required to do to ensure smooth data transfer. For security, nodes cannot delete or edit data, only store and move it. libp2p allows for the existence of specialised nodes for providing services such as caching. These will be introduced in later iterations of the Autonomi Protocol. It's important to note that all the features above emerge from simple local interactions between nodes. Likewise, the codebase is simple, making it easier to maintain, update, audit and secure.
# Encryption and Authentication Content on Autonomi is stored as encrypted chunks. The original content can be recreated from these chunks, provided we have a map of where the chunks are plus the keys to decrypt them.\ \ A 'file' on the Network is really a collection of chunks, with a datamap that allows us to discover all the chunks and decrypt the file. Files are kept in folders which are created as part of the [Self-Encryption](/how-it-works/encryption-and-authentication/self-encryption) process and are encrypted, meaning their contents are only accessible to their owner by default. The API for upload by default self-encrypts all files. {% hint style="info" %} **Keeping it Simple** All content on Autonomi is encrypted by default. When content is stored on the Network it is first broken into chunks, hashed and then encrypted and these chunks are themselves encrypted using the hash of another chunk from the same file. This is ‘self-encryption’—a method originally patented by MaidSafe but now open-sourced. The encryption uses ChaCha20-Poly1305 for symmetric encryption and BLAKE3 for hashing. When content is made public, its containing folder is decrypted, meaning anyone can reassemble the chunks. {% endhint %} At the network level, Autonomi uses the QUIC protocol (built on UDP) and all data moved by this protocol is encrypted from 'bit 1', using post-quantum cryptography. The TLS 1.3 handshake integrated into QUIC uses ML-KEM-768 for key exchange and ML-DSA-65 for digital signatures — both NIST-standardised post-quantum algorithms. This means connections are quantum-resistant from before any application data is exchanged. So communications between the Network and the user are always encrypted, never in plain text. No classical cryptographic fallback is used — Autonomi 2.0 is 100% post-quantum at the transport layer. Note that any node on the Network can be used as a bootstrap server so long as its IP address is added to the configuration file of the joining node. It does not have to be one provided by MaidSafe. # Self-Encryption **All content (documents, images, videos, etc.) on Autonomi are encrypted.** When a client uploads a piece of content to the Network (for example a video) it is first broken into chunks (each up to 4MB). Those chunks are then ‘self-encrypted’, a process originally patented by MaidSafe but now open-sourced, by which each chunk is encrypted using the ChaCha20-Poly1305 cipher with keys derived from its own BLAKE3 hash and the hashes of the two previous chunks in the same file. These encrypted chunks are then hashed again to arrive at the XOR Network address where the chunk will be stored. At the same time, a ‘data map’ is created on the client device, which maps the chunk number to the XOR network address of the chunk and the hash to decrypt it and its two successors, allowing the content to be recreated. A number of copies of each chunk are stored by nodes in the close group to ensure redundancy. Data maps and other metadata are not encrypted, but on the network they are kept inside encrypted folders if the data is private. The Data Map is the key to your content. Without it, the chunks are meaningless encrypted fragments scattered across the network. Data Maps are a client-side construct — when stored on the network, they’re stored as chunks themselves. What makes data public or private is simply where the Data Map lives: * **Private (default):** Data Map kept locally on your device — you alone have the "recipe" to reassemble the chunks. If you lose the Data Map, your content is inaccessible forever. * **Public:** Data Map stored as a chunk on the network — anyone with its address can retrieve the Data Map and access your content. * **Private but persistent:** Encrypt and store the Data Map itself as a chunk on the network, protected by your key. Only someone with the correct key can retrieve and decrypt it. This lets you access your content from any device. The client retains the data map for the content it has uploaded and keys to decrypt it locally. That way no keys or passwords need ever leave a person’s device. Users can choose to share content with others by sharing their keys / data map with them. They can also choose to make the content fully public, in which case the folders containing the relevant files are unencrypted. {% hint style="info" %} **Deeper Dive…** [Self-encrypting Data — MaidSafe White-paper (2010)](http://docs.maidsafe.net/Whitepapers/pdf/SelfEncryptingData.pdf) \[PDF] {% endhint %}
# Multilayered encryption Autonomi uses several layers of encryption to protect a user's anonymity and privacy. The Network is designed to be as 'zero-knowledge' as possible, to the extent that node operators cannot possibly figure out what chunks from which private file they are storing — even if it's their own. By utilizing multiple levels of encryption, Autonomi provides a platform for applications that is both highly secure and anonymized by design. These layers work together: **Self-encryption:** Content is chunked and encrypted on the user's device before it ever touches the network, using ChaCha20-Poly1305 encryption and BLAKE3 hashing. Each chunk is encrypted using keys derived from its neighbouring chunks, creating a web of interdependencies — tamper with any one chunk and the whole structure breaks. **Post-quantum transport encryption:** All connections between nodes and clients are secured by NIST-standardised post-quantum algorithms (ML-KEM-768 for key exchange, ML-DSA-65 for authentication). The connection is quantum-resistant from the very first byte — before any of your data is exchanged. **Content addressing:** The network address where a chunk is stored is derived from the hash of the encrypted chunk itself. This means the network's routing layer reveals nothing about the content of the data it moves — the address tells you nothing about what's inside. # Self-Authentication With data self-encrypted, and its many parts stored by their content address throughout the Network, any one single point of file access is removed, as by default the map to this data is not publicly accessible on the Network. [Self-Authentication](https://docs.maidsafe.net/Whitepapers/pdf/SelfAuthentication.pdf) means access to this data, and the means to reassemble it into information, always resides with the user, never leaving their device (i.e. not accessible to a ‘cloud’). Another key innovation of the Network—at no point does the Network ever store a user’s credentials, there is no chance of passwords being attacked, nor can any user’s data (individual, collective or organisation) be targeted on or via the Network. The authentication system utilises Boneh-Lynn-Shacham Distributed Key Generation (BLS), so that users can securely and anonymously access data, with no central server required to mediate the login process, nor are trusted third parties to store and manage the users’ credentials. It means users can reliably and securely access data from any machine, without ever sending or sharing their details. Furthermore, it also allows for multi-signature credentials for permission-less recovery, without a single point of failure. {% hint style="info" %} #### Deeper Dive… [Self-Authentication White Paper — MaidSafe (2010)](https://docs.maidsafe.net/Whitepapers/pdf/SelfAuthentication.pdf) \[PDF] {% endhint %} # Post-Quantum Identity & Credentials Autonomi 2.0 uses ML-DSA-65 (NIST FIPS 204) post-quantum digital signatures for all identity and authentication, with ML-KEM-768 (NIST FIPS 203) for key exchange — both at NIST Level 3 security. Each user's identity is based on a cryptographic key pair — there are no usernames, passwords, or central authentication servers. Post-quantum keys are larger than classical keys — this is the cost of quantum resistance: * ML-DSA-65 public key: 1,952 bytes (vs \~32 bytes for Ed25519) * ML-DSA-65 signature: 3,309 bytes (vs \~64 bytes for Ed25519) * ML-KEM-768 public key: 1,184 bytes These sizes affect handshake overhead (\~7.5KB vs \~228 bytes for classical TLS) but do not impact data throughput once a connection is established. There is no classical cryptographic fallback. A user's secret key is the root of their identity on the network. From a single master secret key, unlimited child keys can be derived using HKDF (HMAC-based Key Derivation Function). This enables: * **Separate keys for different apps or contexts** — logical separation without managing unrelated keys * **Delegation** — derive a child key for a specific purpose, share it without exposing the master * **Hierarchical access control** — organise data access through key hierarchies * **Per-application data organisation** — each derived key has its own address space on the network Credentials are extremely important, but credential loss can be a serious problem on decentralized networks where there is no central authority to help recover or reset forgotten passwords. **Key Management Best Practices:** Users should securely back up their master secret key. Without it, all data derived from that key — including all child keys and their associated data — becomes permanently inaccessible. There is no recovery mechanism on a decentralised network. For enhanced security, users may choose to split their key across multiple devices or locations, so that no single point of failure results in complete loss of access. # Network Economics In a peer-to-peer, decentralized system, the economic model is one of the most critical components—delivering the incentives of supply and demand to effectively attract, engage and reward participants.\ \ Autonomi's economic system is designed to: ### **Incentivize Node Operators** Encourage node operators to contribute storage space, bandwidth, and computing resources, thereby fostering growth and scalability. ### **Establish a Governable Economic Framework** Construct a resilient economic framework capable of adapting to changes in the external environment. ### **Drive Growth in Network Size and Utility** Support the resilience and growth of the Network by rewarding developers, strategic partners and other key contributors. ### **Sustainably Reward Creativity and Innovation** Meaningful rewards for software development, services, and data that provide value to those using the Network, and that benefit wider society. # Key Properties The token for Autonomi serves as the incentive for node operators to join The Network and cooperate toward the goal of providing secure data storage. Conceptually this is similar to that of Bitcoin: to ensure that cooperative participation is a more rational course of action than uncooperative or malicious activity. Tokens can also be transferred directly between users and used as a means to pay third parties for goods and services. There is no charge for downloading data, but uploaders must pay a one-time fee to pay for storage. * There will be a total [maximum supply](https://docs.autonomi.com/learn/how-it-works/network-economics-under-construction-to-align-with-wp-2.0/key-properties/token-supply) of 1,200,000,000 (1.2 Billion) tokens created over The Network’s lifetime. * Every data upload incurs payments from uploaders to node operators (including during the early phase of The Network an applicable ‘[gas fee](https://docs.autonomi.com/learn/how-it-works/network-economics-under-construction-to-align-with-wp-2.0/key-properties/tokens-and-payments)’. * Unlike conventional cloud or decentralized storage, there is no extra or ongoing fee beyond the initial data payment, preventing cost escalation. This transparent payment system ensures predictability and affordability for users, and allows applications and services to scale rapidly without large data or infrastructure cost burdens. * Most importantly, this approach allows the system to not track data ownership and not give anyone the ability to delete files. This is vitally important for the security and privacy aspect of The Autonomi Network. * Physical infrastructure-based decentralized platforms require upfront infrastructure availability before usage can scale. This not only applies to the DePIN projects, but also to cloud providers such as AWS and GCP. To support node network growth, there will be early emission incentives for node operators (please see ‘Emissions Incentives’) * Node operators will be incentivized to provide correct service to The Network (qualifying to [quote](https://docs.autonomi.com/learn/how-it-works/network-economics-under-construction-to-align-with-wp-2.0/key-properties/quote-calculations) for data uploads by being available and online) - incorrect service will result in exclusion from the ability to quote and receive payments for hosting. Ultimately, incorrect behaviours will result in prompt exclusion of the nodes from The Network, removing their ability to earn. * Tokens (in the early phases of the network) will be on the Ethereum Network (as an ERC20 standard token) and will, by extension, benefit from the transferability, accessibility and integrations boasted by the same. # Token Supply There will be a total ***Maximum Supply*** of 1,200,000,000 (1.2 Billion) whole tokens created over the Network’s lifetime.
#### Token Holders MaidSafeCoin (also known and referred to as ‘OMNI MAID’) was the origin token of the MaidSafe project, at the time known as The SAFE Network. It was issued as part of a crowd-sale in April of 2014 (MaidSafeCoin was the 10th crypto token ever to launch). These tokens have a 1:1 relationship to Autonomi Network Tokens (ANT) and Autonomi’s future ‘Native Token’. Token holders also include those with ‘EMAID’ (the current ERC-20 token), these holders will be ‘airdropped’ Autonomi Network Tokens 1:1 at or shortly following The Network’s Token Generation Event (TGE), following an advised ‘wallet’ snapshot. Also included in this the group of ‘Token Holders’ are those who have earned token allocations via network testing incentives and reward programs prior to TGE —- these participants will receive Autonomi Network Tokens at a ratio of 1:1 to ‘Test Tokens’. This allocation represents 38% of the Maximum Supply, an increase of 8% from 1.0 of the White Paper. #### Emissions Allocation In the early years of The Network especially there is need and therefore an allocation for emissions - governed by a smart contract. Based on community feedback this pool has been reduced to 240,000,000 tokens (20% of Max Supply), which will be emitted over a 12 year period. This is a change from 3,167,866,884 tokens, representing 70% of the Maximum Supply, which was to be emitted (at a diminishing rate) over a period of 30 years. #### Autonomi Foundation The Autonomi Foundation (formerly known as the SAFE Foundation), will play a critical role in enhancing the network through 3 specific areas of activity: 1. **Network Support:** via marketing and partnerships (including but not limited to centralized exchange requirements and liquidity provisions) 2. **Network Support:** via network team responsible for improvements and key developments - Native Token, Mobile Nodes and Upgrades 3. **Network Incentive:** via reward and incentive payments to network applications, builders and supporters The Autonomi Foundation will receive payments via a Smart Contract with allocated amounts that will unlock over a 50 year period: * Year 1: 20% * Year 2-5: 34% * Year 6-12: 31% * Year 13-50: 15% **MaidSafe Shareholders** Shareholders have been allocated 214,748,365 tokens which will be distributed after TGE. # Gas Fee Autonomi will launch with an ERC-20 network token, the Autonomi Network Token (ANT), utilizing smart contracts for token releases and batching multiple transfers into single transactions for efficient gas usage. At the time of writing, a combination of 4MB chunk size and batching means a 150MB file is currently incurring $0.25 gas fee (noting while the quoted price here is currently indicative that it will be subject to Ethereum network fluctuations). The decision to use a blockchain payment solution for the early launch phase of Autonomi, along with deployment time to market advantages, to assist in the network’s ability to scale. Ethereum (Autonomi is using a ‘roll-up chain’ - Arbitrum One, an ‘L2’ - see ‘[Glossary of Term](https://docs.autonomi.com/learn/learn-more/glossary)s’ for brief description on both), is a battle-tested blockchain with proven and respected security features. Until Autonomi has attracted significant levels of participants and data, accessing and benefiting from one of the biggest ecosystems of users, tools and applications (block explorers, DEXs, CEXs, wallet applications etc), will provide the network with significant advantages (via user access, assurance and experience) in its early phase of growth. **Payment Optimisation:** For large uploads, Merkle Tree batch payments reduce on-chain cost from O(n) per chunk to O(1) per batch — a single Merkle root submission on Arbitrum covers an entire batch of chunks. This makes large-scale archiving economically practical. # Quote Calculations Autonomi does not use a flat storage price. Instead, each node quotes a price based on how full it already is. The quote a node returns is based on how many records it is already storing, which gives the network a simple supply-and-demand signal without needing external oracles or manual price setting. ## Pricing Formula Storage pricing follows a calibrated quadratic curve based on node fullness: ``` price_per_chunk_ANT(n) = 0.00390625 + 0.03515625 × (n / 6000)^2 ``` Here, `n` is the number of records currently stored by that node. The non-zero baseline provides a spam barrier even when nodes are empty, and the quadratic term increases pricing as nodes fill up, pushing new uploads toward less-loaded parts of the network. ## Example Points * `n = 0`: `0.00390625 ANT` (baseline only) * `n = 6000`: `0.0390625 ANT` * `n = 12000`: `~0.1445 ANT` * `n = 24000`: `~0.566 ANT` These points show how the baseline keeps pricing non-zero when nodes are empty, while the quadratic term makes prices rise much faster as nodes become more full. # Consensus Not Required ### A Hard Problem Truly decentralized networks can have no master node or oracle to judge what is true or valid and what is not. Instead, the nodes that make up the Network must come to an agreement among themselves about which of many possible versions of "the truth" they will accept and the order in which events occur. This is challenging because each node has a different view of events. They must find a way to converge. ### Decentralized conflict resolution The bitcoin blockchain uses Proof of Work (PoW) to solve these problems of achieving decentralized consensus over the ordering of events to prevent the problem of double-spend – being able to spend the same coin twice – and Byzantine behaviour. Miners battle to verify a block of transactions. If there are two simultaneous winners the chain will split and for a time there are two versions of the truth, i.e. two chains emanating from the disputed block. Ultimately, though, after a few blocks have been added one chain will be longer than the other, and it is this chain that will be accepted as the true state. PoW has proved largely effective against the Sybil attack, also known as the 51-percent attack, where one entity owns more than half of the mining power, but it is slow, massively energy-intensive and it doesn't scale. Also, the consensus is probabilistic rather than deterministic: after some time, you might be 99.9 percent sure that all nodes agree on network state, but never 100 percent. Other blockchains such as ethereum use Proof of Stake (PoS). While much more environmentally friendly, there is a tradeoff in terms of equability in that larger holders of the currency have more power. Autonomi is *naturally secure*, meaning that it doesn't need any artificial slowing down or behavioural assumptions to keep data safe. It does not use PoW or PoS for consensus. Autonomi's core storage layer deals primarily with immutable, content-addressed data — chunks whose address is derived from their content hash. This means there is no conflicting state to resolve: a chunk either exists at its correct address or it doesn't. The close group of nodes responsible for a chunk's address collectively verify and store it. The network also employs constant tests that nodes are reliable, and a local trust scoring system that tracks node behaviour over time — using an exponential moving average (EMA) to weight recent behaviour more heavily, so the network responds quickly to nodes that start misbehaving. A membership threshold prevents Sybil attacks: nodes must prove reliability before receiving storage rewards. Eclipse protection provides additional integrity guarantees. The result is that nodes that consistently provide correct data and stay available build trust, while unreliable nodes are deprioritised. # Data types A data type is a classification which describes how data can be created, transformed and used. All programming languages use them, and common examples include integer, string and boolean. Autonomi 2.0 employs a content-addressed, immutable storage model. All data stored on the network is permanent and unchangeable — this is fundamental to the architecture and what makes the pay-once economic model work. At the network level, Autonomi stores one thing: **chunks**. Chunks are the storage primitive. When content is uploaded, it is split into chunks (each up to \~4MB), encrypted via self-encryption, and stored at content-addressed locations — the address of each chunk is derived from the BLAKE3 hash of its encrypted content. The 4MB limit applies to individual chunks, not to the content they represent — a file of any size is split into as many chunks as needed. When content is self-encrypted, the process produces a **DataMap** — a small structure that records the network addresses of all the chunks and the hashes needed to decrypt them. The DataMap is the key to your content: without it, the chunks are meaningless encrypted fragments scattered across the network. What makes data public or private is simply where the DataMap lives — stored on-network for public data, kept locally (or encrypted on-network) for private data. So a 'file' on the Network is really a set of instructions for finding the content's immutable constituent parts and assembling them to recreate the original content, together with information about what will be returned when you do. All storage on Autonomi is immutable. If your application needs mutable state, real-time interaction, or live collaboration, those capabilities exist in the broader ecosystem through x0x — a complementary post-quantum gossip network that provides CRDTs, pub/sub, and direct messaging. # Chunks A chunk is an immutable data type. Its Network address is derived from the hash of its content. This means the file cannot be edited in any way after it has been uploaded—any change would alter the hash and therefore its address meaning it could not be found. The data chunks are created by [self-encryption](/how-it-works/encryption-and-authentication/self-encryption). Data deduplication is a unique feature of Autonomi and a side benefit of the process of self-encryption. Two identical chunks will have the same hash value, and therefore only one (plus a few copies for redundancy) need be stored on the Network. Chunks can be cached by clients, and fetching the same chunk next time can be quicker. Autonomi also has a planned feature called ‘opportunistic caching’ in which more copies of popular data are created closer to where it is being requested.
# Defence Against Cyberattacks Autonomi has an interlocking set of features, each covering the others’ vulnerabilities. This means that data security on the Network is maximized. While 100 percent security is impossible, this strength-in-depth means that the sort of attacks common on the current web will be much harder to carry out on Autonomi. ## Defensive Features **Random address allocation:** A new node joining the Network cannot set its own address and thus cannot decide which data it will be required to manage. **Nodes are added only as needed:** Nodes that do not pull their weight or act as they should will be ignored, and will cease to earn. **Churn:** Nodes are constantly joining or leaving. Membership is fluid. **Encryption:** All data on the Network is protected by [several layers of encryption](/how-it-works/encryption-and-authentication). [**Self-encryption**](/how-it-works/encryption-and-authentication/self-encryption)**:** Content stored on the Network is broken into chunks with each chunk encrypted using ChaCha20-Poly1305 with keys derived from its own hash and the hashes of the two previous chunks. These chunks are stored at geographically random locations (the XOR location being the hash of the encrypted chunk) with a number of copies retained for redundancy. Without a Data Map, the chunks cannot be retrieved and decrypted. [**XOR Networking**](/how-it-works/network-architecture/content-addressable-storage)**:** Randomizes the geographical distribution of the chunks. Only someone in possession of the data map (i.e. the data owner) can find the chunks and piece them together again to recreate the content. An attacker trying to fake a chunk could not do so as its hash—and therefore its address on the Network—would be different. It could not be used to create a corrupted version of the file. **Self-Authentication:** A user can create a store of data securely and anonymously without requiring any central server to mediate the login process or any trusted third party to store and manage users’ credentials. **Post-Quantum Cryptography:** All node identity, key exchange, and authentication uses NIST-standardised post-quantum algorithms (ML-DSA-65 for signatures, ML-KEM-768 for key exchange). This makes the network resistant to attacks from quantum computers — both current and future. There is no classical cryptographic fallback. **Close Group Validation:** At upload time, payment verification includes cryptographic proof that storing nodes are genuinely members of the data's close group. This prevents nodes from fraudulently claiming to store data they don't hold. # Beating Common Threats ### Sybil attacks Sybil attacks involve malicious actors generating multiple fake identities, known as Sybil nodes, in an attempt to control operations. With sufficient Sybil nodes controlling part of the address space, a malicious actor could block access to certain content, for example. \ \ Autonomi detects Sybil attacks by estimating the network size using a statistical method KL Divergence. This compares the real distribution of node IDs (i.e. their network addresses) with the theoretical one. A significant difference between the two could indicate a Sybil attack. At this point nodes looking for data at a certain address will broaden their search to include a wider range of peers than normal. Even if all nodes closest to a chunk of data are compromised, it may still be accessed via nodes that are further away. ### Man in the Middle attacks *MitM* attacks rely on data being unencrypted or the victim’s browser accepting the attacker's certificate instead of the website’s certificate. They will not work on Autonomi. ### DDoS Exceptionally difficult as there is no single point to attack. The Network will simply re-route around any nodes that are taken down. ### Quantum computing Self-Encrypted data is considered 'quantum secure’, meaning that it cannot currently be defeated by a brute force attack, even with a quantum computer. \ \ On top of that, the volume of encrypted packets means that there could only be targeted attempts at decryption, and decentralization makes such targeting difficult. ### **Phishing & Key-logging etc** While there is some feasibility to these attacks, as the Network cannot protect endpoints such as a device itself, such an attack would only compromise the user’s own data. Using such a compromise as a springboard for a wider attack on a database, or swaths of Network data, is just not possible, and would be of dubious value to an attacker outside of a highly targeted hack. ### Ransomware Files are stored in immutable data and cannot be changed, so ransomware cannot encrypt it, but it could potentially delete Data Maps or hide them, making data inaccessible.
# Team [MaidSafe](https://maidsafe.net) are the team behind Autonomi, and the core developers of its protocol. ### **David Irvine** Founder, Chief R\&D Officer\ [Github](https://github.com/dirvine) ### **Sarah Buxton (Bux)** Chief Executive Officer \ [Twitter](https://twitter.com/ForTheBux) | [Linkedin](https://uk.linkedin.com/in/bux) ### **Jim Collinson** Chief Strategy Officer \ [Twitter ](https://twitter.com/jimcollinson)| [Linkedin](https://www.linkedin.com/in/jimcollinson/) ### **Andy Laverty** Non-exec director\ [Linkedin](https://www.linkedin.com/in/andy-laverty-15a0222/) ### **David Allan** Non-exec director \ [Linkedin](https://www.linkedin.com/in/david-allan-7b45b724/) ### **David Cosh** Non-Exec Director # Autonomi Foundation Based in Geneva, the Autonomi Foundation is a non-profit organisation dedicated to the promotion and stewardship of the Autonomi ecosystem, protocol, and related distributed ledger and computing technology. ### Mission 1. To allow anyone to have unrestricted access to public data: all of humanity's information, available to all of humanity. 2. Enable people to securely, and privately access their own data, and use it to get things done, with no one else involved. 3. Allow individuals to freely communicate with each other privately, and securely. 4. Giving people and businesses the opportunity for financial stability by trading their resources, products, content, and creativity without the need for middlemen, or gatekeepers. ### What the Foundation Does * Fund and support R\&D of decentralized network communication protocols, security, and usability. * Maintain and deliver decentralized networks and necessary tools and applications. * Educate developers, users, and policymakers on decentralized networks and their uses. * Increase adoption and accessibility of decentralized networks and related technologies through funding and outreach. * Collaborate with regulators and standards bodies to shape public policy and develop best practices for distributed computing, privacy, security, and data interoperability. # FAQs
What is an autonomous network? An Autonomous Network is one which has no human gatekeepers. Anyone is able to join and—crucially—no-one can be prevented from taking part. It is a network that can act both as a global market for computer capacity, but also turn that capacity into usable capability that's native to the Internet itself, not just a pointer to existing cloud services.\ \ An Autonomous network is a self-healing, course-correcting system; a huge resource layer that anyone can utilise with no permission required.
Why do we need an autonomous network? An autonomous network is one that manages all of our data and communications without any human intervention and no intermediaries. It is a network that configures itself. Resources are not added by a centralised IT administrator—reducing the opportunity for malicious or negligent activities. The Network becomes permissionless—participation is open to all who seek it, removing the risks of monopolisation by single entities whose power can grow unchecked. Many data breaches are caused by human error. But the issue is more fundamental. We are becoming increasingly reliant on systems in which our data is stored by others. As more of our personal data is in the hands of third parties, the risks of failure grow higher by the day. We already see our data being used for purposes that we dislike today. How likely is it that your access will be revoked entirely? That you will no longer control that stream of data about your life? In some countries, that is already a reality. We can improve physical security. We must ensure that data cannot be deleted, changed, corrupted or accessed without the data owner’s consent. And only by removing humans from the management of our data can physical security be provided. You must have storage locations that are unknown to anyone but the network and one in which the user cannot be identified. Only an autonomous network provides this level of security. An autonomous network automatically splits and encrypts (using self-encryption) all data before storing this dynamically at locations that it selects. Nodes join anonymously and the Network will constantly move these nodes between groups—again without any human intervention or centralised record. Together each group of nodes takes decisions based on the messages that they receive. An autonomous network is also able to create additional copies of popular data which means that requests are served more quickly. At the same time, the Network itself can identify duplicate copies of identical data and reduce these to a minimum. Our design approach is influenced by the humble ant. Ant colonies exhibit complex and highly organised behaviour on a massive scale without reliance on a central authority. Instead, each ant fulfils different duties based on the needs of the colony. In a similar way, nodes on Autonomi perform different functions based on the types of messages that they need. So why do we need an autonomous network? Because humans make mistakes, centralised storage facilities are prone to failure—and we collectively need to build a platform upon which mankind can collaborate as we move into the future.
Who owns Autonomi Autonomi is [open source](https://github.com/maidsafe). Our vision is to create a resource that can be used by everyone to spread all human knowledge and to facilitate sharing across the planet, regardless of country of residence, culture, or economic background.
Does Autonomi use a blockchain? Yes and No.\ \ Autonomi's core data network is a form of Decentralized Ledger Technology (DLT) that doesn't utilise nor require a blockchain to function, so it's able to sidestep many of the obstacles to scaling inherent in other solutions.\ \ However its *payment system* will utilise the Ethereum blockchain at launch, before the integration of its native, and blockchainless currency as a network upgrade.
Can I buy Autonomi Tokens? Yes. You can either buy or earn Autonomi Network Tokens. On decentralized exchanges the token trades as `$ANT`, while some centralized exchanges list it as `$AUTONOMI`.\ \ Have a read of our complete [guide to buying Autonomi Network Tokens](/token/using-autonomi-tokens/buying) for all the details.
What is MaidSafeCoin? MaidSafeCoin was is a proxy token that supported the development of Autonomi and allowed people to pre-purchase Autonomi tokens. If you still hold some you can read more about [how to convert MaidSafeCoin to Autonomi tokens](/token/converting-maidsafecoin/process-overview) in our dedicated guide
Who are MaidSafe? Started in 2006 by Scottish engineer David Irvine, [MaidSafe](mailto:undefined) are the core developers of Autonomi. It’s a small team comprised of thinkers, inventors, tinkerers, PhDs, engineers and designers. Although based in Scotland, we work remotely with talents from many different cultures and countries, reflecting the users that we serve. Despite this variety, we all share a single mission: providing security and privacy for everyone.\ \ Incidentally, MaidSafe stands for **Massive Array of Internet Disks, Secure Access For Everyone.**
What is the SAFE Network? The SAFE Network is the former name for Autonomi. It stands for Secure Access for Everyone.
Why does the Network need a currency? Having a the network currency—a utility token that can be spent on Network services, and transferred between users—and allows for those contributing resources to be automatically rewarded *by the Network itself*, rather than waiting for handouts, or relying solely on voluntary contributions. It also offers new avenues for sustainable (and open) development of vital software and services, and an opportunity to rebuild the web on top of something *other* than advertising and surveillance-based business models.
# Glossary ### ANT Common shorthand for [Autonomi Network Token (ANT)](#autonomi-network-token-ant). ### ant The command-line interface (CLI) for direct interaction with the network. It is part of [`ant-client`](https://github.com/WithAutonomi/ant-client). ### antd The local daemon used by the SDKs and language bindings. It is part of [`ant-sdk`](https://github.com/WithAutonomi/ant-sdk). ### Autonomi An autonomous data network built on the Autonomi Protocol that supports a rich application ecosystem to be created by developers and enjoyed by participants. ### Autonomi Network Token (ANT) The network's ERC-20 utility token on Arbitrum One. It is commonly known as ANT. On decentralized exchanges it trades as `$ANT`, while some centralized exchanges list it as `$AUTONOMI`. It is spent and earned by using and supporting the Autonomi Network. ### Autonomi Foundation Often referred to just as *the Foundation.* A Swiss non-profit that facilitates, supports, funds and promotes the research and development of the Protocol, as well as enables the ongoing delivery, maintenance and adoption of the Network and its technologies. Formerly known as the Safe Network Foundation. ### Autonomi Protocol Often referred to just as *the* *Protocol*. A collection of open source algorithms, libraries and components that allows computers to form an autonomous data network ### Arbitrum One A layer-2 scaling solution for Ethereum, enhancing speed and reducing costs for transactions while maintaining Ethereum's security. ### Asynchronous Not time-dependent. A system that supports asynchronicity should come to consensus no matter what order the various messages arrive in. ### Boneh-Lynn-Shacham Distributed Key Generation (BLS-DKG) A cryptographic system that authenticates the sender of a message, allows for multiple parties to quickly come to a consensus, and can enable multi-signature transactions and n-of-k credentials ### Byzantine Fault Tolerance The ability of a decentralized network to function properly even if up to a third of the nodes (plus 1) is corrupt or faulty ### CashNote Encrypted digital ‘cheque’ for a given value containing all the necessary information for the owner of the associated secret key to spend that value. ### Churn Nodes joining and leaving the Network ### Chunk An immutable data type ### Client Software that allows users to connect to the Network and make use of its services ### Close Group A Close Group is a small number of nodes that look after a specific piece of data, and that only exist as a group for that specific data.\ \ This system of close groups allows nodes to act independently, but together to form a strong autonomous global network, capable of storing and retaining data in perpetuity. ### Conflict-free Data Types (CRDTs) Data structures that obey certain mathematical rules which ensure that when multiple versions of data exist across a distributed network, eventually these will always converge onto one ‘true’ version ### Data map A record of content chunks and their corresponding locations on the Network. Only users in possession of the data map can recreate the file ### Data payment A one-time payment made upfront for data storage, distributed to Nodes as [Resource Supply Rewards](#resource-supply-rewards). ### Distributed hash table A map of where data is stored on a distributed network ### FIAT FIAT currency is money declared by a government to be legal tender, not backed by a physical commodity. "Fiat" comes from Latin, meaning "let it be done," indicating it’s value by decree. ### Fault detection Detecting nodes that are acting suspiciously and removing them from the routing table. ### [Kademlia](/how-it-works/network-architecture/building-on-kademlia) A distributed hash table (DHT) protocol which provides a way for millions of computers to self-organize into a network. ### L2 / Layer 2 A scaling solutions built on top of a blockchain (Layer 1) to increase transaction speed and reduce costs. ### MaidSafeCoin A cryptocurrency token created during a crowd-sale in April 2014 that supported the development of Autonomi.\ There are both Omni (MAID) and ERC-20 (EMAID) variants of MaidSafeCoin. ### Maximum Supply Total number of whole Autonomi Network Tokens created over the Network’s lifetime: 1,200,000,000 (1.2 Billion) tokens. ### MASQUE relay A relay path used as a last resort when direct connection and hole punching cannot connect two peers. ### Multiaddress A unique locator for a peer that encodes multiple networking protocols into a single address ### Native Token A non-blockchain token running on Autonomi to be introduced after the early phase/launch of The Network. ### NAT traversal The set of techniques that help devices behind routers and firewalls connect to each other without manual port forwarding. ### [Node](/how-it-works/fully-autonomous-data-network/nodes) A machine that connects with others using Autonomi's Protocol to form the Network. ### PeerId The node's network identifier. Other nodes use it to recognize a node and measure how close it is to other peers and data in the network. ### Proof-of-Resource A system that rewards nodes based on the quality of the service they provide, making it economically disadvantageous for them to misbehave ### Proof of Work The consensus algorithm used by the Bitcoin blockchain and others to confirm that transactions are valid and to deter attacks. ### Proof of Stake The consensus algorithm used by the Etherum blockchain and others in which voting power is proportional to wealth. ### RPC (Remote Procedure Call) endpoint Allows a program to execute code or perform operations on a remote system as if it were a local function call. RPC is designed to hide the details of the network communication from the programmer. You call a function as if it's local, but it's executed remotely. ### QUIC A modern transport protocol built on UDP. Autonomi uses it for secure peer connections and NAT traversal coordination. ### Resource Supply Rewards Payment to the operators of resource-providing nodes in return for storing data. Also referred to as Data Payments. ### saorsa-transport The shared transport layer used by Autonomi and [x0x](https://github.com/saorsa-labs/x0x) for peer connections, NAT traversal, and relay fallback. The source repo is [`saorsa-transport`](https://github.com/saorsa-labs/saorsa-transport). ### Safe Network The former name for Autonomi ### [Self-Encryption](/how-it-works/encryption-and-authentication/self-encryption) The client-side process that breaks uploaded content into encrypted chunks and creates the Data Map needed to reconstruct it later. It uses BLAKE3 for chunk hashing and ChaCha20-Poly1305 for authenticated encryption. ### Spend Transaction information stored on the Network. ### Stigmergy An indirect mechanism of coordination between actors, in which the trace of an action stimulates the performance of a subsequent action. ### Storage Reward Rate An adjustable factor that determines the rate of pay of participating nodes; it is increased when more storage is needed, decreased when there is an excess of storage space ### Tokens The Autonomi Network Token (’ANT’) are earned by storing data and spent by uploading data. For purposes of these docs they may simply be referred to as ‘tokens’. ### Token Generation Event (TGE) The Token Generation Event represents both the Genesis of the Autonomi Network Token *and* the point at which its distribution begins. ### Tokens Emissions 240,000,000 tokens, representing 20% of the Maximum Supply, will be emitted at a diminishing rate over a period of 12 years. ### Transfer A monetary transaction on the Network. ### XOR address A unique 256-bit number; every entity on the Network has an XOR address ### x0x A complementary layer for realtime, mutable, or collaborative behavior. Autonomi stores permanent, immutable data; [`x0x`](https://github.com/saorsa-labs/x0x) handles live interaction and shared state.
# References ### Autonomi Publications & Papers [Autonomi White Paper](https://autonomi.com/whitepaper) [Autonomous Network (MaidSafe White Paper, 2010)](http://docs.maidsafe.net/Whitepapers/pdf/AutonomousNetwork.pdf) [Data Hierarchy Refinement (MaidSafe RFC and forum discussion)](https://github.com/maidsafe/rfcs/blob/d42c24db6ddfe58f14b347a5664710e493262ce9/text/0052-RDF-for-public-name-resolution/0052-RDF-for-public-name-resolution.md) [Distributed Hash Table (MaidSafe White Paper, 2010)](http://docs.maidsafe.net/Whitepapers/pdf/MaidSafeDistributedHashTable.pdf) [FileTree CRDT for Safe Network (MaidSafe forum discussion)](https://forum.safedev.org/t/filetree-crdt-for-safe-network/2833) [The Impossible Network — David Irvine](https://metaquestions.me/2017/08/12/the-impossible-network/) [Payments (on Safe Network)](https://safenetforum.org/t/update-09-november-2023/38807) [Safe (Autonomi) CLI User Guide (Github)](https://github.com/maidsafe/safe_network/tree/main/sn_cli) [Security of the MaidSafe Vault Network](https://strathprints.strath.ac.uk/48569/1/Paul_etal_wwrf32_vault_network.pdf) [Self-Authentication — MaidSafe White Paper (2010)](https://docs.maidsafe.net/Whitepapers/pdf/SelfAuthentication.pdf) [Self-Encrypting files — convergent encryption plus obfuscation (GitHub)](https://github.com/maidsafe/self_encryption) [Self-Encrypting Data — MaidSafe White Paper (2010)](http://docs.maidsafe.net/Whitepapers/pdf/SelfEncryptingData.pdf) [Self-Encryption on the Safe Network (YouTube](https://www.youtube.com/watch?v=Jnvwv4z17b4)) [XOR-URLs (MaidSafe RFC)](https://github.com/maidsafe/rfcs/blob/357384147ae005e4061079b27a30f43cf379fda5/text/0000-xor-urls/0000-xor-urls.md) ### From Other Contributors [An introduction to state-based CRDTs](https://bartoszsypytkowski.com/the-state-of-a-state-based-crdts/) [A Survey of DHT Security Techniques (Globule)](http://www.globule.org/publi/SDST_acmcs2009.html) [BIP39 Mnemonic Code Converter](https://iancoleman.io/bip39/) [Boneh-Lynn-Shacham (Wikipedia)](https://en.wikipedia.org/wiki/Boneh%E2%80%93Lynn%E2%80%93Shacham) [BLS Threshold Crypto — Interface for Rust library threshold\_crypto (Ian Coleman)](https://www.youtube.com/watch?v=vBU70EjwGfw) [Byzantine Agreement, Made Trivial (Micali) (MIT)](https://people.csail.mit.edu/silvio/Selected%20Scientific%20Papers/Distributed%20Computation/BYZANTYNE%20AGREEMENT%20MADE%20TRIVIAL.pdf) [Ethereum Classic “HACKED” by 51% attack! (Andrew Butler — Medium)](https://medium.com/hackernoon/ethereum-classic-attacked-how-does-the-51-attack-occur-a5f3fa5d852e) [CRDTs and the Quest for Distributed Consistency (YouTube)](https://www.youtube.com/watch?v=B5NULPSiOGw) [CRDTs for Non Academics (YouTube)](< https://www.youtube.com/watch?v=vBU70EjwGfw>) [Crypto 101](https://www.crypto101.io/) [Git Branching — Basic Branching and Merging](https://git-scm.com/book/en/v2/Git-Branching-Basic-Branching-and-Merging) [GossipSub (libp2p)](https://docs.libp2p.io/concepts/pubsub/overview/) [Human-oriented base-32 encoding (O'Whielacronx)](https://philzimmermann.com/docs/human-oriented-base-32-encoding.txt) [Kademlia: A Peer-to-peer information system based on the XOR Metric (Whitepaper, 2010)](https://pdos.csail.mit.edu/~petar/papers/maymounkov-kademlia-lncs.pdf) [Kademlia, Explained (YouTube)](https://www.youtube.com/watch?v=1QdKhNpsj8M) [Kademlia XOR metric properties purposes (Stack Overflow)](https://stackoverflow.com/questions/25751928/kademlia-xor-metric-properties-purposes/25756389#25756389) [libp2p, a modular network stack (IPFS)](https://libp2p.io/) [Stigmergy (Wikipedia)](https://en.wikipedia.org/wiki/Stigmergy) # Start a Node Here's how to offer your spare resources to the Autonomi Network, and contribute to the autonomous and decentralised alternative to the cloud… Starting a node (or even several) is easy, and will work on home computers just like yours. Here's how:
{% stepper %} {% step %} ### **Download & Install the Autonomi App** [Windows](https://downloads.autonomi.com/autonomi-app/windows) (Windows 10+) [Mac](https://downloads.autonomi.com/autonomi-app/mac) (Apple Silicon) [Linux x86-64](https://downloads.autonomi.com/autonomi-app/linux) (Ubuntu 24.04+ recommended) {% hint style="info" %} This app is in **Beta**, so expect regular updates as well as some niggles. *Need help? Ask our friendly* [*Discord community.*](https://discord.gg/autonomi) {% endhint %} {% endstep %} {% step %} ### **Add your Wallet Address** In the **Wallet** screen, adding your Ethereum Address allows you to hold anything your nodes earn. Just make sure it's a [compatible wallet](/token/using-autonomi-tokens/holding/compatible-wallets) to be able to see and use the tokens when you earn. {% endstep %} {% step %} ### Start Your Nodes From the **Nodes** screen add a node or two and start them. We'd recommend trying just a few to begin. You can always add more later. You'll see them connect, and then gradually store data. {% endstep %} {% step %} ### Earn Over Time The more your nodes reliably store and serve data, the more you have the potential to earn over time. But remember, you're also supporting the Network, and the future of the internet, from day one. {% endstep %} {% endstepper %} # Quickstart Guide Here's a step-by-step guide to running some Autonomi nodes for the first time, and contributing your spare computer resources to the Network: {% content-ref url="/pages/jAB74c4EXwtydODVoVLo" %} [For Windows Users](/node/quickstart-guide/for-windows-users-1) {% endcontent-ref %} # For Windows Users OLD {% stepper %} {% step %} ### Download the Autonomi App [Windows](https://downloads.autonomi.com/autonomi-app/windows) (Windows 10+) {% endstep %} {% step %} Unzip the download {% endstep %} {% step %} **Right-click** on the app called node-launchpad and **click Run as administrator** {% endstep %} {% step %} Windows will warn you about an unrecognized app. **Click More** Info and then **Run anyway** {% endstep %} {% step %} The Node Launchpad will now open in a terminal window. {% endstep %} {% step %} **Press O** to go to the Options screen. {% endstep %} {% step %} **Press Ctrl + B** to in order to add your wallet address. {% endstep %} {% step %} You’ll be prompted to accept the [Terms & Conditions](/node/support/terms-and-conditions). Have a read, and if you are happy to continue **Press Y**. {% endstep %} {% step %} **Paste in your** [**Wallet**](/node/system-requirements#compatible-wallets) **Address**, and then **Press Enter**. {% hint style="info" %} Any Ethereum address can be used here, but you'll need to set up a [compatible wallet](/token/using-autonomi-tokens/holding/compatible-wallets) app in order to be able to see and use any tokens you earn. We've got a [step-by-step guide](/token/using-autonomi-tokens/holding/how-to-create-a-metamask-wallet) on how to do that. {% endhint %} {% endstep %} {% step %} Now **Press S** to go back to the Status Screen. {% endstep %} {% step %} Then **Press Ctrl + G** to start some nodes. {% endstep %} {% step %} Press the **up and down arrows** to choose the number of nodes you want to start, then **Press Enter to start them**.\ \ *We’d recommend you start just one or two to begin. Each will use 35GB of storage space, some memory, CPU, and some of your internet connection. Then add more as your resources allow.* {% endstep %} {% step %} You’ll see the node(s) you’ve started appear in a list. They may take a few moments to start, but when they do they’ll turn green. They will be gathering data, then serving it to the Network. If you’ve added several nodes, you can **scroll the list with the up and down arrow keys**. {% endstep %} {% step %} You’ll see the amount of storage space allocated, and the amount of tokens, or [attos](/node/support/faqs#what-is-an-atto), they have earned in the Device Status panel. {% endstep %} {% step %} **Congratulations!** You are up and running, and contributing to the Autonomi Network. {% endstep %} {% endstepper %} # For Windows Users Download the Autonomi App {% stepper %} {% step %} [Windows](https://downloads.autonomi.com/autonomi-app/windows) (Windows 10+) {% endstep %} {% step %} Open the downloaded file and proceed to click **Next**
{% endstep %} {% step %} Now choose the destination folder and click **Next**
{% endstep %} {% step %} Click **Install**
{% endstep %} {% step %} You will get a popup asking if you want to allow the app to make changed to your device, click **Yes**
{% endstep %} {% step %} Click **Finish**
{% endstep %} {% step %} The app will now open. Before we spin nodes up you will want to set your payout wallet so you can earn! On the far left side of the app click **Wallet**. You can click edit and paste your ETH/EVM address directly then click **Save** OR click **Connect Wallet** to link with MetaMask, TrustWallet, Ledger, Trezor etc etc. We recommend you use MetaMask for your wallet choice. You will have to choose the Connect Wallet option if you wish to use the application to upload/download data.
{% endstep %} {% step %} On the far left side of the application click **Nodes** then select **+Add Nodes**
{% endstep %} {% step %} Now select **Add 1 Node**
{% endstep %} {% step %} You will now see Node1 pop up. If you selected too add multiple nodes in the last step you would see Node2 etc etc as well. Click **Node1** and a popup will show up below. Now click **Start**
{% endstep %} {% step %} **Congratulations!** You are up and running, and contributing to the Autonomi Network. {% endstep %} {% endstepper %} # For Mac Users {% stepper %} {% step %} ### Download the Autonomi App [Mac](https://downloads.autonomi.com/autonomi-app/mac) (Apple Silicon) {% endstep %} {% step %} Unzip the download {% endstep %} {% step %} **Right-click** on the app called node-launchpad and **click Open** {% endstep %} {% step %} You may see a warning which says *“node-launchpad can’t be opened because the identity of the developer cannot be confirmed”.* It’s ok, just **click Open**, and continue {% endstep %} {% step %} The Node Launchpad will now open in a terminal window. {% endstep %} {% step %} **Press O** to go to the Options screen. {% endstep %} {% step %} **Press Ctrl + B** to in order to add your wallet address. {% endstep %} {% step %} You’ll be prompted to accept the [Terms & Conditions](/node/support/terms-and-conditions). Have a read, and if you are happy to continue **Press Y**. {% endstep %} {% step %} **Paste in your** [**Wallet**](/node/system-requirements#compatible-wallets) **Address**, and then **Press Enter**. {% hint style="info" %} Any Ethereum address can be used here, but you'll need to set up a [compatible wallet](/token/using-autonomi-tokens/holding/compatible-wallets) app in order to be able to see and use any tokens you earn. We've got a [step-by-step guide](/token/using-autonomi-tokens/holding/how-to-create-a-metamask-wallet) on how to do that. {% endhint %} {% endstep %} {% step %} Now **Press S** to go back to the Status Screen {% endstep %} {% step %} Then **Press Ctrl + G** to start some nodes. {% endstep %} {% step %} **Press the up and down arrows** to choose the number of nodes you want to start, **then Press Enter** to start them. \ \ *We’d recommend you start just one or two to begin. Each will use 35GB of storage space, some memory, CPU, and some of your internet connection. Then add more as your resources allow.* {% endstep %} {% step %} You’ll see the node(s) you’ve started appear in a list. They may take a few moments to start, but when they do they’ll turn green. They will be gathering data, then serving it to the Network. If you’ve added several nodes, you can **scroll the list with the up and down arrow keys**. {% endstep %} {% step %} You’ll see the amount of storage space allocated, and the amount of tokens, or [attos](/node/support/faqs#what-is-an-atto), they have earned in the Device Status panel. {% endstep %} {% step %} **Congratulations!** You are up and running, and contributing to the Autonomi Network. {% endstep %} {% endstepper %} # For Linux Users {% stepper %} {% step %} ### Download the Autonomi App [Linux x86-64](https://downloads.autonomi.com/autonomi-app/linux) (Ubuntu 24.04+ recommended) {% endstep %} {% step %} Unzip the download {% endstep %} {% step %} The Node Launchpad will now open in a terminal window. {% endstep %} {% step %} **Press O** to go to the Options screen. {% endstep %} {% step %} **Press Ctrl + B** to in order to add your wallet address. {% endstep %} {% step %} You’ll be prompted to accept the [Terms & Conditions](/node/support/terms-and-conditions). Have a read, and if you are happy to continue **Press Y**. {% endstep %} {% step %} **Paste in your** [**Wallet**](/node/system-requirements#compatible-wallets) **Address**, and then **Press Enter**. {% hint style="info" %} Any Ethereum address can be used here, but you'll need to set up a [compatible wallet](/token/using-autonomi-tokens/holding/compatible-wallets) app in order to be able to see and use any tokens you earn. We've got a [step-by-step guide](/token/using-autonomi-tokens/holding/how-to-create-a-metamask-wallet) on how to do that. {% endhint %} {% endstep %} {% step %} Now **Press S** to go back to the Status Screen {% endstep %} {% step %} Then **Press Ctrl + G** to start some nodes. {% endstep %} {% step %} Press the **up and down arrows** to choose the number of nodes you want to start, then **Press Enter to start them**.\ \ *We’d recommend you start just one or two to begin. Each will use 35GB of storage space, some memory, CPU, and some of your internet connection. Then add more as your resources allow.* {% endstep %} {% step %} You’ll see the node(s) you’ve started appear in a list. They may take a few moments to start, but when they do they’ll turn green. They will be gathering data, then serving it to the Network. If you’ve added several nodes, you can **scroll the list with the up and down arrow keys**. {% endstep %} {% step %} You’ll see the amount of storage space allocated, and the amount of tokens, or [attos](/node/support/faqs#what-is-an-atto), they have earned in the Device Status panel. {% endstep %} {% step %} **Congratulations!** You are up and running, and contributing to the Autonomi Network. {% endstep %} {% endstepper %} # System Requirements Autonomi nodes are designed to be run on everyday devices, so we can all contribute to an alternative future of the Internet with the devices we already have and not just rely on data centres and specialised equipment. *We’d encourage you to give it a go regardless of what system you are running*. Members of our [Forum](broken://spaces/T1VY0u5KuOsTpycHpSka) community regularly operate nodes on everything from RaspberryPis, to gaming PCs, old laptops, and even some adapted phones! But as a starting point, we’ve built the [Autonomi App](/node/downloads) to run on the following systems with ease. **Windows** (Windows 10+), **Mac** (MacOS 14 Sonoma), and **Linux** (Ubuntu 24.04) computers with: * 4 core CPU: Intel, AMD or Apple * 8 GB ram * Spare hard drive space for the data your node will store * 8 Mbps Up/Down Internet service
## Compatible Wallets You'll also need a Ethereum Wallet to receive and hold tokens earned by your node. Any Ethereum address can be used here, but you'll need to **set up a** [**compatible wallet**](/token/using-autonomi-tokens/holding/compatible-wallets) app in order to be able to see and use any tokens you earn. We've got a [**step-by-step guide**](/token/using-autonomi-tokens/holding/how-to-create-a-metamask-wallet) on how to do that. # Downloads The easiest way to contribute your spare capacity to the Autonomi Network is with the Autonomi App. It’s an application that allow you to start nodes on your computer that run in the background while you get on with other things. ### Download the Autonomi App: [Windows](https://downloads.autonomi.com/autonomi-app/windows) (Windows 10+ recommended) [Mac](https://downloads.autonomi.com/autonomi-app/mac) (Apple Silicon) [Mac](https://downloads.autonomi.com/autonomi-app/mac-intel) (Intel) [Linux x86-64](https://downloads.autonomi.com/autonomi-app/linux) (App Image) (Ubuntu 24.04+ recommended) [Linux x86-64](https://downloads.autonomi.com/autonomi-app/linux-deb) (Deb) (Ubuntu 24.04+ recommended) [Linux x86-64](https://downloads.autonomi.com/autonomi-app/linux-rpm) (Deb) (Ubuntu 24.04+ recommended)
### **Using the CLI** If you are comfortable with Command Line Interfaces and want to run nodes on headless devices, home servers, or more advanced setups such as virtual environments or remote machines, take a look at the [`ant` CLI](https://github.com/WithAutonomi/ant-client) and our [Use the Node CLI](/node/guides/how-to-guides/use-the-node-cli) guide. # How To Guides Find out how to… {% content-ref url="/pages/Qsf8Vi5i1xPnqI7WpzOj" %} [Use the Node CLI](/node/guides/how-to-guides/use-the-node-cli) {% endcontent-ref %} {% content-ref url="/pages/ik8x4ghRxpCDCi3irLRh" %} [Reset Your Nodes](/node/guides/how-to-guides/reset-your-nodes) {% endcontent-ref %} {% content-ref url="/pages/qHmCNe8ukEXavAapWJua" %} [View your Autonomi tokens with the Block Explorer](/node/guides/how-to-guides/view-your-autonomi-tokens-with-the-block-explorer) {% endcontent-ref %} {% content-ref url="/pages/pvHTHPlQYRktSKfxzWPZ" %} [Run as Admin by Default on Windows](/node/guides/how-to-guides/run-as-admin-by-default-on-windows) {% endcontent-ref %} # Use the Node CLI Here's how to use the ant CLI to run one or more Autonomi nodes from your terminal and contribute storage space to the Network The `ant` CLI lets you run one or more Autonomi nodes from your terminal and contribute your spare storage space to the Network. {% hint style="info" %} If this is your first time, we'd recommend you start with just a single node, so you can get a feel for how your machine and connection handle it. Then add more as your resources allow. {% endhint %} {% hint style="info" %} You only need your public wallet address for this. Do not paste your private key or secret recovery phrase into any of these commands. {% endhint %} {% stepper %} {% step %} #### Install the `ant` CLI On Mac and Linux: ```bash curl -fsSL https://raw.githubusercontent.com/WithAutonomi/ant-client/main/install.sh | bash ``` On Windows: ```powershell irm https://raw.githubusercontent.com/WithAutonomi/ant-client/main/install.ps1 | iex ``` When the install finishes, you can check it worked with: ```bash ant --help ``` If your terminal says `ant` cannot be found, close it and open a new one, then try again. {% endstep %} {% step %} #### Start the background daemon Run: ```bash ant node daemon start ``` This starts a small background process that manages your nodes for you. You can check it is running with: ```bash ant node daemon status ``` {% endstep %} {% step %} #### Add your wallet address Now register a node with your wallet address: ```bash ant node add --rewards-address 0xYourWalletAddress ``` Any Ethereum address can be used here, but you'll need a compatible wallet if you want to see and use anything your nodes earn. If this is the first time you've done this, the CLI will fetch the latest `ant-node` binary for you automatically. {% endstep %} {% step %} #### Start your node Run: ```bash ant node start ``` If you only want to start one specific node later on, use its service name instead: ```bash ant node start --service-name node1 ``` {% endstep %} {% step %} #### Check that your node is running To see all of your registered nodes and their status, run: ```bash ant node status ``` To see a summary of the background daemon, run: ```bash ant node daemon status ``` The daemon status command will also show you a local console URL you can open in your browser. Once your node is running, it will begin gathering data and serving it to the Network. Your nodes will update themselves automatically over time, so you do not need to manually reinstall the node binary for normal updates. {% endstep %} {% step %} #### Add more nodes later if you want to When you're ready to contribute more storage space, just add more nodes and start them: ```bash ant node add --rewards-address 0xYourWalletAddress --count 2 ant node start ``` If you'd prefer to choose the ports yourself, you can do that too: ```bash ant node add --rewards-address 0xYourWalletAddress --count 2 --node-port 12000-12001 ``` {% endstep %} {% step %} #### Stop your nodes To stop all of your running nodes, run: ```bash ant node stop ``` Or stop just one of them: ```bash ant node stop --service-name node1 ``` {% endstep %} {% step %} #### Reset everything if you need a clean start First stop your nodes: ```bash ant node stop ``` Then reset everything: ```bash ant node reset --force ``` The reset command will not run while nodes are still running. This removes your node data, logs, and local node registry, so only use it if you really want to start over. {% endstep %} {% step %} #### Congratulations You are up and running, and contributing to the Autonomi Network from the Command Line. {% endstep %} {% endstepper %} ## Notes * If you install `ant` using the commands above, you should not need to enter bootstrap peers manually for normal live-network use. * When you add nodes, the CLI will show you where each node's data and logs are being stored. ## Other useful commands If you want to stop the background daemon itself, first stop your nodes: ```bash ant node stop ant node daemon stop ``` If you want to check the daemon again later: ```bash ant node daemon status ``` If you want to update the `ant` CLI itself: ```bash ant update ``` ## Advanced options When adding nodes, there are a few extra options you may find useful: * `--metrics-port` to set metrics ports * `--network-id` to target a specific network * `--bootstrap` to provide bootstrap peers manually * `--env` to pass environment variables to the node For a fuller list of commands and options, run: ```bash ant node --help ant node add --help ant node daemon --help ``` # Reset Your Nodes Occasionally, you might need to *reset* the Nodes on your device. This might be if they have stopped functioning properly or if it's needed to update their code. ### Resetting with the Node Launchpad {% stepper %} {% step %} **Download** the latest version of the [Node Launchpad](/node/downloads) {% endstep %} {% step %} Open the launchpad and **Press** **O** to access the Options screen. {% endstep %} {% step %} **Press Ctrl + R** {% endstep %} {% step %} Type the word **`reset`** and **Press Enter.** *Your nodes will reset and refresh in the background. Sometimes this can take a few moments.* {% endstep %} {% step %} **Press Q** to Launchpad, and then re-open it {% endstep %} {% step %} **Press** **Ctrl + G** to add your Nodes again, and **Press Enter** to start them {% endstep %} {% endstepper %} ### Resetting using the CLI Here's the series of commands for advanced users already using the Node Manager CLI tool: `antctl`.\ \ After resetting, and while adding nodes again, note the additional arguments that should be used each time depending, on your circumstances. In particular the `--rewards-address` argument which allows you to attach your [wallet](broken://pages/toNOJmbb6CI5SpEvThmb) address to each node. This is now using the Arbitum One network: ```bash 1. antup update (to make sure you are on the latest version of the Node Manager) 2. antctl reset 3. antctl add (with the following args) --count <# of nodes> => If not specified, only a single node is added --log-dir-path => optional, path to store the log files. --home-network => optional, if you're behind a NAT/home router/ without port-forwarding --upnp => optional, if you have enabled upnp in your router, mutually exclusive with home-network --node-port => If --home-network or --upnp is not provided, then you have to port-forward a set of ports and provide them here. We accept a single port i.e., 12000 or a range i.e., 12000-12010. The number of ports here should match the number of nodes specified using --count --enable-metrics-server => optional, if you want the stats to be displayed inside the launchpad --rewards-address evm-arbitrum-one => Must be specified at the end, to store your earned ANT. 4. antctl start --interval 2000 5. antctl status --details ``` # View your Autonomi tokens with the Block Explorer If you are having trouble viewing your Autonomi token balance with in MetaMask, or in the Node Launchpad, you can check them on the block explorer. Here's how to do that {% stepper %} {% step %} ### Open the [**Arbitrum Block Explorer**](https://arbiscan.io/) {% endstep %} {% step %} ### **Enter your ETH wallet address** In the search bar paste in your wallet address, and press enter
{% endstep %} {% step %} ### **Click the Token Holdings dropdown** If you have and Autonomi tokens at this address Autonomi ($AUTONOMI) will show in this dropdown.
{% endstep %} {% step %} ### **Click it** and you'll open a history your Autonomi transactions You'll also be able to see the current Autonomi token balance of your wallet
{% endstep %} {% endstepper %} # Run as Admin by Default on Windows Sometimes software runs into hiccups and needs to be run as an Administrator to work properly on Windows. Here is how to do that. {% stepper %} {% step %} **Right click** the **node-launchpad.exe** file {% endstep %} {% step %} Click **Properties** {% endstep %} {% step %} Navigate to the **Compatibility** tab on the top ![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXdiiIgh3T7HjepNBGR6QnrrLbCYlMvjzLDH2SRm_86K-d4x28IZk-ozFLsb7Q3LPQY7VxmEiY8yh0ixPBjITANmIhAXi2CyALlH9f8XT9nRLEhAWRCuc7Oeoley3tl7Lwzs9_bHhoayGgbJ6cRHM9RRP5n-?key=_NWr5hCpCjy46dsIzSmbOA) {% endstep %} {% step %} Under **Settings**, check **Run this program as an administrator** {% endstep %} {% step %} Click **Apply** {% endstep %} {% step %} Click **OK** The node-launchpad.exe will now run the program as an administrator my default {% endstep %} {% endstepper %} # Troubleshooting Bumping up against some issues? Here are some guides to get to the bottom of some common problems: {% content-ref url="/pages/F93AU6kB2cQtTzpekFx6" %} [My Nodes Aren't Earning anything](/node/guides/troubleshooting/my-nodes-arent-earning-anything) {% endcontent-ref %} {% content-ref url="/pages/86ToZcwoUZd82cHDdIuW" %} [Broken mention](broken://pages/86ToZcwoUZd82cHDdIuW) {% endcontent-ref %} {% content-ref url="/pages/0dr4OhYahbVWPCwsmB4c" %} [Broken mention](broken://pages/0dr4OhYahbVWPCwsmB4c) {% endcontent-ref %} {% content-ref url="/pages/Fhd0CDyhq51rCUzo9TLQ" %} [Broken mention](broken://pages/Fhd0CDyhq51rCUzo9TLQ) {% endcontent-ref %} {% content-ref url="/pages/pYZ66LYrgF12I36iZKD0" %} [Broken mention](broken://pages/pYZ66LYrgF12I36iZKD0) {% endcontent-ref %} {% content-ref url="/pages/vDxkThJ5kNY8yYCu4Y4Y" %} [Broken mention](broken://pages/vDxkThJ5kNY8yYCu4Y4Y) {% endcontent-ref %} {% content-ref url="/pages/Mi6EqPccMhWTF9dc8TU7" %} [Broken mention](broken://pages/Mi6EqPccMhWTF9dc8TU7) {% endcontent-ref %} {% content-ref url="/pages/D4bSyodfGC63a4jDC8H3" %} [Broken mention](broken://pages/D4bSyodfGC63a4jDC8H3) {% endcontent-ref %} {% content-ref url="/pages/M8SdrZmbBKU7hTSiltHH" %} [Broken mention](broken://pages/M8SdrZmbBKU7hTSiltHH) {% endcontent-ref %} {% content-ref url="/pages/218vTU67o8HUSxv9QJgz" %} [Broken mention](broken://pages/218vTU67o8HUSxv9QJgz) {% endcontent-ref %} # My Nodes Aren't Earning anything When you start your nodes they begin the work of providing resources to the Network, storing existing data chunks, and checking the work of other nodes too. By running nodes, you're already helping build the new Internet, right from the start, so thank you! Nodes earn Autonomi tokens when they receive and store some *new* data chunks when they are uploaded. Which nodes will receive the new data, and therefore the tokens, is entirely random. That's part of the security design of the Network. What we can say, though, is that over time *all* nodes that are working reliably will eventually receive payments. It's just a matter of time. How long, depends on the size of the Network, and how much new data is being uploaded. # Get Help If you're looking for a helping hand with running a node or getting on board with the beta, here's how to get support. ### Report an Issue in Discord You can also report an issue and get direct team support right in Discord: Use the `/help` command to report an issue and launch a DM thread with the support team. ### Email Support You can contact the Autonomi team directly for support by emailing: [**support@autonomi.zendesk.com**](mailto:support@autonomi.zendesk.com) We are a small and busy team though, so please be patient, and kind! ### Community Support We have a helpful, passionate and deeply knowledgeable community that often offers the most rapid support. Ask for help via the dedicated [support channels on Discord](https://discord.com/channels/1209059621319221268/1247881515107483759), or in our longstanding [Autonomi Community Forum](https://forum.autonomi.community/). {% hint style="info" %} When requesting support, or reporting an issue, you'll get a quicker and more accurate response if you include: * **Your operating system** and version (e.g. Mac 14.0) * **Software version** of the Launchpad or Node * And **be as specific as you can** about what is happening, and when it occurs Plus: screen grabs, and node [log files](broken://pages/TAhX9Kg7SQlSCy2pqo6U) (if you are asked for them) are very helpful too. {% endhint %} # FAQs
How much does a Node cost? **Nothing!** In fact, you can get paid for running a node, or as many nodes as you want. They are designed to run on everyday computers.
What Rewards can I earn? By running a node you'll be rewarded with Autonomi tokens. The number of tokens you'll earn depends on the number of nodes you operate, how reliably they serve the network, how much data they store, and of course how long they are conected.
What sort of computer do I need? Autonomi nodes are designed to work on everyday home devices. So even relatively modest-performance computers will happily run a node, or even many nodes at once. Each node uses some storage space, as well as some CPU, memory, and of course Internet bandwidth. Our easy-to-use [Node Launchpad](/node/downloads) software is compatible with Windows, Mac and Linux. Many people use typical home computers, or even RaspberryPis, to contribute to the Network. There are options for more advanced users to utilise their headless computers, home servers, or virtual environments. But we'd encourage you to start with what you already have. It's probably right in front of you.
How many nodes can I run? A typical home PC will be able to run several nodes at once, and you can start nodes on as many computers as you like. We'd recommend you start with just a single node to begin, and then add more gradually as your computer and Internet connection capacity allows.
What is an Atto? An Atto is a fraction of a whole token. One quintillionth in fact. It's the increments that node's are paid in by the Network. Strictly speaking they are just fractions of a full token—18 decimal places—so sometimes the terms are used interchangeably.
How do I get Help? If you haven't already take a look at our [Quick Start Guides](/node/quickstart-guide). Then for more direct pointers and support there is the [Autonomi Discord](https://discord.gg/autonomi). And of course not forgetting the [Autonomi Forum](https://forum.autonomi.community) for a wealth of knowledge and detailed support from our dedicated community.
# Acronyms Here is a list of common acronyms you may hear with their explanations. If you hear terminology you don't understand, Discord and the forum are great places to ask for clarification! * **ARB (Arbitrium)**: A popular Ethereum Layer 2 scaling solution that improves transaction speed and reduces costs by processing transactions off-chain. * **CEX (Centralized Exchange)**: An exchange that is run by a company or organization that controls the platform, facilitates crypto trading, and manages user transactions. * **dApp (Decentralized Application)**: Applications built to run on a decentralized network, such as Autonomi, that operate without a central authority. * **DEX (Decentralized Exchange)**: A peer-to-peer cryptocurrency exchange that allows users to trade directly without the need for a centralized intermediary, often without requiring KYC verification. Popular DEXs include [Uniswap](https://app.uniswap.org/) and [SushiSwap](https://www.sushi.com/ethereum/swap). * **ERC-20 (Ethereum Request for Comment 20)**: A widely adopted technical standard for creating and issuing tokens on the Ethereum blockchain. ERC-20 tokens are interoperable with Ethereum's ecosystem and are the foundation for many dApps. This is the tech standard used for eMAID and the upcoming Autonomi token. * **ETH (Ethereum)**: A leading blockchain platform that supports smart contracts and dApps, with Ether (ETH) being its native cryptocurrency. * **EVM (Ethereum Virtual Machine)**: The environment in which all Ethereum smart contracts and dApps run, executing decentralized code as part of the Ethereum blockchain. It ensures consistency and enables interoperability across different Ethereum-compatible networks (such as ARB). * **ICO (Initial Coin Offering)**: A fundraising mechanism in which a company or project offers new cryptocurrencies or tokens to investors in exchange for established cryptocurrencies (such as Bitcoin or Ethereum) or fiat money. In the case of Autonomi, the ICO was the MaidSafe crowdsale back in April 2014. * **MM (MetaMask)**: A popular [cryptocurrency wallet](https://metamask.io/) and gateway to decentralized applications (dApps) that allows users to manage, store, and trade their digital assets securely. Including Autonomi's Network Token. * **TGE (Token Generation Event)**: The moment when a project's tokens are created and distributed to investors and participants. For Autonomi, this is scheduled to take place on the 6th of February 2025. # Terms & Conditions By operating a node on the Autonomi Network (the "Network"), you agree to the following terms and conditions: 1. **Node Operation** You will be expected to run a node on Autonomi, which will require you to allocate a portion of your computer's resources to support the Network for data storage and processing tasks. 2. **Network Tokens**: The Autonomi Network operates with Autonomi Tokens, which are utility tokens used for network transactions and rewards. 3. **Rewards**: Rewards are based on your node(s) performance on the Network. Performance is measured through data storage and retrieval services provided to the Network. Rewards are distributed based on your node's contribution to the Network's operation and may require your node to be running the latest software version. 4. **Data Protection and Privacy**: In accordance with the General Data Protection Regulation (GDPR) and the Swiss Federal Act on Data Protection (FADP), we are committed to ensuring the protection and privacy of your data. We will ensure that your personal data is processed lawfully, fairly, and transparently, without adversely affecting your rights. We will take all necessary measures to protect information against unauthorised or unlawful processing and against accidental loss, destruction, or damage, using appropriate technical or organisational measures. Your information will not be shared with third parties without your explicit consent, except as required by law or as necessary for the operation of the Network. You have the right to access, rectify, erase, restrict, and object to the processing of your personal data. You also have the right to data portability where applicable. Should you wish to exercise these rights or have any concerns about how your personal data is handled, please contact us at . You also have the right to lodge a complaint with a supervisory authority competent for your country or region. 5. **IP Address Visibility**: When operating a node, your node's IP address will be visible to other nodes it connects to on the Network, and you will be able to see the IP addresses of nodes that connect to yours. This is necessary for the peer-to-peer operation of the Network. 6. **Wallet Address Visibility**: The wallet address associated with your node will be: * Provided to clients when they request storage quotes from your node * Visible and permanently stored on the blockchain when your node receives data payments from clients * Visible and permanently stored on the blockchain when your node receives emission payments from the Network This is necessary for the Network's payment and reward systems to function. 7. **Reward Distribution**: Rewards will be distributed to the wallet address associated with your node. 8. **Changes and Termination**: We reserve the right to modify these terms and conditions or terminate your participation in the Network at any time and for any reason, without liability to you. ### General Restrictions Persons who are in possession of these Terms and Conditions are expressly required to inform themselves about applicable laws and regulations as well as to observe and comply with such restrictions. These Terms and Conditions may not be communicated, used for or in connection with any offer to, or solicitation by, anyone in any jurisdiction or in any circumstances in which such offer or solicitation is not authorised or is unlawful. These Terms and Conditions are not for release, publication, circulation and distribution, and do not constitute or form a part of any offer or solicitation to use the Services, directly or indirectly, in or into the United States (including its territories and dependencies, any state of the United States and the District of Columbia), North Korea, Iran, Myanmar, Afghanistan, Angola, Aruba, Bangladesh, Belarus, Benin, Bhutan, Bolivia, Botswana, Brunei Darussalam, Burkina Faso, Bosnia, Burundi, Cambodia, Cameroon, Cape Verde, Central Africa republic, Chad, Comorros, Congo, Congo Democratic republic, Cuba, Cote d'Ivoire, Djibouti, Dominica, Ecuador, El Salvador, Equatorial Guinea, Eritrea, Ethiopia, Gabon, Gambia, Ghana, Guatemala, Guyana, Guinea, Guinea Bissau, Haiti, Honduras, Iraq, Jordan, Kenya, Kyrgyz Republic, Laos People's Republic, Lesotho, Liberia, Libya, Madagascar, Malawi, Mali, Mauritania, Micronesia, Moldova, Mongolia, Mozambique, Nauru, Nepal, New Caledonia, Nicaragua, Niger, Nigeria, Niue, Oman, Pakistan, Palestinian Areas, Papua New Guinea, Republic of China, Reunion, Rwanda, Samoa, Sao Tome and Principe, Senegal, Sierra Leone, Somalia, South Korea, South Georgia, Sudan, Sri Lanka, Suriname, Syria, Swaziland, Tajikistan, Tanzania, Timor, Togo, Tonga, Tunisia, Turkmenistan, Uganda, USA, Uzbekistan, Venezuela, Western Sahara, Yemen, Zambia, Zimbabwe or any jurisdiction into which the same would be unlawful (the "Restricted Countries"). In particular, these Terms and Conditions do not constitute or form a part of any offer or solicitation to use the Services of the Network in the Restricted Countries. The list of such Restricted Countries is not exhaustive and may be adapted at any time. Moreover, the Network may contain additional restricted countries and other restrictions. Residents, citizens and/or green card holders for the USA, or a person located or domiciled, including without limitation, any corporation or partnership created or organised in or under the relevant applicable laws, of the Restricted Countries shall not use or attempt to use the Services ("Restricted Person(s)"). Restricted Persons that use the Services of the Network by providing false or inaccurate information about their citizenship, residency and/or nationality shall be in breach of these Terms and Conditions and shall indemnify the Foundation in respect of any damages and/or loses suffered due to this breach in accordance with the indemnification provisions set out in these Terms and Conditions. Users should not construe anything in these Terms and Conditions as legal, business or tax advice. Each User should consult its own advisors as needed to make its decision and to determine whether it is legally permitted to use the Services of the Network under applicable laws and regulations.

# Autonomi Network Tokens Autonomi Network Tokens are the oil of the Network's economy. Users uploading data to the Network **pay in these tokens**, and people contributing their spare resources to the network are **rewarded with them** for doing so. It's is a utility token that allows for the autonomous network to function without human intervention - a dynamic global market for secure data storage and communication. Listings vary by venue: on decentralized exchanges the token typically appears as `ANT`, while some centralized exchanges list it as `AUTONOMI`. ## Key Features * **Ethereum wallet** addresses can receive Autonomi Network Tokens. * **Earnings are paid in Autonomi Tokens.** When running a node, your [earnings](/token/using-autonomi-tokens/earning) will be paid by the network to your Ethereum wallet address * Autonomi tokens **work on the Arbitrum blockchain**. This is what is known as a Ethereum L2 blockchain, which makes faster and more cost effective. * **You'll need a** [**compatible wallet**](/token/using-autonomi-tokens/holding/compatible-wallets) that works Arbitrum in order to see them. * To transfer them, or make payments for data you will also need a small amount of **Arbitrum Ethereum** in your wallet for Gas Fees. * They are **divisible down to 18 decimal places**, so you can pay for small amounts of data, and receive tiny transactions. ## Tokenomics and Design If you're interested in the economic design of the Network, and understanding more about how Autonomi tokens function within it you can read all the detail in the [Autonomi White Paper ](https://autonomi.com/whitepaper)and [Network Documentation](broken://spaces/T1VY0u5KuOsTpycHpSka). # Holding To hold and use Autonomi Network Tokens you'll need: * An **Ethereum wallet address.** You'll get one via your wallet app, if you don't already * A [**compatible wallet**](/token/using-autonomi-tokens/holding/compatible-wallets) app or hardware wallet * To set up your wallet to work with the [**Arbitrum One network**](/token/using-autonomi-tokens/holding/add-arbitrum-network) so you can see your Autonomi Network Tokens # Compatible Wallets To store and manage your Autonomi Network Tokens on Arbitrum, you will need a compatible Ethereum-based wallet that supports the Arbitrum network. Below are the recommended wallets: ## **MetaMask** [MetaMask](https://metamask.io/download/) is one of the most widely used wallets with the compatibility needed for Autonomi Network Tokens on Arbitrum. It's available as both a browser extension and mobile app, and allows easy switching between the Ethereum main-net and Arbitrum for compatibility with Autonomi Network Tokens. [Follow our guide to setting one](/token/using-autonomi-tokens/holding/how-to-create-a-metamask-wallet) up for the first time, and if you already have, don't forget to [Add Arbitrum](/token/using-autonomi-tokens/holding/add-arbitrum-network) and [import the token contract](/token/using-autonomi-tokens/holding/import-the-autonomi-token) so you are ready to go. ## **Ledger (with MetaMask integration)** Ledger is a leading hardware wallet, and is designed for increased maximum security. As such it's suitable solution for long-term storage of your tokens. It can be used in conjunction with MetaMask to interact with the Arbitrum blockchain, on which Autonomi tokens operate. {% hint style="info" %} In order to see your Autonomi Network Tokens in your wallet, make sure to [Add Arbitrum](/token/using-autonomi-tokens/holding/add-arbitrum-network) and [import the token contract](/token/using-autonomi-tokens/holding/import-the-autonomi-token). {% endhint %} # How to Create a MetaMask Wallet MetaMask is a widely used Wallet that is fully compatible with Autonomi tokens, allowing you to hold, use, and receive them. In this guide we'll walk you through creating a MetaMask wallet, and configuring it to work with Autonomi Network Tokens. {% stepper %} {% step %} To begin, go to: and **click Get MetaMask**.
{% endstep %} {% step %} Now **click Add to Chrome**. The page will adjust depending on your browser. It should install just fine in Chrome, Firefox, and Brave.
{% endstep %} {% step %} **Click Add Extension**
{% endstep %} {% step %} Now click the **checkbox “I agree to MetaMask’s Terms of Use”**, and **click Create a new wallet**.
{% endstep %} {% step %} **Click No thanks**
{% endstep %} {% step %} **Create a password** 1. Make sure it's at least 8 characters 2. You'll need to confirm it 3. **Check the checkbox** so you understand you'll need to keep your password safe 4. Then click **Create a Wallet**
{% endstep %} {% step %} Now let's get your secret recovery phrase so you can access your MetaMask wallet from anywhere in the world. **Click Secure my wallet**
{% endstep %} {% step %} **Click Reveal Secret Recovery Phrase**
{% endstep %} {% step %} **Now you will see your recovery phrase** This should be written down on paper so you can store it somewhere safe. {% hint style="danger" %} **Note:** Never take a screenshot of your recovery phrase, store in Notepad, etc. This should be written down on paper and put somewhere safe. Anyone with these 12, 18, or 24 words can access your wallet, and therefore any of your assets witin. {% endhint %} {% endstep %} {% step %} Now we need to verify the words and **click Confirm** This step helps you confirm you've taken them down correctly.
{% endstep %} {% step %} **Click Got it**, then **Next**, then **Done**
{% endstep %} {% step %} **Congratulations!** You've now successfully created an Ethereum wallet. {% endstep %} {% step %} Next you'll need to [**Add Arbitrum**](/token/using-autonomi-tokens/holding/add-arbitrum-network) and [**import the token contract**](/token/using-autonomi-tokens/holding/import-the-autonomi-token) so you can see and use Autonomi Network Tokens… {% endstep %} {% endstepper %} # Add Arbitrum Network For low costs, and efficient transactions, Autonomi utilises the **Arbitrum** blockchain. So in order to be able to see and transact with Autonomi Network Tokens, you'll need to add the Arbitrum One network to your wallet. Here's an example of how to do that using MetaMask ## Adding Arbitrum to MetaMask {% stepper %} {% step %} At the top left, **click where it says Ethereum Mainnet** {% endstep %} {% step %} Now you should get a pop up and should **click + Add network**
{% endstep %} {% step %} From the list of networks, click **Add** next to **Arbitrum One** {% endstep %} {% step %} Now click **Switch to Arbitrum One** {% endstep %} {% endstepper %} Next you'll need to [**import the token contract**](/token/using-autonomi-tokens/holding/import-the-autonomi-token) so you can see your Autonomi Network Tokens in your wallet… # Import the Autonomi Token Once you have [added and enabled the Arbitrum Network](/token/using-autonomi-tokens/holding/add-arbitrum-network) you'll need to import the Autonomi Network Token contract into your wallet so you can see any tokens you receive. ## Token contract address ``` 0xa78d8321B20c4Ef90eCd72f2588AA985A4BDb684 ``` Most wallets will populate any remaining fields after you enter the contract address. ## Importing the token in MetaMask Here's an example of how the process works in MetaMask. The screens may look slightly different depending on the version of MetaMask you are using, but it's the same process. {% stepper %} {% step %} **Make sure you are on the Arbitrum Network** You can use the dropdown top left to **select Arbitrum One**
{% endstep %} {% step %} **Click the small dots menu**, then **Import Token**
{% endstep %} {% step %} Select the **Custom Token Tab**
{% endstep %} {% step %} Paste in the following **Token contract address** in the text box ``` 0xa78d8321B20c4Ef90eCd72f2588AA985A4BDb684 ```
{% endstep %} {% step %} **Click Next** then **Import**
{% endstep %} {% endstepper %} You'll now be able to see your Autonomi Network Tokens in your wallet! # Trezor Setup Trezor Safe 5 Used 1. Order your Trezor from the [Official Store](https://trezor.io/store). Do not buy from Amazon or any 3rd party retailers. 2. When you receive your Trezor, ensure the packaging is intact, with no signs of tampering. Inside the box, you should find * Trezor device * USB cable * Recovery seed cards (blank) * Stickers * User manual 3. On your laptop or desktop, go to the [official website](https://trezor.io/start) and **Download for Desktop**.
4. Now Install the program
5. The Trezor Suite will now open. Please **allow access**.
6. Unselect "**Allow anonymous data collection**", and click Confirm
7. You will now be prompted to connect your Trezor to your computer, do so now. I am using the Trezor Safe 5.
8. Click **Install Firmware**
9. It will now begin installing, once complete, click **Continue** then **Start**
10. You will now be prompted to check your Trezor device. Follow the directions and **Swipe Up,** then **Tap to Confirm**
11. Now check back in the Trezor Suite and click **Continue**
12. **Skip** the tutorial and click **Continue**
13. We will now **create a new wallet**.
14. Next, select **Default** Backup Type if not already set and click **Create Wallet**
15. Now go to your Trezor device and **Swipe Up**.
16. Now **Hold to Confirm** on the Trezor. This takes a few seconds.
17. The wallet has now been created. **Swipe Up**.
18. Now click **Continue to backup**. You can skip this step, but if you loose the Trezor or it gets damaged, you will loose any assets on it. Don't be lazy, back it up.
19. Click the 3 boxes, and then **Create wallet backup**. The backup you are about to get will allow you to recover your assets if the Trezor if it is damaged or lost. Do **NOT** take a picture of these words. I recommend **writing them down and putting them somewhere safe** like a safety deposit box, a gun safe, or in a locked filing cabinet. If someone gets access to these words, they can access your crypto.
20. Now go back to your Trezor device and **Swipe Up**.
21. Now you will swipe through your 20 word backup. Please write the words down 1 at a time.
22. Now that you have written all 20 words down, the Trezor device will ask you to **Hold to Confirm**
23. Please **Swipe Up**
24. Now c**onfirm the words requested**. You will have to do this for 3 different words. Once complete this your wallet backup is complete, please **Swipe Up**.
25. Now go back to the Trezor Suite, and **Continue to Pin** and then click **Set Pin.** This is like a passcode on your phone. If you forget it, you can reset the device with your 20 word backup you wrote down in Step 21.
26. Now go back to your Trezor device and **Swipe Up** to setup a PIN, and enter it. Then click the green checkmark to confirm. Now you will be asked to enter it 1 more time.
27. Now **Swipe Up** and click **Contine** in Trezor Suite
28. Unselect Bitcoin and select **Ethereum**. Then **Complete Setup**.
29. Now **Go to Trezor Suite**
30. Select **Enable**
31. Now you will be taken to the dashboard in which you want to go to **Settings.** Next select **Experimental Features** as well as **Support Ethereum L2 networks** and **NFTs (non-fungible tokens)**.
32. Now click the **+** on the upper left side of the screen. Next select the **Arbitrum One** Network and click **Find my Arbitrum One Accounts**.
33. I previously send some ETH on Arbitrum which now just populated. You can set your nodes to earn here as well. Lets assume you have some Autonomi tokens here. You need to select **Tokens**. Then click **Hidden**. Then **Unhide**.
34. After you click Unhide you will be given this prompt in which you must click **Unhide** again
35. Now all you need to do is click **Tokens** in the dashboard and you can see your Autonomi Network Tokens!
# Trezor Sending Trezor Safe 5 Used Now that your nodes have been hard at work and you have some Autonomi Network Tokens in your wallet, maybe you want to send some to a friend or move them to a centralized exchange. Let's take a look at how to do this inside Trezor Suite. 1. Go to your Trezor Suite dashboard while your Trezor is plugged in and the PIN is unlocked. Now select **Tokens** and click the **arrow** on the right to send.
2. Enter the recipients EVM address which always starts with 0x. Then enter the amount you want to send or click **Send Max**. Next click **Review and Send**.
3. Now go to your Trezor device and click the **3 red lines** on the top right.
4. Click **Contine Anyway** and then **Swipe Up.** Then **Swipe Up** again.
5. Next you must **Hold to Sign**
6. Now go back to Trezor Suite and click **Send**
# Ledger Setup Nano X Used 1. Order your Ledger from the [Official Store](https://shop.ledger.com/). Do not buy from Amazon or any 3rd party retailers. 2. When you receive your Ledger, ensure the packaging is intact, with no signs of tampering. Inside the box, you should find * Ledger device * USB cable * Recovery seed cards (blank) * Stickers * Quick Start Guide * Keychain/Lanyard 3. On your laptop or desktop, go to the [official website](https://www.ledger.com/ledger-live) and **Download** for your specific OS. In my case it is Windows.
4. **Install** the program, then click **Finish**.
5. Now Plug your Ledger into your computer with the provided cable. Use the silver circle button to scroll to the right. Now follow the on screen prompts of the Ledger. ![](/files/qZyAkJQfTUQxRdKGXWw7)
6. You now want to create a **PIN**. This is like a passcode on your phone. If you forget it, you can reset the device with your 24 word backup you wrote down in Step 9.
7. You will have to enter it then enter it again to confirm.
8. You will now be prompted to **Write Down Your Recovery Phrase**.
9. You will have to scroll through 24 words, write them down 1 at a time. Then you will have to confirm them again.
10. Now lets navigate to the Ledger Live application on your desktop or laptop we installed at the start of this guide. It will prompt you to enter your **PIN** on your Ledger, then click **Retry**.
11. Now click both the black and silver button on the Ledger to confirm
12. Go to Ethereum and click **Install**
13. Select **Add Account** next to Ethereum.
14. Confirm on the Ledger and click **Add Account**
15. Your Ethereum Account has now been created. 16. You can see your EVM address by selecting **Accounts** then **Receive**
17. Click **Continue** on Ledger Live, then you can see the address on both Ledger Live and the Ledger Device.
18. Now we need to add the Arbitrum network to Ledger Live. Click **Accounts** then **+ Add Account**
19. Choose **Arbitrum (ETH)** then **Continue**
20. Now select **Add Account**. I previously send some ETH on Arbitrum to this address which you can see with the balance of .00001 ETH.
# Ledger Sending Nano X Used Now that your nodes have been hard at work and you have some Autonomi Network Tokens in your wallet, maybe you want to send some to a friend or move them to a centralized exchange. Currently the token is not supported in Ledger Live, but have no fear! 1. Open the **Ethereum app** on your Ledger device and navigate to **Settings**. You must **enable Blind signing**. 2. Open **MetaMask** in your browser and select **+ Add account or hardware wallet**
2. Select **Add hardware wallet**
3. Choose **Ledger** and click **Continue**. Now select the Ethereum app on your Ledger device
4. Select any of the newley generated EVM addresses and click **Unlock**
5. Make sure to [add the Arbitrum network](/token/using-autonomi-tokens/holding/add-arbitrum-network) and [import the token contract](/token/using-autonomi-tokens/holding/import-the-autonomi-token) 6. Click **Send**
7. Enter the EVM address you wish to send to and the amount of Autonomi Network Tokens, then click **Continue**
8. Click **Confirm**, then select **Accept Risk and Send** on the Ledger device.
# Buying Autonomi Network Tokens are available on the following exchanges. Listings vary by venue, so follow the exact market shown on each exchange page. ## Centralized Exchanges (CEX) [MEXC (AUTONOMI/USDT)](https://www.mexc.com/en-GB/exchange/AUTONOMI_USDT) [BingX (AUTONOMI/USDT)](https://bingx.com/en/spot/AUTONOMIUSDT) [OurBit (AUTONOMI/USDT)](https://www.ourbit.com/exchange/AUTONOMI_USDT?_from=search) ## Decentralized Exchanges (DEX) [Uniswap (ANT/USDC)](https://app.uniswap.org/explore/tokens/arbitrum/0xa78d8321b20c4ef90ecd72f2588aa985a4bdb684) # Via BitMart Buying Autonomi tokens on the BitMart Centralized Exchange BitMart lists the token in the `ANT/USDT` market. {% stepper %} {% step %} #### **Create a BitMart Account** * Visit [BitMart](https://www.bitmart.com/) * Click **"Sign Up"** and complete the registration process. * Verify your identity (if required for your region). {% hint style="info" %} It is always good practice to enable 2FA when possible. {% endhint %} {% endstep %} {% step %} #### **Deposit Funds** * Go to **Wallet > Deposit** * Choose **USDT** and deposit funds from your preferred exchange or wallet. {% endstep %} {% step %} #### Buy * Go to the [**ANT/USDT** trading pair](https://www.bitmart.com/trade/en-US?type=spot\&symbol=ANT_USDT). * Enter the amount of you want to buy and place a **Market or Limit order**. {% endstep %} {% step %} #### **Withdraw (Optional)** * If you prefer self-custody, withdraw your Autonomi Network Tokens to your [compatible wallet](/token/using-autonomi-tokens/holding/compatible-wallets) such as MetaMask. * Go to **Wallet > Withdraw**, enter your wallet address, and confirm the transaction. {% endstep %} {% endstepper %} {% hint style="info" %} In order to see your Autonomi Network Tokens in your wallet, make sure to [Add Arbitrum](/token/using-autonomi-tokens/holding/add-arbitrum-network) and [import the token contract](/token/using-autonomi-tokens/holding/import-the-autonomi-token). {% endhint %} # Via Uniswap Buying Autonomi Network Tokens on Uniswap (Arbitrum) On Uniswap, Autonomi Network Tokens are listed as `ANT`. {% stepper %} {% step %} #### **Set Up a Wallet** * Download and install a [**compatible wallet**](/token/using-autonomi-tokens/holding/compatible-wallets) such as MetaMask * Ensure your wallet is set to the [**Arbitrum One Network**](/token/using-autonomi-tokens/holding/add-arbitrum-network) (ARB) {% endstep %} {% step %} #### **Fund Your Wallet** * You'll need some USDC in your wallet, ready to trade for `ANT` on Uniswap. If you don't have any already, you can buy it on a centralized exchange such as [Coinbase](https://www.coinbase.com/), [BitMart](https://www.bitmart.com/), or [Binance](https://www.binance.com/), and add it to your wallet. * You'll also need a small amount of Ethereum (ETH) for gas fees to your wallet. We recommend you start with around $10 worth of ETH. * Make sure you send the ETH on the **Arbitrum** network, ***not***** on the ETH mainnet**.
{% endstep %} {% step %} #### **Connect to Uniswap** * Visit [Uniswap](https://app.uniswap.org/) * Click **"Connect Wallet"** and select your wallet (e.g. MetaMask) {% endstep %} {% step %} #### **Swap USDC for ANT** * Go to the [**ANT token page on Uniswap**](https://app.uniswap.org/explore/tokens/arbitrum/0xa78d8321b20c4ef90ecd72f2588aa985a4bdb684) * Enter the amount of USDC you want to swap for Autonomi Network Tokens. * Click **"Swap"** and confirm the transaction in your wallet. {% endstep %} {% endstepper %} {% hint style="info" %} In order to see your Autonomi Network Tokens in your wallet, make sure to [Add Arbitrum](/token/using-autonomi-tokens/holding/add-arbitrum-network) and [import the token contract](/token/using-autonomi-tokens/holding/import-the-autonomi-token). {% endhint %} # Via MEXC # Earning You can earn Autonomi tokens by running a node, rewarding you for contributing your spare hard drive space to the Network. Starting a node (or even several) is easy, and will work on home computers just like yours. Here's how: {% stepper %} {% step %} ### **Download the Node Launchpad** [Windows](https://downloads.autonomi.com/autonomi-app/windows) (Windows 10+) [Mac](https://downloads.autonomi.com/autonomi-app/mac) (Apple Silicon) [Linux x86-64](https://downloads.autonomi.com/autonomi-app/linux) (Ubuntu 24.04+ recommended) {% endstep %} {% step %} ### **Take a look at the Quickstart Guide** Our [**step-by-step guides**](broken://spaces/E2vCbzFkA1U5BwZFjnvL/pages/qz3Kn6HsuztRa6IjiCde) will walk your through each step of getting nodes running your computer. {% endstep %} {% step %} ### **Add your Wallet Address** Adding your [wallet address](/token/using-autonomi-tokens/holding/compatible-wallets) allows you to hold anything your node earns, and be rewarded for it. The more data your nodes store serve, and the longer and more reliably they do it, the more they will earn. {% endstep %} {% endstepper %} # Process Overview MaidSafeCoin is a proxy token for Autonomi tokens, which was made available for purchase during the MaidSafe ICO in 2014. It's redeemable 1:1 for Autonomi tokens through an airdrop. Holders of [MAID (Omni)](/token/converting-maidsafecoin/how-to-convert-maid) and [eMAID (ERC20)](/token/converting-maidsafecoin/how-to-convert-emaid) can redeem their tokens for Autonomi tokens without the need for KYC. The process varies slightly depending on the token type, but involves **burning your MaidSafeCoin** then **receiving your Autonomi tokens by airdrop** according to a [set schedule](/token/converting-maidsafecoin/timeline). Here are the step-by-step guides for how to do it: {% content-ref url="/pages/qCBQfOo5sSZdkJxPZjBu" %} [How to Convert MAID](/token/converting-maidsafecoin/how-to-convert-maid) {% endcontent-ref %} {% content-ref url="/pages/6URqLAPhLplNfCmIKv0o" %} [How to Convert eMAID](/token/converting-maidsafecoin/how-to-convert-emaid) {% endcontent-ref %} ## **Key Details** * No KYC is required to receive the airdrop * You must carefully complete the process, as submitting the incorrect information could result in permanent token loss. * You do not need to convert all your MaidSafeCoin in one go * Airdrops occur on a [rolling schedule](/token/converting-maidsafecoin/timeline) beginning on the **14 February 2025** * The last and final deadline for the airdrop will be **3 February 2028** # Timeline The conversion process will open at **11:00 GMT on February 6th, 2025** with the first airdrop being Friday 14th February 2025. The final deadline is **February 3rd, 2028.** ## **Airdrop Schedule** You can initiate the process and submit your details at any time until the final deadline, but your Autonomi Network Tokens will be airdropped according to the following schedule: * **Twice weekly** (Tuesdays & Fridays) from **14 February 2025 – 7 March 2025** * **Once weekly** (Fridays) from **8 March 2025 – 4 April 2025** * **Fortnightly** (every second Friday) from **5 April 2025 – 2 May 2025** * **Monthly** (second Friday of the month) from **3 May 2025 – 6 February 2026** * **Quarterly** (last Friday of the quarter) from **7 February 2026 – 3 February 2028** {% hint style="info" %} For example: If you burn 50 MaidSafeCoin and complete the process by 10th of March 2025, 50 Autonomi Network Tokens will be airdropped to your wallet on the 14th of March 2025. {% endhint %} {% hint style="info" %} Please note this is a manual process and can sometimes be delayed a few days. If you have questions, come to the discord. Be mindful there are many times scammers that join the server and send fake links or DMs impersonating team members. You can trust any of the dark blue names who are Maidsafe members such as Rusty Spork or Bux as well as the moderators with red names such as Neo and Mightyfool while inside our official server. {% endhint %} # How to Convert MAID The process of converting from MAID (the original coin on the Omni chain) differs slightly depending on where you are currently holding your coins. We've compiled some step-by-step guide for the most common types. But note, all of these will require your to use OmniWallet to complete the process. {% content-ref url="/pages/ryJLgDeRACDPCxKCrNZe" %} [From a Paper Wallet](/token/converting-maidsafecoin/how-to-convert-maid/from-a-paper-wallet) {% endcontent-ref %} {% content-ref url="/pages/bZ1SYxfeIVgnpzO8isVQ" %} [From OmniWallet](/token/converting-maidsafecoin/how-to-convert-maid/from-omniwallet) {% endcontent-ref %} {% content-ref url="/pages/AbjihQLYOSSYXyhTTFcs" %} [From a Hardware Wallet](/token/converting-maidsafecoin/how-to-convert-maid/from-a-hardware-wallet) {% endcontent-ref %} # From a Paper Wallet Please note these instructions will apply to people holding MAID on paper wallets, or who so simply hold the private key. {% stepper %} {% step %} ### First, c**reate an OmniWallet Account** * Go to [OmniWallet](https://www.omniwallet.org/) * Click on **Create Wallet** * Set up a **strong password** and securely store it * After registering, **download the wallet backup** and store it safely {% endstep %} {% step %} ### **Import Your Private Key** * Log into your **OmniWallet** account * Navigate to **My Wallet > My Addresses** * Click **Add Address,** then proceed to select **Import Address With Private Key.**
* Click on **Import Bitcoin Address** * Enter your **private key** into the provided field. Your private key is written down on your paper wallet. * Click **Add Address** to finalize the import {% hint style="danger" %} Never give anyone your private key or seed phrase as they can access your funds with it {% endhint %} {% endstep %} {% step %} ### [**Continue with the Omni Wallet steps…** ](/token/converting-maidsafecoin/how-to-convert-maid/from-omniwallet) Next, continue on with the step by step process described in our [Omni Wallet guide](/token/converting-maidsafecoin/how-to-convert-maid/from-omniwallet) {% endstep %} {% endstepper %} # From OmniWallet The process involves using the OmniWallet app to sign your address and then sending your MAID to a burn address, collecting key information as you do. You'll then submit this information via a form, and receive your Autonomi tokens via a [scheduled airdrop](/token/converting-maidsafecoin/timeline#airdrop-schedule). Below is a step-by-step guide, with the information you'll need to save as you go **highlighted in green.** We'd recommend you read through it to familiarise yourself with the overall process. {% hint style="info" %} **You don't have to convert all your MaidSafeCoin in one go.** You could choose to try the process with a small amount first, should you wish. {% endhint %} {% stepper %} {% step %} ### **Set Up an** Autonomi token **Compatible Wallet** * Download and install an Autonomi tokens[ **compatible wallet**](/token/using-autonomi-tokens/holding/compatible-wallets) such as [MetaMask](https://metamask.io/) * Ensure your wallet is set to the [**Arbitrum One Network**](/token/using-autonomi-tokens/holding/add-arbitrum-network) {% hint style="success" %} **Copy your wallet address** (otherwise known as an ETH address) for the next step. This is the wallet your Autonomi tokens will be sent to. You'll need this for the final step too. {% endhint %} {% endstep %} {% step %} ### **Sign Your Omni Wallet Address** * Log into your [**OmniWallet**](https://www.omniwallet.org/) * Navigate to **My Wallet > My Addresses** to view your stored addresses * Click on the **Actions** button next to the address containing your MAID and select **Sign Message** * **Paste your ETH wallet address into the text box.** This is the same wallet from *Step 1*, and it's where you'll receive your Autonomi tokens via airdrop * Click **"Sign Message"** to generate a signature {% hint style="success" %} **Copy and save this signature.** you'll need to submit this in the final step {% endhint %} {% hint style="success" %} **Copy and save the Omni Address** containing your MAID, as you'll need to submit that in the final step too. {% endhint %} {% endstep %} {% step %} ### **Burn MAID Tokens** * **Ensure you have a small amount of Bitcoin in your OmniWallet to cover the transaction fees.** The fee is the same regardless of how much you are sending. To get a accurate estimate of how much you may need, you can check the [Bitcoin Average Transaction Fee](https://ycharts.com/indicators/bitcoin_average_transaction_fee). *As an example, it cost as little as $2 worth of BTC a few days ago. So, $10 worth of BTC would be more than sufficient, even if fees increase temporarily.* * Navigate to **My Wallet > Send** * Enter the amount of MAID (full integers) you wish to swap then… * **Send it to this burn address:** ``` 1BitcoinEaterAddressDontSendf59kuE ``` {% hint style="info" %} This may look like it's not a valid address, but it is. It contains the warning `DontSend` as it will burn any tokens or BTC sent to it… but it is the correct address to send to in order to burn your MAID as part of the conversion process. {% endhint %} {% hint style="success" %} **Save a copy of the Transaction Hash** that you are shown aften sending to this address. You'll need to submit it in the final step. {% endhint %} {% endstep %} {% step %} ### **Submit Your Information** To complete the airdrop, you'll need to submit the following details through this [**Airdrop Form**](https://form.typeform.com/to/uM679hXj) **✅** The **ETH Wallet Address** where you want receive your Autonomi tokens, copied from *Step 1* — which should be the same address used to sign the message in *Step 2* **✅** The **Signed Message Signature** you copied at the end of *Step 2* **✅** The **Omni Address** you sent your MAID from in *Step 3* **✅** The **Burn Transaction Hash** you saved the end of *Step 3* {% hint style="info" %} The information you submit will be used by the Autonomi Foundation only to validate and process your airdrop of Autonomi tokens, and will be held for no longer than 30 days after the airdrop transaction is completed, after which it will be deleted. \ \ We use the third party tool [Typeform](https://www.typeform.com) to collect this submission data.\ \ No other personally identifiable information (such as an email or IP Address) is collected nor processed by the Autonomi Foundation with this submission. This is to protect your personal data.\ \ It means that **you cannot be contacted about your submission**, so please check the details carefully! We'd recommend keeping a copy of this information until after your receive your Autonomi tokens airdrop. {% endhint %} {% endstep %} {% step %} ### **Wait to Receive Your** Autonomi tokens Your Autonomi tokens tokens will be airdropped to the same ETH wallet from you used to sign the message in *Step 2* and that you submitted in *Step 4*.\ \ The number of tokens received will match the number of burned tokens 1:1. \ \ Please be patient, as airdrops will be made according to a [set schedule](/token/converting-maidsafecoin/timeline). {% endstep %} {% endstepper %} {% hint style="info" %} In order to see your Autonomi Network Tokens in your wallet, make sure to [Add Arbitrum](/token/using-autonomi-tokens/holding/add-arbitrum-network) and [import the token contract](/token/using-autonomi-tokens/holding/import-the-autonomi-token). {% endhint %} # From a Hardware Wallet There are a variety of hardware wallet solutions that the community have used in the past to store MAID, and all may need slightly different approaches depending on how they are set up, and whether you have any other crypto assets stored on the wallet at the same time. There are two broad solutions though ### Use Your Private Key Similar to the approach for those with [Paper Wallets](/token/converting-maidsafecoin/how-to-convert-maid/from-a-paper-wallet), you can Import Private Key into a new OmniWallet, and then continue with the [OmniWallet steps](/token/converting-maidsafecoin/how-to-convert-maid/from-omniwallet) from there. ### Send to a new OmniWallet Or, if you don't want to expose your Private Key—should you still have other crypto assets stored on your device for example—then another solution is to create a new OmniWallet, and send your MAID to it (and some BTC for gas), and proceed from there. # How to Convert eMAID The process of converting from eMAID (the newer ERC-20 version of MaidSafeCoin) differs slightly depending on where you are currently holding your coins. We've compiled some step-by-step guide for the most common types: {% content-ref url="/pages/6ZQrjnOoa22Dmt0zvTVs" %} [From a Software Wallet](/token/converting-maidsafecoin/how-to-convert-emaid/from-a-software-wallet) {% endcontent-ref %} {% content-ref url="/pages/NFqg8bSicHw8hpXOnJDE" %} [From a Hardware Wallet](/token/converting-maidsafecoin/how-to-convert-emaid/from-a-hardware-wallet) {% endcontent-ref %} # From a Software Wallet How to convert from eMAID to Autonomi tokens if your coins are on a software wallet, such as MetaMask. {% stepper %} {% step %} ## **Burn Your eMAID Tokens** * Go to the [eMAID contract address on Etherscan](https://etherscan.io/address/0x329c6e459ffa7475718838145e5e85802db2a303) * Click on **Contract**, then select **Write as Proxy**.
* Connect your ETH wallet holding eMAID using **Connect to Web3**.
* In the burn dropdown, enter the number of tokens to burn and confirm the transaction.
{% hint style="warning" %} **Note the format here is `uint256`**. You should write the amount of eMAID you wish to burn as an integer with 18 decimals. That means 18 trailing zeros.\ \ For example `1`eMAID is written as `1000000000000000000` {% endhint %} {% endstep %} {% step %} ### **Wait for Verification** No further action is required. The system will automatically detect your burn transaction. {% endstep %} {% step %} ### **Receive your** Autonomi tokens Your Autonomi tokens will be airdropped to the same ETH wallet from which you burned your eMAID. The number of tokens received will match the number of burned tokens 1:1. Please be patient, as this is on a [set schedule](/token/converting-maidsafecoin/timeline). {% endstep %} {% endstepper %} {% hint style="info" %} In order to see your Autonomi Network Tokens in your wallet, make sure to [Add Arbitrum](/token/using-autonomi-tokens/holding/add-arbitrum-network) and [import the token contract](/token/using-autonomi-tokens/holding/import-the-autonomi-token). {% endhint %} # From a Hardware Wallet How to convert from eMAID to Autonomi tokens if your coins are on a Hardware wallet, such as Ledger. A hardware wallet like **Ledger** or **Trezor** enhances security by keeping your private keys offline. By integrating it with **MetaMask**, you can interact with decentralized applications (dApps) while ensuring your assets remain protected. {% stepper %} {% step %} Open **MetaMask** in your browser. Click on your profile icon and select **+ Add account or hardware wallet**
{% endstep %} {% step %} Select **Add hardware wallet**
{% endstep %} {% step %} Choose **Ledger** or **Trezor** and click **Continue**.
{% endstep %} {% step %} **Connect and unlock** your hardware wallet. Your can now follow on with the steps outlined in the [**software wallet guide**](/token/converting-maidsafecoin/how-to-convert-emaid/from-a-software-wallet) to complete your eMAID conversion {% endstep %} {% endstepper %} # BitMart Conversion If you have your eMAID on the [Bitmart](https://www.bitmart.com/) exchange, they will complete the conversion for you automatically. This process will take between 3-5 working days after Autonomi tokens has been listed, which is currently anticipated to be on the **11th of February, 2025**, but is still subject to change. {% hint style="warning" %} **Withdrawals, deposits and trading will be suspended at 11:00 GMT on February 6th, 2025** If you wish to complete the conversion process yourself, or don't want Bitmart to convert your to Autonomi tokens for you, you should withdraw your eMAID from the exchange prior to this date. {% endhint %} # T\&Cs # Redeeming Beta Rewards If you participated in the later stages of the Beta Rewards program, or the early Network launch reward phases, where an **Ethereum Wallet Address** was required, then you don't need to do anything.\ \ We'll send your rewards direct to the address you specified on the **14th February 2025**. ## Redeeming with your Discord account But for those of your that participated in the early waves of the Beta Rewards Program, where your Discord Username was used to track rewards. Depending on your wave you will need to go into Pioneer, Trail Blazers, or Explorers Discord announcement channel and submit a form. Then contact `Atomic654` via Discord and supply her with a wallet address to receive your rewards\ \ After that is done and dusted, your rewards will be sent to your wallet in a weekly scheduled airdrop.
### Don't forget to configure your wallet In both cases, you'll need to make sure your wallet is ready to receive and display your Autonomi Network Tokens when they arrive by [adding Arbitrum](/token/using-autonomi-tokens/holding/add-arbitrum-network) and [importing the token contract](/token/using-autonomi-tokens/holding/import-the-autonomi-token). # Get Help If you're looking for a helping hand with using Autonomi Network Tokens, running a node, or anything in between, here's how to get support. ### Community Support We have a helpful, passionate and deeply knowledgeable community that often offers the most rapid support. Ask for help via the dedicated [support channels on Discord](https://discord.com/channels/1209059621319221268/1247881515107483759), or in our longstanding [Autonomi Community Forum](https://forum.autonomi.community/). ### Email Support You can contact the Autonomi team directly for support by emailing: [**support@autonomi.zendesk.com**](mailto:support@autonomi.zendesk.com) We are a small and busy team though, so please be patient, and kind! # FAQs ### Holding
What is Arbitrum and the Arbitrum One Network? While the Autonomi Network [isn't blockchain based](broken://spaces/T1VY0u5KuOsTpycHpSka/pages/be2hGLrKdFlf1EeYQivD) it works with common blockchain payment systems to make the Network accessible and easy to integrate alongside other decentralized solutions. So Autonomi Network Tokens use the Ethereum payment system for this reason. But in order to make payments efficient and low cost, Autonomi Network Tokens utilise Arbitrum Network—which is what is know as an L2 blockchain—which sits oin top of Ethereum. This means much lower transactions fees (known as Gas) even for small amounts of data, than if it were to use the Ethereum main net directly.\ \ Arbitrum One is simply the name of the live production network, So, speaking practically: * Any Ethereum address can receive Autonomi Network Tokens * You'll need an Arbitrum [compatible wallet](/token/using-autonomi-tokens/holding/compatible-wallets) * You'll also need to [configure it so you can see and use your tokens](/token/using-autonomi-tokens/holding/add-arbitrum-network)
### Buying
Are Autonomi Tokens available on a DEX? **Yes!** You can buy and trade on decentralized exchnages like [Uniswap V3 and PancakeSwap](/token/using-autonomi-tokens/buying#decentralized-exchanges). On decentralized exchanges the token typically appears as `ANT`.
BitMart isn't available in my region, what can I do? It's an unfortunate fact that most centralised exchanges aren't available to everyone everywhere, do to the complexities of local regulations.\ \ However, you can in many cases still use [Decentralized Exchanges](/token/using-autonomi-tokens/buying#decentralized-exchanges) (DEX) to buy Autonomi Network Tokens, in conjunction with an exchange you can access in your area.\ \ For example: Use Coinbase to buy some USDC, then [use Uniswap](/token/using-autonomi-tokens/buying/via-uniswap) to exchange this for `ANT`.
### Earning
How much does a Node cost? **Nothing!** In fact, you get paid for running a node, or as many nodes as you want. They are designed to run on everyday computers.
What sort of computer do I need? Autonomi nodes are designed to work on everyday home devices. So even relatively modest-performance computers will happily run a node, or even many nodes at once. Each node uses around 35 GB of storage space, as well as some CPU, memory, and of course Internet bandwidth. Our easy-to-use [Node Launchpad](broken://spaces/E2vCbzFkA1U5BwZFjnvL) software is compatible with Windows, Mac and Linux. Many people use typical home computers, or even RaspberryPis, to contribute to the Network. There are options for more advanced users to utilise their headless computers, home servers, or virtual environments. But we'd encourage you to start with what you already have. It's probably right in front of you.
How many nodes can I run? A typical home PC will be able to run several nodes at once, and you can start nodes on as many computers as you like. We'd recommend you start just a few nodes to begin, and then add more gradually as your computer and Internet connection capacity allows.
How much can I earn? How many Autonomi Network Tokens you can earn depends on a number of factors such as: * How many nodes you are running on your devices * How long, and how reliably they are storing and serving data * The demand for data storage on the Network at a given time So while we can't give you a direct answer, we can recommend you dive in and give it a try. It's straightforward and even, dare we say it, fun!
### Converting MaidSafeCoin
Do I need to convert all my MaidSafeCoin in one go? **No!** You don't have to convert all your MaidSafeCoin in one go. You could choose to try the process with a small amount first, should you wish.ou could choose to try the process with a small amount first, should you wish.
What happens to my MaidSafeCoin if I leave it on an exchange? If you leave your eMAID on the BitMart exchange after the 6th of February, it will automatically be converted to Autonomi Network Tokens for you. If you have MaidSafeCoin on another exchange you will need to withdraw it and [follow the process to convert](/token/converting-maidsafecoin/process-overview) it by receiving the Autonomi Network Token airdrop.
How long do I have to convert my MaidSafeCoin to Autonomi Network Tokens? The final deadline to convert is **February 3rd, 2028,** with the very last airdrop happening on February 3rd, 2028.\ \ We'd recommend you [follow the instructions](/token/converting-maidsafecoin/process-overview), and convert well in advance of this deadline.
Will my Autonomi Network Tokens be air-dropped to Ethereum Mainnet, or Arbitrum One? While Autonomi Network Tokens can be received by any Ethereum wallet address, your tokens will be airdropped via the **Arbitrum One Network**, not the Ethereum Mainnet.\ \ You'll need to [Add Arbitrum](/token/using-autonomi-tokens/holding/add-arbitrum-network) to your wallet app, and [import the token contract](/token/using-autonomi-tokens/holding/import-the-autonomi-token) to be able to see and use them.
When burning eMAID, the field says uints256 does that mean one eMAID is 1, or 1000000000000000000? As the units are in `uints256` format, you must type them asn a 18 decimals integer.\ \ So 1 token would be written as `1000000000000000000`
When entering my ETH Address, do I include the leading 0xdigits? **Yes!** You should paste in the address in full including the digits `0x`at the start
When adding my ETH wallet address, is it case sensitive? **No.** Casing doesn't matter. Just paste it across as it is.
# What is Autonomi? Autonomi is a decentralized peer-to-peer network for permanent, immutable data storage. Data is encrypted before upload, stored using content addressing, and paid for once when you write it to the network. ## What makes Autonomi different At a high level, Autonomi gives you: * immutable storage, where changing the content produces a new address instead of mutating the old one * client-side encryption through self-encryption before chunks are stored on the network * public and private retrieval through addresses and DataMaps * pay-once storage, where you pay in Autonomi Network Token (ANT) when you upload and downloads are free * post-quantum cryptography in the transport and security model ## How you can build on Autonomi You can work with Autonomi in four main ways. ### SDK Use the SDK when you want to build an application in Python, Node.js / TypeScript, Go, Rust, Java, C#, Kotlin, Swift, Ruby, PHP, Dart, Zig, or another supported language. The SDK uses a local daemon called `antd`, which exposes REST and gRPC and keeps the network-facing work out of your application. Start with [Build with the SDKs](/developers/sdk/install). ### MCP Use the MCP server when you want an AI tool such as Claude Desktop, Claude Code, or another MCP-compatible client to interact with Autonomi through structured tools. The MCP server also talks to `antd`, but it presents Autonomi through an AI-tool interface rather than through language bindings. Start with [Use MCP with AI Tools](/developers/mcp/use-mcp-with-ai-tools). ### CLI Use the CLI when you want direct shell access for uploads, downloads, wallet checks, chunk operations, or node-management workflows. Start with [Use the CLI](/developers/cli/use-the-cli). ### Developing in Rust Build directly in Rust when you want in-process control over networking, uploads, and downloads without using `antd`. Start with [Developing in Rust](/developers/developing-in-rust/rust). ## Build with an AI coding tool If you are working in Claude Code or another AI coding tool, install the [Autonomi Developer Skill](/developers/developer-skill). It gives your tool a verified, focused guide to building on Autonomi, so it picks the right path, uses real APIs, and avoids common mistakes. ## Core concepts * [Data Types](/developers/core-concepts/data-types) * [Keys, Addresses, and DataMaps](/developers/core-concepts/keys-addresses-and-datamaps) * [Self-Encryption](/developers/core-concepts/self-encryption) * [Payment Model](/developers/core-concepts/payment-model) * [Post-Quantum Cryptography](/developers/core-concepts/post-quantum-cryptography) ## Go deeper * [System Overview](/developers/architecture/system-overview) * [Source Repositories](/developers/reference-extras/source-repositories) # Use the Autonomi Developer Skill The Autonomi Developer Skill is a verified knowledge package for AI coding tools such as Claude Code. It is a companion to these docs, not a replacement, and gives your AI coding tool the operational expertise it needs to help you build, integrate, and deploy applications on the Autonomi Network. **Preview release.** The skill is currently in a draft state. Install names and identifiers may shift before the first non-draft version. ## What it gives your AI * **Autonomi development expertise**, including how to choose the right path for your project across the SDK, CLI, Direct Rust, and MCP. * **Access to verified API surfaces, golden flows, and common-failure recipes**, so your AI works from real endpoints, real CLI commands, and real method names instead of guessing. * **Safety rules around wallets, keys, uploads, and public-network work**, so it defaults to a local devnet first and asks before touching real Autonomi Network Token (ANT). ## Install it ### In Claude Code Run these commands inside Claude Code to add the Autonomi marketplace and install the skill: ``` /plugin marketplace add WithAutonomi/autonomi-developer-docs /plugin install developer@withautonomi /reload-plugins ``` The skill is now available across all your Claude Code sessions. Claude uses it automatically when you work on Autonomi tasks. To invoke it explicitly, type `/developer:start`. ### In other AI tools Any tool that loads Claude-style skill files can read it directly from the canonical URL: ``` https://raw.githubusercontent.com/WithAutonomi/autonomi-developer-docs/main/skills/start/SKILL.md ``` Follow your tool's instructions for installing a Markdown skill file. ### Manual install To install the skill by hand into Claude Code, drop the file into your Claude Code skills directory: ```bash mkdir -p ~/.claude/skills/autonomi-developer curl -fsSL https://raw.githubusercontent.com/WithAutonomi/autonomi-developer-docs/main/skills/start/SKILL.md \ -o ~/.claude/skills/autonomi-developer/SKILL.md ``` ## Staying current The skill checks for newer published versions on each use and tells you when one is available so you can refresh your local copy. The verified upstream commits are recorded in the skill's metadata, so you can always see exactly which versions of the Autonomi source repos a given copy of the skill was verified against. ## Related pages * [What is Autonomi?](/developers) * [Build with the SDKs](/developers/sdk/install) * [Use the CLI](/developers/cli/use-the-cli) * [Developing in Rust](/developers/developing-in-rust/rust) * [Use MCP with AI Tools](/developers/mcp/use-mcp-with-ai-tools) # Overview This page introduces the concepts that matter most when you build on Autonomi. ## Storage model Autonomi stores data as immutable, content-addressed chunks. The developer-facing storage surfaces in this docs set are public data, private data, chunks, files, and DataMaps. Public workflows return an address that can be shared; private workflows return retrieval metadata that you keep client-side. Read more in [Data Types](/developers/core-concepts/data-types). ## Keys, addresses, and DataMaps Wallet keys pay for writes, public addresses retrieve public data, and `DataMap` values are the critical retrieval material for private data. Read more in [Keys, Addresses, and DataMaps](/developers/core-concepts/keys-addresses-and-datamaps). ## Self-encryption Before uploaded content is stored, it is encrypted and split into chunks. The `self_encryption` crate and the higher-level upload paths in `ant-sdk` and `ant-core` are responsible for producing the DataMap and chunk layout used later for retrieval. Read more in [Self-Encryption](/developers/core-concepts/self-encryption). ## Post-quantum cryptography The cryptography stack uses ML-DSA-65 for signatures and ML-KEM-768 for key encapsulation. Those algorithms matter most when you are reasoning about network identity, transport security, or the broader security model. Read more in [Post-Quantum Cryptography](/developers/core-concepts/post-quantum-cryptography). ## Payment model Autonomi is designed around pay-once, immutable storage. Uploads are wallet-backed writes: you pay when you store data, then retrieve it later without recurring storage fees or retrieval payments. Read more in [Payment Model](/developers/core-concepts/payment-model). ## Reading guide Start here depending on what you need next: * If you are building an application: [Data Types](/developers/core-concepts/data-types), then [Store and Retrieve Data with the SDKs](/developers/sdk/install/how-to-guides/store-and-retrieve-data) * If you need to understand wallets, public addresses, and private retrieval material: [Keys, Addresses, and DataMaps](/developers/core-concepts/keys-addresses-and-datamaps) * If you need to understand the encryption path: [Self-Encryption](/developers/core-concepts/self-encryption) * If you need to understand upload costs and wallets: [Payment Model](/developers/core-concepts/payment-model), then [Estimate Costs and Handle Upload Payments](/developers/guides/estimate-costs-and-handle-upload-payments) * If you need the security context: [Post-Quantum Cryptography](/developers/core-concepts/post-quantum-cryptography) # Data Types Autonomi stores content as immutable, content-addressed chunks. As a developer, you usually work with higher-level interfaces such as public data, private data, files, and DataMaps. ## Why it matters Because Autonomi stores content as immutable, content-addressed chunks, developers need to understand the higher-level interfaces they use to package, publish, and retrieve that data. This page explains how public data, private data, files, and DataMap handling fit together. ## One storage primitive underneath Autonomi has one underlying storage primitive: the chunk. When you upload data: * self-encryption turns the content into encrypted chunks * a `DataMap` records how those chunks fit back together * public and private workflows mainly differ in where that `DataMap` lives A `DataMap` is not a separate storage primitive. It is retrieval metadata. ## Content-addressed and immutable When you upload data to Autonomi, the stored result is content-addressed rather than mutable. In practice, that means: * changing the content produces a different address * public data and public file uploads can be retrieved from their content-derived addresses * private workflows still store content-addressed chunks, but you keep the retrieval metadata locally in a `DataMap` This is why Autonomi is immutable rather than update-in-place. ## Developer-facing interfaces at a glance | Interface | Under the hood | Typical use | | ------------ | --------------------------------------------------------- | ---------------------------------------------------------- | | Public data | Chunks plus a published `DataMap` address | Shared payloads, app data, public content | | Private data | Chunks plus a client-held `DataMap` | Encrypted content you keep client-side | | Chunk | A single chunk stored directly | Small payloads and low-level tooling | | File | Self-encrypted chunks plus a file-oriented `DataMap` flow | Uploading and downloading files from disk | | `DataMap` | Retrieval metadata for chunked content | Private retrieval, public file addressing, later downloads | ## Public and private data Public and private data are not two different low-level storage systems. * In public workflows, the `DataMap` is stored or published so the content can be retrieved by address. * In private workflows, the `DataMap` stays with you and is not stored publicly. In the daemon APIs, you can see this difference clearly: * `POST /v1/data/public` returns a public address * `POST /v1/data` returns a serialized `DataMap` (the DataMap is not stored on-network) In both cases, the underlying content is still stored as chunks. ## Chunks Chunks are the low-level storage unit. The CLI exposes them through `ant chunk put` and `ant chunk get`, and the daemon exposes them through `/v1/chunks`. Use chunk operations when you are building low-level tooling or want explicit control over single-chunk payloads. For most application data, use public/private data or file uploads instead. ## Files File uploads wrap the same chunk-and-DataMap model for content that already lives on disk. Behavior differs slightly by interface: * `antd` exposes public file upload/download endpoints * `ant` supports both public file uploads and private uploads that keep a local `.datamap` file Use these surfaces when you want the tooling to handle file-system input and output directly instead of working with raw byte arrays. ## DataMap A DataMap is the retrieval metadata that ties uploaded content back to its encrypted chunks. In the SDK and CLI surfaces, a DataMap shows up in two main ways: * private uploads return it directly to you * public uploads store it on-network and return an address that can be fetched later This is one of the main differences between public and private workflows. ## Practical example The tooling maps cleanly onto these interfaces: * use `POST /v1/data/public` or `client.data_put_public(...)` when you want the `DataMap` stored publicly and returned as an address * use `POST /v1/data` or `client.data_put(...)` when you want the `DataMap` returned to you directly * use `POST /v1/files/public` or `ant file upload ... --public` when you want file content to be publicly retrievable * use `ant file upload ...` without `--public` when you want the CLI to keep the `.datamap` file locally instead ## Related pages * [Store and Retrieve Data with the SDKs](/developers/sdk/install/how-to-guides/store-and-retrieve-data) * [Payment Model](/developers/core-concepts/payment-model) * [Keys, Addresses, and DataMaps](/developers/core-concepts/keys-addresses-and-datamaps) * [Self-Encryption](/developers/core-concepts/self-encryption) # Keys, Addresses, and DataMaps Autonomi keeps upload payment, public retrieval, and private retrieval separate. ## Why it matters If you are building on Autonomi, you need to understand three different things: * wallet keys pay for uploads * public addresses retrieve public data * `DataMap` retrieves private data Treating those as one all-purpose developer key makes the rest of the system harder to understand. ## What you handle | Material | When you get it | What you do with it | | ------------------ | -------------------------------------------------------------- | ------------------------------------------------------ | | Wallet private key | You provide it | Pay for uploads | | Public address | Returned after a public upload or public DataMap store | Share or store it, then use it to retrieve public data | | `DataMap` | Returned after a private upload or saved locally by some tools | Store it safely, then use it to retrieve private data | ## Wallet private key The wallet private key is used for paid writes. Depending on the tool you use, that appears as: * `AUTONOMI_WALLET_KEY` for `antd` * `SECRET_KEY` for `ant` * an attached `Wallet` in `ant-core` This key is about payment, not about private-data decryption. ## Public address A public address is what you use to retrieve data that has been published on the network. When you upload public data or store a public DataMap, the tooling returns an address that other readers can use later. If the content changes, the address changes too, because the storage model is content-addressed and immutable. ## DataMap A `DataMap` is the private retrieval material that ties uploaded content back to its encrypted chunks. For private data: * the chunks are still stored on the network * the `DataMap` is returned to you instead of being stored publicly * if you lose that `DataMap`, you lose the practical ability to retrieve the private content That means `DataMap` handling is a data-access concern, not a payment concern. ## Practical example The simplest way to think about the split is: * use a wallet key when you need to upload data * use a public address when you want to retrieve public data * use a `DataMap` when you want to retrieve private data ## Upstream sources * [ant-sdk](https://github.com/WithAutonomi/ant-sdk) * [ant-client](https://github.com/WithAutonomi/ant-client) * [self\_encryption](https://github.com/WithAutonomi/self_encryption) ## Related pages * [Data Types](/developers/core-concepts/data-types) * [Self-Encryption](/developers/core-concepts/self-encryption) * [Prepare a Wallet for Uploads](/developers/guides/prepare-a-wallet-for-uploads) * [Build Read-Only Features](/developers/guides/build-read-only-features) # Self-Encryption Self-encryption is the content-processing step that turns input bytes into a `DataMap` plus encrypted chunks before those chunks are stored elsewhere. ## Why it matters This is the layer that makes uploads content-addressed and client-side encrypted. Higher-level tools such as `antd` and `ant-core` rely on it to produce the `DataMap` and chunk layout used for later retrieval. ## How it works The crate surface revolves around a few core operations: * `encrypt(bytes)` returns `(DataMap, Vec)` * `decrypt(data_map, chunks)` reconstructs the original content * `stream_encrypt(...)` and `streaming_decrypt(...)` support streaming flows for files and large payloads The implementation uses: * BLAKE3 for chunk hashing * ChaCha20-Poly1305 for authenticated encryption * Brotli compression during chunk processing Chunk addresses are derived from the encrypted content. That is why the higher-level storage model is content-addressed: if the content changes, the resulting encrypted chunks and their addresses change too. Important limits from the crate itself: * `MIN_ENCRYPTABLE_BYTES` is `3` * `MAX_CHUNK_SIZE` is `4_190_208` bytes The crate stores chunk metadata in a `DataMap`, and the `DataMap` can be shrunk recursively when it grows beyond the immediate chunk set. In the higher-level SDK and CLI workflows, that `DataMap` is what turns a set of encrypted chunks back into retrievable content. ## Practical example ```rust use bytes::Bytes; use self_encryption::{decrypt, encrypt}; fn main() -> Result<(), Box> { let data = Bytes::from("Hello, World!".repeat(1000)); let (data_map, encrypted_chunks) = encrypt(data.clone())?; let decrypted = decrypt(&data_map, &encrypted_chunks)?; assert_eq!(data, decrypted); Ok(()) } ``` The crate does not store anything on the network for you. Persisting the encrypted chunks and keeping the `DataMap` somewhere safe is the caller's responsibility. That is why higher-level tools build on top of it: they handle payment, network storage, and the public/private retrieval choices around the `DataMap`. ## Upstream sources * [self\_encryption](https://github.com/WithAutonomi/self_encryption) ## Related pages * [Data Types](/developers/core-concepts/data-types) * [Keys, Addresses, and DataMaps](/developers/core-concepts/keys-addresses-and-datamaps) * [Store and Retrieve Data with the SDKs](/developers/sdk/install/how-to-guides/store-and-retrieve-data) * [Core Concepts Overview](/developers/core-concepts/overview) # Post-Quantum Cryptography The post-quantum cryptography described here centers on `saorsa-pqc`, transport documentation built around ML-KEM-768 and ML-DSA-65, and `ant-keygen` release-signing with ML-DSA-65. ## Why it matters If you are reasoning about security, transport identity, or release authenticity, you need to know which cryptographic primitives the stack uses. ## How it works ### saorsa-pqc `saorsa-pqc` is a broader PQC library that includes: * ML-KEM key encapsulation variants * ML-DSA signature variants * SLH-DSA signature variants * BLAKE3, SHA3, HMAC, HKDF, AES-256-GCM, and ChaCha20-Poly1305 So the library itself is broader than any single Autonomi-facing transport choice. ### saorsa-transport `saorsa-transport` describes its transport layer as pure post-quantum and highlights this pair for transport use: * ML-KEM-768 for key exchange * ML-DSA-65 for signatures The transport layer has no classical fallback. ### ant-keygen `ant-keygen` is the release-signing CLI that uses ML-DSA-65. It generates release-signing keypairs, signs files, verifies signatures, and supports a signing context for domain separation. ### Key separation and signing contexts `saorsa-pqc` provides HKDF-SHA3-256 and HKDF-SHA3-512 as key-derivation primitives. That means the crypto library can derive new key material from shared secrets or existing key material. `ant-keygen` also supports a signing context so one signing domain stays separate from another. The default context is `ant-node-release-v1`. ## Practical example ```bash ant-keygen generate ./keys ant-keygen sign \ --key ./keys/release-signing-key.secret \ --input ./artifact.tar.gz \ --output ./artifact.sig ant-keygen verify \ --key ./keys/release-signing-key.pub \ --input ./artifact.tar.gz \ --signature ./artifact.sig ``` ## Upstream sources * [saorsa-pqc](https://github.com/saorsa-labs/saorsa-pqc) * [saorsa-transport](https://github.com/saorsa-labs/saorsa-transport) * [ant-keygen](https://github.com/WithAutonomi/ant-keygen) ## Related pages * [Self-Encryption](/developers/core-concepts/self-encryption) * [Core Concepts Overview](/developers/core-concepts/overview) # Payment Model Autonomi uses a pay-once storage model. You pay in Autonomi Network Token (ANT) when you upload data, then retrieve it later without ongoing storage charges or download fees. ## Why it matters You cannot treat uploads as fire-and-forget writes. The daemon, CLI, and native Rust library all require wallet context for paid storage operations, and they differ in where they expose cost estimation, wallet approval, and payment-mode control. ## How it works ### Pay once on upload Autonomi is designed around immutable storage rather than renewable storage leases. In practice, that means the payment event happens when you upload data. There are no recurring storage fees or separate retrieval payments. ### Wallet-backed writes The tools use different wallet inputs: * `antd` uses `AUTONOMI_WALLET_KEY` for direct-wallet uploads * `ant` and `ant-core` use `SECRET_KEY` or an attached `Wallet` Without wallet configuration, write endpoints either fail or switch into an external-signer preparation flow. When you use the CLI or build in Rust with ant-core, quote collection and payment construction use on-chain market prices from the payment vault when preparing uploads. That keeps the client-side payment proofs aligned with the prices nodes verify on receipt. ### EVM network choices The `ant` CLI exposes these EVM network values: * `arbitrum-one` * `arbitrum-sepolia` * `local` The daemon-side external-signer flow also exposes the RPC URL and payment contract addresses the signer needs to submit the transaction for the selected network. ### Cost estimation The `antd` surface exposes cost estimation explicitly: * `POST /v1/data/cost` * `POST /v1/files/cost` Those endpoints return a structured estimate with cost, file size, chunk count, estimated gas, and the payment mode that would be used. ### Payment modes The supported payment modes are: | Mode | Current behavior | | -------- | -------------------------------------------------------------- | | `auto` | Choose Merkle for larger batches and single payments otherwise | | `merkle` | Force Merkle batch payment | | `single` | Force per-chunk payment | In `ant-core`, the Merkle threshold is `64` chunks. Nodes verify the payment proof that arrives with each write. That includes signature checks, on-chain payment verification, and record-level validation before content is accepted into the chunk store. Node-side storage pricing follows `BASELINE + K × (n / D)^2`, where `n` is the number of close records the node is already storing and `D` is a fixed divisor. That gives lightly loaded nodes a non-zero spam-barrier price and pushes larger uploads toward less-loaded close groups as the network fills. ### What happens on retrieval Downloads do not require a separate payment step. Payments are tied to storage writes such as storing data, chunks, or files. ## Practical example Two payment patterns show up across the daemon and direct-network interfaces: 1. Estimate and upload through `antd` ```bash DATA_B64=$(printf 'Hello, Autonomi!' | base64) curl -X POST http://localhost:8082/v1/data/cost \ -H "Content-Type: application/json" \ -d "{\"data\":\"$DATA_B64\"}" curl -X POST http://localhost:8082/v1/data/public \ -H "Content-Type: application/json" \ -d "{\"data\":\"$DATA_B64\",\"payment_mode\":\"merkle\"}" ``` 2. Upload directly with `ant` ```bash SECRET_KEY=0x... ant \ --devnet-manifest /tmp/devnet.json \ --allow-loopback \ --evm-network local \ file upload my_data.bin --public --merkle ``` In both examples, payment happens as part of the upload flow, but the daemon example exposes explicit cost-estimation endpoints while the CLI example emphasizes direct upload flags and wallet setup. ## Related pages * [Keys, Addresses, and DataMaps](/developers/core-concepts/keys-addresses-and-datamaps) * [Prepare a Wallet for Uploads](/developers/guides/prepare-a-wallet-for-uploads) * [Estimate Costs and Handle Upload Payments](/developers/guides/estimate-costs-and-handle-upload-payments) * [Use External Signers for Upload Payments](/developers/sdk/install/how-to-guides/use-external-signers-for-upload-payments) * [Build Read-Only Features](/developers/guides/build-read-only-features) * [Data Types](/developers/core-concepts/data-types) # Build with the SDKs Use the SDKs when you want a simpler application integration model on Autonomi. This approach combines: * a local daemon called `antd` * REST and gRPC interfaces exposed by that daemon * language SDKs in Python, Node.js / TypeScript, Go, Rust, Java, C#, Kotlin, Swift, Ruby, PHP, Dart, Zig, and other supported languages ## Why use the SDKs Choose the SDKs if you want: * a local API between your application and the network * a stable local API instead of direct peer-to-peer networking in your app * one local daemon process that multiple apps, scripts, or tools can share * SDK support in the language you already work in ## How the SDKs work `antd` runs on your machine and talks to the network for you. The SDKs, REST API, gRPC clients, and MCP server all build on that same local daemon. Your application code can still be Python, Node.js / TypeScript, Go, Rust, or another supported language. The supported `antd` install method in these docs is to build the daemon from the `ant-sdk` repo, then connect to it from the SDK language you choose. If you would rather work directly from the terminal, use [the CLI](/developers/cli/use-the-cli). If you want daemon-free Rust access, see [Build Directly in Rust](/developers/developing-in-rust/build-directly-in-rust). ## What to do next ### 1. Start the local daemon Start with [Start the Local Daemon](/developers/sdk/install/start-the-local-daemon) to build `antd` from source, run it in read-only mode, and verify that it is healthy. ### 2. Retrieve data from the network If you only need read-only features, continue to [Retrieve Data from the Network](/developers/sdk/install/retrieve-data-from-the-network). ### 3. Choose how you want to handle writes If you need uploads after the read-only flow, choose one of these next steps: * [Prepare a Wallet for Uploads](/developers/guides/prepare-a-wallet-for-uploads) for daemon-signed writes on the default network * [Use External Signers for Upload Payments](/developers/sdk/install/how-to-guides/use-external-signers-for-upload-payments) when your app should keep the signing key outside `antd` * [Set Up a Local Network](/developers/guides/set-up-a-local-network) if you want local services and test funds provisioned for you ### 4. Store data on the network Once the daemon is running and you have set up writes, continue to [Store Data on the Network](/developers/sdk/install/store-data-on-the-network). ### 5. Language-specific references If you already know your target language, use the [Language Bindings](/developers/sdk/install/reference/language-bindings/overview) section for setup and API details. ## Related pages * [Start the Local Daemon](/developers/sdk/install/start-the-local-daemon) * [Retrieve Data from the Network](/developers/sdk/install/retrieve-data-from-the-network) * [Prepare a Wallet for Uploads](/developers/guides/prepare-a-wallet-for-uploads) * [Use External Signers for Upload Payments](/developers/sdk/install/how-to-guides/use-external-signers-for-upload-payments) * [Store Data on the Network](/developers/sdk/install/store-data-on-the-network) * [SDK Overview](/developers/sdk/install/reference/overview) --- [Next Page](/llms-full.txt/1)