Autonomi combines the spare capacity of everyday devices to form a new, autonomous, data and communications layer of the Internet.

It allows you to securely store data, communicate, access knowledge, 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…

What it means…

Decentralized, distributed and quantum encrypted; 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's quantum-proof encrypted, before it even leaves an end user's computer. That means that no personal information ever touches the internet—and neither does any information relating to how, where, or when you choose to access it.

A register is a general CRDT mutable data type that holds a value. Registers are used to store appendable data—data can be added to a register with previous values still being accessible.

Autonomi deploys a special type of register called a Merkle register which supports concurrent writes. If two actors write to a register at the same time a fork will be created with both versions kept available. It's then up to client software to decide which fork to choose, according to the app's own rules.

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.

Autonomi will launch with an ERC standard 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 (ahead of the network implementing its own Native Token) is, 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 Terms’ 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.

There's another way to drive consistency asynchronously across a decentralized network without consensus: Conflict-free Replicated Data Types, or CRDTs.

With CRDTs consistency is inherent in the data structure itself. If different versions of the same data exist across a set of connected nodes (or replicas as they are known in CRDT-speak), they will all eventually converge on the same state. If some data is changed on an offline replica, as soon as connection is re-established this change will propagate to all other replicas, even if the same data was changed on another replica in its absence. At the end of the process, everyone will have the exact same version.

In asynchronous decentralised networks, each node can perceive a different order of events. With CRDTs it is not necessary to try to enforce an order or agree on it before changes can be applied.

CRDTs can range from simple counters to more complex structures, such as documents on which many people collaborate. Because CRDTs follow a strict set of rules based on metadata contained within their structure, conflicts (i.e. the persistence of multiple states of the same data) are automatically avoided without any special code or user intervention required.

Not every data structure can be a CRDT, but where it's possible it makes the job of ensuring consistency significantly easier. Changes can be made locally to CRDTs in complete confidence that they will be valid whatever may be happening elsewhere.

On Autonomi all mutable data types are CRDTs

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.

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…

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.

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.

The Autonomi Network is formed of interconnected machines running node software. This software connects the devices to each other using existing protocols like TCP and UDP, manages data and routes it around the Network. It allows users to offer computer resources, like hard drive space, to the Network, and earn Network Tokens in return. This process of providing a service in return for a reward is analogous to Bitcoin mining, but is designed to be 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 fully encrypted 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.

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.

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 .

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.

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. 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.

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 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.

At the network level, the Autonomi uses the TCP, UTP and µTP protocols and all the data moved by these protocols is encrypted from 'bit 1'.

So communications between the Network and the user are always encrypted, never in plain text. 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.

Content stored on Autonomi is first broken into chunks, hashed and then encrypted, in a unique process known as . 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.

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 . 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.

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’—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.

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.

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.

Quantum-Secure Encryption

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.

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.

Passwords and credentials never leave the client computer when accessing and decrypting data. And users need only a single set of credentials while interacting with an unlimited number of services, businesses, identities, or contexts of use.

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.

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.

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 a currency native to the network that acts as a medium of exchange for these resources, and allows the autonomous market to function. This currency is referred to as ‘network token(s)’.

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).

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. Those chunks are then ‘self-encrypted’, a process patented by MaidSafe by which each chunk is encrypted using its own 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 Section 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 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.

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 provides two native data types for storing and retrieving data: chunk and register. Registers are mutable data types, whereas Chunks are immutable.

Data itself comes in different forms too. Content or binary data is always encrypted and is spread out over the Network as immutable chunks. It can be read by anyone with a data map, which shows how to decrypt and reconstruct the content from its constituent chunks. The data also holds other metadata such as filename and type (video, image, etc). 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.

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.

Instead it uses a system similar to that utilized by ants, Stigmergy, plus a combination of lightweight mechanisms including Conflict-free Data Types (CRDTs) and constant tests that nodes are reliable.

libp2p is a Kademlia-based open-source peer-to-peer networking framework developed by IPFS. It consists of a collection of protocols, specifications and libraries that facilitate P2P communication between network peers (nodes).

It is used in the Autonomi Network to allow nodes to discover and connect to other nodes, to manage those connections thereafter, and to facilitate data routing.

libp2p is modular, meaning Autonomi developers can use the parts they want without having to worry about the parts they don't need. The Rust implementation of libp2p is the one adopted.

Among libp2p features useful to Autonomi are:

Transport:

libp2p supports TCP, UDP, μUDP and QUIC and can be configured to allow connections with nodes behind home routers or business firewalls (NATS), which has long been a problematic area for decentralized networks.

Verification:

libp2p includes several security features, such as peer identity verification using public key cryptography and encrypted communication between nodes.

Fault tolerance:

libp2p is designed to recover quickly from disruptions or failures. It also offers protection against network attacks through the use of mitigation techniques.

