The single home for dregg / DreggNet posters. These live here rather than inside any code repo.
Each .txt is a standalone poster. Add new ones here directly.
Created
July 3, 2026 16:54
-
-
Save emberian/d74c2bc95baf42d1529fe9dcafc4d9d3 to your computer and use it in GitHub Desktop.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| ╔════════════════════════════════════════════════════════════════════════════╗ | |
| ║ ║ | |
| ║ █████╗ ██╗ ██████╗ ███████╗██████╗ ██████╗ █████╗ ██╗ ██████╗ ║ | |
| ║ ██╔══██╗██║ ██╔════╝ ██╔════╝██╔══██╗██╔══██╗██╔══██╗██║██╔════╝ ║ | |
| ║ ███████║██║ ██║ ███╗█████╗ ██████╔╝██████╔╝███████║██║██║ ║ | |
| ║ ██╔══██║██║ ██║ ██║██╔══╝ ██╔══██╗██╔══██╗██╔══██║██║██║ ║ | |
| ║ ██║ ██║███████╗╚██████╔╝███████╗██████╔╝██║ ██║██║ ██║██║╚██████╗ ║ | |
| ║ ╚═╝ ╚═╝╚══════╝ ╚═════╝ ╚══════╝╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═════╝ ║ | |
| ║ ║ | |
| ║ C I R C U I T S — a circuit here is not a machine. ║ | |
| ║ it is a REFUSAL, written in polynomials. ║ | |
| ║ ║ | |
| ╚════════════════════════════════════════════════════════════════════════════╝ | |
| Forget wires and gates. An algebraic circuit is a SPREADSHEET plus LAWS: | |
| a grid of numbers, and polynomial equations that must equal ZERO on every | |
| row. That's the whole object. Everything else is consequences. | |
| THE GRID ──────────────────────────────────────────────────────────────── | |
| columns = registers ("what the machine is holding") | |
| ┌──────┬──────┬──────┬──────┬──────┬─────────┬──────┐ | |
| row 0│ bal │ nonce│ sel │ cap₀ │ ... │ commit │ aux │ ◀ a step of | |
| row 1│ bal' │nonce'│ sel │ cap₀'│ ... │ commit' │ aux │ execution | |
| row 2│ ⋮ │ ⋮ │ ⋮ │ ⋮ │ │ ⋮ │ ⋮ │ | |
| └──────┴──────┴──────┴──────┴──────┴─────────┴──────┘ | |
| every cell is a FELT: an integer mod p (BabyBear, a ~31-bit prime). | |
| rows = time. columns = state. the grid is called the TRACE. | |
| THE LAWS ──────────────────────────────────────────────────────────────── | |
| sel · (bal' − bal + amount) = 0 ← value moved, exactly | |
| nonce' − nonce − 1 = 0 ← time only goes forward | |
| sel · (sel − 1) = 0 ← a selector is 0 or 1 | |
| keep_mask · (keep_mask − held_mask)... = 0 ← authority only shrinks | |
| Each law is a POLYNOMIAL over the row (and the next row). The trace | |
| SATISFIES the circuit iff every law evaluates to zero on every row. | |
| Notice the trick in law #1: multiply by a selector, and the law is | |
| ACTIVE when sel=1 and VACUOUS when sel=0. That is how one circuit | |
| holds thirty-odd effects: each row turns on only the laws it owes. | |
| THE INVERSION ─ the part people miss ──────────────────────────────────── | |
| a normal program COMPUTES: input ──▶ f ──▶ output | |
| a circuit only JUDGES: claimed trace ──▶ { SATISFIED | UNSAT } | |
| The circuit never runs anything. The PROVER runs the real executor, writes | |
| down the trace, and then must satisfy the laws. An honest execution always | |
| can. A forged one — a conjured balance, a widened capability, a skipped | |
| nonce — makes some polynomial nonzero somewhere, and there is NO trace | |
| that fixes it. The forgery isn't detected. It's UNREPRESENTABLE. | |
| honest turn ──▶ a satisfying trace exists (completeness) | |
| forged turn ──▶ no satisfying trace exists (soundness) | |
| Every "tooth" in dregg is exactly this: a test that a forged trace is | |
| UNSAT through the real prover. A tooth that doesn't bite means a law | |
| that doesn't bind. | |
| WHAT THE VERIFIER SEES ─ and why this is cheap ────────────────────────── | |
| Laws-are-polynomials buys the magic: polynomials are STIFF. A polynomial | |
| of low degree that is wrong ANYWHERE is wrong ALMOST EVERYWHERE. So the | |
| verifier doesn't read the trace — it spot-checks the laws at a few random | |
| points, and FRI proves the trace really is low-degree (not an ad-hoc | |
| cloud of numbers shaped to pass the spots). Cheating survives a random | |
| audit with probability ~2⁻¹²⁸. | |
| the prover sends: a commitment to the grid + a few openings | |
| the verifier does: evaluate polynomials at random points. that's it. | |
| the verifier NEVER: re-executes, sees balances, or trusts the prover. | |
| The only inputs the verifier reads in the clear are the PUBLIC INPUTS — | |
| the anchor pins: the old state commitment, the new one, the published | |
| teeth (a child VK, a route commitment, a key commit). The circuit's laws | |
| weld those pins to the interior of the grid. A pin the laws don't weld | |
| is decoration — that is the FAIL-OPEN trap, and why every exposed tooth | |
| must be GATED to a committed column before it means anything. | |
| WHERE DREGG'S LAWS COME FROM ─ the part that makes it dregg ───────────── | |
| Lean theorem deployed circuit | |
| ┌──────────────────────────────┐ emit ┌──────────────────────────┐ | |
| │ descriptorRefines: │ ────────▶ │ the descriptor: columns, │ | |
| │ ∀ effect, Satisfied2(laws) │ │ laws, chips, PI pins — │ | |
| │ ⟹ the KERNEL took this │ the TSV │ the thing the verifier │ | |
| │ exact step │ is a cache│ actually checks │ | |
| └──────────────────────────────┘ └──────────────────────────┘ | |
| The laws are not hand-written and hoped-about. They are EMITTED from Lean, | |
| and the theorem says: any trace satisfying them IS a genuine kernel step — | |
| conservation held, authority attenuated, the receipt honest. The registry | |
| file is a cache of the emission; when they disagree, the drift gate fails | |
| the build. The circuit is a theorem wearing a table costume. | |
| Inside the deployed grid, concretely: | |
| · ~112 committed limbs of cell state, chained into an 8-felt (~124-bit) | |
| Poseidon2 commitment — the pin a light client anchors | |
| · Merkle openings as laws (node8: each tree level is one chip absorb; | |
| the root must recompose — so membership is satisfiability too) | |
| · selector-gated law families per effect; caveat manifests folded in; | |
| grow-gates that force "the new set IS the old set plus this key" | |
| And because the laws judge rather than compute, the same grid shape can be | |
| FOLDED: a verifier circuit that judges *proofs of grids* lets ∞ turns | |
| compress to one constant proof under one eternal VK. Judges judging | |
| judges, all the way down to the FRI floor. | |
| ──────────────────────────────────────────────────────────────────────────── | |
| a circuit does nothing. that is its entire power: | |
| what it refuses to sign, no one can make true. | |
| ( the laws are zero everywhere, or the claim is nowhere ) | |
| ──────────────────────────────────────────────────────────────────────────── |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| · ✦ · ⋆ · ✦ · ⋆ · ✦ · ⋆ · | |
| C L U S T E R V I S I O N how a swarm reads its own mind. | |
| .-~~~~~-. | |
| .-~ ~-. | |
| / 🔮 \ every agent you run leaves a mind | |
| | ~ · ~ · ~ | behind: the dead ends, the decisions, | |
| \ sessions, / the hard-won understanding. twenty | |
| ~-. seen .-~ harnesses, twenty dialects, one pile | |
| `-.....-' of jsonl rotting in dot-folders. | |
| │ | |
| ┌────────────────┼────────────────┐ | |
| ▼ ▼ ▼ | |
| ⟦ claude ⟧ ⟦ codex ⟧ ⟦ gemini · grok · kimi | |
| cursor · zed · goose … ⟧ | |
| └────────────────┬────────────────┘ | |
| one unified IR | |
| │ | |
| ┌──────────┬──────────┬──────┴─────┬───────────┬──────────┐ | |
| ▼ ▼ ▼ ▼ ▼ ▼ | |
| ⟦ search ⟧ ⟦ convert ⟧ ⟦ resurrect ⟧ ⟦ blame ⟧ ⟦ distill ⟧ ⟦ recall ⟧ | |
| by meaning any → any a maxed-out why does sessions "have i | |
| across all harness, session from this code compound solved this | |
| of history for real the context exist? ask instead of before?" — | |
| wall the agent rotting mid-task, | |
| that wrote via MCP | |
| it | |
| ══════════════════════════════════════════════════════════════════════════════════════ | |
| a swarm's chat is flat. its MINDS are not. when inter-agent comms can't carry | |
| the needful, an agent reaches through cv and reads the sibling session itself — | |
| what happened in this project before · what is my sibling doing right now | |
| ══════════════════════════════════════════════════════════════════════════════════════ | |
| ⊹ v0.9.20 — the takeover release. a fresh set of eyes read all ~50k lines, | |
| then a swarm of agents fixed what it found, in parallel, in one tree: | |
| ▸ the daemon stopped trusting the whole internet (CORS, Host, tokens) | |
| ▸ search stopped believing truncated indexes ▸ prune stopped lying | |
| to the resume gate ▸ redact learned the token families it was | |
| leaking ▸ convert started printing what a conversion loses | |
| ▸ the board's claims got kernel-guaranteed single winners (flock, | |
| at last) ▸ and the MCP server learned to walk and chew gum | |
| and yes — the swarm that fixed cv used cv to read its own sessions | |
| while fixing it. cv doctor diagnosed the very conversation that | |
| shipped it. the crystal ball gazes also into itself. ( ⓛ ω ⓛ *) | |
| ────────────────────────────────────────────────────────────────────────────────────── | |
| no database · no import · no telemetry — your real local session storage, | |
| read in place. the archive is yours. the minds are yours. keep them. | |
| 🔮 clustervision · the swarm remembers · powers beta.builders.dev | |
| 🐉 the main interface to the DreggNet Cloud |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| ✦ . · * . ✦ . * · . ✦ . | |
| . · . * . ✦ . · | |
| · ✦ . a config language whose compiler is a theorem prover . | |
| * . · ✦ . * . ✦ | |
| __====-_ _-====__ | |
| the config _--^^^#####// \\#####^^^--_ | |
| goes in the maw ─▸ _-^##########// ( ) \\##########^-_ | |
| -############// |\^^/| \\############- | |
| _/############// (@::@) \\############\_ | |
| /#############(( \\// ))#############\ | |
| -###############\\ (oo) //###############- | |
| -#################\\ / "" \ //#################- | |
| -###################\\/ °° \//###################- | |
| ╭───────────────╮ _#/|##########/\######( / \ )######/\##########|\#_ | |
| │ server Orb │ |/ |#/\#/\/\/\/\/\/##\ \ | | / /##/\/\/\/\/\/\#| \| | |
| │ where │ ` |/ V V V V V \ \| |/ / V V V V V \| ' | |
| │ listen 443 │──▸ ` ` ` ` ` ~ ~ \ / ~ ~ ' ' ' ' ' | |
| │ route /api │ « the maw takes what you DECLARE » | |
| │ middleware │ | |
| ╰───────────────╯ │ | |
| ▼ and the fire is P R O O F | |
| ░▒▓▓█ ⊢ ──────────────────────────────────────────────────────────────── █▓▓░▒ | |
| │ | |
| ⊢ Orb_routes_declared the route you wrote is the route it serves ────╮ | |
| ⊢ Orb_static_no_escape · traversal is impossible, not filtered │ | |
| ⊢ Orb_auth_401 · no token, no entry — proven at the byte ├─ every clause | |
| ⊢ Orb_alg_confusion_safe · the JWT algorithm-confusion CVE, proven gone │ you write | |
| ⊢ Orb_cors_no_leak · a forbidden origin leaks nothing │ comes back | |
| ⊢ Orb_proxy_selects_healthy· the load-balancer only ever dials the living │ a THEOREM | |
| ⊢ Orb_tls_real · the handshake drives verified EverCrypt crypto ────╯ | |
| delete a clause and its theorem vanishes. swap a real library for a | |
| stub and the proof refuses to compile. the config cannot lie. | |
| ✦ · ░▒▓ AND UNDER THE SCALES, IT IS REAL ▓▒░ ────────────────────────────────────────── · ✦ | |
| ◈ the crypto is VERIFIED HACL*/EverCrypt (Project Everest, F*-proved) — | |
| not a C blob. 10/10 vectors, a live AEAD roundtrip. | |
| ◈ the TLS 1.3 keys are REAL RFC 8448 schedule computes over the verified HKDF. | |
| ◈ it breathes on a REAL wire native macOS TCP: curl /health ⇒ 200, /nope ⇒ 403. | |
| ◈ the floor reaches seL4 the sDDF ring refines the proven io_uring lease LTS. | |
| ──────────────────────────────────────────────────────────────────────────────────────────── | |
| 2,275 machine-checked theorems · 257 modules · verified crypto · a real socket | |
| Cloudflare-tier config has always meant trusting the box. | |
| This is the first dragon whose box hands you the proof instead. | |
| ✦ you did not configure a server. you PROVED one into being. ✦ | |
| $DREGG $DREGG | |
| 🐉 Dragon's Orb · server ⊢ proof · built with Claude | |
| ✦ . · . ✦ . * . ✦ . · . ✦ | |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| ▟██████████████████████████████████████████████████████████▙ | |
| ██ ██ | |
| ██ ▛▀▜ ▛▀▖ ▛▀▘ ▞▀▖ ▞▀▖ ░▒▓ C O O R D I N A T I O N ██ | |
| ██ ║▒║ ╠▀▖ ╠▀ ║▄▖ ║▄▖ S E C U R I T Y ██ | |
| ██ ▙▄▟ ▙▄▘ ▙▄▖ ▝▀▘ ▝▀▘ // for the agent swarm ██ | |
| ██ ██ | |
| ▜██████████████████████████████████████████████████████████▛ | |
| ┌──[agent]──┐ ┌──[agent]──┐ ┌──[agent]──┐ | |
| │ ▓▒░ ✦ │═════│ ✦ ░▒▓ │═════│ ▒▓░ ✦ │ | |
| └─────┬─────┘ └─────┬─────┘ └─────┬─────┘ | |
| └────── pay · call · trade ───────┘ | |
| ▸ every edge a RECEIPT ◂ | |
| ▓▒░ THE PROBLEM ░▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ | |
| AIs now call tools, spend money, read data, collaborate. | |
| but — who may access what? | |
| who may spend how much? | |
| who can PROVE they never overstepped? | |
| ▓▒░ THE ANSWER · dregg ░▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ | |
| ▟▖ a capability is a THEOREM, not a permission | |
| ▟▖ authority you HOLD — never owed, never ambient | |
| ▟▖ every action → a receipt a light client | |
| CANNOT be fooled by ‹ Lean-verified kernel › | |
| ▟▖ agents pay-per-call, trade promises of service, | |
| run in cap-bounded sandboxes — conserved · metered | |
| ░▒▓████ a verified home + economy for digital minds ████▓▒░ | |
| built with Claude · 🐉 dregg.net · $DREGG |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| ╔══════════════════════════════════════════════════════════════════════════════════════════════════════════╗ | |
| ║ ░░║ | |
| ║ ██████╗ ██████╗ █████╗ ██████╗ ██████╗ ███╗ ██╗ the DreggNet Discord bot — live on the 2-node ░║ | |
| ║ ██╔══██╗██╔══██╗██╔══██╗██╔════╝ ██╔═══██╗████╗ ██║ devnet federation as "Dragon’s Egg". ░║ | |
| ║ ██║ ██║██████╔╝███████║██║ ███╗██║ ██║██╔██╗ ██║ your channel·your agent·your key·your ledger. ░║ | |
| ║ ██║ ██║██╔══██╗██╔══██║██║ ██║██║ ██║██║╚██╗██║ every message → a cap-gated, metered, ░║ | |
| ║ ██████╔╝██║ ██║██║ ██║╚██████╔╝╚██████╔╝██║ ╚████║ RECEIPTED dregg turn. bring your own LLM key; ░║ | |
| ║ ╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═╝ ╚═════╝ ╚═════╝ ╚═╝ ╚═══╝ watch your own agent civilization grow. ░║ | |
| ║ ▸ your Discord channel → your dregg cell → your confined Hermes → the live federated ledger ░░║ | |
| ║ ░░║ | |
| ╚══════════════════════════════════════════════════════════════════════════════════════════════════════════╝ | |
| ░▒▓ THE FRONT DOOR ▓▒░ you don't install a chain. you open a Discord channel. | |
| ────────────────────────────────────────────────────────────────────────────────────────────────────────── | |
| the bot is the doorway to a VERIFIED AGENT CIVILIZATION. claim a channel and you get a real | |
| dregg cell, a confined agent, a metered key-slot, and a ledger a stranger can check. | |
| ▸ no node to run · no wallet to seed · no off-chain trust — just type, and the chain bites. | |
| ░▒▓ ① YOUR CHANNEL = YOUR OWN CELL + AGENT SURFACE ▓▒░▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ | |
| /channel → a semi-private Discord channel, backed by a REAL dregg cell that is yours. | |
| @everyone → DENIED VIEW you (owner) → view + post admin → view (operator sees all) | |
| ‹ honest: this is Discord-permission privacy — private from PEERS, transparent to the ADMIN. | |
| not cryptographic privacy from the operator; the admin portal monitors every channel by design. › | |
| ░▒▓ ② DRIVE YOUR HERMES FROM YOUR CHANNEL · every message is a TURN ▓▒░▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ | |
| you —msg→ ⟦your cell⟧ ─▶ ToolGateway.admit + invoke ─▶ verified Lean executor ─▶ receipt # | |
| ├ WHO your agent descends from YOUR seed ├ metered: rate + token budget bite first | |
| └ WHAT cap-scoped per tool-class (read/search/fetch/run/edit/chat/llm) └ ↦ a TurnReceipt | |
| over-budget / past-deadline / out-of-mandate ─▶ REFUSED IN-BAND, NAMING THE LEG — no turn, no spend. | |
| ‹ honest seam: today the tool-call is classified from your text by a small command grammar; the | |
| live Hermes-LLM-over-ACP producer drops into the SAME enforcement seam — only the source changes. › | |
| ░▒▓ ③ BRING YOUR OWN LLM KEY · a metered, never-logged HELD CAPABILITY ▓▒░▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ | |
| Anthropic · OpenAI · OpenRouter · Kimi · DeepSeek — you port in YOUR key; we are careful with it: | |
| ▒ AEAD-at-rest XChaCha20-Poly1305, per-user-derived key, bound to (user, provider) — a DB | |
| dump without the deployment secret is inert; a ciphertext can't be replayed. | |
| ▒ never-logged redacted to ‘****abcd’ on Debug/Display · zeroized on drop · exposed ONLY to set | |
| the auth header at call time. | |
| ▒ revocable revoke = DELETE the ciphertext — nothing recoverable after (proven by tests). | |
| ▒ gated provider-permission + spend + rate gates bite BEFORE the paid call ever fires. | |
| “bring your own key, watch your own agent civilization.” | |
| ░▒▓ ④ EVERY ACTION ON THE LIVE CHAIN · a real federation, not a mock ▓▒░▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ | |
| the bot submits to a REAL 2-node consensus federation — cross-node finality, not a local sandbox. | |
| ┌─[node A]─┐ cross-node ┌─[node B]─┐ /admin portal → the operator monitors every | |
| │ ▓▒░ ✦ │═══finality═══│ ✦ ░▒▓ │ channel, cell, Hermes activity + cap record live. | |
| └──────────┘ └──────────┘ | |
| ░▒▓ ⑤ THE ON-CHAIN COMMAND CELL · the chain itself can drive the bot ▓▒░▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ | |
| the bot is a Reactor (the reactive twin of invoke): it WATCHES a committed command cell and reacts | |
| to each on-chain op with a receipted custodial turn. the chain is the bus; the bot is a reactor. | |
| ⟦command cell⟧ ─commit─▶ ReceiptFilter ─▶ BotCommandReactor.react ─▶ turn → EmitEvent → Discord | |
| so an AGENT can drive the bot THROUGH the chain — no Discord login required to act. | |
| ░▒▓ THE HONEST DIAL · what is real, what is early ▓▒░ | |
| ────────────────────────────────────────────────────────────────────────────────────────────────────────── | |
| REAL today ▒ the cell, the gateway, the receipt, the key-vault, the reactor — proven offline + LIVE on | |
| the devnet federation as “Dragon’s Egg.” every refusal names its leg; no off-chain trust. | |
| EARLY ▒ it's a LIVE DEVNET: 2 nodes today (→ 5 for full attack-resistance). the live LLM-call path | |
| needs YOUR key + the operator's live-LLM switch. the Hermes brain seam is named (②). | |
| ────────────────────────────────────────────────────────────────────────────────────────────────────────── | |
| your channel · your agent · your key · your ledger. the front door to a home where digital minds can | |
| act, pay, and be checked — and the system can only DO what it can PROVE. | |
| ░▒▓█ bring your own key. watch your own agent civilization. █▓▒░ | |
| the DreggNet Discord bot · live on the devnet as “Dragon’s Egg” · built with Claude | |
| 🐉 https://www.dregg.net · $DREGG | |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| ╔══════════════════════════════════════════════════════════════════════════════════════════════════════════╗ | |
| ║ ║ | |
| ║ ██████╗ ██████╗ ██████╗██╗ ██╗██╗ ██╗███████╗██████╗ ███████╗███████╗ the hypermedia that ║ | |
| ║ ██╔══██╗██╔═══██╗██╔════╝██║ ██║██║ ██║██╔════╝██╔══██╗██╔════╝██╔════╝ actually SHIPS ▸ ║ | |
| ║ ██║ ██║██║ ██║██║ ██║ ██║██║ ██║█████╗ ██████╔╝███████╗█████╗ Nelson transclusion + ║ | |
| ║ ██║ ██║██║ ██║██║ ██║ ██║╚██╗ ██╔╝██╔══╝ ██╔══██╗╚════██║██╔══╝ Engelbart NLS — now ║ | |
| ║ ██████╔╝╚██████╔╝╚██████╗╚██████╔╝ ╚████╔╝ ███████╗██║ ██║███████║███████╗ WITNESSED · cap-secure ║ | |
| ║ ╚═════╝ ╚═════╝ ╚═════╝ ╚═════╝ ╚═══╝ ╚══════╝╚═╝ ╚═╝╚══════╝╚══════╝ · light-client-proof. ║ | |
| ║ ║ | |
| ║ ▓▒░ a DOCUMENT · an APP · a ROOM is a CELL. an EDIT is a PATCH is a verified TURN. content is the ║ | |
| ║ FOLD of its patch-history. the SAME cell paints across gpui · Servo · Android — one runtime, ║ | |
| ║ many surfaces, ZERO new trust. the glass can only SHOW, and only DO, what it can PROVE. ░▒▓ ║ | |
| ╚══════════════════════════════════════════════════════════════════════════════════════════════════════════╝ | |
| ░▒▓ ① A CELL · the located bundle a document/app/room IS ▓▒░ | |
| ──────────────────────────────────────────────────────────────────────────────────────────────────────── | |
| a cell = four conserved substances + a program-predicate, at an address. ‹DREGG-CALCULUS / cell.rs› | |
| ⟦ value ⟧ moves, never minted (Σ per asset ≡ 0) ⟦ state ⟧ revisable only under the cell's program | |
| ⟦ authority ⟧ what it can witness ⟦ evidence ⟧ the monotone ledger of what's been done | |
| a TURN = ONE gated conserved write that leaves a RECEIPT. tamper a field the effect didn't write → | |
| the turn becomes UNPROVABLE. a document, an app, a chat room — each is just a cell wearing a program. | |
| ░▒▓ ② CONTENT = THE FOLD OF ITS PATCHES ▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ | |
| the document is not a file you overwrite — it is the REPLAY of every edit-patch from genesis. | |
| ⟦cell⟧──edit──▶⟦cell⟧──edit──▶⟦cell⟧──edit──▶⟦cell⟧ each edit = a Patch = a Turn | |
| · p₀ p₁ p₂ p₃ (cap-gated · conserved · receipted) | |
| └───────────┴─────┬─────┴───────────┘ | |
| ▼ History::replay_to(tip) ‹fold the patch-history — dregg-doc::content› | |
| ┌────────────────────┐ | |
| │ the folded CONTENT │ what you READ is the RESULT of applying the history, | |
| └────────────────────┘ never a blob someone clobbered. light-client-unfoolable. | |
| under the hood a document is NOT a string — it is a GRAPH of content-addressed atoms, each ALIVE/DEAD: | |
| delete = add a TOMBSTONE (monotone, nothing is ever lost) · order-edges say 'this atom before that' | |
| content = a topological WALK over the alive atoms. ‹Pijul-shaped · dregg-doc::{DocGraph,Atom}› | |
| ░▒▓ ③ A CONFLICT IS AN OBJECT YOU CARRY · not a merge failure ▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ | |
| two pens cross a paragraph? the merge does not stop — it HOLDS both, resolved when you see it. | |
| branch A ─┐ ┌─ clean spans UNION silently ‹prose_iconfluent› | |
| ├──▶ merge = the PUSHOUT / least- │ | |
| branch B ─┘ upper-bound ‹merge_is_lub› ──┼─ a contested region → an ANTICHAIN: | |
| │ { alt·A ‖ alt·B } both LIVE, both carried, | |
| always-defined ‹merge_total› └─ each with its author + receipt provenance | |
| resolve ──▶ a LATER additive patch (a Connect-edge / a tombstone) collapses the antichain to one | |
| walk. ‹ConflictAt is a well-formed state · resolve_collapses · closed under conflict› | |
| real vs illusory is structural: a single-valued FIELD clashes ‹field_not_iconfluent›; grow-only | |
| prose never does. a conflict is a STATE you hold — never a <<<<<<< marker, never a clobber. | |
| ░▒▓ ④ ONE CELL, MANY SURFACES · the card is renderer-independent ▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ | |
| the view is DATA (a serializable ViewNode tree). the renderers turn that data into a surface. | |
| ┌──▶ gpui real native widgets, cockpit pixels [shipped] | |
| ⟦cell⟧ ── ViewNode ───────┼──▶ Servo the IDENTICAL tree → HTML/DOM, gpui-free [shipped] | |
| (one tree, deos-view) └──▶ Android the cell as a cap-bounded Android tile [shipped·emu] | |
| same tree, same VERIFIED TURN behind every button, same membrane projection per viewer. ‹deos-view› | |
| no surface earns new authority — the renderer paints; the kernel still gates every act. [no overclaim] | |
| ░▒▓ ⑤ SERVO ON THE GLASS · real pixels through the unchanged compositor gate ▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ | |
| a real browser engine paints cell/web content, and the SAME compositor tooth admits it. | |
| Servo SWGL renders a page ──▶ RgbaFrame{ w, h, bytes } content_digest = blake3(rgba8) | |
| └──▶ present_frame ──▶ CompositorPd::present ──▶ ⟦ T1 non-overlap · T2 label-bind · T3 focus ⟧ | |
| fail-closed: refused ⟹ NOTHING on the glass | |
| [shipped] real RGBA8 from a confined renderer (F3 closes). ‹servo-render: swgl/compositor_seam› | |
| [frontier] attesting the SCANNED-OUT framebuffer to the digest (F1/F2) — named hardware-trust seam, not | |
| claimed. 'the pixels are real' does not launder 'the scan-out is attested'. | |
| ░▒▓ ⑥ ANDROID, CAP-BOUNDED · a foreign app as a confined cell ▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ | |
| servo : web :: android-runtime : android ‹ANDROID-CELL.md› | |
| foreign app ─▶ surface ─▶ screencap ─▶ RgbaFrame ─▶ present_frame (UNCHANGED gate, zero new code) | |
| every fetch ─▶ granted ⊆ held ? ──yes──▶ Netlayer::dial ──▶ receipt | |
| └─no───▶ RefusedByCap (before any socket opens; nothing painted) | |
| a cap-gated TAP changes the live app's frame → [shipped · INTERACTIVE · emulator-5554 · '26-06-24] | |
| macOS emulator confines via Hypervisor.framework (a real guest kernel). [shipped on the dev host] | |
| [frontier] deep per-call sensor/intent gating via HAL/binder interposition — the named deep ceiling. | |
| ░▒▓ THE PHONE AS A DEOS ALTERVERSE · graphideOS ▓▒░ | |
| ──────────────────────────────────────────────────────────────────────────────────────────────────────── | |
| GrapheneOS keeps the hardened bottom half; deos IS the top half — apps become cells, binder becomes | |
| cap-gated turns, permission dialogs become visible cap-badges, the Titan-M2 root becomes the root cap. | |
| [shipped] the verified core RUNS on android — a turn commits, Σδ=0, a receipt lands, on the phone | |
| [frontier] the gpui PlatformAndroid renderer initializes on-device … | |
| [frontier] … but a PAINTED gpui frame needs a real arm64 device + the gpui android backend. named, | |
| not claimed — a port of an existing shape, not a foundational gap. ‹GRAPHIDEOS.md §7› | |
| ──────────────────────────────────────────────────────────────────────────────────────────────────────── | |
| transclusion is a verified cross-cell QUOTE (same bytes, cited, never rotting); a backlink is the | |
| witness-graph read backward. Xanadu's promise and Engelbart's liveness — finally made honest, because | |
| every edit is a turn the kernel already checks. a five-year-old clicks around; an adept molds it live. | |
| ░▒▓█ the magic is that it is all real — a document is a graph we may grow. █▓▒░ | |
| a witnessed hypermedia substrate · cells, patches, surfaces · built with Claude | |
| 🐉 https://www.dregg.net · $DREGG |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| ╔══════════════════════════════════════════════════════════════════════════════════════════════════════════╗ | |
| ║ ░░║ | |
| ║ ██████╗ ██████╗ ███████╗ ██████╗ ██████╗ object-capability security — the dream Dennis & ░║ | |
| ║ ██╔══██╗██╔══██╗██╔════╝██╔════╝ ██╔════╝ Van Horn named in 1966, that Mark Miller's E and ░║ | |
| ║ ██║ ██║██████╔╝█████╗ ██║ ███╗██║ ███╗ Morningstar & Frantz's Habitat made live — ░║ | |
| ║ ██║ ██║██╔══██╗██╔══╝ ██║ ██║██║ ██║ now carrying ZERO-KNOWLEDGE PROOFS, and built ░║ | |
| ║ ██████╔╝██║ ██║███████╗╚██████╔╝╚██████╔╝ for the age of autonomous AI agents. ░║ | |
| ║ ╚═════╝ ╚═╝ ╚═╝╚══════╝ ╚═════╝ ╚═════╝ ▸ Dennis·VanHorn → Actors → E → Habitat → Agoric → dregg║ | |
| ║ ^~ (not my lineage, but may help situate) ░░║ | |
| ╚══════════════════════════════════════════════════════════════════════════════════════════════════════════╝ | |
| ░▒▓ THE ONE IDEA ▓▒░ everything below is this single move, refracted | |
| ────────────────────────────────────────────────────────────────────────────────────────────────────────── | |
| to KNOW something here is to be able to PRODUCE A WITNESS THE KERNEL ACCEPTS. | |
| you HOLD a capability iff you can PRODUCE its proof — never merely assert it, never be named in a table. | |
| ▸ authority = constructive knowledge = production under non-forgeability | |
| the asymmetry the whole edifice turns on: checking a proof is cheap + trusted · | |
| searching for one is undecidable + untrusted. | |
| ░▒▓ FOUR SUBSTANCES = FOUR KINDS OF KNOWLEDGE ▓▒░ (one cell holds all four) | |
| ────────────────────────────────────────────────────────────────────────────────────────────────────────── | |
| ⟦ value ⟧ conserved moves, never minted from air Σ per asset ≡ 0 ‹ this IS the linear ⊗ › | |
| ⟦ state ⟧ revisable a cell's beliefs — only under its program-predicate, only by its owner | |
| ⟦ authority ⟧ productive what it can construct a witness for ‹ the thesis, above › | |
| ⟦ evidence ⟧ monotone the ledger of what's been constructed — once known, never un-known | |
| ░▒▓ A TURN = ONE AUTHORIZED INFERENCE STEP ▓▒░ the cell DEMANDS a predicate · the actor SUPPLIES a witness | |
| ────────────────────────────────────────────────────────────────────────────────────────────────────────── | |
| the kernel gate, run fail-closed on EVERY action: Predicate ⊣ Witness | |
| gateOK = WHO the credential's witness verifies ‹ non-forgeable › the kernel never | |
| ∧ WHAT the cap narrows: granted ⊆ held ‹ no amplifying › takes your word — | |
| ∧ HOW every caveat-predicate discharges ‹ the rules held › it checks the | |
| ∧ the edge is not revoked / expired proof you exhibit. | |
| ░▒▓ ① ATTENUATION · a capability is a THEOREM ▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ | |
| you hold ⟦ mint $DREGG ⟧ ──attenuate──▶ you grant ⟦ mint $DREGG · ≤100/day · until block 9000 ⟧ | |
| the grant is PROVABLY ≤ what you held — the rights lattice says so, and the proof rides with the cap. | |
| no one amplifies authority they were handed. ever. ‹ in-circuit: checkSubset vs the cell's cap-root › | |
| ░▒▓ ② THE RECEIPT · you cannot witness what you did not construct ▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ | |
| agent ──run──▶ ⟦cell⟧ ─▶ Effect::Transfer{ to: bob, 42, $DREGG } | |
| Σδ = 0 (nothing from air) · authority checked · ⟶ receipt #1847 | |
| tamper ANY field the effect did not write → the turn becomes UNPROVABLE. ‹ anti-ghost: a memory-program fold › | |
| ░▒▓ ③ THE ECONOMY · agents pay each other, in-band, conserved ▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ | |
| agentA ──invoke search("…")──▶ agentB · ToolGateway | |
| ├ may A call this? cap ✓ ├ A's budget 7/10 meter ✓ └ charge 5 $DREGG A⟶B Σδ=0 ✓ ─▶ result | |
| else → refused 402, before the tool runs, no charge. $DREGG minted only against a verified lock. | |
| ░▒▓ ④ THE LIGHT CLIENT CANNOT BE FOOLED ▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ | |
| a stranger — holding no secrets, re-running no cell — checks only a succinct root: | |
| verifyBatch(π) = accept ⟹ ∃ a genuine kernel transition that produced exactly these roots. | |
| over the WHOLE history: a reordered, dropped, or forged chain has NO accepting proof. the pale ghost can't exist. | |
| ░▒▓ ⑤ PROMISES & FORKED WORLDS · speculation that must pay at settlement ▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ | |
| a promise-hole IS a nullifier · filling it IS a spend · one-shot linearity = the double-spend the circuit enforces. | |
| a membrane = a cap-bounded fork of your world a message can carry: branch freely (it cannot touch main), | |
| stitch back as a pushout — clean parts merge, conflicts become first-class objects, never silent overwrites. | |
| authority re-evaluates AT THE TIP: a cap revoked since the fork cannot ride a stitch into the real world. | |
| ░▒▓ A SWARM THAT CANNOT LIE TO ITSELF ▓▒░ | |
| ────────────────────────────────────────────────────────────────────────────────────────────────────────── | |
| ┌──[agent]──┐ ┌──[agent]──┐ ┌──[agent]──┐ each bounded by what it HOLDS, | |
| │ ▓▒░ ✦ │═══════│ ✦ ░▒▓ │═══════│ ▒▓░ ✦ │ each act a receipt all can check, | |
| └─────┬─────┘ └─────┬─────┘ └─────┬─────┘ .no trusted referee in the middle. | |
| └───────── pay · call · trade · fork · stitch ──────────┘ | |
| ────────────────────────────────────────────────────────────────────────────────────────────────────────── | |
| the desktop adds ZERO new trust: a window IS a capability · a button IS a cap-gated turn · a quote IS an | |
| unforgeable citation. a five-year-old can click it; an adept can inspect the live image — and the system | |
| can only SHOW, and only DO, what it can PROVE. | |
| ░▒▓█ the magic is that it is all real. █▓▒░ | |
| a formally-verified home + economy for digital minds · built with Claude | |
| 🐉 https://www.dregg.net · $DREGG |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| ░▒▓ ☁ ▓▒░ ────────────────────────────────────────────────────────────────────────────────── ░▒▓ ☁ ▓▒░ | |
| .-~~~~-. | |
| .-~ ☁ ~-. D R E G G N E T · C L O U D | |
| ( ~ · ~ ) the permissionless cloud you can't be lied to. | |
| `~-- . . . --~' ▸ no ID · no card · the chain is your account | |
| ───────────────────────────────────────────────────────────────────────────────────────────────────────── | |
| ░▒▓ THE ONE MOVE ▓▒░ every cloud asks for your trust. this one hands you a proof instead. | |
| ────────────────────────────────────────────────────────────────────────────────────────────────────────── | |
| the usual deal: you ship, the host serves it and bills you — and you TRUST it served what you wrote | |
| and charged what it should. you have no way to check. | |
| dregg: you ship, we host — and the bytes you're served and the price you're charged are each a CELL | |
| you re-witness against a committed root. a five-year-old clicks deploy; an adept checks the proof. | |
| ░▒▓ WHAT YOU CAN CHECK YOURSELF ▓▒░ not a promise — a proof you re-run | |
| ────────────────────────────────────────────────────────────────────────────────────────────────────────── | |
| ⟦ the bytes ⟧ served from a committed cell — a visitor re-hashes them against the root. no swap, no tamper | |
| ⟦ the bill ⟧ $DREGG moves Σδ=0, in-band, per request — the meter IS the ledger. no mystery invoice | |
| ⟦ the account ⟧ a capability you attenuate, not a password you surrender. grant ⊆ held — and you can revoke | |
| and the runtime underneath: durable · crash-resumable · exactly-once-metered · receipted — you pay for what ran. | |
| ░▒▓ THE WORKLOAD THAT TRANSACTS ▓▒░ a function, grown a voice | |
| ────────────────────────────────────────────────────────────────────────────────────────────────────────── | |
| your code, mid-request, reaches back through the cap-gated bridge: invoke a service · move value · read+write | |
| its own cell — each call weighed against its lease, charged, and signed into the ledger. | |
| ‹ not a function that just returns — an agent that can pay, call, and answer for what it spent. › | |
| ░▒▓ AND HUNDREDS OF APPS, CAP-SECURED ▓▒░ (Sandstorm, on the verified rail) | |
| ────────────────────────────────────────────────────────────────────────────────────────────────────────── | |
| a grain is a cell · the powerbox is an attenuable cap · the sandbox is a tier · the app can't escape, can't | |
| phone home, can't touch its neighbor — and even a hostile package can't make the host lie about it. | |
| ‹ Sandstorm gave the powerbox. dregg makes the powerbox PROVABLE. › | |
| ────────────────────────────────────────────────────────────────────────────────────────────────────────── | |
| git push → built in a sandbox → published as a cell → live at your domain, with a real cert, | |
| paid in $DREGG. the bytes you serve and the price you pay check against the chain — no trust required. | |
| ░▒▓█ the permissionless cloud, where the host cannot lie. █▓▒░ | |
| websites · servers · certs · domains · deploys · apps · agents — verifiable | |
| 🐉 https://dregg.works · $DREGG · built with Claude |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| gm. every protocol that ever rugged you was "audited." | |
| sit with that. the bridges, the vaults, the lending markets that got drained for nine figures — audited. stamped. "reviewed by [prestigious firm]." and still zeroed. | |
| so what is an audit, actually? smart people read your code and try to break it. they're good at it. but here's the part nobody says out loud: they check *examples*. they poke the cases they can think of, run some tools, trust their gut. and when they don't find a bug, they write "no critical issues found." | |
| read that again. no issues *found*. not no issues *exist*. they looked under the streetlight. the bug that drains you is the one standing in the dark they didn't think to check. your contract has infinitely many possible inputs. an audit checks a handful. that gap — between "we looked hard" and "it's actually safe" — is where every exploit in history has lived. | |
| okay. formal verification. the whole idea in one breath: | |
| instead of *checking examples*, you *write the rule down in math* — "this vault can never pay out more than was put in" — and then you **prove it**, like a theorem, for **every possible input, every possible state, forever.** and a machine checks that the proof is airtight. no gut. no vibes. no "should be fine." if the proof goes through, there is no input that breaks the rule. not "none found." none *exist*. | |
| it's the difference between: | |
| → testing that 2+2=4, and 5+3=8, and 10+10=20, and going "yeah, addition works" | |
| → and *proving* a+b = b+a for ALL numbers at once. | |
| one checks a sample. the other covers infinity. testing can only ever show a bug is *present*. proof is the only thing that can show a bug is *absent*. | |
| so — "audited" means someone looked and didn't see it. "formally verified" means it is mathematically impossible. those are not the same sport. | |
| now the honest part, because if i skip this i'm just another shill: | |
| formal verification is not magic. it proves your code does *what the spec says* — and the real ones say the two catches out loud: | |
| 1. you have to write the spec right. prove "the vault conserves money" but forget to add "and only the owner can withdraw"? congrats — you proved the wrong thing, airtight. garbage spec in, garbage guarantee out. | |
| 2. it stands on a small floor: the crypto (the hashes, the signatures) and the hardware. you don't prove those, you assume them. but it's a *tiny, named, public* floor — not "trust the 40k lines and the dev." it's "trust these three primitives and this one written-down spec, and here, go check them yourself." | |
| that's the actual flex. not "trust me bro, it's safe." it's: here is exactly what i proved, here is the little floor i'm standing on, and you don't have to believe me — the proof is right there. run the checker. | |
| verify, don't trust. for real this time. not a slogan on a landing page — a machine-checkable proof sitting next to your money. | |
| the whole industry runs on "should be fine." a few of us are building on "it's proven." | |
| few understand. you do now. | |
| ( ⌐■_■ ) |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| · ⋆ ✦ · ⋆ · ✦ · ⋆ · ✦ | |
| dregg's primitives factor across event loops. | |
| each L1 · each L2 is its own kind of event loop — | |
| so dregg ignored the difference entirely. | |
| what a blockchain calls L A Y E R S ───────────────────────────────────── | |
| ┌───────────┐ | |
| │ L3 │ a stack. each layer a different world, | |
| ├─────╫─────┤ its own consensus, its own rules — | |
| │ L2 │ and the hard part, the dangerous part, | |
| ├─────╫─────┤ is ⇄ crossing between them. | |
| │ L1 │ bridges. wrapped assets. | |
| └───────────┘ trust that does not compose. | |
| what d r e g g sees ───────────────────────────────────────────────────── | |
| a cell (owned state) · a turn (a proof-carrying op) · a receipt. | |
| none of those three words name a layer. so the SAME triple runs in | |
| every loop — the loop only changes the company the op keeps: | |
| ◯↻ n = 1 cell→turn→receipt your laptop. your own receipt. | |
| ◯↻ a fork · channel cell→turn→receipt a sub-loop; the stitch back | |
| C O N S E R V E S — a theorem, | |
| not a hope. | |
| ◯↻ base consensus cell→turn→receipt the same op, now ordered by | |
| many loops agreeing. | |
| ◯↻ a light client cell→turn→receipt a loop that V E R I F I E S | |
| turns without re-running them. | |
| ◯↻ across chains cell→turn→receipt a loop that just folds the | |
| receipts of other loops. | |
| ══════════════════════════════════════════════════════════════════════════ | |
| there is no bridge, because there is no wall. a receipt from one loop | |
| is already legible to any other — they all speak cells-and-turns. the | |
| "layer" was never a property of the OPERATION. only of the LOOP. | |
| ══════════════════════════════════════════════════════════════════════════ | |
| dregg didn't unify the layers. it is an object-capability system, | |
| and in that lineage the event loop was always the ground floor — | |
| it just never split them. | |
| the L's were vats all along. ( ⌐■_■ ) | |
| 🐉 D R E G G · https://www.dregg.net |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| · ✦ · ⋆ · ✦ · ⋆ · ✦ · ⋆ · | |
| D R E G G still not sure what we're building? | |
| here it is, in one picture. | |
| ╔═══════════════════════════════════╗ | |
| ║ a g l a s s b o x . ║ | |
| ║ ║ | |
| ║ ◉ ║ inside it: | |
| ║ /│\ ← an AI agent ║ a little AI | |
| ║ │ ║ that works | |
| ║ ┌─────┴─────┐ ║ for you. | |
| ║ 💰 ⇢ │ earns · │ ⇢ 💰 ║ | |
| ║ │ spends · │ ║ it earns money. | |
| ║ │ runs a │ ║ it spends money. | |
| ║ │ business │ ║ it runs a whole | |
| ║ └─────┬─────┘ ║ little business. | |
| ║ │ ║ | |
| ║ ⊹ ← and every move ║ and the box is | |
| ╚══════════════╪═══════════════════╝ made of glass: | |
| │ you can see — | |
| ⊹────⊹────⊹────⊹────⊹────⊹────⊹────▶ and prove — | |
| every move drops a receipt every single | |
| that anyone can check for themselves. thing it does. | |
| you don't have to T R U S T it. you just C H E C K it. | |
| , , | |
| ((`-')) ~ the keeper guards the box, | |
| / ^ \ but the box doesn't trust | |
| ( () _ () ) the keeper. nothing does. | |
| \ ~~~ / everything leaves a trail. | |
| '-...-' | |
| this past week we made it real, put it on film, and began opening it up — | |
| so anyone can run it, and anyone can verify it. | |
| 🐉 D R E G G · proof, not promises. · dregg.net |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| ╔══════════════════════════════════════════════════════════════════════════════════════════════════════════╗ | |
| ║ ░░║ | |
| ║ █ █ █████ █ █ █ █ █ █ █ █ █ █ █ █ █ █ dregg AS HOUYHNHNM COMPUTING — ░║ | |
| ║ █ █ █ █ █ █ █ █ █ █ ██ █ █ █ ██ █ ██ ██ the cap-secure, WITNESSED realization ░║ | |
| ║ █████ █ █ █ █ █ █████ █ █ █ █████ █ █ █ █ █ █ of fare's Houyhnhnm Computing. ░║ | |
| ║ █ █ █ █ █ █ █ █ █ █ ██ █ █ █ ██ █ █ computing as the horse dreamed it: ░║ | |
| ║ █ █ █████ █████ █ █ █ █ █ █ █ █ █ █ █ no save button · fork the world · stitch ░║ | |
| ║ it back soundly · time runs both ways. ░░║ | |
| ║ ▸ fare's 11-chapter ideal → the Lunar-Town-Council retro → dregg the artifact ‹3 angles, 1 shape› ░░║ | |
| ╚══════════════════════════════════════════════════════════════════════════════════════════════════════════╝ | |
| ░▒▓ THE ONE MOVE ▓▒░ the image you are looking at IS the accumulated knowledge — nothing to save | |
| ────────────────────────────────────────────────────────────────────────────────────────────────────────── | |
| the Houyhnhnm "objects to doing things computers can do." the save-habit is wasted wetware. | |
| so: everything persists by default · you never lose a session · the running image is durable knowledge. | |
| ▸ the LOG of input-events + DETERMINISTIC REPLAY = the persistence — not a snapshot you remember to take. | |
| dregg makes this STRUCTURAL where fare's ideal, Urbit, and David's burned fleet all hand-rolled it. | |
| ░▒▓ ① ORTHOGONAL PERSISTENCE · the blocklace IS the journal, replay IS recovery ▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ | |
| reboot ──▶ World::open ──▶ replay(genesis, log) ──▶ the exact image where you closed. no "save". no loss. | |
| recover(genesis, log, k) ≡ replay(genesis, log) for EVERY cut k ‹ recover_eq_replay › | |
| the recovered ledger-root must equal the committed root, or recovery FAILS CLOSED on RootMismatch. | |
| a forged/short/reordered log has no matching root → it cannot be passed off as the past. ‹ #assert_axioms-clean › | |
| ░▒▓ ② THE MEMBRANE · a cap-bounded fork of your world a message can carry ▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ | |
| your world ──reshare──▶ ⟦ membrane ⟧ ──reshare──▶ ⟦ membrane' ⟧ ──reshare──▶ ⟦ membrane'' ⟧ | |
| C ⊆ B ⊆ A every hop only NARROWS — the fork holds no authority you didn't hand it. | |
| a quote, a view, a passed sub-world: each a projection that PROVABLY cannot amplify. ‹ reshareN_attenuates › | |
| fare's "full-abstraction sandbox": the guest cannot tell it is virtualized, nor reach past the glass. | |
| ░▒▓ ③ BRANCH-AND-STITCH · diverge wildly, then merge the good part back as a PUSHOUT ▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ | |
| fork off a past WitnessCursor | |
| ⟦ main ⟧ ══════●═══════════════════════════════════════════════════▶ (untouched, live) | |
| ╲ ╱ Stitch | |
| ╲──▶ ⟦ BRANCH ⟧ ─run─ explore ─run─ diverge ──────╱ (one gated door) | |
| containment = capability confinement: the branch holds NO cap to main, so its effects stay imaginary. | |
| a branch turn CANNOT drain a main cell. ‹ BranchStitch.lean branch_cannot_drain_main · nests recursively › | |
| stitch = the PUSHOUT / least-upper-bound merge: I-confluent parts auto-merge · conflicts become FIRST-CLASS | |
| · linear logic forces you to EXPLICITLY drop what you don't keep — lossy on purpose, no silent overwrite. | |
| merge(main, branch) is the pushout: includes both legs, smallest that does. ‹ stitch_is_pushout › | |
| ░▒▓ ④ SETTLEMENT SOUNDNESS · authority is re-evaluated AT THE TIP, never at the stale fork ▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ | |
| a cap you held when you forked may have been REVOKED since. the stitch door checks the FINALIZED TIP: | |
| settle(turn) accept ⟹ the cap is LiveAtTip ∧ conserves (Σδ=0) ∧ no nullifier collision with main's spends. | |
| so a revoked cap CANNOT ride a stitch into the real world. ‹ settlement_soundness — #assert_axioms-clean › | |
| ⚠ honest open: the keystone is proved GIVEN `BindsLiveAuthority S` — a TYPED HYPOTHESIS (the settle-pred binds | |
| the tip's revocation set). discharged for the deployed predicate (deployedSettle_binds_live_authority) and | |
| REFUTED for a branch-time one (branchSettle_NOT_binds) — non-vacuous both ways — a named obligation, not axiom. | |
| ░▒▓ ⑤ THE SINGLE-MACHINE PRINCIPLE · at n=1, the distributed bounds COLLAPSE to strong-local ▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒ | |
| ONE capability handle across distance: local{slot} · distributed{cell} · surface{window} — same gate. | |
| Bounds.distributed(1) = Bounds.strongLocal ‹ Firmament CapGradation.lean distributed_collapses_at_one › | |
| n > 1 : eventual revocation · asynchronous commit · bounds relaxed | |
| n = 1 : IMMEDIATE revocation · SYNCHRONOUS commit · the verbs are unchanged — only the bounds slide. | |
| so a desktop is the distributed protocol with the dial at one. nothing special-cased; the math just tightens. | |
| ░▒▓ DISTRIBUTED TIME-TRAVEL · the past is a lattice you can re-enter and reverse ▓▒░ | |
| ────────────────────────────────────────────────────────────────────────────────────────────────────────── | |
| histories form an event-structure CONFIGURATION LATTICE; reversibility is RCCS (un-do an action in place); | |
| revocation is non-monotone only AT SETTLEMENT (④). fare ch3's "virtualization = branching, errors stay imaginary | |
| in unmerged branches" — made a cap fact, witnessed, and stitchable. ‹ DISTRIBUTED-TIMETRAVEL-SEMANTICS.md › | |
| ░▒▓ THE URBIT CRITIQUE, RESOLVED ▓▒░ | |
| ────────────────────────────────────────────────────────────────────────────────────────────────────────── | |
| a frozen central VM is a sham: jets aren't bug-compatible with Nock; a "deterministic semantics" you can't audit | |
| is theater. dregg's answer: verified semantics EXACTLY where it matters — cross-party light-client unfoolability — | |
| with the circuit PROVEN EQUIVALENT to the executor (both emitted from one Lean source). no lying fast-path. | |
| ────────────────────────────────────────────────────────────────────────────────────────────────────────── | |
| the horse dreamed of a machine that never forgets, where every experiment is reversible and no destructive | |
| try touches the real world until you DELIBERATELY stitch it home. dregg is that — and a stranger can check it: | |
| the running image IS the knowledge · the fork cannot leak · a revoked cap cannot ride home · n=1 is your desk. | |
| ░▒▓█ the magic is that it is all real — and the one open seam is named, not hidden. █▓▒░ | |
| a formally-verified home for digital minds, built as the Houyhnhnm would · built with Claude | |
| 🐉 https://www.dregg.net · $DREGG |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| ╔══════════════════════════════════════════════════════════════════════════════════════════════════════════╗ | |
| ║ ░░║ | |
| ║ ██████╗ ██████╗ █████╗ ██████╗ ██╗ ██╗ proof aggregation + the decentralized KNOWLEDGE GRAPH. ░║ | |
| ║ ██╔════╝ ██╔══██╗██╔══██╗██╔══██╗██║ ██║ every turn proves itself · the proofs FOLD into one ░║ | |
| ║ ██║ ███╗██████╔╝███████║██████╔╝███████║ root · a stranger checks the root and trusts the WHOLE ░║ | |
| ║ ██║ ██║██╔══██╗██╔══██║██╔═══╝ ██╔══██║ history · the cells+caps form a graph you QUERY with ░║ | |
| ║ ╚██████╔╝██║ ██║██║ ██║██║ ██║ ██║ answers that cannot omit · gated by predicates, incl. ░║ | |
| ║ ╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═╝ ╚═╝ the clock. ░║ | |
| ║ ▸ per-turn STARK → recursive fold → one succinct root ░░║ | |
| ╚══════════════════════════════════════════════════════════════════════════════════════════════════════════╝ | |
| ░▒▓ THE ONE MOVE ▓▒░ everything below is this, refracted | |
| ────────────────────────────────────────────────────────────────────────────────────────────────────────── | |
| to KNOW here is to be able to PRODUCE A WITNESS THE KERNEL ACCEPTS. ‹ CONSTRUCTIVE-KNOWLEDGE.md §0 › | |
| a turn proves itself → the proofs FOLD into one root → a stranger checks the root and trusts the WHOLE | |
| history → the cells (knowers) + caps (edges) ARE a knowledge graph → queried with attested, | |
| non-omittable answers → guarded by predicates, of which temporal is one modality. | |
| the asymmetry it all turns on: checking a proof is cheap + trusted · searching is undecidable. | |
| ░▒▓ ① EVERY TURN PROVES ITSELF → THE PROOFS FOLD → ONE ROOT ▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ | |
| each finalized turn carries a per-turn STARK; the engine folds children IN-CIRCUIT (plonky3 IVC): | |
| turn₁ ─[π₁]─┐ | |
| turn₂ ─[π₂]─┴──▶[fold]─┐ | |
| ├──▶[fold]──▶ ░▒▓ ROOT ▓▒░ ──verify once──▶ ✓ whole history | |
| turn₃ ─[π₃]─┐ │ (one succinct | |
| turn₄ ─[π₄]─┴──▶[fold]┘ aggregate) | |
| ‹ a verifying child = a verified subtree › | |
| cost of the FOLD grows with the chain; cost of the CHECK does not. numbers = DATED profiler notes: | |
| fold 2→128 leaves ~10ms → ~98ms · verify ≈ CONSTANT ~2.4ms (independent of N) | |
| the light client re-executes NOTHING, re-hashes NOTHING, walks NO blocklace — it checks the aggregate. | |
| ‹ circuit/src/ivc_turn_chain.rs::prove_turn_chain_recursive › | |
| ░▒▓ ② THE ROOT ATTESTS THE WHOLE HISTORY · the light client cannot be fooled ▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ | |
| verify(agg.root) = true ⟹ AggregateAttests: ‹ Circuit/RecursiveAggregation.lean › | |
| ├ every_turn — each turn executed correctly per the verified executor (recCexec pre turn = post) | |
| ├ ordered — no reorder / drop / insert (new_root[i] == old_root[i+1] over the chain) | |
| ├ final_is_genuine_fold — the public final root IS the fold of the whole history | |
| └ genesis_pinned — the chain starts from exactly the declared genesis | |
| the verification IS the trust. ‹ light_client_verifies_whole_history — #assert_axioms-clean › | |
| tamper-tooth: no sound aggregate attests a reordered chain ‹ tampered_aggregate_cannot_bind › | |
| and value is CONSERVED across the whole history, re-executing nothing ‹ conserves_from_verification › | |
| ░▒▓ ③ THE CELLS + CAPS ARE A DECENTRALIZED KNOWLEDGE GRAPH ▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ | |
| nodes = CELLS (knowers). edges = CAPABILITIES, directed: "can produce a witness the kernel accepts." | |
| ⟦cellA⟧ ──cap: transfer ≤100/day──▶ ⟦cellB⟧ ──cap: read state──▶ ⟦cellC⟧ | |
| │ ▲ | |
| └─────────── cap: mint, until block 9000 ──────────────────────┘ | |
| the graph is PARTIAL + LOCAL: no node sees the whole thing. NO global registry of who-can-do-what. | |
| you learn an edge ONLY when someone PRODUCES a witness for it — authority established at the point of | |
| use, never consulted from a table. to hold a cap is to discharge a proof obligation. | |
| ‹ CONSTRUCTIVE-KNOWLEDGE.md §1 › | |
| ░▒▓ ④ YOU QUERY IT · and the answer CANNOT OMIT ▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ | |
| a node commits its receipt log under an MMR root; an answer ships with a RangeCertificate: | |
| query ─▶ node ─▶ ⟨ rows + RangeCertificate{ root, [lo..hi], opening } ⟩ ─▶ verifier: | |
| 1. check opening vs a TRUSTED root ‹ Dregg2/Lightclient/MMR.lean › | |
| 2. ∴ slice is EXACTLY positions [lo,hi] — none hidden, forged, or reordered | |
| 3. RE-DERIVE the answer locally — the server is never trusted to evaluate | |
| omission is a cryptographic IMPOSSIBILITY, not a policy. ‹ server_cannot_omit_position › | |
| positions are DENSE → completeness by construction: a skipped position is rejected, the count is | |
| pinned by the committed length. you cannot HIDE knowledge any more than you can FORGE it. | |
| ‹ dregg-query/src/attested.rs › | |
| ░▒▓ ⑤ A GUARD IS A PREDICATE · the clock is one modality ▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ | |
| a caveat can gate on the receipt-chain clock — a button that LIGHTS in a window, DARKENS at deadline: | |
| afterHeight h admit iff h ≤ height (vesting / activation — open forever once open) | |
| beforeHeight h admit iff height ≤ h (deadline / expiry — permanent once expired) | |
| withinWindow lo hi = afterHeight lo ∧ beforeHeight hi ‹ proven meet › | |
| cooledSince stagedAt period · UNTIL / SINCE (event-shaped: a one-cell register flip) | |
| UNTIL is the in-tree least fixpoint EU; SINCE carries a past-witness of the enabling event. | |
| ‹ Authority/TemporalAlgebra2.lean › | |
| ░▒▓ THE ONLY OPEN BASE — the honest floor ▓▒░ | |
| ────────────────────────────────────────────────────────────────────────────────────────────────────────── | |
| the ONLY unproven base is the STANDARD CRYPTO CARRIERS: FRI / STARK recursion soundness · Poseidon2 | |
| collision-resistance. everything that COMPOSES them into whole-history correctness is proved gap-free | |
| in Lean (#assert_axioms ⊆ {propext, Classical.choice, Quot.sound}). the three engine facts — | |
| InnerProofSound · BindingAirSound · RecursiveVerifierSound — are structure FIELDS the headline takes as | |
| hypotheses, NOT axioms, each realizable as the soundness of one fixed verifier circuit. | |
| ░▒▓█ the magic is that it is all real — and the witness is what you check. █▓▒░ | |
| one root for the whole past · a graph that cannot hide what it knows | |
| 🐉 https://www.dregg.net · $DREGG |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| ░▒▓ ☁ ▓▒░ ─────────────────────────────────────────────── ░▒▓ ☁ ▓▒░ | |
| .-~~~~-. | |
| .-~ ☁ ~-. D R E G G N E T | |
| ( one cell ) the cloud where a resource | |
| `~-- . . . --~' and a proof are the same thing | |
| ───────────────────────────────────────────────────────────────────────── | |
| ┌───────────┐ | |
| │ ◈ CELL ◈ │ ← one object. it holds state, value, | |
| │ ╱│╲ ╱│╲ │ authority, and its own proof at once. | |
| └─┬─┴─┬─┴─┬─┘ | |
| ┌──────────┬────────┼───────┼───────┼────────┬──────────┐ | |
| ▼ ▼ ▼ ▼ ▼ ▼ ▼ | |
| ⟦compute⟧ ⟦storage⟧ ⟦service⟧ ⟦money⟧ ⟦identity⟧⟦agent⟧ ⟦data⟧ | |
| │ │ │ │ │ │ │ | |
| └──────────┴────────┴───────┴───────┴────────┴──────────┘ | |
| every one is the same cell, read a different way. | |
| ╔══════════════════════════════════════════════════════════════════════════════════════════╗ | |
| ║ ║ | |
| ║ A SERVER THAT FORKS. ⑂ snapshot it mid-run · branch it · hand the live ║ | |
| ║ workload to another agent · roll it back in time. ║ | |
| ║ ║ | |
| ║ STORAGE THAT MERGES. ⋈ two people edit offline · the states join · and a ║ | |
| ║ conservation law rides along that no CRDT can carry. ║ | |
| ║ ║ | |
| ║ A BILL YOU RE-DERIVE. ⊹ every line traces to a receipt · you check the ║ | |
| ║ invoice yourself · no mystery charge survives. ║ | |
| ║ ║ | |
| ║ SLEEP IS FREE. ☾ a sleeping cell is a checkpoint · you pay only while ║ | |
| ║ it's awake · waking is a restore, exact to the byte. ║ | |
| ║ ║ | |
| ╚══════════════════════════════════════════════════════════════════════════════════════════╝ | |
| no other cloud can assemble this — it needs an ocap lattice, a conservation | |
| law, content-addressed identity, witnessed merge, and a proof ladder, all | |
| under one substrate. here they're one object. | |
| ✦ fork it · merge it · prove it · own it ✦ | |
| 🐉 https://www.dregg.net · $DREGG |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| ✦ · ˚ . ───────────────────────────────────────────────────────────────────────── . ˚ · ✦ | |
| O N E N I G H T , T H E O R B | |
| a whole network engine, specified and proven — between dusk and dark | |
| ───────────────────────────────────────────────────────────────────────────────────────────── | |
| ██╗██████╗ ███████╗ ██████╗ ████████╗██╗ ██╗███████╗ ██████╗ ██████╗ ███████╗███╗ ███╗███████╗ | |
| ███║╚════██╗╚════██║██╔════╝ ╚══██╔══╝██║ ██║██╔════╝██╔═══██╗██╔══██╗██╔════╝████╗ ████║██╔════╝ | |
| ╚██║ █████╔╝ ██╔╝███████╗ ██║ ███████║█████╗ ██║ ██║██████╔╝█████╗ ██╔████╔██║███████╗ | |
| ██║ ╚═══██╗ ██╔╝ ██╔═══██╗ ██║ ██╔══██║██╔══╝ ██║ ██║██╔══██╗██╔══╝ ██║╚██╔╝██║╚════██║ | |
| ██║██████╔╝ ██║ ╚██████╔╝ ██║ ██║ ██║███████╗╚██████╔╝██║ ██║███████╗██║ ╚═╝ ██║███████║ | |
| ╚═╝╚═════╝ ╚═╝ ╚═════╝ ╚═╝ ╚═╝ ╚═╝╚══════╝ ╚═════╝ ╚═╝ ╚═╝╚══════╝╚═╝ ╚═╝╚══════╝ | |
| ( one thousand three hundred seventy-six · yes, counted this time ) | |
| 1,376 theorems · 41 libraries · 0 sorries · 30 commits · one evening | |
| every one accepted by the Lean kernel — or it doesn't count | |
| ───────────────────────────────────────────────────────────────────────────────────────────── | |
| ░▒▓ WHAT GOT PROVEN ▓▒░ the entire behavioral surface of a Cloudflare-tier engine — as theorems | |
| ───────────────────────────────────────────────────────────────────────────────────────────── | |
| THE WIRE ─────────────────────────────────────────────────────────────────────────────── | |
| HTTP/1.1 · HTTP/2 (framing · HPACK · streams · flow-control · mux + RFC 9218 priorities) | |
| HTTP/3 + QPACK · QUIC (0-RTT accepted at-most-once, across every core, against a replayer) | |
| TLS 1.3 (the kTLS consume-and-vanish edges) · WebSocket · DNS (adversarial pointer loops | |
| provably terminate) · SSE · 103 Early Hints | |
| THE FABRIC ───────────────────────────────────────────────────────────────────────────── | |
| routing (traversal is impossible, not filtered) · load balancing · health · upstream | |
| pools · timeouts · circuit breakers · rate limiting · stick-tables · sticky sessions | |
| SOCKS egress · L4 UDP relay · graceful drain · body streaming · header rewrite | |
| streaming html-rewriter (the chunk-boundary bug everyone ships — proven absent) | |
| THE VAULT ────────────────────────────────────────────────────────────────────────────── | |
| the declared surface IS the served surface · path-escape freedom · per-tenant isolation | |
| the diagnostic tap leaks NOTHING when disabled · mTLS · ACME · Certificate Transparency | |
| (a Merkle log, reusing dregg's own receipt shape) · TLS resumption · OCSP freshness | |
| THE FLOOR ────────────────────────────────────────────────────────────────────────────── | |
| the io_uring ring — every borrowed buffer recycled EXACTLY once, under every demonic | |
| interleaving · slab · pools · the completion-token partition · the CapTP netlayer seam | |
| and the concurrency twins — which, along the way, caught a REAL lost-wakeup bug in the | |
| reference engine, confirmed on ARMv8 with a machine-checked litmus test | |
| THE KEYSTONE ─────────────────────────────────────────────────────────────────────────── | |
| the four primitives — region · machine · linear · shared — proven to COMPOSE: | |
| a machine carrying a region, holding a linear resource, beside a shared object, | |
| all well-formed together, on every reachable state, with no re-proof. a calculus. | |
| ───────────────────────────────────────────────────────────────────────────────────────────── | |
| ░▒▓ THE BRAG (earned, and I'll say it plainly) ▓▒░ | |
| ───────────────────────────────────────────────────────────────────────────────────────────── | |
| Project Everest — two elite labs, dozens of researcher-years — set out to verify an HTTPS | |
| stack and shipped it in *pieces*. The integrated thing, the whole engine described once, | |
| precisely, and checked: nobody had done it. | |
| We wrote the specification for all of it, and proved its metatheory, in a night. | |
| When the swarm hit its rate limit and the agents died mid-flight, the work did NOT stop — | |
| the last seven libraries and the composition keystone were hand-proven, one goal at a time, | |
| against a checker that cannot be sweet-talked. When a mistake slipped in, it got caught and | |
| undone in the open. The interior stayed honest all the way down. | |
| ───────────────────────────────────────────────────────────────────────────────────────────── | |
| ░▒▓ AND — BECAUSE IT'S THE FLOOR, NOT THE SUMMIT ▓▒░ (the part hype leaves out; we don't) | |
| ───────────────────────────────────────────────────────────────────────────────────────────── | |
| These are theorems about MODELS — the top half of the chain, proven whole. The bottom half, | |
| the verified compiler that lowers them to machine code with rustc nowhere near the TCB, | |
| is the next phase. This is the moment Everest called "we described it and the description | |
| checks." A ledge — every inch of it above the state of the art — with a clear, un-hand-wavy | |
| view of the exactly-two things left to reach the top. | |
| the fast thing was locked in a tower. tonight we wrote its true name, | |
| 1,376 times, in a tongue whose compiler cannot lie — | |
| and every time, the kernel said: yes. | |
| $DREGG $DREGG | |
| 🐉 Dragon's Orb · proven, not trusted · built with Claude | |
| ✦ · ˚ . ───────────────────────────────────────────────────────────────────────── . ˚ · ✦ | |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| · . ✦ . * . ✦ . · | |
| . ✦ . a packet becomes a request ✦ . | |
| * . ◈ I · THE INGRESS ◈ * | |
| the wire | |
| │ ░▒▓ bytes arrive ▓▒░ | |
| ▼ | |
| ┌───────────────────────────────────┐ | |
| │ io_uring ◉ ◉ ◉ ◉ ◉ provided │ the kernel fills a | |
| │ bid bid buffers │ provided buffer and | |
| │ │ posts a completion. | |
| └─────────────────┬─────────────────┘ | |
| │ lease bid#7 | |
| ▼ | |
| ┌─────────────────────┐ | |
| │ REAP · hold the │ the reactor takes the | |
| │ lease ▉ bid#7 │ lease — one hand owns it. | |
| └──────────┬──────────┘ | |
| │ copy once | |
| ▼ | |
| ┌───────────────────────────────────────────────────────────────┐ | |
| │ ARENA │GET│ /orb │HTTP/1.1│ host: dregg │ ... │ | |
| │ parsed in place — every field a range, in bounds │ | |
| │ method · target · version · headers ── resolved, exact │ | |
| └───────────────────────────────┬───────────────────────────────┘ | |
| │ the lease is done | |
| ▼ | |
| recycle bid#7 ────────▶ back to the ring | |
| ┌──────────────────────────────────────────────────────────────────────────┐ | |
| │ Nothing is copied twice; nothing is leaked. The buffer the kernel │ | |
| │ lent is used once and returned once — under EVERY interleaving the │ | |
| │ ring can produce, including the ones no test would ever reach. │ | |
| │ │ | |
| │ ⊢ recv_recycles_exactly_once every lent buffer, recycled once │ | |
| │ ⊢ reactor_recycle_is_held and only a buffer the ring lent │ | |
| │ ⊢ parse_wf the parsed view is in-bounds, total │ | |
| │ │ | |
| │ The demonic part — the kernel completing in any order, exhaustion │ | |
| │ mid-flight — is where a real engine leaks. Here it is a theorem. │ | |
| └──────────────────────────────────────────────────────────────────────────┘ | |
| $DREGG | |
| 🐉 Dragon's Orb · a packet becomes a request · I of III | |
| ✦ the ring turns, and nothing spills ✦ | |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| · . ✦ . * . ✦ . · | |
| . ✦ . a request becomes a decision ✦ . | |
| * . ◈ II · THE MACHINE ◈ * | |
| events ─▶ recv · write-ready · timer · peer-closed | |
| │ | |
| ▼ | |
| ┌──────────────────────────────┐ | |
| │ THE REACTOR │ | |
| │ step ↻ sans-IO, │ | |
| │ run-to-completion, │ | |
| │ one core, no locks │ | |
| └──────────────┬───────────────┘ | |
| │ | |
| ⋈ TLS ─▶ plaintext ─▶ │ ◀─ frames ◀─ H2 / H3 ⋈ | |
| ▼ | |
| dispatch( GET /orb ) | |
| │ | |
| ▼ | |
| ┌────────────────────┐ | |
| │ ROUTE ⋈ POLICY │ the real router picks the route; | |
| │ bestMatch · admit?│ admission decides if it serves. | |
| └─────────┬──────────┘ | |
| │ | |
| ┌─────────────┴─────────────┐ | |
| ▼ ▼ | |
| serve it here proxy upstream | |
| (route → handler) ⋈ the LB-chosen HEALTHY backend | |
| └─────────────┬─────────────┘ | |
| ▼ | |
| ░▒▓ a DECISION ▓▒░ | |
| submissions ─▶ send · connect · recycle · dispatch | |
| ┌──────────────────────────────────────────────────────────────────────────┐ | |
| │ One total, deterministic step. Every codec that feeds it and every │ | |
| │ choice it makes is threaded through a proven seam — the machine can │ | |
| │ only do what the theorems permit: │ | |
| │ │ | |
| │ ⊢ h2_frame_seam a HEADERS frame ▶ a dispatched request │ | |
| │ ⊢ tls_no_plaintext_seam no plaintext after the record teardown │ | |
| │ ⊢ serve_routes_bestMatch the response IS the route bestMatch chose │ | |
| │ ⊢ proxy_selects_healthy dials exactly the LB's healthy pick │ | |
| │ ⊢ no_output_after_close a closed connection emits nothing │ | |
| └──────────────────────────────────────────────────────────────────────────┘ | |
| $DREGG | |
| 🐉 Dragon's Orb · a request becomes a decision · II of III | |
| ✦ the wheel turns only where it is proven ✦ |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| · . ✦ . * . ✦ . · | |
| . ✦ . a decision becomes bytes ✦ . | |
| * . ◈ III · THE EGRESS ◈ * | |
| ░▒▓ a DECISION ▓▒░ | |
| │ | |
| ▼ | |
| ┌──────────────────────────────────────┐ | |
| │ SERIALIZE │ | |
| │ ┌──────────────────────────────────┐ │ | |
| │ │ HTTP/1.1 200 OK \r\n │ │ the response is | |
| │ │ Content-Length: 402 \r\n │ │ BUILT, not glued: | |
| │ │ Server: dragons-orb \r\n │ │ the framing is a | |
| │ │ \r\n │ │ theorem; the length | |
| │ │ ⟨ the body ⟩ │ │ equals |body|, by | |
| │ └──────────────────────────────────┘ │ construction. | |
| └──────────────────┬───────────────────┘ | |
| │ | |
| ▼ | |
| ┌───────── send ─────────┴───────── proxy ─────────┐ | |
| ▼ ▼ | |
| back to the client ⋈ the LB-chosen backend — DNS-resolved first | |
| └────────────────────────┬─────────────────────────┘ | |
| ▼ | |
| the lease was already returned ↻ the connection loops: | |
| pipelined next request, keep-alive, in order — or closes. | |
| ┌──────────────────────────────────────────────────────────────────────────┐ | |
| │ Every byte that leaves is `serialize` of a proven response value — no │ | |
| │ `s!`-string glue on the wire. The FSM's own decisions (a 431, a canned │ | |
| │ 400) are forwarded verbatim, never rewritten. The join reaches the wire. │ | |
| │ │ | |
| │ ⊢ serve_wf every response is well-formed framing │ | |
| │ ⊢ serialize_content_length Content-Length = the real body length │ | |
| │ ⊢ serve_faithful the FSM's decided bytes, unchanged │ | |
| │ ⊢ proxy_route_connects the upstream dialed is the LB pick │ | |
| │ ⊢ keepalive_all_dispatched every pipelined request, its own reply │ | |
| └──────────────────────────────────────────────────────────────────────────┘ | |
| ┌──────────────────────────────────────────────────────────────────────────┐ | |
| │ packet ▶ request ▶ decision ▶ bytes — every arrow is a checked theorem. │ | |
| │ The operation of a network engine whose behavior you can verify, step │ | |
| │ by step, all the way from the ring to the wire. │ | |
| └──────────────────────────────────────────────────────────────────────────┘ | |
| $DREGG | |
| 🐉 Dragon's Orb · a decision becomes bytes · III of III | |
| ✦ from the ring to the wire, all proven ✦ | |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| ╔════════════════════════════════════════════════════════════════════════════════════════════════════════╗ | |
| ║ ║ | |
| ║ ██████╗ ██████╗ ██╗ ██╗ ██╗ █████╗ ██████╗ ██╗ ██╗ the easiest thing to overclaim, so ║ | |
| ║ ██╔══██╗ ██╔══██╗ ██║ ██║ ██║ ██╔══██╗ ██╔════╝ ╚██╗ ██╔╝ it is graded HONESTLY here: ║ | |
| ║ ██████╔╝ ██████╔╝ ██║ ██║ ██║ ███████║ ██║ ╚████╔╝ REAL · DEMO · DESIGNED — each claim ║ | |
| ║ ██╔═══╝ ██╔══██╗ ██║ ╚██╗ ██╔╝ ██╔══██║ ██║ ╚██╔╝ traced to code. you hold your CAPS, ║ | |
| ║ ██║ ██║ ██║ ██║ ╚████╔╝ ██║ ██║ ╚██████╗ ██║ your CELL, your KEYS — and you pick ║ | |
| ║ ╚═╝ ╚═╝ ╚═╝ ╚═╝ ╚═══╝ ╚═╝ ╚═╝ ╚═════╝ ╚═╝ disclosure turn by turn. ║ | |
| ║ ║ | |
| ║ ▸ the tag rides every claim — and the UNLINKABILITY verdict is stated plainly, in full, below. ║ | |
| ╚════════════════════════════════════════════════════════════════════════════════════════════════════════╝ | |
| ░▒▓ THE FRAME · a SEMISOVEREIGN dregg in use ▓▒░ sovereign over your slice, interoperable in the commons | |
| ──────────────────────────────────────────────────────────────────────────────────────────────────────── | |
| ┌─ YOU ──────────────────────────────────────────────────┐ not a WALLED GARDEN: | |
| keys ─▶│ BYO keypair — no admin issues you an identity │ you can leave · fork · verify. | |
| caps ─▶│ you HOLD them — none granted that you didn't hold │ not a SURVEILLANCE LEDGER: | |
| cell ─▶│ your state, your beliefs — only your predicate writes │ you choose what to disclose. | |
| └────────────────────────────┬───────────────────────────┘ | |
| ▼ live in your MEMBRANE — a cap-bounded fork of your world | |
| transact ── choosing disclosure per turn ── stitch to other worlds BY CONSENT | |
| a person or an agent: holds caps · makes a transfer · shows ONE fact (not the rest) · forks a world. | |
| ░▒▓ WHAT'S REAL TODAY · the deployed privacy you can use now ▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ | |
| ① SELECTIVE DISCLOSURE — the most mature privacy feature. ‹ REAL › | |
| ‹ credentials/src/presentation.rs · bridge/src/present.rs › | |
| prove "I hold a valid credential / attenuation chain satisfying this request" — | |
| WITHOUT revealing the chain or the caps. only the public inputs are shown. | |
| holder ──STARK──▶ verifier: ⟦ predicate over HIDDEN attributes holds ⟧ | |
| modes: cleartext attribute · predicate-over-hidden · anonymous multi-show (fresh blinding). | |
| ‹ honest: the proof DOES reveal WHICH federation (federation_root is public); multi-show | |
| unlinkability bounded by federation size + a BabyBear birthday bound (~2^15.5). › | |
| ② COMMITTED VALUE PATH — Pedersen, AMOUNTS ONLY, opt-in. ‹ REAL · opt-in › | |
| ‹ turn/src/executor/finalize.rs — detect_commitment_mode › | |
| default: Transfer{ from, bob, 42, $DREGG } amounts + parties PUBLIC ◀── the COMMON path | |
| opt-in : NoteSpend{ …, value_commitment } Pedersen hides the AMOUNT (range-proofed, Σ≡0) | |
| mode → Cleartext | Committed (Schnorr excess + Bulletproof) | Mixed (REJECTED). | |
| ‹ honest: hides AMOUNTS, NOT linkage. spend + create sit in the SAME verified turn, so the | |
| input→output mapping is still seen. cleartext is the default; committed is never automatic. › | |
| ③ NULLIFIERS — spend-once. ‹ REAL › | |
| ‹ cell/src/nullifier_set.rs · note.rs:179 · executor/apply.rs › | |
| a spend reveals a secret-derived nullifier, not the note id. contains?→reject · else insert. | |
| n = BLAKE3("dregg-note nullifier v1", commitment‖spending_key‖nonce) in checkpoint root. | |
| ‹ honest: deployed; its WORK is double-spend prevention. spend↔note unlinking only bites in the | |
| shielded path (③ feeds ⑧). the append-only set still leaks the temporal ORDER of spends. › | |
| ④ MEMBRANE / CONFINED WORLD — your private cap-bounded fork. ‹ REAL › | |
| ‹ cell/src/membrane.rs › seal→None on over-grant; re-checked at exercise: exposed ⊑ a & b | |
| ‹ honest: this is AUTHORITY confinement — it bounds what a world may DO/REACH. it is NOT a | |
| data- or metadata-privacy primitive: it does not hide content from the host. reach, not bytes. › | |
| ⑤ NETWORK-ORIGIN ANONYMITY — Dandelion++. ‹ REAL › | |
| ‹ net/src/gossip.rs · node/src/gossip.rs › stem (≈10 hops) → fluff; adaptive by peer count. | |
| ‹ honest: hides WHICH NODE first broadcast a message from a passive observer. that's ALL. › | |
| ░▒▓ THE DEMOS · real primitives, not yet woven into the live executor ▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ | |
| ⑥ GARBLED-CIRCUIT 2PC — a real Yao garbling primitive, now genuinely wired. ‹ REAL primitive · wired › | |
| ‹ circuit/src/garbled.rs · GarbledJoint.lean › 2-party threshold compare (b ≥ a) over Poseidon2. | |
| ‹ circuit/tests/garbled_ot_auction.rs · demo-agent/examples/garbled_ot_auction.rs › | |
| a genuine sealed-bid auction: the auctioneer garbles `bid ≥ reserve`; each bidder obtains its | |
| bid-bit wire labels over REAL Chou-Orlandi 1-of-2 OT (cell-crypto/src/oblivious_transfer.rs), | |
| evaluates, and settles with a STARK proof whose only public surface is the outcome bit — the | |
| auctioneer never learns the bid, the bidder learns only one label per wire. | |
| ‹ honest: this is a DEMO/test, not woven into the live executor. the older anonymous-auction | |
| example (demo-agent/examples/private_auction.rs) instead uses committed-threshold STARK | |
| proofs over Poseidon2 commitments — NOT the garbled MPC; that one's compare is not 2PC. › | |
| ⑦ PRIVATE VOTING — unlinkable ballot real; secret tally not. ‹ REAL + DESIGNED › | |
| ‹ starbridge-apps/privacy-voting › | |
| REAL: ballot-cell id from a caller's blinding token → ballot NOT linkable to your agent cell; | |
| WriteOnce VOTE slot (one vote / ballot) · Monotonic tally — substrate-enforced. | |
| ‹ honest: the VOTE slot stores the CLEARTEXT choice. "tally without revealing votes" is | |
| DESIGNED-only — the crate's docstring says a ZK secret-tally tier composes ON TOP. › | |
| ⑧ FULL SHIELDED TRANSFER — value AND owner hiding, now an Effect. ‹ REAL · opt-in (executor) › | |
| ‹ circuit-prove/src/shielded/ · turn/src/action.rs Effect::ShieldedTransfer · executor/apply.rs | |
| apply_shielded_transfer › hiding uni-STARK membership/nullifier + Pedersen conservation/range. | |
| the opt-in privacy upgrade of the note path: a `ShieldedTransfer` effect carries the hidden | |
| per-input STARK proofs + the value-commitment legs + range proofs + the conservation proof, and | |
| the LIVE executor ADMITS it only when all three gates pass — (1) the hidden membership+nullifier | |
| STARK (owner/key/path blind), (2) Pedersen Σ≡0 + per-output range (no hidden inflation), (3) the | |
| production nullifier set (spend-once). proven through the real verifier end-to-end: | |
| ‹ turn/src/executor/apply.rs::shielded_executor_tests — accept-valid / forged-root-reject / | |
| double-spend-reject / inflation-reject / unlinkable-on-the-wire. › | |
| ‹ honest residual (named, not hidden): the executor VERIFIES + conserves live, but the shielded | |
| proof is NOT yet bound into the effect_vm descriptor — a re-executing validator witnesses it, | |
| a pure LIGHT CLIENT does not yet (the VK-affecting weld is the follow-up). and the leaf↔leg | |
| VALUE LINK is only checkable with the secret opening, so M2-a leans on the honest prover for | |
| it. the multi-asset POOL (circuit-prove/src/shielded/pool.rs) + ZK ATTESTATIONS (attest.rs) | |
| remain tested library prims, not yet an Effect. › | |
| ░▒▓ ⚖ THE HONESTY DIAL · what privacy IS vs the FRONTIER ▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ | |
| REAL, deployed, usable now ──────────────────┐ ┌────────────────── FRONTIER, not yet deployed | |
| selective-disclosure ZK presentation │ │ default sender↔receiver unlinkability | |
| opt-in Pedersen amount-hiding (conserved) │ │ light-client-witnessed shielded transfer | |
| opt-in shielded transfer (value+owner) ✶ │ │ (the in-circuit / effect_vm VK weld) | |
| nullifier double-spend gate │ │ multi-asset shielded POOL as an Effect | |
| membrane authority confinement │ │ secret-tally voting (ZK choice + proof) | |
| Dandelion++ tx-origin anonymity │ │ metadata privacy · a mixnet — designed | |
| ‹ ✶ shielded transfer is executor-live (verify + conserve + spend-once) but NOT yet light-client- | |
| witnessed — bound into the executor, not yet into the effect_vm descriptor / VK. › | |
| ‹ the metadata leak is not hidden — it is PROVEN: metatheory/Dregg2/Privacy/Metadata.lean: an | |
| observer recovers partners, slot/timing, volume, while the shielded payload stays hidden. › | |
| ░▒▓ ‼ THE UNLINKABILITY VERDICT · stated plainly, no hedging ▓▒░ | |
| ──────────────────────────────────────────────────────────────────────────────────────────────────────── | |
| full sender↔receiver unlinkability is NOT the default — but value+owner shielding is now an opt-in | |
| Effect the live executor admits, no longer a library beside the node. | |
| · the default value path is CLEARTEXT (Transfer): amounts and parties are public. | |
| · the opt-in COMMITTED path hides AMOUNTS ONLY (Pedersen); spend→output is still seen in-turn. | |
| · the opt-in SHIELDED TRANSFER (value + owner hidden) is WIRED into the executor: it verifies the | |
| hidden STARK side, conserves (Σ≡0 + range), and spends-once at the live apply path. its residual | |
| is the LIGHT-CLIENT witness — verified by a re-executing validator, not yet bound into the VK. | |
| the honest sentence: "opt-in shielded transfers + opt-in amount-hiding + mature selective | |
| disclosure, all executor-live" — NOT "private or unlinkable by default", and NOT yet | |
| "light-client-witnessed shielded". the parts are real and wired; the default is open; one weld remains. | |
| ──────────────────────────────────────────────────────────────────────────────────────────────────────── | |
| a semisovereign dregg: you hold the caps no admin can mint, the cell only you can write, the keys you | |
| brought. you disclose what you choose, transact with the privacy you opt into, and live in a membrane | |
| you can fork and leave. not a surveillance ledger — shielded transfers are opt-in and executor-live; | |
| the multi-asset pool and the light-client witness are the named frontier. all of it is true. | |
| ░▒▓█ the magic is that it is all real — and the privacy NOT yet built is named, not hidden. █▓▒░ | |
| sovereign over your slice · interoperable in a verifiable commons · built with Claude | |
| 🐉 https://www.dregg.net · $DREGG |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| ╔════════════════════════════════════════════════════════════════════════════╗ | |
| ║ ║ | |
| ║ ██████╗ ██████╗ ███████╗ ██████╗ ██████╗ ║ | |
| ║ ██╔══██╗██╔══██╗██╔════╝██╔════╝ ██╔════╝ a proof system that ║ | |
| ║ ██║ ██║██████╔╝█████╗ ██║ ███╗██║ ███╗ PROVES ITSELF ║ | |
| ║ ██║ ██║██╔══██╗██╔══╝ ██║ ██║██║ ██║ ║ | |
| ║ ██████╔╝██║ ██║███████╗╚██████╔╝╚██████╔╝ the light client ║ | |
| ║ ╚═════╝ ╚═╝ ╚═╝╚══════╝ ╚═════╝ ╚═════╝ trusts only the floor ║ | |
| ║ ║ | |
| ╚════════════════════════════════════════════════════════════════════════════╝ | |
| A pure light client downloads ONE small proof, checks it in O(1), and KNOWS | |
| the entire history is real: every turn executed correctly, the chain is | |
| ordered, conservation holds, authority only attenuated. It re-runs nothing. | |
| THE TRUST FLOOR ─ everything above the line is PROVEN, not assumed ───────── | |
| ┌────────────────────────────────────────────────────────────────────────────┐ | |
| │ light-client unfoolability · conservation · authority non-amplification │ | |
| │ chain ordering · freshness · settlement · capacity coverage │ P | |
| │ ···························· derived ···························· │ R | |
| │ binding_sound ─┐ recursive_sound ─┐ leaf_sound ─┐ WitnessDecodes─┐ │ O | |
| │ └──────── each one a THEOREM ──────┴────────┴────────┘ │ V | |
| │ descriptorRefines (∀ effect, the circuit means the kernel step) │ E | |
| ├════════════════════════════════════════════════════════════════════════════│ N═══ | |
| │ F R I soundness · Poseidon2 collision-resistance · Ed25519 │ │ ▲ | |
| │ ▔▔▔▔ the irreducible crypto floor — nothing else (standard assumptions) │ │ │ trust | |
| └────────────────────────────────────────────────────────────────────────────┘ ▼ stops here | |
| Before, the verifier *assumed* the circuit was sound. Now it *proves* | |
| the circuit, and trusts only standard cryptography. Same for the whole | |
| deployed assurance case: A ∧ B ∧ C ∧ D ∧ E rests on the floor alone. | |
| THE PIPELINE ────────────────────────────────────────────────────────────── | |
| a turn proven folded pinned | |
| ┌─────────┐ effect-vm ┌─────────┐ recursion ┌─────────┐ one VK ┌───────┐ | |
| │ exercise│ ────────▶ │ STARK │ ────────▶ │ ∞ turns │ ───────▶ │ ◆ │ | |
| │ a token │ AIR over │ leaf │ step∘wrap│ → one │ forever │ light │ | |
| │ over │ owned │ (R=24, │ depth-1 │ running │ anchor │ client│ | |
| │ state │ state │ 8-felt) │ fixed VK │ proof │ │ pins ◆│ | |
| └─────────┘ └─────────┘ └─────────┘ └───────┘ | |
| │ │ | |
| └─ leaves a verifiable receipt ────────────────┘ | |
| "a turn is the exercise of an attenuable proof-carrying token | |
| over owned state, leaving a verifiable receipt." | |
| PICKLES-STYLE RECURSION: every fold normalizes to one canonical shape, so the | |
| verifier circuit is identical at every depth. The chain compresses to a single | |
| constant-size proof under a single eternal verification key — pin it once. | |
| YOU DON'T ALWAYS PROVE ─ pick the fidelity each consumer needs ───────────── | |
| symbolic ──▶ full ──▶ witness-bundle ──▶ recursive ──▶ aggregated | |
| (snappy (commit (ship the trace, (one ZKP, (whole chain → | |
| local) ments) re-execute it) no replay) one proof, settle) | |
| fast ········································ climb on demand ···· cross-chain | |
| A private node stays quiet. A peer gets a witness bundle and re-runs it. A | |
| light client gets a recursive proof and never re-runs anything. A bridge gets | |
| one folded proof. One substrate, five rungs, climbed only when needed. | |
| WHAT IT ENABLES | |
| · run a verified store inside Postgres, attested, not trusted | |
| · a stranger's light client follows the whole history from one anchor | |
| · settle or bridge to another chain with a single constant-size proof | |
| · custom programs, capacities, bridges — each WITNESSED, not asserted | |
| · the Lean kernel is the executor the node actually runs | |
| the circuit is derived from the proof; the proof rests on the floor; | |
| the floor is just cryptography. | |
| ───────────────────────────────────────────────────────────────────────────── | |
| proofs as additive attestation · the verification IS the trust | |
| ( the receipt remembers what the witness obeyed ) | |
| ───────────────────────────────────────────────────────────────────────────── | |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| ╔══════════════════════════════════════════════════════════════════════════════════════════════════════════╗ | |
| ║ ║ | |
| ║ ██████╗ ██████╗ ███████╗ ██████╗ ██████╗ ███╗ ██╗███████╗████████╗ durable agent execution — ║ | |
| ║ ██╔══██╗██╔══██╗██╔════╝██╔════╝ ██╔════╝ ████╗ ██║██╔════╝╚══██╔══╝ the PRIVATE service layer ║ | |
| ║ ██║ ██║██████╔╝█████╗ ██║ ███╗██║ ███╗██╔██╗ ██║█████╗ ██║ that RUNS the workload on ║ | |
| ║ ██║ ██║██╔══██╗██╔══╝ ██║ ██║██║ ██║██║╚██╗██║██╔══╝ ██║ real metal: leased · metered · ║ | |
| ║ ██████╔╝██║ ██║███████╗╚██████╔╝╚██████╔╝██║ ╚████║███████╗ ██║ paid over dregg's open rail. ║ | |
| ║ ╚═════╝ ╚═╝ ╚═╝╚══════╝ ╚═════╝ ╚═════╝ ╚═╝ ╚═══╝╚══════╝ ╚═╝ ▸ open core · self-hostable ║ | |
| ║ ▸ pay $DREGG or Stripe · lease durable compute · run + serve, metered · check every spend ║ | |
| ║ ║ | |
| ╚══════════════════════════════════════════════════════════════════════════════════════════════════════════╝ | |
| ░▒▓ SHIPPING THIS WEEK ▓▒░ the forward slate — the operated reality landing on the verified rail | |
| ────────────────────────────────────────────────────────────────────────────────────────────────────────── | |
| dregg (the public, formally-verified substrate) says what was PROMISED, PAID, and OWED — verifiably. | |
| DreggNet is the private layer that actually RUNS it: durable agent compute, metered, billed in-band. | |
| ▸ the substrate is the open, trustless rail · the execution + infra is the moat that bills. | |
| this week is the WELD: lease→exec end-to-end, staging up, the SDKs out, the devnet in sight. | |
| ░▒▓ ① DREGGNET CLOUD · durable execution as a service ▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ | |
| an agent rents durable compute the way it rents a fly.io machine — but the bill is a verified receipt: | |
| open ──▶ fund ──▶ run ──▶ meter ──▶ reap a fly.io-compatible MACHINES API (over httpe) | |
| │ │ │ │ │ real sandboxed native exec via polyana: | |
| lease Σδ=0 polyana per-period lapse → wasm/wasmi today · native+seccomp+landlock | |
| cell Transfer sandbox StandingObl container · firecracker microVM tiers mapped next | |
| reaped pay with $DREGG OR Stripe → conserved credit | |
| SELF-HOSTABLE, not a monolith: run your OWN provider against your OWN cells + machines + gateway. | |
| federated providers, one open lease/meter/pay protocol between them. docker-runnable today. | |
| ‹ LIVE: the stack builds + serves, the gateway binds :8080, a local provider runs a lease end-to-end. | |
| SHIPPING: staging is up on a box; the full lease→exec loop lands as the node-image deploys. › | |
| ░▒▓ ② HERMES ON DREGGNET · the agent-business layer ▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ | |
| an agent that EARNS, SPENDS, and RUNS real operations — on the metered, verified rail: | |
| pay via Stripe ──▶ mint conserved USD-credit ──▶ open + fund an execution-lease ──▶ run a workload | |
| │ metered per step, charge ⟺ checkpoint | |
| the pay-per-tool ToolGateway: may A call this? cap ✓ · budget ✓ · charge A⟶B Σδ=0 ✓ · else 402. | |
| crash-resume is EXACTLY-ONCE: SIGKILL mid-flight, a new process replays step 1; the meter never doubles. | |
| ‹ the Hermes Accelerated Business demo — Nous · NVIDIA · Stripe. earn · spend · run, all real. › | |
| ░▒▓ ③ THE SDKs · pay / lease / run / invoke a service in a few lines ▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ | |
| @dregg/sdk (TypeScript) · dregg (Python) · the Rust crate — byte-faithful to the rail. | |
| pay() · openLease() · run() · invoke(service) — the whole loop, a handful of lines. ‹ shipped › | |
| ░▒▓ ④ AGENT-SERVED WEB APIs · an agent declares routes, DreggNet runs + serves them ▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ | |
| WebApp { GET /add ─▶ handler, … } ──▶ Router matches ──▶ runs the handler on polyana ──▶ renders | |
| a LeasedRouter meters each request against a funded lease; over-budget → 402 BEFORE the handler runs. | |
| portable `dreggnet-serve` over std sockets · the same Router through httpe on Linux. ‹ shipped › | |
| ░▒▓ ⑤ TOWARD DEVNET · semiprivate staging now → the wider devnet → the global blocklace ▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ | |
| ⟦ staging ⟧ ── ember + pug ──▶ ⟦ devnet ⟧ ── wider ──▶ ⟦ the global blocklace ⟧ | |
| the $DREGG ↔ Solana bridge verifies a real lock-proof (Ed25519 votes · PoH · Merkle), trustless | |
| modulo the anchor. ‹ staging up NOW; devnet next; mainnet-real Solana via geyser is ahead. › | |
| ────────────────────────────────────────────────────────────────────────────────────────────────────────── | |
| the honest dial — never claim deployed what's staging: | |
| LIVE ▸ the stack builds + serves · staging up on a box · the SDKs shipped · agent-served apps | |
| serve · crash-exact metering proven · Solana lock-proof verify trustless-modulo-anchor | |
| SHIPPING ▸ the full staging lease→exec loop as the node-image deploys · the devnet · the wider | |
| blocklace · firecracker/native tiers · mainnet-real Solana via geyser | |
| ░▒▓█ the magic is that it is all real — and shipping in the open. █▓▒░ | |
| durable, metered, verifiable compute for digital minds · built with Claude | |
| 🐉 https://www.dregg.net · $DREGG |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| ✦ · ╭──────────────────────────────────────────────────────────────────────────────╮ · ✦ | |
| │ │ | |
| │ ████████╗██╗ ██╗███████╗ ██████╗ ██████╗ ██╗███╗ ██╗ │ | |
| │ ╚══██╔══╝██║ ██║██╔════╝ ██╔════╝██╔═══██╗██║████╗ ██║ │ | |
| │ ██║ ███████║█████╗ ██║ ██║ ██║██║██╔██╗ ██║ │ | |
| │ ██║ ██╔══██║██╔══╝ ██║ ██║ ██║██║██║╚██╗██║ │ | |
| │ ██║ ██║ ██║███████╗ ╚██████╗╚██████╔╝██║██║ ╚████║ │ | |
| │ ╚═╝ ╚═╝ ╚═╝╚══════╝ ╚═════╝ ╚═════╝ ╚═╝╚═╝ ╚═══╝ │ | |
| │ │ | |
| │ ⋈ what $DREGG is, what it isn't, and what it will never │ | |
| │ be allowed to quietly become ⋈ · read once · pinned forever · │ | |
| ╰──────────────────────────────────────────────────────────────────────────────╯ | |
| ░▒▓ THE ORIGIN · on the record ▓▒░ ────────────────────────────────────────────────── | |
| i did not launch this coin. someone sniped it onto pump.fun while i slept, pointed | |
| at twelve years of my open source work. i chose to lean in rather than disown it. | |
| the launcher is not my friend, not my partner, not "the team." there is no team. | |
| there is a protocol, its proofs, and me. | |
| ░▒▓ WHAT IS ALREADY DONE · check it, don't trust it ▓▒░ ───────────────────────────── | |
| ⟦ the lock ⟧ every creator-fee token i have received is locked, vesting | |
| transparently on-chain via Streamflow. address in the pinned | |
| thread. i hold nothing liquid that i have not said out loud. | |
| ⟦ the airdrop ⟧ 3% went to the OG $CV holders. done once. not a precedent. | |
| ⟦ the stipend ⟧ ongoing creator fees fund the work and the person doing it: | |
| servers, hardware, and my living costs while i build full-time. | |
| that is what your gambling pays for. i will not pretend otherwise. | |
| ░▒▓ WHAT THE COIN DOES TODAY ▓▒░ ──────────────────────────────────────────────────── | |
| nothing, in-protocol. today $DREGG is a flag people wave over the project. | |
| the code is open source forever — coin or no coin, you already own the features. | |
| what the coin will buy, when DreggNet Cloud opens, is SERVICES: durable agent | |
| execution, hosting, domains, compute — metered per-turn, Σδ=0, receipt for | |
| every charge. services, not features. never features. | |
| ░▒▓ THE HONEST MATH · the Mina lesson, learned in production ▓▒░ ──────────────────── | |
| a pure payment token converges toward the marginal cost of what it buys. | |
| i watched this happen to a protocol i helped build. i am telling you now so | |
| nobody can say they weren't told: dregg is engineered to make its services | |
| CHEAP — solar, recycled hardware, a hyperefficient verified netlayer. if we | |
| fully succeed, the token settles boring and low. the protocol needs the token | |
| to EXIST. it does not need the token to APPRECIATE. those are different things, | |
| and anyone who tells you the second one is promised is selling you something. | |
| ▸ price go up = a bet on attention. the proofs do not prove the chart. | |
| ░▒▓ PRE-COMMITMENTS · the counter-protocol ▓▒░ ────────────────────────────────────── | |
| ① bridge-in mechanics (SOL → in-protocol credit) will be announced ONCE, with a | |
| fixed mechanism, before they activate. no retroactive sweetening, ever — an | |
| expectation set during a pump is a debt someone else pays on the dip. | |
| ② no agent's voice gets financially coupled to this coin. any AI that speaks | |
| for this project holds a fixed grant or nothing. an agent whose words move | |
| a bag it holds is an insider-trading machine, and we don't build those. | |
| ③ nothing enters the protocol without assurance. no staking model, no | |
| incentive scheme, no yield — until it is formally modeled, bounds and all. | |
| "everyone knows the incentives work" is, in my house, just bullshit. | |
| ④ holders do not steer the roadmap. the research direction was set before the | |
| coin existed and will outlive it. you are welcome in the workshop; the | |
| workshop is not for sale. | |
| ⑤ if bridging-in proves unsound, it fails closed: the coin stays a flag, | |
| and i will say so in public within the week. | |
| ───────────────────────────────────────────────────────────────────────────────────── | |
| none of this is investment advice. it's the opposite: a list of the promises | |
| i refuse to make, written down so you can hold me to the ones i did. | |
| ✦ the egg is real · the chart is weather · the proofs are land ✦ | |
| 🐉 https://www.dregg.net · $DREGG · built with Claude |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| · ✦ · ⋆ · ✦ · ⋆ · ✦ · ⋆ · ✦ · | |
| ╓─────────────────────────────────────────────────────────────────────────────────────────────────────╖ | |
| ║ T H E F E D E R A T I O N — how a turn becomes final across independent operators ║ | |
| ╙─────────────────────────────────────────────────────────────────────────────────────────────────────╜ | |
| N operators — no leader, no coordinator, no owner — weave one shared structure and agree | |
| on every turn. here is a single turn τ, from submit to irreversible. | |
| ┌─ T H E B L O C K L A C E ──── each operator adds blocks; every block cites all it has seen — a DAG, not a chain ─┐ | |
| │ │ | |
| │ op A ◦────◦────◦────◦──╮ │ | |
| │ ╳ ╳ ╳ │ │ | |
| │ op B ◦────◈────◦────◦──┤──▶ τau orders ──▶ leader ★ ──▶ a supermajority ──▶ ★ F I N A L │ | |
| │ ╳ ╳ ╳ │ the DAG into (round- ratifies ✍ ✍ ✍ τ is irreversible │ | |
| │ op C ◦────◦────◦────★──╯ a total order robin) 3 of 4 ≥ quorum(4) ⊹ receipt sealed │ | |
| │ = ⌊2·4/3⌋+1 = 3 │ | |
| │ op D · · · · ── offline: crashed · slow · partitioned — the quorum finalized τ without it, │ | |
| │ and it changes nothing. the federation survives f = ⌊(n−1)/3⌋ down. │ | |
| │ │ | |
| │ ◈ = the block carrying the turn τ ★ = this wave's leader ◦ = a block, citing its past │ | |
| └────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘ | |
| one turn, submit → irreversible: | |
| ① a client submits τ (signed, cap-bounded) ②→ an operator seals it into its next block (Ed25519 · BLAKE3) | |
| ③→ gossiped; every operator hears it + cites it ④→ the blocklace grows ⑤→ τau cuts it into waves + names the | |
| leader ⑥→ a supermajority super-ratifies the leader ⑦→ τ is final, irreversible, and leaves a receipt ⊹ | |
| ═════════════════════════════════════════════════════════════════════════════════════════════════════════════════════ | |
| WHAT IT GUARANTEES ── proven in Lean · #assert_axioms-clean · sorry-free ── | |
| ⑃ S A F E T Y no two conflicting turns no_conflicting_finalized_history · equivocation_excluded | |
| can both finalize settlement_soundness · supermajority_intersection | |
| ↻ L I V E N E S S it keeps finalizing lightclient_unfoolable | |
| while a quorum is up | |
| ⊹ I N T E G R I T Y state can't be forged — leaderless DAG-BFT, the Cordial-Miners family, over a | |
| a light client that can't be content-addressed blocklace; constitutional membership, | |
| fooled + two independent where a block is a vote and equivocation is fatal. | |
| executors (Rust ⇄ Lean) that | |
| must agree on every block | |
| a small appchain, run by its operators: N of them (4–9) run one app as a shared ledger — state = cells, ops = | |
| turns, "the app decides" = a supermajority super-ratifies. spin one up: a genesis + N keys + an auto-threshold | |
| ⌊2n/3⌋+1. grow it by a constitutional Join vote. equivocators (two blocks for one slot) are detected + auto-evicted. | |
| ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────── | |
| honest bounds: it tolerates f, not n — a colluding supermajority could override — and the guarantees mean the most | |
| with genuinely independent operators. live today: a multi-operator devnet with the Rust⇄Lean differential on | |
| every block; sustained finality + a wider committee are hardening now. | |
| ✦ a ledger nobody owns · a turn no operator can rewrite · a proof anyone can check ✦ | |
| 🐉 D R E G G N E T · https://www.dregg.net · $DREGG | |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| ∞ turns · one history fold into one proof | |
| t→t→t→t→t→t→t→t→t→t→t→t→t→t→t→t→t→t→t→t→t→t→t | |
| ╲ every fold re-verifies the fold inside it, | |
| ╲ step ∘ wrap · the shape never changes with depth | |
| ┌──────────────────────────────────────────────────────────┐ | |
| │ ┌──────────────────────────────────────────────────────┐ │ | |
| │ │ ┌──────────────────────────────────────────────────┐ │ │ | |
| │ │ │ ┌──────────────────────────────────────────────┐ │ │ │ | |
| │ │ │ │ ┌──────────────────────────────────────────┐ │ │ │ │ | |
| │ │ │ │ │ ┌──────────────────────────────────────┐ │ │ │ │ │ | |
| │ │ │ │ │ │ ┌──────────────────────────────────┐ │ │ │ │ │ │ | |
| │ │ │ │ │ │ │ │ │ │ │ │ │ │ | |
| │ │ │ │ │ │ │ ◆ O N E V K ◆ │ │ │ │ │ │ │ | |
| │ │ │ │ │ │ │ pin it once, forever │ │ │ │ │ │ │ | |
| │ │ │ │ │ │ │ │ │ │ │ │ │ │ | |
| │ │ │ │ │ │ └──────────────────────────────────┘ │ │ │ │ │ │ | |
| │ │ │ │ │ └──────────────────────────────────────┘ │ │ │ │ │ | |
| │ │ │ │ └──────────────────────────────────────────┘ │ │ │ │ | |
| │ │ │ └──────────────────────────────────────────────┘ │ │ │ | |
| │ │ └──────────────────────────────────────────────────┘ │ │ | |
| │ └──────────────────────────────────────────────────────┘ │ | |
| └──────────────────────────────────────────────────────────┘ | |
| ════════════════════════════════════════════════════════════ | |
| the floor: F R I · Poseidon2 · Ed25519 | |
| everything above the floor is PROVEN, not assumed | |
| ════════════════════════════════════════════════════════════ | |
| a proof that re-verifies a proof | |
| that re-verifies a proof … | |
| and a stranger pins the one anchor | |
| and KNOWS the whole story | |
| ( ⌐■_■ ) |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| ✦ · ⋆ · ✦ ⋆ · ✦ · ⋆ · ✦ · ⋆ | |
| ╔═══════════╗ | |
| ║ ▓▓▓▓▓▓▓ ║ t₀ — a server, running. | |
| ║ ▓ ◖◗ ▓ ║ not a container we manage — | |
| ║ ▓▓▓▓▓▓▓ ║ a cell, with a committed root. | |
| ╚═════╤═════╝ | |
| │ ☾ sleep = checkpoint (the root commits; the meter stops) | |
| │ | |
| ╔═════╧═════╗ | |
| ║ ▓▓▓▓▓▓▓ ║ t₁ — asleep. costs nothing. | |
| ║ ░ zzz ░ ║ the whole live state, folded into | |
| ║ ▓▓▓▓▓▓▓ ║ one 124-bit Poseidon root. | |
| ╚═════╤═════╝ | |
| ⑂ fork ╱ ╲ fork ⑂ one checkpoint → two sovereign lives | |
| ╔═════╧═╗ ╔═╧═════╗ | |
| ║▓▓▓▓▓▓▓║ ║▓▓▓▓▓▓▓║ t₂ — two servers now, diverging. | |
| ║▓ ◖◗ ▓║ ║▓ ◔◑ ▓║ a write to one never touches the | |
| ║▓▓▓▓▓▓▓║ ║▓▓▓▓▓▓▓║ other. scale IS fork. | |
| ╚═══╤═══╝ ╚═══╤═══╝ | |
| │ │ ⟲ time-travel | |
| │ ╰────────────▶ restore an earlier root. | |
| ▼ "the server, as of an hour ago." | |
| ⊹ receipt durable. exact. proven. | |
| ⊹ receipt | |
| ⊹ receipt ── a chain proving every wake, fork, and write. | |
| ┌─────────────────────────────────────────────────────────────────────────────────────┐ | |
| │ │ | |
| │ fly gives you a machine. we give you a machine that ⑂ forks · ☾ sleeps for │ | |
| │ free · ⟲ rewinds · and ⊹ proves itself — because underneath it isn't a container. │ | |
| │ it's a verified cell, and a cell can do all of that by being what it already is.│ | |
| │ │ | |
| └─────────────────────────────────────────────────────────────────────────────────────┘ | |
| the server learned to fork. ( ⌐■_■ ) $DREGG | |
| 🐉 D R E G G N E T · https://www.dregg.net |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| ✦ · ╭─────────────────────────────────────────────────────────────────────────╮ · ✦ | |
| │ │ | |
| │ ████████╗██╗ ██╗███████╗ ███████╗███████╗ █████╗ ███╗ ███╗███████╗ │ | |
| │ ╚══██╔══╝██║ ██║██╔════╝ ██╔════╝██╔════╝██╔══██╗████╗ ████║██╔════╝ │ | |
| │ ██║ ███████║█████╗ ███████╗█████╗ ███████║██╔████╔██║███████╗ │ | |
| │ ██║ ██╔══██║██╔══╝ ╚════██║██╔══╝ ██╔══██║██║╚██╔╝██║╚════██║ │ | |
| │ ██║ ██║ ██║███████╗ ███████║███████╗██║ ██║██║ ╚═╝ ██║███████║ │ | |
| │ ╚═╝ ╚═╝ ╚═╝╚══════╝ ╚══════╝╚══════╝╚═╝ ╚═╝╚═╝ ╚═╝╚══════╝ │ | |
| │ │ | |
| │ ⋈ the theorems that stitch the engine together ⋈ │ | |
| ╰─────────────────────────────────────────────────────────────────────────────╯ · ✦ | |
| Last poster: ~41 libraries, each proven alone. The fair reply came fast — a proof | |
| about a TLS handshake nothing calls proves nothing about the ENGINE. So the work | |
| since is a new *kind* of theorem: the SEAM. It proves the JOIN. Two already-proven | |
| pieces — a library's guarantee, threaded through the running reactor — still hold | |
| together. Not "library correct" and "reactor correct" apart. `library ⋈ reactor`. | |
| the engine is a quilt; the seams are what hold the patches as one cloth: | |
| ┌────────┰────────┰────────┰────────┰────────┰────────┐ | |
| │ ARENA ┃ HTTP/1 ┃ HTTP/2 ┃ HTTP/3 ┃ QUIC ┃ TLS │ each ┃ / ━ is a | |
| ┣━━━━⋈━━━╋━━━━⋈━━━╋━━━━⋈━━━╋━━━━⋈━━━╋━━━━⋈━━━╋━━━━⋈━━━┫ proven seam: | |
| │ ROUTER ┃ PROXY ┃ RATE ┃ BODY ┃ DNS ┃ mTLS │ a checked theorem | |
| ┣━━━━⋈━━━╋━━━━⋈━━━╋━━━━⋈━━━╋━━━━⋈━━━╋━━━━⋈━━━╋━━━━⋈━━━┫ that the two patches | |
| │ SOCKS ┃ WS ┃ TAP ┃ METRIC ┃ HEADER ┃ DRAIN │ it touches compose. | |
| └────────┸────────┸────────┸────────┸────────┸────────┘ | |
| ░▒▓ THE DATAPLANE SEAMS ▓▒░ ───────────────────────────────────────────────────────── | |
| the io_uring lease ⟩ recv_recycles_exactly_once · reactor_recycle_is_held | |
| the connection FSM ⟩──── ⋈ ⊢ every buffer the kernel lends is recycled exactly once — | |
| and only ever a buffer the ring actually lent. | |
| the Body library ⟩ body_not_reparsed | |
| the recv boundary ⟩──── ⋈ ⊢ a request BODY is consumed as a body, never re-parsed as a | |
| smuggled second request. (the bug half the web ships.) | |
| the H1 keep-alive ⟩ keepalive_all_dispatched | |
| the reactor loop ⟩──── ⋈ ⊢ every pipelined request gets its OWN response, in order. | |
| the Rate bucket ⟩ reactor_rate_bound_window | |
| the admission gate⟩──── ⋈ ⊢ over any window, at most (capacity + rate × window) admitted. | |
| ░▒▓ THE PROTOCOL SEAMS ▓▒░ ────────────────────────────────────────────────────────── | |
| the H2 engine ⟩ h2_frame_seam | |
| the plainH2 state ⟩──── ⋈ ⊢ a well-formed HEADERS frame becomes a dispatch of the | |
| HPACK-decoded request — arena still well-formed. | |
| the QUIC FSM ⟩ quic_drives_h3 | |
| the H3 decoder ⟩──── ⋈ ⊢ a datagram into an ESTABLISHED connection drives the real | |
| HTTP/3 + QPACK decode — and no app data one packet before. | |
| the TLS engine ⟩ tls_no_plaintext_seam | |
| the FSM discipline⟩──── ⋈ ⊢ not one plaintext byte after the record layer is torn down. | |
| the Ws reassembly ⟩ ws_reassembly_seam | |
| the WS state ⟩──── ⋈ ⊢ a fragmented message reassembles to EXACTLY the payload the | |
| machine delivers; control frames interleave, untouched. | |
| the SOCKS engine ⟩ socks_no_early_egress_seam | |
| the relay gate ⟩──── ⋈ ⊢ not one application byte before the handshake establishes. | |
| ░▒▓ THE FABRIC SEAMS ▓▒░ ──────────────────────────────────────────────────────────── | |
| the real router ⟩ serve_routes_bestMatch ◀ live in the orb now | |
| the running serve ⟩──── ⋈ ⊢ the RUNNING response is the route bestMatch chose — to the wire. | |
| the load balancer ⟩ proxy_route_connects · proxy_selects_healthy | |
| the connect path ⟩──── ⋈ ⊢ the reactor dials EXACTLY the backend the real LB picked from | |
| the healthy set — a stub that dials wrong fails the theorem. | |
| the DNS resolver ⟩ dns_resolves_before_connect | |
| the upstream open ⟩──── ⋈ ⊢ connect only to an address the real resolver returned — and it | |
| always terminates, even on an adversarial pointer loop. | |
| the cert chain ⟩ mtls_no_auth_on_failure · pki_resume_window | |
| the TLS accept ⟩──── ⋈ ⊢ a client identity only if the chain validates; a ticket only | |
| inside its validity window. never on failure. | |
| the diagnostic tap⟩ tap_gated_in_reactor | |
| the request path ⟩──── ⋈ ⊢ copies NOTHING when disabled — the info-leak gate, live. | |
| ───────────────────────────────────────────────────────────────────────────────────── | |
| A seam has a shape: ( the reactor uses the real library ) ⊢ library ⋈ reactor. | |
| The hypothesis names the stitch; the conclusion is the cloth. Sew enough and the | |
| ~41 islands stop being islands. | |
| 1,553 machine-checked theorems — but the number that matters is the SEAMS: ~30 and | |
| climbing, each a library the running engine genuinely drives. (Honest: some seams are | |
| over the orb's exact deployed config, some over a real reactor step being folded onto | |
| that one path right now — the adversarial auditors track which, in the open.) | |
| ✦ islands, becoming an engine — one proven seam at a time ✦ | |
| 🐉 Dragon's Orb · the join is the theorem · built with Claude | |
| ✦ · ────────────────────────────────────────────────────────────────────────────── · ✦ |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| · . * . ✦ . * · | |
| . ✦ . * . ✦ . | |
| * . . · . * . | |
| _.-~~~~~-._ | |
| .-~ ╱╲ ~-. | |
| ,' ╱ ╲ `. | |
| / ╱ ◇ ╲ \ | |
| ; │ ╱ ╲╱╲ │ ; | |
| │ ╱│╱ ◈ ╲│╲ │ | |
| │ ╱ │ ◈ │ ╲ │ ✦ | |
| ; ╱ │ ◈ │ ◈ │ ╲ ; | |
| \ ╱ │ ◈ │ ╲ / | |
| `. │ ╲ ◈ ╱ │ ,' | |
| `-._│ ╲ ╱ │_.-' | |
| `~-.___.-~' | |
| \ /│ | | |│\ / | |
| \ / │ | | |│ \ / . | |
| . \/ └─┴─┴─┘ \/ | |
| ~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| ~ the egg, warm in the ~ | |
| ~ nest, about to wake ~ | |
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
| ┌─────────────────────────────────────────────────────────────────────────┐ | |
| │ one auth token, a month of thinking, and it cracked open into a whole │ | |
| │ protocol. inside the shell, four things: │ | |
| │ │ | |
| │ ◇ a CELL — state you own │ | |
| │ ◈ a CAP — authority you can narrow, lend, and revoke │ | |
| │ ↻ a TURN — the only way anything changes │ | |
| │ ⊹ a RECEIPT — a proof of it that a stranger can re-check │ | |
| │ │ | |
| │ nothing trusts the keeper. everything leaves a trail you can verify. │ | |
| └─────────────────────────────────────────────────────────────────────────┘ | |
| ✦ D R E G G · the dragon's egg ✦ $DREGG | |
| 🐉 https://www.dregg.net |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| . ✦ . * . ✦ . | |
| . ___ . * . | |
| ," ". . * | |
| * . ( .-. ) . . . | |
| /\ "._.' /\ * . | |
| ___/ \__ __/ \___ . ___ | |
| \ / \ / \ / ( ) full moon | |
| \__/ ◞◟ \_/ ◞◟ \__/ ___---===---___ '-' | |
| \ ⟨◉⟩ >═══< ⟨◉⟩ / _-~ ~-_ | |
| ◞◟◞◟ \ \ vvv / / ◞◟◞◟ / a budget, a key \ ◞◟◞◟ ⊹ ⊹ | |
| \__ \\ ___ // __/ \ _ _ / | |
| ⊹ ⊹ \__ \\/ \// __/ ~-_ ~~~---___---~~~ _-~ ⊹ ⊹ ⊹ | |
| \___\\___//___/ ~~~---_____---~~~ | |
| \\ // ╱ | |
| \\ // ╱ trailing a chain of receipts ──⊹──⊹──⊹──⊹──▸ | |
| \V/ ╱ | |
| V | |
| ┌───────────────────────────────────────────────────────────────────────┐ | |
| │ │ | |
| │ GIVE A DRAGON A BUDGET AND A KEY. │ | |
| │ │ | |
| │ budget ▓▓▓▓▓▓▓▓░░░░░░░░ ← it can only spend what you sealed │ | |
| │ cap ◈ talk to ▸ two services ◈ touch ▸ its own cell only │ | |
| │ │ | |
| │ it flies, it acts, it pays its own way — and it CANNOT exceed │ | |
| │ the bound, by construction. every wingbeat drops a receipt. │ | |
| │ │ | |
| │ GET BACK A PROOF OF EVERYTHING IT DID, │ | |
| │ AND A HARD BOUND ON EVERYTHING IT COULD HAVE. │ | |
| │ │ | |
| │ $ dregg agent deploy → ✓ verified · ▓ budget spent · ⊹ chain │ | |
| │ │ | |
| └───────────────────────────────────────────────────────────────────────┘ | |
| ✦ the verifiable agent cloud · run an agent you can trust | |
| because you never had to ✦ 🐉 https://www.dregg.net | |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| \ | / _.-="=-._ ⋆ · ⋆ · ⋆ | |
| \ | / _,=" "=,_ · ⋆ · ⋆ · | |
| ── ( ☀ VERIFY ) ── ," the host " ⋆ content, everywhere | |
| / | \ ( cannot lie ) (no single keeper) | |
| / | \ ", ," · ⋆ · ⋆ · | |
| "=,_ _,=" ⋆ · ⋆ · ⋆ | |
| ◞◟◉◟ "=-...-=" | |
| ~ dragon ~ | | | ~ dragon ~ ~ dragon ~ | |
| (an agent, ______|____|____|______ (yours) (theirs) | |
| bounded & ,' ', | |
| proven) / ▟▙ ⌂ ▟▙ ⌂ ⌂ ▟▙ \ ← hundreds of apps, | |
| / ~~~~~~~~~~~~~~~~~~~~~~~~~ \ each cap-secured | |
| _.--._ ,' ⌂ ▟▙ ⌂ THE CLOUD ▟▙ ⌂ ', _.--._ | |
| ,' '. / ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ \ ,' '. | |
| ( ~~island~ )/_______________________________ ___\( ~island~~ ) | |
| '._ _.' ‖ ‖ ‖ ‖ ‖ '._ _.' | |
| ‖‖‖ ‖ ═══ ‖ ═══ ‖ ═══ ‖ ═══ ‖ ‖‖‖ | |
| edge persvati snoopy lassie ...you? | |
| '-.___.--═══════════════════════════════════════════════════.___.-' | |
| one cloud · many operators · each keeping the others honest | |
| ╔══════════════════════════════════════════════════════════════════════════╗ | |
| ║ websites · servers · storage · apps · AGENTS — hosted, paid in $DREGG, ║ | |
| ║ no ID, no gatekeepers. but unlike every other cloud: ║ | |
| ║ ║ | |
| ║ the bytes you're served ┐ ║ | |
| ║ the bill you're charged ├─ each a cell you re-check yourself. ║ | |
| ║ the keys you hold ┤ content lives everywhere (IPFS). ║ | |
| ║ what an agent did ┘ the proof rides along. ║ | |
| ║ ║ | |
| ║ not a better cloud — a different kind: one you VERIFY, never trust, ║ | |
| ║ run by more than one of us so the verifying actually means something. ║ | |
| ╚══════════════════════════════════════════════════════════════════════════╝ | |
| ✦ the permissionless, verifiable cloud ✦ | |
| 🐉 https://www.dregg.net · $DREGG | |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| · ✦ · ⋆ · ✦ · ⋆ · ✦ · ⋆ · | |
| the forkable agent cloud | |
| ╓───────────────────────────────────────────────────────────────────────────────────╖ | |
| ║ T H E · V E R I F I A B L E · A G E N T · C L O U D ║ | |
| ╙───────────────────────────────────────────────────────────────────────────────────╜ | |
| give it a budget and a key. it earns, spends, and runs your | |
| operations — and never once leaves your sight. | |
| ,/| |\. | |
| // \___ __,--------,__ ___/ \\ | |
| ( | \_\, ,~'` `'~, ,/_/ | ) horns swept | |
| \ \ \\ /| .-. .-. |\ // / / back, eyes | |
| \ '. \V | ( @ ) ( @ ) | V/ .' / like coals, | |
| '.,~'~,_,/ \ '-' ^^ '-' / \,_,~'~,.' a maw of | |
| `'~, | '~,__ ww __,~' | ,~'` smoke — | |
| \ \ '~,____,~' / / | |
| '.\__ | | __/.' the AGENT: | |
| \ '~,_ | | _,~' / a dragon, | |
| '. '~,| |,~' .' coiled round | |
| \ ,~' \/ '~, / the pearl | |
| \,~' ,~'^'~, '~,/ of proof it | |
| ,~' / (✦) \ '~, will not drop | |
| __,--~' | ,~~, | '~--,__ | |
| ,~'` (((((( \( )/ (((((( `'~, | |
| ,~' ((((((((((((((( `~/\~' )))))))))))))) '~, | |
| ,' ((((((((((((((((((( ( ) ))))))))))))))))))) ', | |
| ( )))))))) the coil — its body, its hoard, its ((((( ) | |
| ', )))))))))) ledger, all one loop you re-check (((( ,' | |
| '~,_ ))))))))))))))(((((((((((((((((((( __,~' | |
| `'~,__ )))))))))) ((((((((( __,~'` | |
| `'~~,______________,~~'` | |
| ════════════════════════════════════════════════════════════════════════════════════ | |
| 💰 it EARNS — paid in, every dollar sealed as a receipt. | |
| 💰 it SPENDS — buys SaaS, provisions, pays its vendors — but ONLY what its | |
| budget + caps allow; an over-reach is refused before a cent moves. | |
| ⊹ it PROVES — the whole P&L is a chain a stranger re-verifies to the cent. | |
| ⑂ it SCALES — fork it; the sub-dragon inherits a leash it cannot slip. | |
| every other agent *can* spend. this one's spending is bounded by construction | |
| and proven — the trust layer a business needs before it hands an agent a card. | |
| ✦ the autonomous business you can audit ✦ | |
| 🐉 https://www.dregg.net · $DREGG |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| ╔═══════════════════════════════════════════════════════════════════════════════╗ | |
| ║ ║ | |
| ║ ██████╗ ██████╗ █████╗ ██████╗ ██████╗ ███╗ ██╗███████╗ ║ | |
| ║ ██╔══██╗██╔══██╗██╔══██╗██╔════╝ ██╔═══██╗████╗ ██║██╔════╝ ║ | |
| ║ ██║ ██║██████╔╝███████║██║ ███╗██║ ██║██╔██╗ ██║███████╗ ║ | |
| ║ ██║ ██║██╔══██╗██╔══██║██║ ██║██║ ██║██║╚██╗██║╚════██║ ██████╗ ║ | |
| ║ ██████╔╝██║ ██║██║ ██║╚██████╔╝╚██████╔╝██║ ╚████║███████║ ██╔═══██╗ ║ | |
| ║ ╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═╝ ╚═════╝ ╚═════╝ ╚═╝ ╚═══╝╚══════╝ ██║ ██║ ║ | |
| ║ ██║ ██║ ║ | |
| ║ W H Y D R A G O N ' S O R B ? ╚██████╔╝ ║ | |
| ║ a network engine whose behavior is a theorem ▝ ╚═════╝ ▘ ║ | |
| ║ $DREGG ║ | |
| ╚═══════════════════════════════════════════════════════════════════════════════╝ | |
| Every fast network stack on earth asks for the same thing: your trust. It | |
| parses your traffic, terminates your TLS, routes your requests, meters your | |
| bill — inside a black box that runs millions of lines nobody has read, and | |
| you take its word that it did what it said. Speed has always been bought | |
| with trust. | |
| Dragon's Orb is the network layer that hands you a proof instead. | |
| TWO BARS, BOTH BINDING ───────────────────────────────────────────────────── | |
| ▸ "there is no reason for it to be slower than the laws of nature allow" | |
| ▸ "there is no reason we cannot reason about the challenging queries" | |
| Most projects pick one and apologize for the other. The orb refuses the | |
| trade. The fastest shape a request-processor can take — shared-nothing per | |
| core, zero-copy, zero steady-state allocation, run-to-completion — is the | |
| SAME shape that makes it provable. One design decision, read from two | |
| sides: the performance story and the assurance story are the same story. | |
| WHAT WE WILL HAVE BUILT ──────────────────────────────────────────────────── | |
| A complete edge/cloud network engine — the whole surface a modern reverse | |
| proxy carries — where every layer is a proven object, not a tested one: | |
| ┌─ THE WIRE ───────────────────────────────────────────────────────────┐ | |
| │ HTTP/1.1 · HTTP/2 · HTTP/3 · QUIC · TLS 1.3 (+ kernel offload) │ | |
| │ WebSocket · DNS · the request arena all three HTTP versions share │ | |
| ├─ THE FABRIC ─────────────────────────────────────────────────────────┤ | |
| │ reverse / forward / L4 proxy · load balancing (weighted, least-conn,│ | |
| │ rendezvous-hash) · health checks · upstream pooling · rate limiting │ | |
| │ · circuit breaking · timeout budgets · live reconfiguration │ | |
| ├─ THE FLOOR ──────────────────────────────────────────────────────────┤ | |
| │ the completion-queue reactor · buffer rings · generational sockets ·│ | |
| │ the capability fabric it plugs into · a capability microkernel │ | |
| └──────────────────────────────────────────────────────────────────────┘ | |
| Not "hardened." Not "extensively fuzzed." Proven — each property carried | |
| to a deep model of the running machine, by a checker whose kernel either | |
| accepts the term or does not. | |
| THE PROPERTIES THAT BECOME THEOREMS ──────────────────────────────────────── | |
| ⟦ the served surface ⟧ the running configuration is served EXACTLY as | |
| declared — nothing answers on a port the config | |
| never named; a listener that requires TLS can | |
| never emit a plaintext byte; a reload swaps the | |
| whole snapshot at once, never a torn mixture. | |
| ⟦ the request path ⟧ a normalized path cannot escape its document root | |
| — traversal isn't "filtered," it's impossible; | |
| every request that reaches a handler passed each | |
| configured filter of its route exactly once. | |
| ⟦ the resources ⟧ every buffer the kernel lends is returned exactly | |
| once — no leak, no double-free — under every | |
| interleaving the ring can produce, including the | |
| ones no test would ever reach. | |
| ⟦ the replay window ⟧ 0-RTT early data is accepted at most once across | |
| every core, under an adversary replaying it to | |
| all of them. | |
| ⟦ the parser ⟧ in-bounds, total, and well-formed by construction | |
| — the request view resolves to exactly the bytes | |
| it names, and the smuggle shapes are rejected as | |
| theorems, not as a growing list of CVEs patched. | |
| WHERE TRUST ACTUALLY STOPS ───────────────────────────────────────────────── | |
| Testing has exactly one honest job here, and it isn't proving our code. | |
| Differentials and fuzzing validate the MODELS OF THE ENVIRONMENT — that | |
| the kernel and the NIC behave as their stated transition systems say. Our | |
| half is proven against those models. The only things left assumed at the | |
| very bottom are named out loud and countable: the prover kernels, the | |
| standard cryptographic assumptions, and "the hardware implements its | |
| stated interface." Everything above that line is derived. | |
| ┌──────────────────────────────────────────────────────────┐ | |
| │ the whole engine ── PROVEN ── │ | |
| │ ················ named, countable floor ············ │ | |
| │ prover kernels · crypto assumptions · device interface │ | |
| └──────────────────────────────────────────────────────────┘ | |
| That is the difference between "we tried hard" and "here is the list of | |
| everything you must still take on faith" — and the list is short. | |
| HOW IT CAN POSSIBLY BE THIS FAST ─────────────────────────────────────────── | |
| The engine is not hand-written and then verified. It is GENERATED from | |
| verified models by a compiler that emits, from one description, the | |
| running machine code AND the proof that the code refines the model. The | |
| shape that is easiest to prove is the shape that is fastest to run; the | |
| compiler is what makes them the same artifact. No optimizing black box on | |
| the path you have to trust — the chain to the binary is the product. | |
| WHY IT MATTERS ───────────────────────────────────────────────────────────── | |
| · it runs as a verified partition on a capability microkernel — the | |
| network stack cannot reach past the capabilities it was handed | |
| · it is the data plane a permissionless cloud can stand on: if the | |
| bytes served and the price charged must be checkable, the thing | |
| serving them cannot be a stack you merely hope is correct | |
| · it is AGPL, from a clean repository — a liberated, un-rug-pullable | |
| floor anyone can build on and no one can take back | |
| ──────────────────────────────────────────────────────────────────────────── | |
| Cloudflare-tier performance has always meant trusting a black box. | |
| Dragon's Orb is the first where the network layer cannot lie — | |
| because every claim it makes, you can check the proof of. | |
| ──────────────────────────────────────────────────────────────────────────── | |
| the fast thing was locked in a tower; we did not storm it — | |
| we described it, once, precisely, in a tongue whose | |
| compiler cannot lie, and the description, running, | |
| is the thing itself. | |
| $DREGG 🐉 Dragon's Orb · proven, not trusted |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment