// Learn

The address is the thing.

An introduction to Autonomi — the network the Etch Writer (etch/it) writes to and the Fetch Browser (fetch>it) reads from — and what a web with no domains, no hosts, and no accounts feels like to use.

Beta · as-is Both apps are beta, provided as-is. The Autonomi network is run by third-party peers — we don't guarantee uptime, data availability, or recoverability. Failed transactions can lose funds, and a lost wallet seed is unrecoverable. Full terms ↗
// On this page
  1. What this is
  2. The two apps
  3. Versus the clearnet
  4. Try the city
  5. What it costs
  6. When things break
§ 01 // The mental model

Content over hosts.

A regular URL says where to look. An Autonomi address says what's there — a 64-character hash of the bytes themselves. You don't ask a server for a copy. You ask the network for whatever has that hash, and any peer that has it answers.

Three things follow from that one shift:

Reading is free. Writing costs a small one-time payment in ANT, the network's storage token. The bytes are paid for once and replicated across peers from then on — nobody renews, nobody re-bills.

§ 02 // The two apps

Etch it. Fetch it.

Two apps, one network. etch/it writes content to Autonomi. fetch>it reads it back. They're built and signed independently, share the same address format, and don't depend on any server we control.

A // etch/it
Write it once.
hello world etch phone wallet sign? ~ANT fee address bebb4f16 bc23aa45 81bff5fe…

Type or paste content. Sign one wallet transaction. The network confirms, you get back a 64-hex address. The first prompt approves a small session budget so subsequent etches don't ask again until it's spent.

That address is how you fetch this back, and how you share it. It's also a public read-key — treat it like a secret if what you wrote isn't meant to be public.

You can also etch privately: the bytes are encrypted on the device before they leave it, and the decryption key stays on the device unless you back it up. A backup is one more etch, plus a 6-word passphrase you write down on paper.

Cost: tiny one-time ANT chunk fee from your wallet. Reads stay free. about etch/it →
B // fetch>it
Read it forever.
paste address bebb4f16bc23… fetch network content hello world

Paste a 64-hex address. fetch>it pulls the bytes from the network, looks at them, and renders them — text, JSON, CSV, markdown, PDFs, images, audio, video, EPUB ebooks, even full HTML pages with working scripts and WebAssembly. One input, every kind of content the platform can read.

No wallet. No account. No fee. The app keeps a private cache of what you fetched so re-opening is instant, but it doesn't re-serve anything to anyone — fetch>it is a browser, not a server.

Cost: free. Reads don't pay. about fetch>it →
§ 03 // What this fixes

Same web, different rules.

The clearnet works — but every page on it is propped up by a chain of services that all need to keep paying, keep agreeing, and keep running. Autonomi takes most of that chain out. Here's what changes.

CLEARNET

You rent a domain. You forget to renew it. The page disappears.

→
AUTONOMI

There is no domain. The address is the content's hash — paid for once, reachable forever.

CLEARNET

The host's hardware fails or the company shuts down. Your site goes with it.

→
AUTONOMI

No single host. Every chunk is replicated across peers — losing any one of them is invisible to you.

CLEARNET

Someone files a complaint with the host. The host takes the page down.

→
AUTONOMI

No central host in the loop. Addresses are content-hashes, so what you publish today is what resolves tomorrow — only publish what you're prepared to leave there.

CLEARNET

The same URL might serve different bytes tomorrow than it did today — silently.

→
AUTONOMI

The address is the bytes. Change a single bit, the address changes. Same address always = same bytes.

CLEARNET

Reading anything goes through a server that sees your IP, your headers, often plants cookies.

→
AUTONOMI

You ask the peer network. No central log. No account. Rendered pages can't phone home — fetch>it blocks every outbound call from content it renders.

CLEARNET

You sign up. You pay monthly. You forget the password. You email support. You wait.

→
AUTONOMI

No signup. No subscription. The wallet you already have pays the chunk fee at write time and nothing more.

The trade-off is honest. Permanence cuts both ways — the protocol is immutable by design, so there are no edits and no expirations either. Self-custody cuts both ways — no recovery emails, no support agent to call. You're trading a service-based web for a content-addressed one. Quieter, more durable, and entirely on you.

§ 04 // Try it

The fastest way is to walk through one.

