Skip to content
CryptoDecentral

Note

An Address Is Not a Location: How Autonomi Finds Data Without a Directory

On Autonomi, a data address names a point in XOR space, not a machine. Finding data means walking through peers, and that walk has its own trust and visibility profile.

2026-11-17 · autonomi, kademlia, dht, xor-distance, close-group, churn, sybil, eclipse, metadata, civil-liberties

Listen · 8 min · AI voice

Dark CryptoDecentral hex mesh with a thin teal path hopping across a few distant cells toward one small glowing cluster of bronze cells, the cells along the path faintly lit as if they saw it pass; no text.

On the ordinary web, an address tells you where to go. A URL names a domain, the domain resolves to a server, and the server either hands you the file or does not. Whoever runs that server, or that name, sits at a fixed point you can find, pressure or switch off.

Autonomi uses the word "address" for something else. On Autonomi, a data address names a point in a mathematical space, not a machine. Finding data means walking through peers who each know a small part of that space, and the walk has its own trust and visibility profile, separate from the encryption of what you find. Earlier notes here covered self-encryption and the Data Map and immutable chunks. This one is about the step between them: getting from an address to the bytes.

Two kinds of address in one space

Two things live in the same 256-bit space. A chunk's address is derived from its content: per the Data types page, "the address of each chunk is derived from the BLAKE3 hash of its encrypted content." A node's address is derived from its key: the Nodes page says a node's PeerId "is derived from that identity as the BLAKE3 hash of its public key."

Because both are numbers in one space, you can measure how close a node is to a chunk. The measure is XOR distance, and the Building on Kademlia page is plain about what it is not: "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."

So an address does not say where data is. It says which neighbourhood of nodes is responsible for it. The Content-Addressable Storage page puts it as "the nodes whose IDs are closest (in XOR terms) to that address," and the glossary calls that set the close group. The docs give its size as a tuneable parameter, "currently it is set at 5."

How a lookup walks

No node knows the whole network. Each keeps a routing table split into k-buckets: the farthest bucket covers half the address space, the next a quarter, then an eighth, and so on. Autonomi's docs say each node holds "up to 20 nodes in each k-bucket," so it knows its own region well and distant regions thinly, but never not at all.

A lookup uses that shape. In the docs' words, a node "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." Each step roughly halves the remaining distance, which is why the docs say the space is "traversable in just a few hops." The original Kademlia paper gives the bound: most operations take about log n steps for n nodes.

One detail is worth flagging rather than smoothing over. The Autonomi overview describes the walk as nodes passing a message on. The Kademlia paper's lookup is driven by the asker: the initiator sends parallel FIND_NODE or FIND_VALUE requests to several close nodes, learns about closer ones from the replies, and queries those itself. Autonomi's System Overview says routing is handled by a Kademlia DHT inside its networking layer, and that a client runs its own client-mode peer rather than routing through a local node. Which lookup style the current code uses could not be checked this week, because the WithAutonomi source repositories returned "not found" on the web.

The holders keep changing

An address is stable, but the machines behind it are not. Nodes join and leave; the docs call this churn, and say "the node's close group will change." Data held by a node "is automatically replicated to the nodes in its close group for redundancy," and when a new close node appears, existing nodes share part of their store with it. The Chunks page adds that clients can cache chunks they have fetched.

This is why "permanent" on Autonomi is a claim about the network's rules, not about any one disk. Data persists only if close groups keep replicating it as membership turns over. The docs also state that "nodes cannot delete or edit data, only store and move it"; that describes intended protocol behaviour, not the absence of disk failure or software bugs.

Where trust sits in routing

Encryption protects content. It does not protect the walk. If one party controls enough identities near an address, it can sit in the close group for that address, or surround a victim with its own nodes so that every lookup returns answers it chose. The research literature names both: the Sybil attack (one entity posing as many) and the eclipse attack, which the S/Kademlia paper analyses for Kademlia networks and counters with disjoint lookup paths and costly node IDs.

Autonomi's docs list their own countermeasures. A node "cannot set its own address" because its PeerId is derived from its key. The Consensus Not Required page describes a local trust score weighted towards recent behaviour, "a membership threshold" against Sybil attacks, and "Eclipse protection" as an added integrity guarantee. The Defence Against Cyberattacks page says upload checks include "cryptographic proof that storing nodes are genuinely members of the data's close group."

Two limits stay true. A derived ID stops a node declaring a position, but the cost of generating many identities is a separate question, and that cost is what the Sybil literature centres on. And a fake chunk cannot pass as a real one, because its hash would not match its address, but a hostile neighbourhood can still withhold or delay data it is meant to serve. Content addressing guarantees integrity, not availability.

What a lookup reveals

The Kademlia paper defines FIND_VALUE as taking the key as its argument. Every peer you ask is told which address you want. On Autonomi that address is the hash of ciphertext, so a peer learns an address, not readable content. For private data, the address alone does not reveal the file or its other chunks; those live in a Data Map the peer does not hold.

Public data is different. If an address has been published, a peer that sees requests for it knows what is being requested. Connections also run over ordinary internet transport: the Connectivity page says peers connect directly first, then try hole punching, and use a relay only "as a last resort." The pages fetched for this note do not describe a mechanism that hides the requested address from the peers asked, so it is safest not to assume one exists.

Why it matters for civil liberties

A directory is a choke point. A takedown, a seized server or a blocked domain works because there is one place where "this name points here" is recorded. A DHT has no such record; responsibility for an address is spread across whichever nodes are currently nearest, and changes as they come and go. That moves the pressure point; it does not abolish observation. Distributed peers can still see requests, and an adversary that can afford many nodes can still try to stand in the right neighbourhoods. A useful threat model asks both questions: who can stop me reaching this, and who learns that I tried?

What this is not

This is not a guide to running a node, and it says nothing about node rewards, earnings or token prices. It is not a security audit of Autonomi's routing code; the source repositories could not be reached this week, so every protocol claim here comes from the docs as published on 17 November 2026 and from the cited papers. It does not say Autonomi lookups are private or that they are not, only what the fetched pages do and do not describe. It does not rank Autonomi against other storage networks, and nothing here describes a tested app. It does not cover mutable data; the docs place that in a separate gossip layer, outside this note.

The one-line takeaway: a chunk address tells the network which neighbourhood to ask, not which machine holds the data; encryption protects what you get, while routing decides who answers and who sees the question.

Related on CryptoDecentral

Further reading (primary)

More on this topic

All notes · Get the Monday radar by email