the420code.org — first-principles, offline, sovereign

The maker

the420code.org is the work of G — a self-taught engineer with no degree and no permission asked. That's not a footnote; it's the point. Faraday had no mathematics, Ramanujan had no diploma, and a credential has never once made an idea true or false — evidence does. We judge this work on the work.

Judging it honestly is the deepest respect we can pay a friend's life's work. A page that oversells would set it up to be torn apart the first time it met a hostile expert. So we've sanded every claim down to what's defensible, and put the ambition where it belongs — clearly marked as ambition. The real thing is strong enough to stand on its own.

Three pillars

1 · Offline, on-device AI

Prototype

It runs on a phone in airplane mode — no network, no telemetry, no call home. Most things that call themselves "AI" simply stop working the moment the signal drops. This doesn't. That makes it private and sovereign by construction: data that never leaves the device can't be sold, demanded from a server we don't run, or leaked from a cloud. How it fits and runs on-device is proprietary.

Honest scope: the win here is sovereignty and trust — an AI that owes nothing to a network it can't see.

2 · A first-principles knowledge graph

Prototype

Instead of learning from a scraped corpus, it reasons over a curated structure built by hand from the primary body of knowledge — Einstein, Bohr, Tesla, and the rest of the canon. No training run is required: the knowledge is represented directly, and it can be inspected, corrected, and traced. How it's represented and reasoned over is proprietary.

Honest scope: holding knowledge this way genuinely needs no training set — that claim stands. We're simply not going to publish the internals of how it's done.

3 · SHA-256 notarization on retired rigs

Standard crypto

Old Bitcoin mining rigs do exactly one thing supremely well: SHA-256 hashing. That's the right tool for provenance — taking a fingerprint of a document, a model, or a watermark so anyone can later prove it is unaltered, and fix its place in an ordered, tamper-evident chain. Anchor that chain to a public ledger and you get trustworthy time on top. Hardware built for a speculative bubble gets a second, useful life as a notary.

Honest scope: those ASICs hash; they don't run general code, encryption, or a new language. Hashing alone proves integrity and order, not wall-clock time — that comes from the public anchor, not the rig. Tamper-proofing fits them perfectly; general compute does not, and we don't pretend otherwise.

What we claim — and what we don't

The fastest way to lose trust is to overstate. So, plainly:

We do claim

It runs fully offline on a phone — private by construction.
Knowledge can be held as a first-principles graph with no training set, fully inspectable.
SHA-256 on retired rigs gives verifiable provenance and tamper-evidence.
The architecture is sovereign: you own the device, the data, and the proofs.

We don't claim

That any model "understands quantum gravity" — humanity has no settled theory to understand.
That a small phone model out-reasons a frontier datacentre model.
That mining ASICs do general compute, encryption, or DRM — they hash, nothing more.
That fluent, confident text is the same as a correct result. It isn't, and we say so.

This is the same creed as the rest of CongoSky and of Klaus: warmth and credibility come through honesty, not around it. Every boundary is collected in one place — what we don't claim ↗.

What we're exploring Concept

Bigger bets, named honestly as bets — not yet shipped, not yet proven. The approaches are proprietary; what we'll share is the goal, not the recipe:

A new language from first principles — built to express the system on its own terms, grown deliberately rather than declared finished. A runnable ~150-line deterministic seed already lives in the proofs.
A cryptographic spine — encryption, authentication, DRM, and watermarking woven together with the provenance layer.
Knowledge-grounded compression — when sender and receiver share the same body of knowledge, you transmit the difference, not the whole. A shared model is, in principle, a compressor. The method is proprietary; the bound is information theory, and we respect it.
Rethinking compute itself — the long-horizon ambition. Extraordinary by definition, so held to an extraordinary standard of proof before it's claimed as done.

If any of these crosses from bet to proven, it moves up the page into the pillars — with the evidence attached.

Receipts Runnable

A cover is a promise; a number you can re-run is a receipt. These are small, self-verifying proofs that back the claims above with working code — each one exits with an error if any claim fails. They live in the repo and run with nothing but Python.

Compression. A deterministic, dependency-free coder, primed on shared knowledge and mixing contexts, beats general-purpose xz on 6 of 7 held-out files (≈11% smaller in aggregate) and is competitive with dictionary-DEFLATE — lossless, byte-identical re-encode. (Honest detail: it wins outright on smaller files; LZ catches up on the largest.)
Notarization. A SHA-256 Merkle notary: one flipped bit changes the root; inclusion proofs verify. Integrity and ordering — time comes from a public anchor.
Knowledge graph + offline Q&A. A no-training, hand-curated graph with deterministic, explainable reasoning — and a fully offline question-answerer that replies from facts and says "I don't know" rather than fabricate. An honest dead-end at quantum gravity, because there is no answer to fetch.
Determinism. The coder emits identical bytes across independent processes — the integer-only discipline the on-device AI rests on.
Encryption. Authenticated encryption by composition of standard primitives; tamper and wrong keys are rejected. No new cipher — that's the point.
Watermarking. An invisible, authenticated, content-bound owner mark — verifiable, unforgeable, and honestly fragile (a provenance mark, not DRM).
Coherence Ledger. A black-box recorder for AI agents: signed, hash-linked event chains you can audit, anchor, and replay — and prove an event happened without revealing its contents. It records what happened, honestly not whether the AI was right. Try it live in your browser → (sovereign — no server, no OpenAI).

Browse all 27 proofs → — each with its measured result, the command to run it, and its honest limits.

Why it lives on CongoSky

CongoSky is the sovereign glue — compute, storage, identity, and AI you actually own. An offline-first, provenance-stamped, first-principles AI is the same idea pushed to its edge: intelligence that owes nothing to a network it can't see. It belongs here.

the420code.org is G's project, hosted and championed on CongoSky. Want the deep version, or to challenge a claim on this page? That's exactly the point — come find us.

First principles.Offline. Sovereign.