decdn is a content delivery network where there's no central operator. Bytes flow from anyone willing to serve them to anyone willing to pay for them, denominated in dollars, with cryptographic verification at the edge and no contract longer than a single megabyte. This post is the plain-English introduction.

The elevator version

A traditional CDN is a company that runs servers near your users and charges your business a monthly bill. CloudFront, Fastly, Akamai, Cloudflare. They cache your content, route around the slow paths of the public internet, and absorb traffic spikes for you. They charge $0.04–$0.20 per gigabyte. Their operations are opaque to you, and you're locked in to whoever you signed with.

decdn is the same job — caching content near users, routing around the slow paths, absorbing spikes — but the operators are anyone with a server and a stake. They compete on price and latency. There's no monthly bill. You pay per megabyte, in USDC, only for what you actually pulled. The target market rate is $0.01/GB, four to twenty times cheaper than incumbent list pricing.

The two roles

There are two kinds of participant in the network.

Nodes serve content. A node is a process running on a server (cloud VPS, dedicated hardware, or a spare machine in someone's closet) that bonds the network's native token, joins the peer mesh, advertises itself via gossip, and accepts paid delivery requests. Nodes set their own per-megabyte rate, manage their own cache, and earn USDC for every byte they ship. Some nodes are configured with an origin backend (S3, R2, B2, NFS, local disk) — those are the ones that can answer the first request for a hash that's never been served before. Most nodes are pure caches that pull from peers on miss and re-serve.

Clients consume content. A client opens a payment channel against a node's network identity, deposits some USDC, and signs vouchers as bytes flow. Each voucher is a structured signature saying "I now owe this node N USDC, cumulative." When the session ends, the channel closes on-chain and the node gets paid. The client only ever pays for bytes it received, verified, and accepted.

There's no third role. No platform. No middleman. The protocol is the platform.

What's underneath

Every part of the stack is a primitive that already exists. decdn is the protocol that composes them.

Rust, for systems-level performance and the absence of a garbage collector introducing tail-latency spikes.
iroh, for QUIC-based peer-to-peer transport with NAT traversal, hole punching, relay fallback, and connection migration as a library function.
BLAKE3, for content addressing — every blob is identified by the BLAKE3 hash of its bytes; verification happens at line rate at receipt.
USDC, for delivery payments — denominated in dollars, the same currency as a node operator's server bill.
A low-cost EVM L2 for settlement — payment channels open, close, and dispute on-chain, with per-transaction costs in the cents range.
ERC-4337 account abstraction and Safe smart wallets, so operators and clients can use modern wallet UX, batch approvals, and pay gas in stablecoins instead of native chain tokens.

The protocol surface is thin: a wire format for probe and delivery, a payment channel contract, a bonding registry, a slashing judge, a content blacklist, and a governance system. We did not invent any of the underlying primitives. We invented the protocol that composes them.

The economic shape

Two currencies, doing two jobs.

USDC is for delivery payments. Every byte transferred is paid in USDC, including the bytes one node pulls from another on a cache miss. The economic gradient is the replication strategy: popular content propagates because each cache becomes a paying source for the next hop. Operator revenue tracks operator costs in the same currency as the operator's server bill.

The native token is for bonding, governance, and value accrual. Operators bond to register, sized to the capacity they declare; the bond is slashable for misbehavior. Voting weight comes from proven delivered bytes, not from locked tokens — the operators actually moving traffic steer protocol parameters. Thirty percent of every settlement is routed to buyback-and-burn, so network usage accrues to holders through deflation rather than a fee-share payout. The native token is never used to pay for bandwidth — the network that tries to do that is the network that loses its supply side the first time the token drops.

The split is deliberate. Volatility goes in one currency, used for alignment over long horizons. Stability goes in the other, used for payments matched to fiat-denominated server bills.

What we're not

To set expectations, here's what decdn does not do.

We don't store data. Storage is a different invariant. Origin storage stays where it already is — S3, R2, B2, MinIO, NFS, local disk — opaque to the network. We compete only on the delivery layer.
We don't run our own chain. We deploy on a public L2 and inherit Ethereum-grade security via fraud proofs. We do not split the team's attention between defending consensus and shipping a CDN.
We don't pay operators in our own token. Delivery is in USDC. Operator P&L tracks fiat costs in fiat-pegged revenue.
We don't bolt onto an existing CDN. This is its own protocol from the bottom up — not a sidecar, not a plugin layer, not an "edge computing" wrapper around someone else's bandwidth.

Who this is for

If you're a node operator — a sysadmin, a homelabber, a datacenter shop with spare bandwidth — decdn is supply-side opportunity. Bond, register, serve, earn USDC.

If you're a content publisher — a team shipping large payloads — decdn is the fraction-of-the-cost alternative to incumbent CDN pricing, with origin protection and optional end-to-end encryption built in.

If you're an end user, you don't have to think about any of this. The client verifies bytes against the requested hash automatically; payment channels open and close in the background; the network finds the fastest peer.