Support for PubSub (publish & subscribe):

This allows for the transmission and receipt of messages via the gossip protocol, meaning that nodes can listen out for and react to messages that affect them while ignoring the rest.

libp2p is interoperable, opening the door to future collaborations with other projects that use it.

Peers using libp2p are assigned a ’multiaddress’, a type of URL that encodes multiple layers of addressing information into a single “future-proof” path structure. It defines human-readable and machine-optimised encodings of common transport and overlay protocols and allows many layers of addressing to be combined and used together. A multi-addresss looks like this:

/ip4/139.59.181.245/tcp/37569/p2p/12D3KooWPHE8qcKL4CB2n8QvPpE25TRsP9nmkfeM6Qa61aAsokib

Importantly, on joining or rejoining the Network a node cannot simply pick its own XOR address

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.

If a node is seen to be acting unreliably, it is simply ignored by other nodes by being removed from their routing tables and it will not earn any more tokens.

The closest parallels for this come from nature. Stigmergy is a scientific term to describe the mechanisms that ants, termites and bees use to create complex, resilient societies, without requiring central planning, control, or direct communication between the elements. These insects follow simple chemical signals to validate that individuals are who they purport to be, rather than invaders from another colony, and that they are behaving as they should. In the Autonomi Network, deviance is punished by being ignored and unable to earn.

With this approach, so long as the rules are carefully written and properly implemented, it is possible to exceed the limit of one-third of nodes being Byzantine inherent in the "Proof of" approaches and still be protected against things like double spends.

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 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’.

• 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 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.

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.

Self-encryption: Content stored on the Network is broken into chunks with each chunk encrypted using 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: 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.

BLS-DKG: BLS cryptography allows secure authentication and multi-signature transactions.

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

So, the Protocol considers two basic components: nodes and 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.

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.

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.

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 or edit data—and there are no recurring fees either, data uploaded is stored for the lifetime of the Network: Perpetual Data.

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.

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.

Boneh-Lynn-Shacham Distributed Key Generation (BLS-DKG) is used to help users handle their authentication credentials so they don't automatically lose their data if they lose their key.

Credentials are thus 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. The temptation may be to choose simple credentials that are easy to remember, but these will likely be insecure (easily guessed or cracked) and prone to collisions—other people may choose the same ones and inadvertently stumble upon the user's private information.

Autonomi requires at least two separate credentials, generally referred to as 'access keys', with the option to add more. In combination, these access keys have sufficient entropy (randomness) to make collisions vanishingly unlikely.

Onboarding for the first time requires the user to choose a password (the first access key) from which a second access key is generated in the form of a passphrase (12 random words with a checksum), which the user writes down, perhaps keeping copies in a few safe places. With these two access keys, we have something you know (the password), and something you have (the passphrase), and in combination, we can generate a suitable amount of entropy to avoid collisions. This is the minimum requirement for creating your data store on the Network.

The user may also choose to create a third access key, a device key, on a trusted smartphone or computer, which is where BLS-DKG comes in, enabling a 2-of-3 key scheme, or even further to any k-of-n!

Now instead of requiring the passphrase, on this trusted device the user can just use the password and the device key—something you have—maybe utilising some inbuilt biometrics too, for an element of something you are.

Additional access keys can be created to provide more flexibility and resilience. A backup passphrase is one example, and additional devices can be set up too. Then if the user forgets the password or loses a device, a combination of another device and or passphrase will allow the password to be reset.

In this way, Autonomi caters for people with security needs ranging from the everyday to the extreme.

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.

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 libp2p 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.

In order to guarantee strong consistency, the Network uses conflict-free replicated data types (CRDTs) for storing data.

Client connections managed by libp2p 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 language bindings layer.

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.

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 ANT (and Autonomi’s future ‘Native Token’). Token holders also include those with ‘EMAID’ (the current ERC-20 token), these holders will be ‘airdropped’ ANT 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 ANT 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.

The pricing within The Network is determined by a supply-and-demand mechanism. Each node assesses its internal resource availability to calculate the price it needs to charge. Specifically, a node compares the number of records it is responsible for storing against the maximum capacity of records a node is allowed to hold.

Because The Network uniformly distributes the addresses of both nodes and records, the number of records assigned to each node accurately reflects the ratio between the total number of nodes (indicating storage space supply) and the total number of records (indicating storage space demand). The ANT token will serve as The Network's currency during the early phases of network scale (in future this will be valued at 1:1 with ‘Native Token’ when the same becomes available). As a result, the effective payment amount in ‘FIAT’ terms depends on ANT’s market value, which will be inherently volatile. To address this, prices are normalized by the token price, ensuring that The Network's size and functionality are governed by the true supply and demand for storage space, rather than fluctuations in market conditions.

