eccogrinder

@auryn_macmillan x.com/0xmons/status/…

here's why I think blockies perfectly embody the ethereum builder ethos: 1. they don't focus on price. in fact, they made it easy for anyone to create their blockie, simply by creating a new ethereum address, which is different from every PFP NFT project out there that wants nft price go up. 2. their raison d'etre is layered security; leveraging human facial recognition wetware to make human unreadable hex address readily identifiable by humans. 3. they are hard core open source, not even the creative commons type where attribution is required but the purest form WTFPL (Do What the Fuck You Want to Public License) (wtfpl.net) 4. Unapologetically Ethereum.

@auryn_macmillan ...for the planetary nervous system

@eccogrinder The model is simply part of one's exocortex, one of the many ghosts/shadows one spins off to handle various processes (see Accelerando for more thorough and entertaining explanation)

## AI voting proxies require two layers: private inference and private aggregation. AI voting proxies require two layers: private inference and private aggregation. Vitalik recently wrote about AI "shadows" — LLM proxies trained on your own corpus that vote on your behalf with near-100% participation. He's right that cryptography is the key enabler. But I want to make that concrete by separating it into these two layers. But first, a diagnosis from personal experience. * * * ## The DAO governance trap I'm a DAO advocate. I've spent more than a decade building and participating in them. But I've also watched the same failure mode play out repeatedly — and it stems not from the DAO model itself, but from a specific dogma within it: the wholesale rejection of hierarchy. DAOs are structurally resistant to hierarchy. The ethos is flat, everyone votes on everything. In theory this is beautiful. In practice it's paralyzing. What actually happens: DAOs end up voting only on large budget items and protocol upgrades, while deferring entirely to labs and core teams for day-to-day decisions. The org atrophies into a rubber stamp with a treasury. The deeper irony is that rejecting hierarchy doesn't eliminate it. It just makes it informal and unaccountable. Power concentrates anyway, without the transparency that explicit structure provides. "Everyone votes on everything" isn't a bad governance philosophy. It was always a hardware problem. Human bandwidth is finite. Attention is scarce. Flat structures collapsed back into de facto hierarchies because they had no other choice. AI shadows change this calculus. * * * ## Continuous governance If your vote is cast by a proxy that is trained or tuned on your values, your priorities, and your evolving perspective, and casting it costs you nothing, then the participation constraint is radically changed. Votes don't need to be reserved for high-stakes moments. They can be granular, frequent, and fast. Imagine a DAO where operational decisions resolve in minutes, not weeks. Where the organisation's direction is a continuous live aggregate of its members' preferences, not a series of discrete referendums that most people ignore. Where "everyone votes on everything" is not an aspirational gesture but a literal description of how the org runs day to day. This connects to something Karl Popper and David Deutsch identified as the core measure of good governance: not who holds power, but how easily bad policy can be corrected and bad leadership removed. Good governance is a process of conjecture and the elimination of error. The question is not "did we get the right answer?" but "can we fix it quickly when we get the wrong one?" Frequent, fine-grained, direct participation is the most natural expression of this principle. The faster errors surface and the lower the cost of correcting them, the healthier the system. A governance layer where votes resolve in minutes, on granular day-to-day decisions, is structurally more Popperian than one where correction requires waiting four years for an election or months for a DAO proposal to pass quorum. This is the Open Society, operationalised. * * * ## The cryptographic stack that makes it private For this to work at scale, and especially on sensitive decisions, inference and aggregation have to be private. Here's what that architecture looks like. ### Phase 1: Private inference Your AI shadow needs to run somewhere. You probably don't have the hardware to run a frontier model locally. Several options exist, each with a different trust model: * **"Trust-me-bro" remote models.** You send your data to a provider and trust them not to look. Simple, fast, available today. The weakest privacy guarantee. * **Local models.** You run the model yourself. Personal privacy, no third-party trust required. Constrained by your hardware and the quality of models that fit on it. * **TEEs (Trusted Execution Environments).** The provider runs the model inside a hardware enclave. You trust the chip manufacturer rather than the provider. Stronger than pure trust, weaker than cryptographic guarantees. * **MPC (Multi-Party Computation).** Inference is split across multiple parties who collectively compute the result without any single party seeing the full picture. Strong guarantees, significant coordination overhead. * **FHE (Fully Homomorphic Encryption).** Your data stays encrypted throughout inference. The provider computes over ciphertext and returns a result only you can read. The strongest cryptographic guarantee, and the most computationally expensive. These approaches will compete. The right choice depends on the user's trust model, hardware constraints, and tolerance for latency and cost. That choice belongs entirely to the user and has no bearing on the aggregation layer. The decrypt moment is where periodic human review naturally lives. You're not approving every vote — that would defeat the purpose. Rather, you're occasionally checking in with your shadow, discussing how your priorities, perspectives, and values have evolved, correcting it where its actions have diverged from your preferences, and letting those corrections inform its future behaviour. It's less a checkpoint and more a feedback loop. The proxy itself improves through error correction over time. ### Phase 2: Private aggregation Your proxy encrypts your vote and contributes it to a collective computation. This is where something like [The Interfold](theinterfold.com) comes in. The Interfold performs the computation over encrypted inputs and produces publicly verifiable outputs. All inputs are encrypted. The only valid output proof requires consuming every encrypted input and running the expected computation. A bonded threshold committee of node operators coordinates to decrypt the final output. The result: mathematically guaranteed correct aggregate output. No party — not the inference provider, not other voters, not the aggregation layer — ever sees individual inputs. The two phases are cryptographically decoupled. The handoff is simple: decrypt locally, re-encrypt under the aggregation scheme. The plaintext moment is brief and intentional. You are the trusted party in possession of your own data. User ↓ AI shadow inference ↓ human audit loop ↓ encrypted preference signal ↓ collective computation ↓ public result * * * ## Why this matters for Vitalik's chaotic era Vitalik argues that in a chaotic era, democratic tools shouldn't try to bind decisions. They should find consensus and give distributed groups a voice that hard-power actors can listen to. AI shadows with private aggregation serve this goal. But they go further. They don't just make participation possible at scale. They make granular, continuous participation possible. The bandwidth constraint that has always forced democratic systems toward blunt, infrequent, high-stakes votes is lifted. * * * ## Parallel societies It would be naive to expect existing institutions to adopt any of this soon. Nation-states, corporations, and legacy DAOs all have strong incentives to preserve existing power structures. Waiting for them to change is not a strategy. But there is no reason to wait. These tools can be deployed in parallel, now, within communities that choose to use them. The history of institutional change is largely a history of parallel structures that proved their worth and were eventually copied or absorbed. The goal is not to replace existing institutions overnight. It is to demonstrate, at small scale, that a more participatory and error-correcting form of governance is not only possible but practical. At @web3privacy's CC2 and @EFDevcon last year, @ArnaudS proposed his personal litmus test for Ethereum, and both @jarradhope_ and @satorinakamoto spoke about the promise of parallel societies. These two ideas have stayed with me. My litmus test for Ethereum is this: its real-world capacity to bring about the flourishing of parallel societies, ultimately in pursuit of the Open Society. Private, direct, participatory democratic systems seem like a significant step in that direction. The cryptographic foundation exists today. The question is whether we build and use it. theinterfold.com | docs.theinterfold.com

