Back to the hub

From parody to authenticity

Nobody can change our republic to a direct democracy without changing a law. Everybody might if we work together. Can direct democracy work? What does Nobody know? Nobody thinks we should blithely continue arguing political binaries "because it's always been this way."

Forward

If trust in our institutions erodes inexorably due to flooding information, this Hail Mary postulates the same flood might be ridden to rebuild trust among ourselves. The chassis runtime supports true server-less peer to peer data sharing and commerce. Chassis are minimal and will be open sourced. Evolution depends on Everybody's expertise. Be Nobody.

Premise

We're wired to process inputs from a limited number of people; that's the size of our troop. The United States has ~3.5 million troops who are underserved by mass media. Language models can help us with that. They're coming to a computer near you. Nobody wants you to start using software that can access the models' power outside of our latest billionaire's datacenter.
Common interest will break barriers between siloed citizens who have become victims of a manipulative news media. We can try to find out what we want together by using software to connect us. Remember when the internet was going to do that? We can try again and use online language models to help us while we gradually deploy them locally.
An office holder elected by that common interest can use the same tools to put all issues before their electorate, morally bound to execute their office as directed by the people who elected them. Voters will use their local language model to understand issues before their representative, then exercise civic responsibility by instructing the representative, all while holding down a job, raising kids, and enjoying leisure.
We may learn how to trust each other, trade, and establish rules we live under when institutions we've depended upon for that continue losing legitimacy.

A mustard seed:

Chassis

A peer-to-peer runtime where your device, not a company's server, stores and serves your apps, chats, and data, directly to other people's devices.

In plain terms

Normally, apps store your stuff on a company's servers, and you're trusting that company to keep it safe, keep it available, and not peek at or alter it.

A chassis is a small program that lets your own device (or a cheap always-on box) hold and serve your data directly, with no company's servers required in the middle.
Two chassis instances sync by talking straight to each other. Your chat, your documents, your apps replicate peer-to-peer, each side keeping a real copy, not just a view of someone else's.
Every piece of content is labeled by what it is, not by which server it's sitting on, called content-addressable data. A copy from any random peer can be checked against what you actually asked for, and can't be secretly swapped or corrupted along the way.
That's what makes it a trustless service: you don't have to trust the specific peer who handed you a file, or trust any one company's uptime or good behavior. The data verifies itself.
Publishing something, even a small app generated just by describing it in chat, means announcing "here's my copy." Anyone else's chassis can find it and sync it, with no approval step and no platform that can quietly take it down.

Instead of trusting a company to hold your data honestly, you trust math: a copy either matches the hash you expect, or it doesn't.

In distributed-systems terms

Built on iroh: QUIC transport with relay fallback, iroh-docs for replicated documents, iroh-gossip for presence, and iroh-blobs for storage and trustless service.

Each chassis is a full peer, not a client of a backend: it authors, stores, and serves its own replicas over QUIC with relay fallback.
Documents are replicated key/value structures (iroh-docs) with capability-gated writes: a NamespaceSecret (or a read-only derivative) is the only access credential: possession-based authorization, not ACLs, and un-revocable short of rotating to a new namespace.
Blob content is content-addressed: a BLAKE3 hash maps to bytes, so any peer can serve any blob for any other peer. Integrity is checked against the hash locally, never against the sender's identity or reputation. That's the basis of the system's trustlessness: correctness depends on the hash matching, not on trusting a particular operator.
Discovery and liveness run on iroh-gossip peer-sampling (presence), not a fixed server list: sync targets are whoever's currently reachable, reseeded opportunistically instead of dialed from static addresses.
"Apps" and "topics" are just documents: a content manifest plus metadata keys. Publishing writes a proof-carrying name-to-namespace entry into a shared, gossip-watched directory document that other peers mirror into their local provider tables.
An AI app-creation path sits on the same substrate: a sandboxed agent generates and publishes a real document/capability-backed app, with no separate deployment plane from what a human would produce by hand.

Any peer, trusted or not, can serve any content; hash verification does the work a trusted intermediary would otherwise be needed for.

How it fits together

Three chassis instances. No node in the middle has special authority, including the one that happens to answer a fetch.

            iroh-gossip (presence/discovery)
        ┌────────────────────────────────────────┐
        │                                        │
┌───────▼─────────┐                      ┌───────▼─────────┐
│   Chassis A     │◄──── QUIC/relay ────►│   Chassis B     │        ┌────────────────┐
│  (your device)  │        sync          │ (friend's node) │◄──────►│   Chassis C    │
│                 │                      │                 │  sync  │ (stranger's    │
│ ┌─────────────┐ │                      │ ┌─────────────┐ │        │  node, need    │
│ │ apps/ dir   │◄┼──────────────────────┼►│ apps/ dir   │ │        │  not be        │
│ │ name→ns map │ │                      │ │ name→ns map │ │        │  trusted)      │
│ └──────┬──────┘ │                      │ └──────┬──────┘ │        └────────────────┘
│        │        │                      │        │        │
│ ┌──────▼──────┐ │                      │ ┌──────▼──────┐ │
│ │ app/topic   │◄┼──────────────────────┼►│ app/topic   │ │
│ │ documents   │ │   capability ticket  │ │ documents   │ │
│ │ (cap-gated  │ │   = the only key     │ │ (cap-gated  │ │
│ │  writes)    │ │                      │ │  writes)    │ │
│ └──────┬──────┘ │                      │ └──────┬──────┘ │
│        │        │                      │        │        │
│ ┌──────▼──────┐ │   fetch by hash,     │ ┌──────▼──────┐ │
│ │ content-    │◄┼───verify locally────►│ │ content-    │ │
│ │ addressed   │ │   (trustless:        │ │ addressed   │ │
│ │ blob store  │ │   any peer can serve │ │ blob store  │ │
│ │ hash→bytes  │ │   it, hash proves    │ │ hash→bytes  │ │
│ └─────────────┘ │   it's unaltered)    │ └─────────────┘ │
│                 │                      │                 │
│  local HTTP API │                      │  local HTTP API │
│  → your browser │                      │  → your browser │
└─────────────────┘                      └─────────────────┘

Key point the diagram is making: nothing flows through a privileged middle node. Chassis C, a complete stranger, could serve chassis A a blob it asked for, and A can still trust the bytes, because it checks them against the hash it already knows, not against who sent them.

Quick start

Apple silicon users can mail chassis@nobody.news to request repo access and an installer.

2. Once it's running, open http://localhost:4919 in your browser.

The chassis landing page at http://localhost:4919, showing the Published apps and Imported apps lists

The first page is your chassis's own home: not an app, just the chassis itself telling you what it already knows.

A Published apps list shows every app currently published on your little network. Apps you've published yourself show a "Delete" button, which demotes the app back to your own imported apps list, not erasing it.
An Imported apps list holds apps you've pulled in by ticket but haven't published yet, each with "Read ticket" and "Write ticket" buttons you can hand to someone else so their chassis can find and sync yours.
"Import app" lets you paste someone else's ticket to start syncing their app.
"Create app" starts an AI-guided chat that builds you a brand-new app from a description, the same way this page itself came to exist.