Note: The number of nodes in The Network is constrained by the availability of raw resources such as disk space, bandwidth, and CPU power. Consequently, the node count alone should not be used to infer the total network capacity, as this would incorrectly assume that disk space is the sole limiting factor.

As it can be seen from the charts above, the fair storage price will initially rise. The system must overcome this initial price resistance to benefit from the subsequent decline in price, driven by increasing data upload rates and decreasing raw resource costs. To address this initial friction, The Network will provide additional incentives to node operators during The Network's early stages - derived from an emission allocation.

To do this The Autonomi Foundation will mint new ANT tokens and distribute them to the participating node operators.

Autonomi Publications & Papers

Autonomi White Paper (2024)

Autonomous Network (MaidSafe White Paper, 2010)

Data Hierarchy Refinement (MaidSafe RFC and forum discussion)

Distributed Hash Table (MaidSafe Whitepaper, 2010)

FileTree CRDT for Safe Network (MaidSafe forum discussion)

The Impossible Network — David Irvine

Payments (on Safe Network)

Safe (Autonomi) CLI User Guide (Github)

Security of the MaidSafe Vault Network

Self-Authentication — MaidSafe White Paper (2010)

Self-Encrypting files — convergent encryption plus obfuscation (GitHub)

Self-Encrypting Data — MaidSafe White Paper (2010)

Self-Encryption on the Safe Network (YouTube)

XOR-URLs (MaidSafe RFC)

From Other Contributors

An introduction to state-based CRDTs

A Survey of DHT Security Techniques (Globule)

BIP39 Mnemonic Code Converter

Boneh-Lynn-Shacham (Wikipedia)

BLS Threshold Crypto — Interface for Rust library threshold_crypto (Ian Coleman)

Byzantine Agreement, Made Trivial (Micali) (MIT)

Ethereum Classic “HACKED” by 51% attack! (Andrew Butler — Medium)

CRDTs and the Quest for Distributed Consistency (YouTube)

CRDTs for Non Academics (YouTube)

Crypto 101

Git Branching — Basic Branching and Merging

GossipSub (libp2p)

Human-oriented base-32 encoding (O'Whielacronx)

Kademlia: A Peer-to-peer information system based on the XOR Metric (Whitepaper, 2010)

Kademlia, Explained (YouTube)

Kademlia XOR metric properties purposes (Stack Overflow)

libp2p, a modular network stack (IPFS)

Stigmergy (Wikipedia)

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:

ANT

Short for: ‘Autonomi Network Token’, an ERC20 standard token that will be distributed (see ‘Token Allocation’), as well as spent and earned by using and/or supporting the Autonomi Network. A ‘$’ sign maybe used in front of it to indicate that it is a cryptocurrency.

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 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.

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.

GossipSub

A libp2p publish/subscribe system whereby peers congregate around topics they are interested in by subscribing to them.

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.

libp2p

A Kademlia-based open source peer-to-peer networking framework.

MaidSafeCoin

A cryptocurrency token, created during a crowd-sale (or ICO) in April 2014, that will be exchangeable, on a 1:1 basis for Autonomi's native token once the Network is live. 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.

Multiaddress

A unique locator for a peer that encodes multiple networking protocols into a single address

Multimap

A mutable CRDT data type for mapping keys to multiple values.

Native Token

A non-blockchain token running on Autonomi to be introduced after the early phase/launch of The Network.

Node

A machine that connects with others using Autonomi's Protocol to form the Network.

Node Network Reserve

18% of data payments (up to 10% of maximum supply) are sent to this allocation for node operators. This allocation will be used to support payments to nodes should the network upload values experience volatility. If the Node Network Reserve holds 10% of the network’s Maximum Supply of tokens, 18% payment reduces to 2%, with the 2% payment burned (removed from Maximum Supply).

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.

Register

A mutable CRDT data type.

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.

Resource Supply Rewards

Payment to the operators of resource-providing nodes in return for storing data. Also referred to as Data Payments.

Safe Network

The former name for Autonomi

Self-Encryption

Content uploaded to the Autonomi is broken up into chunks. These chunks are then hashed, encrypted locally using the AES-256 encryption algorithm and the hashes of neighbouring chunks. Because content is encrypted and decrypted locally, there is no need for keys to leave the user’s machine.

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’), and then the ‘Native’ Token of Autonomi, are earned by storing data and spent by uploading data. For purposes of this white paper and ahead of the launch of Autonomi, 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

MaidSafe are the team behind Autonomi, and the core developers of its protocol.

David Irvine

Founder, Chief R&D Officer Github

Sarah Buxton (Bux)

Chief Executive Officer Twitter | Linkedin

Jim Collinson

Chief Strategy Officer Twitter | Linkedin

Andy Laverty

Non-exec director Linkedin

David Allan

Non-exec director Linkedin

David Cosh

Non-Exec Director

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 . 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.