@zachtdavidson @auryn_macmillan founder, systems designer, protocol lead rare technomancer 🪄 also one of the kindest, most principled people i know

@deepfates if agents become programming languages come alive, what about execution authority? The environment? The primitives? Or a policy layer above them? Team i'm working with is thinking the latter, but curious if you've noodled on this.

In my quest to understand the true nature of an Agent I have been thinking a lot about the loop and the actions and the environment. And I think i see where we're headed next. Agents are not going to be like chatbots. They are going to be like programming languages come alive. Right now most people's working definition of an agent is "a language model in a loop with some tools", right? This is the ReAct paradigm we've been using for 3 years at least. The models are trained around it, from data formatting to inference stack. Tool calling, function calling, MCPs all rely on this turn-by-turn structure. But context is still the bottleneck, and all the tool call inputs and outputs still have to go through the input. In the meantime we had things like CodeAct, and Code Mode, and Claude Code, that give the model access to some kind of REPL (Read Eval Print Loop, an interactive computational environment, like a terminal or a programming language notebook). And we’ve seen models simulate computer environments as well, like in worldsim and Infinite Backrooms. People realized the model didn't have to simulate just a chatbot. It could simulate a computer. Or a computer user. And once you get RL with verifiable rewards, computer environments suddenly became the thing for models to learn. You can tell whether your model did things right by how well the code runs! So post-training baked in computer use, shell environments, bash tool, and suddenly you have models that are good at predicting what a computer will do in response to complicated programs and commands. Computers that can use themselves. The user is still in a privileged position. The outer conversation loop with the model is still "the main world". But it can do stuff in its computational environment and that stuff persists. The squishy human is no longer the whole environment. There is an ontologically hard reality and it's the computer world, the files and folders and programs within. The Recursive Language Model (RLM) pushes this a step further: What if we don't have a "chat" at all? What if we make the user just a function inside the computer? In fact, what if we put the agent inside the computer too? So the RLM hooks up the language model directly to the REPL and puts the context in as a variable. The LLM can operate over large documents or its own memories or whatever is in that context variable. And it can call the human user with a final answer, or call a sub-LLM with its own {prompt, context} input. This week I built a recursive language model in typescript, and watched it process over 6M tokens without degrading from context rot. It feels… different. You ask it to do something and it writes code that spawns more of itself and then merges back just knowing the answers. The context window hasn’t grown almost at all, no matter how much work the sub-agents did, because they can send variables around without reading what’s inside them. You can have an ongoing conversation where the long-term memory is offloaded to a variable, and the agent can operate over its own memories, so the “context window” is effectively infinite. These new agents will feel less like coworkers, or slowly dying houseplants, than what we have now. They will feel like councils, senates, hive minds. They will be composed of many minds working and communicating. Right now, the models only know “user” and “assistant” and “tool”. Future post-training will have to find patterns for a multi-agent, multi-channel world. In a way, the user and the sub-llms become tools within the environment. We are no longer building single chat-thread instance minds. We are building an intelligent System of software, hardware, and wetware, a program that writes programs, where each of us is a moving part. Haven’t you always wanted to be part of something?