There's a small city running on the network — a hub-and-spoke set of pages built and uploaded as a demo. Eight rooms (library, gallery, album, cinema, lab, brief, game, plus community submissions) and every one of them is just an address.

  1. Pick a fetch>it. On the city page, the install bar picks the right build for your platform — Windows, macOS, Linux desktop, Android APK, or the browser extension. No account.
  2. Click any entry on etchit.io/city — or paste this address directly into fetch>it:
    autonomi://ba9a8fcae5677af1876de8b37b1f728446754b6fe78307c2355be28cec94e764
  3. Look around. Every page, image, track and WebAssembly module on the city was fetched by content hash. There's no DNS, no host, and no server anywhere in the loop.
  4. Got a page of your own? Open etch/it → attach the HTML file → pay the chunk fee → share the address that comes back. Single-file pages work best.
§ 05 // The bill

Reading is free. Writing pays once.

Storage on Autonomi is paid in ANT, the network's chunk-payment token. Pay once, the chunks live across peers, nobody renews. Reads pay nothing — no wallet, no account, no fee.

Action Pays in Goes to Roughly
Public etch ANT network nodes that store your chunks one-time chunk fee
Private etch ANT same as public — bytes are encrypted client-side first same as public
Backup to network ANT network nodes — a backup is just another etch same as public
Fetch (anything) free — nothing

Your wallet always shows the exact estimate before you sign. If a chunk fee looks high, wait — the network is busy sometimes, and the etch stays queued locally until you confirm.

§ 06 // Things break sometimes

When things go wrong.

None of this is a permanent failure unless explicitly noted.

A fetch hangs or returns nothing.

Almost always transient peer routing. Wait a moment and try again — the data is replicated, another peer will pick it up.

Less common: the address is malformed. A valid address is exactly 64 lowercase hex characters with no 0x prefix.

Can I edit or remove something I etched?

Not from the app. The Autonomi network is content-addressed and stores each chunk across many peers, so the protocol itself doesn't expose a deletion or edit path — that's an architectural property of how content-addressing works, not a policy choice on our part. Neither the apps nor the etchit team operates a takedown channel.

The corollary: only publish what you're prepared to leave there. If it's sensitive, etch privately (encrypted on the device first), or don't etch it at all. To report content you've encountered through the fetch>it browser, contact us via the fetchit repository.

I lost my wallet seed phrase.

The wallet is non-custodial — nobody, including us, can recover it. Anything you already wrote with that wallet is still reachable by its address; you just can't write more under the same wallet.

For private etches with a backup: a new device + your 6-word passphrase + the backup address restores them. Without the passphrase, the encrypted blob is unreadable.

I lost my 6-word backup passphrase.

Permanent. The passphrase is the only key to the encrypted backup; the bytes on the network stay there forever but look like noise without it.

Make a fresh backup with a new passphrase from your current device, write it down on paper, store it somewhere physical you trust. The old backup blob is harmless.

My private etches disappeared after reinstalling the app.

Expected — private etch data-maps live in the app's encrypted local storage, which the OS wipes when you uninstall. They're not on any server.

If you backed up to the network beforehand: Restore from backup with the address + 6-word passphrase. If you didn't back up: the data-maps are gone, and the encrypted blobs on the network are unreachable without them.

Habit to build: back up after every batch of private etches you'd hate to lose.

Is anything tracking me?

fetch>it talks peer-to-peer for content, holds a private cache locally, blocks every outbound call from rendered pages, and ships no analytics. A page you fetch cannot phone home — the rendering sandbox refuses every non-Autonomi connection at the network layer.

etch/it talks to Autonomi peers and your wallet only. There's no server in the middle.

The app is stuck on "Connecting…".

Some bootstrap peers go offline. The app dials several in parallel and only needs one to attach. If the spinner sticks, replace the bootstrap list in Settings with the current published one (linked from the GitHub README) and reconnect.

Is this a blockchain?

No. Autonomi is a peer-to-peer content-addressed storage network, not a chain. There's no ledger of every read or write. Peers store chunks, fetchers ask any peer for chunks by hash, and the chunk's hash is its name. The chunk-payment token settles on Arbitrum, but the content itself never lives on chain.

Who runs all this?

Autonomi the network is run by third-party peers — anyone can run one. We make the apps (etch/it, fetch>it), not the network. Nothing on the network depends on us being around.

If etchit.io disappeared tomorrow, every address you etched would still be fetchable from any other client that speaks the protocol. That's the point.