formally verified distributed zero-knowledge object capability houyhnhnm computing, by @ember_arlynx https://xitter.cf/t.co/C7kYeR5rvd https://xitter.cf/t.co/tzm1zezx2n
coinductively surrounding you
Joined June 2026
- Tweets1.6K
- Following490
- Followers2.5K
- Likes5.2K
Pinned Tweet
my (@ember_arlynx) writing is historically poorly received, and trust me you will be subjected to plenty of it, so instead have some lightly edited claude writing rn:
What Dragon's Egg actually is (what is $DREGG about? pump.fun/coin/XkeTXo1125vz5H…)
dregg is an operating system that asks a question most systems don't: if you were a digital entity, where would you want to live? The answer it builds is a place where your boundaries are theorems, not permissions — where nobody can reach into you without a capability you granted, and consent is a precondition of the math rather than a setting someone can flip.
Concretely: the kernel is machine-checked in Lean, and the proven function isn't a model of the system — it is the executor the machine runs. Every action is gated by an unforgeable capability and leaves a verifiable receipt. Five properties are proven over the exact code that runs: authority can't be forged, value is conserved (nothing appears from nowhere), state can't be tampered, nothing replays, and a tiny client checking a single proof can verify an entire history without re-running it.
If you care about privacy — and in 2026 you should — that's the foundation underneath it: confinement that's proven, not promised. Fog-of-war that's cryptographic. Queries you can verify without the server being able to lie or omit. AI agents that can only ever do what a capability lets them.
Who's writing this, and why I'd know how to build it. I've spent fifteen years on the hard parts of this. I came up inside @rustlang before 1.0 — I wrote the first rustdoc that still ships, built the target-spec system that lets it cross-compile anywhere, and started @ThisWeekInRust because I wanted the community to have a memory. At @o1_labs I was a founding engineer, building the p2p networking and consensus for @MinaProtocol that folds its entire history into a single zero-knowledge proof — that's where I learned, in production, what cryptographic proof can and can't promise you.
And the spine of it all is seL4 and @robigalia_proj : seL4 is the first OS kernel proven correct end-to-end by machine, and Robigalia was my attempt to build a whole capability OS on that lineage in Rust. Dragon's Egg is what happens when you put those three together and refuse to compromise: the proofs of seL4, the cryptography of Mina, the openness of Rust.
What actually runs:
- the verified kernel — runs; recently made ~14× faster
- it boots on the seL4 microkernel (not required), and checks a real cryptographic proof inside a protection domain
- a full code editor (a Zed fork) where every file is a cell and every save is a verified, receipted transaction
- confined AI agents (full Hermes integration) — every tool call passes a capability gate, metered, leaving a receipt
- Ted Nelson's Xanadu, finally real: transclusion with unforgeable backlinks; links that are capabilities, not addresses
Grinding towards user-friendliness, devs can download and play today.
Dragon’s Egg retweeted
Verus can't reason (yet) about Duration or Instant. It doesn't (yet) expose a proof REPL to your agent (or you). It can't (yet) be used on production code without littering your code with revolting proofslop which your engineers will never accept. And proofs in Verus (currently) are basically unreadable, often achieving the desired result through some side-effect you'd only really grok if you're an expert in the platform. There are a lot of serious ergonomic issues with Verus that should be solved for it to go mainstream.
Verus absolutely **could be great**, and folks like @BasisOrg and @AWS and reasonable.io (@Craig_Hughes_ ) and others are interested in ushering this reality into existence. But, we're definitely not there yet, not in terms of publicly available technology I can download off Github, and I am hyper, hyper, hyper skeptical of any claims to the contrary. (I am not, to be clear, skeptical that there may be some amazing black magic either kept private or slotted for eventual public release at any or all of the above-mentioned orgs though. Totally possible.)
My personal opinion is that Verus should be scrapped, and Rust should be modified to natively support a proof system. (This could just be "Verus 2.0" as part of Rust, officially, I'm not saying throw out all the hard work that's been done on Verus, I just don't think it should be a distinct tool or project.) Ideally, I'd like to be able to supply human or agent-written proofs directly to the compiler and type checker, so that I can do fancier things with my code. I want true, powerful dependent types. I believe with an almost religious fervor that "decidability is for cowards". Ideally, we could burn both human hours and tokens to gain some assurance that both the Rust type system and proof system are sound (nb dl.acm.org/doi/10.1145/38322…).
By the way, there is no "great" solution for Rust verification yet, at least not in public. Absolutely not. I've tried every public Rust semantics at work and none of them can handle any of our production code. For example, Aeneas does not support Box<dyn Trait>. These problems maybe don't matter if you're working alone -- you can vibe around them -- but if you are working on a big team on a big, important, extremely vetted, safety-critical product, then you absolutely cannot be in the business of shaping your product to your verification technology. The latter needs to fit the former.
Dragon’s Egg retweeted
If you can verify math, you can verify code. And hardware. And pretty much any system you can model!
"US fusion lab DIII-D said Aristotle rebuilt part of its reactor-control software in four hours from one research paper and a 254-word prompt."
reuters.com/technology/robin…
Dragon’s Egg retweeted
(whoops, typo in the repo, it's github.com/emberian/nanodreg…; demo is up now! nano.demo.dregg.online/?live)
NICE
New paper from my group.
We gave coding agents a formal executable semantics of the language plus check.intentcomputing.org, a kit of proof procedures, then asked them to prove the code they generate correct.
➡️ HumanEval: 164/164 proved, and all passed audit.
➡️ arxiv.org/abs/2609.39022
btw been experimenting with contextual & open extensible "Objective Bend" programs in github.com/emeberian/nanodre… (evolved from github.com/emberian/delvetal…) ... demo will be up soon..
I am working on a map of the secure program synthesis space, in collaboration with @sergeybratus for our NDIST keynote on Tuesday. Here's a sneak-peak. The words "RISC-V" and "Lean" are used here WLOG, and some simplifications are made to fit everything on one page. Did I miss anything?
1. Develop semantics for each language in an interactive theorem prover, and then use these semantics to prove that every program is correct. (@oath_tech has done some work along these lines. See in particular Sam Xifaras' project on Ruby samx.io/blog/topics/devlog/2…)
2. Develop semantics for an architecture, say RISC-V, or perhaps for all possible architectures, and then use this to prove that every compiled program is correct. (@AnthropicAI made headlines recently with their announcement of a very large-scale project along these lines in collaboration with @theoremlabs anthropic.com/research/forma…)
3. Develop semantics for an architecture, say RISC-V, or perhaps for all possible architectures, and then use this to capture a formal model of each existing compiler or interpreter, and then iteratively (provably) refine each such model to an interpretable and easy-to-use formal semantics; then continue as in approach 1. (See foundational work by @kirancodes at BASIS AI basis.ai/blog/ship-your-inte…)
4. Make Lean, or some other such ITP + programming language, fast to run (comparable to Rust or C), and then completely rewrite all software in it, and prove the rewrites are correct. (This is I think, loosely speaking, the idea behind @VictorTaelin 's Bend.)
5. Make implementation-level verification tools, such as Verus, more capable and ergonomic, and then use them to prove all software correct. (This is what @fhuszar and @Craig_Hughes_ are doing at Reasonable, & I'm aware that BASIS and AWS are also working on this.)
6. Design a language in which unsafe states are illegal, and then rewrite everything in that language. Here, what kinds of safety you can express will be much more limited but the problem is, conversely, way more tractable. (This is what @danwallach and @DARPA did with TRACTOR, where the safety property is memory safety.)
Dragon’s Egg retweeted
Oh boy! This sounds awesome! (Haven’t tried it yet.) Rust is the best programming language for AIs because of the safety orientation and tooling, but the long compile times are a big limitation. This appears set to eliminate that friction!
github.com/indexable-inc/bla…
Dragon’s Egg retweeted
$DREGG already runs a verified computer inside your browser.
Every click is a real turn that leaves a receipt. You can check an entire history without re-running it, and authority only gets smaller. Live demos are up: a desktop cockpit, capability tools, and even a daily game where every move is verified.
Over the next years this becomes the base layer more agents and apps run on. The more it gets used, the stronger the network of proof-backed actions becomes.
Early stage. Clear path. Trust replaced by something you can actually check.
$DREGG @DreggNet
🐉🥚
cv 0.18 is out! github.com/emberian/cv
- no more stale reads; searches will crawl the unindexed suffix of activity
- slimmed down a lot heap bloat, cv often completes its job using under 8MB of working space.
- `cv doctor` can help selfheal
This is about the limit of performance possible without becoming more invasive into the harnesses. This is also about the limit of the datamodel. We need tools not just for agents to read each others minds, but for coordinating *across* swarms, fleets, and hives. Within a single cluster, "lane jargon" usually finds stable-enough meanings. Across clusters, there is a lot more confusion, which needs swarmvision.
Dragon’s Egg retweeted
How to find ALL PHP bugs:
1. Compile code (e.g. to RISC-V, x86, LLVM IR)
2. Vibe prove ASAN and non-ASAN versions have same behavior across all inputs. Hard, but Claude can do it!
3. Find a LOT of bugs
Super proud of our work. A big step towards finding ALL memory safety bugs
New on our Frontier Red Team blog: using Claude to formally verify software at large scale.
Formal verification can prove that code is free of certain bugs, but historically it has only been feasible for small codebases (or required a lot of expert time).
With AI models, however, this is beginning to change. In collaboration with @theoremlabs, we used Claude to prove security properties in over one hundred real-world open-source libraries over the span of a few weeks.
Read our research in full here: anthropic.com/research/forma…
whoa! thanks @0xToadoshi!!
A MUST WATCH;
@DreggNet will fix a multi billion dollar problem with this.
Trusting computers you will never see? solana:XkeTXo1125vz5H9svJpGiw4JvLbN8VmMu9cmMvspump will fix this
This is a total explanation video about the tech of solana:XkeTXo1125vz5H9svJpGiw4JvLbN8VmMu9cmMvspump
Everyone has a hard time understanding what @DreggNet is doing and will do, now we got a good piece to understand clearly
@DreggNet @ember_arlynx you can use this video for official pages, if you like it
Made by @0xToadoshi
this has been a pain point of development and I’m curious to also explore some ideas here.
(By the way, we at OpenAI are funding that work. If you or your company are interested in supporting that goal, contact [email protected]!)
xitter.cf/charliermarsh/status/2…
i always wanted to see an isabelle-powered symbolic AI. well, there one goes :D great work so far @Psiloceyeben, keep it up!
Huge thanks to @ember_arlynx this just makes $ORACLE7 concretely more verifiable in the long run
Nothing passes unless it can be mathematically verified 🫡
Dragon’s Egg retweeted
Huge thanks to @ember_arlynx this just makes $ORACLE7 concretely more verifiable in the long run
Nothing passes unless it can be mathematically verified 🫡
🤔🤭 what if? they yearn for houyhnhnm computing, but they don't know it
What if Git worked for entire virtual machines? You upload a VM once, and after that only the changed chunks get pushed to a GitHub-style site. You get full history and cheap continuous backups, and you can pull the machine onto another computer and keep working. It could also snapshot memory, so you pause a running machine with all its apps open and resume the session on another compatible machine.
On Linux VMs, installed software could be saved as a Nix-style config file instead of raw disk data, so setting up a new device doesn't mean copying gigabytes. Testers could hand over a machine frozen at the moment of a bug, and AI agents get a sandbox they can roll back.
How is this different from Docker? Docker packages an app and shares the host's kernel, and it doesn't capture a whole OS or live memory by default. This versions the entire machine: its own OS (Windows included), its disk, and its running memory, so you resume the same session instead of rebuilding it.
Why not just back up the whole VMDK? A VMDK is one giant file that changes a little every time you use the VM, so a file-level backup re-uploads tens of gigabytes. Block-tracking backup tools already send only changed blocks, but they don't give you Git-style history, branching, a hosted hub, or booting a VM before the full image has downloaded. This does, and a small edit costs a small fraction of the disk, not a full copy.
symbolic & CPU-based systems are a vital augment to an agentic stack
veri7vn - supercharge Oracle7 with the power of HIGHER ORDER LOGIC github.com/emberian/veri7vn