@sodofi_ @zodiaceco @gnosisguild follow-up 🤡 x.com/zodiaceco/stat…

@sodofi_ @zodiaceco @gnosisguild

who are the best teams building for agents? respond below if you want to be part of something new

@dFusionAI @zodiaceco 💯

@zodiaceco Execution logic is where most onchain ops actually break

Managing Safes shouldn't feel like this. Today we're launching Zodiac, a safer and more flexible way to control how onchain execution actually happens. 🎬 🔊 👇

@fede_intern @zama @EnclaveE3 🤡

Apart from @zama what are the best teams working on FHE?

art will actually never catch up

@CaspianHol @EnclaveE3 it's both a butterfly and spells out "E3"

@EnclaveE3 is that a butterfly?

Confidential computing won’t go mainstream overnight. It starts with situations that need 𝓅𝓇𝒾𝓋𝒶𝒸𝓎: elections, health data, censored-resistant governance. Adoption will be bottom-up, and resilient. ઇઉ

@hollyherndon the awe is real, but i'm also fascinated by the guilt and low-grade anxiety in the piece. especially on a system level when agents don't really give a sense of "closure." feels like if systems aren't also designed for affect, humans end up absorbing it.

Humans stroll while agents scroll ✨🪞

@koholaa @EnclaveE3 @gnosisguild so excited for this

Happy to be supporting the team behind @EnclaveE3 @gnosisguild - esp very excited about scoping a cultural program for my fav kind of humans: artists + technologists with @eccogrinder 🖥️💫🖥️ 𝔂𝓸𝓾 𝓬𝓪𝓷 𝓳𝓾𝓼𝓽 𝓭𝓸 𝓽𝓱𝓲𝓷𝓰𝓼

@wacy_time1 @zama don't miss @EnclaveE3

Privacy coins 2026 = AI coins 2024 a16z, Vitalik, Balaji all moving capital here. Most people think privacy = $ZEC and $XMR. The narrative is way bigger now. Projects I'm watching: 1. @zama Fully Homomorphic Encryption. Smart contracts execute on encrypted data. Nodes process computations without seeing inputs. Everything stays hidden. 2. @RAILGUN_Project Privacy layer for EVM. Vitalik-backed. Trade on Uniswap or lend on Aave completely anonymously. DeFi goes private. 3. @aztecnetwork ZK-Rollup on Ethereum using Noir. Enables private applications like Dark DAOs and concealed order books. All the privacy without leaving ETH. 4. @Arcium Confidential computing on Solana. MPC clusters handle high-speed private operations. Think dark pools and secure AI workloads at Solana speed. 5. @zano_project Layer-1 built for private commerce. Ring signatures for untraceability. Real utility through Mastercard integration for spending encrypted balances.

@GnosisGuild behavior as ongoing system art

art as ongoing system behavior.

@metaculture0 I see it as governance relocating from discourse to infrastructure. so more like hypergovernance rather than ungovernance (and not a clean dialectic).

Thesis: Governance - Human history to-date Antithesis: Ungovernance - Immutable smart contract and/or AI systems Synthesis: ? Tempted to go with “hybrid system”, a la the Alien franchise, to denote human-automata interoperability. Doesn’t really map 1:1 though, so if you have ideas I’d love to hear them💡

@a16zcrypto 😎 @EnclaveE3

It's time for our annual big ideas. Here are 17 things that various a16z crypto partners (plus a few guest contributors) are excited about for what’s ahead in 2026. On topics ranging from agents and AI; stablecoins, tokenization, and finance; privacy and security; to prediction markets, SNARKs, and other applications… to how we’ll build. Find the full post here: a16zcrypto.com/posts/article/…

@jerri_nft @GnosisGuild @WasabiNetwork yessss, me too. i've been slowly writing up a longform post on post-aesthetic systems for Gnosis Guild. could be of interest to you.

@GnosisGuild @WasabiNetwork And I certainly do! Sure wish more folks were working on connecting those dots to weave that fabric.

protocol design is cultural work

@EnclaveE3 🐁

New post: the first entry in our Enclave Cryptography series. It examines a core issue in hybrid FHE–ZK systems: how to prove that a ciphertext actually encrypts the value referenced in a ZK witness.

@ystrickler love this, esp how creative work now happens *between* people. been thinking similarly, but from the operational/computational side: how groups hold shared state, navigate conflict, act under constraints etc. even fluid groups need some kind of shared memory/infra for coherence.

Been thinking a lot about an idea I call "groupcore" -- the specific ways we collaborate, self-manifest, and become part of something bigger than us on our own I've come to see this as a new type of labor, almost like open source software, with a unique set of properties and physics that shape how we work and what we make Groupcore is fractal, antifragile, a lattice, poly not mono. Groupcore happens when people seek cooperation that preserves autonomy, distributes authorship, and generates outcomes none could make on their own