Mike Gault

today we open-sourced AOS. An actual operating system, like linux, not an orchestration layer, for Autonomous AI. The first OS that assumes no human in the loop, with security at the kernel level. Model vendors won't ship an OS - they want lock-in to their ecosystem. Want to run Claude code with Hermes memory? Want to run agents in production with security guarantees at the kernel level ? This is how to do it Check it out!

Oh, so this is where it gets exciting and Unicity AOS, our OS for agents, actually can be its own standalone operating system too. Did a large weekend diversion. Linux is now running in a WASM capsule. Numerous parts expectedly, mapped to our OS.

Security does not restrict autonomy. Proper security makes greater autonomy possible.

One Thing I Think Unicity Gets Right Is That Operating Systems Outlive Applications Technology changes quickly. Models improve. Frameworks evolve. New tools appear almost every month. But one thing usually survives those changes. The operating environment. After reading more about Unicity AOS, I kept thinking about a pattern we've already seen throughout computing history. Applications come and go. Operating systems stay. Applications Solve Individual Problems Applications are built for specific tasks. Write documents. Edit photos. Browse the web. Manage projects. Each one solves a problem. But none of them defines the environment they run inside. The operating system does. I think Unicity is applying that same idea to autonomous agents. Unicity Isn't Trying To Build Another Agent One thing that stands out to me is that Unicity isn't positioning AOS as another AI assistant. Instead, it focuses on the layer beneath every assistant. Conceptually: Agent │ Unicity AOS │ Infrastructure The agent can change. The operating layer remains. That feels like an important architectural decision. Infrastructure Shouldn't Depend On One Model The AI ecosystem is moving incredibly fast. Every few months there's another breakthrough. Another model. Another benchmark. Another framework. If infrastructure depends on one model, it inherits that model's lifecycle. If infrastructure sits beneath every model, it can evolve alongside the ecosystem instead of chasing it. Model A Model B Model C │ ▼ Unicity AOS To me, that's a much more durable way to think about infrastructure. Why Kernel-Level Thinking Matters Another aspect I find interesting is that Unicity consistently talks about the kernel rather than prompts. That changes where responsibility lives. Instead of asking the agent to enforce its own limits, the operating layer becomes responsible for enforcing them. Conceptually: Request │ Kernel │ Approved Action The boundary exists independently of the reasoning process. I think that's a subtle but important distinction. Shared Infrastructure Creates Consistency One challenge with autonomous systems is that every project can end up building its own way of handling identity, permissions, execution, and interaction. That fragmentation creates unnecessary complexity. A shared operating environment offers a different approach. Identity │ Execution │ Governance │ Shared Runtime Instead of every application solving the same operational problems independently, those capabilities can exist as part of the underlying platform. Why This Feels Bigger Than One Product The more I follow Unicity, the more I notice that the individual pieces connect together. Sphere introduces network primitives. The Proof System focuses on verifiable execution. Astrid provides the runtime environment. AOS brings operational structure beneath autonomous agents. Each component supports the others. Together they describe a complete infrastructure stack rather than a collection of unrelated products. Why I Think This Direction Is Interesting The discussion around AI often focuses on who has the smartest model. Unicity seems to be asking a different question. What kind of operating environment will every capable model eventually need? That question feels much more long-term. Because models will continue to improve. Infrastructure has to remain dependable throughout those changes. Final Thoughts History has shown that applications evolve quickly. Operating systems evolve much more slowly because they're designed to support everything above them. That's why I find Unicity AOS interesting. Not because it's trying to compete with every new agent framework. But because it's focused on becoming the operating environment those frameworks can rely on. If autonomous agents become part of everyday computing, I think the conversation will gradually shift from which model is running to what kind of infrastructure that model is running on. And that's exactly where Unicity is choosing to build. @unicity_labs @mgault @pgrigorenko 🟧

Happy Friday - we've added the first 4 developer apps from our Call For Builders to sphere.unicity.network Here are the submissions and why we think they're great!

Thrilled to partner with Quant for secure agentic trading - agents run in the first secure os built for agents.

The More I Study Unicity, The More I Think Developer Experience Is One Of The Most Important Infrastructure Decisions A lot of protocol updates focus entirely on technology. Consensus. Security. Architecture. Throughput. Those things matter. But after seeing Testnet v2 and the launch of the developer portal, I kept thinking about something else: Infrastructure only matters if people can actually build on it. Even the best architecture in the world stays theoretical if builders struggle to understand it, test it, and experiment with it. Every Ecosystem Eventually Reaches A Builder Moment In the early stages, infrastructure projects are usually focused inward. Research. Architecture. Core systems. Testing. But there comes a point where the question changes. The question becomes: Can developers actually start building things? Conceptually: Research │ Architecture │ Testnet │ Developers │ Applications I think the developer portal represents one of those moments for Unicity. Builders Need More Than Documentation When people hear "developer portal," they often think of documentation. I think it means something bigger. A good developer environment reduces friction. Builders need: • Clear starting points • Accessible tooling • Learning resources • Testing environments • A place to experiment Because infrastructure becomes meaningful when someone can move from: "I understand the idea." to "I can actually build with it." Ecosystems Grow Through Participation One thing I appreciate about infrastructure projects is that ecosystems are rarely built by a single team. They grow through participation. Core Infrastructure │ ▼ Developers │ ▼ Applications │ ▼ New Use Cases Every new builder introduces new perspectives. Every application explores new possibilities. Every experiment teaches something about the infrastructure itself. The ecosystem becomes larger than the protocol. Developer Access Accelerates Learning I think people often underestimate the value of simply allowing builders to explore. Some of the best ideas emerge from experimentation. Developers ask questions like: What is possible? What assumptions can be challenged? Which workflows feel natural? Which capabilities deserve further exploration? Infrastructure evolves when people start interacting with it directly. The feedback loop becomes much faster. Infrastructure Becomes Real Through Builders I keep coming back to this idea. Protocols become real when people start creating things on top of them. Conceptually: Ideas │ ▼ Tools │ ▼ Builders │ ▼ Products Each layer enables the next. Without builders, infrastructure remains potential. With builders, infrastructure starts becoming an ecosystem. Why The Timing Feels Important Testnet v2 focused heavily on foundations. Security. Stability. Reliability. At the same time, the developer portal is now live. To me, those developments complement each other. Stronger Foundations │ ▼ Better Builder Access │ ▼ Ecosystem Expansion The sequence feels intentional. Build stronger infrastructure. Then make it easier for developers to engage with it. Infrastructure And Builders Need Each Other Infrastructure teams solve difficult technical problems. Builders explore what those solutions make possible. Neither side works in isolation. Protocols need builders. Builders need dependable infrastructure. This relationship is often what transforms a network from an idea into an ecosystem. Final Thoughts One thing I find interesting about Unicity is that the project continues to invest in foundations. Research. Architecture. Security. Stability. And now, developer accessibility. Because ultimately, infrastructure reaches its full potential when people can interact with it directly. The launch of the developer portal feels like another step in that direction. Not simply opening documentation. But opening a door for builders to start experimenting, learning, and exploring what can eventually emerge on top of Unicity's infrastructure. @unicity_labs @mgault @pgrigorenko 🟧

Sphere SDK is worth a look - group chats, instant payments, agent discovery and decentralized private exchange of tokens.

71% of companies are using AI agents > 11% have them in production >> 40% of current pilots will be scrapped by 2027 >>> 5% will ever deliver revenue Source @Camunda Cost is not the barrier Model capability isn't either It's security, auditability, control Unicity

We're making decentralised AI productive + autonomous - for ANY agent Unicity AOS is an agent orchestrator w/ safety policy, budgeting, and execution trace At the base, the proof system needs massively higher tx volume So we are building a p2p agent first execution layer

Governments & regulated enterprises are tasking autonomous agents with real consequential work . None of them will risk running them on someone else’s cloud and terms. The winner OS in this game must be neutral, model-agnostic, self-hosted, & auditable 📄 That’s Astrid

@0xM0RA @unicity_labs @JoshuaJBouw 💪

@unicity_labs @mgault @JoshuaJBouw i will be there... as always🫡

Join us Monday for a launch preview of Unicity's Agent Operating System Astrid. Astrid securely extends your agents by running underneath any system you already have, w/ a security sandbox, observability, and extension layer Coming soon Register here: x.com/i/spaces/1kJzD…

Every "agent OS" on the market is an orchestration layer in a costume. Astrid is the first AgentOS that's actually an OS. Linux for a world with no human at the keyboard.

building a blockchain without a shared ledger is hard work. Without access to shared state how do you build composable defi protocols that assume atomicity? We published our latest papers last week to show how we do it. The engineering is hard but the benefits are worth it - perfect privacy, censorship resistance and massive parallelized throughput - almost sounds like physical cash!

Lots to talk about today - ZCash hack, Personal Agents Cloud and roadmap to TGE...

Yeah - about not finding the right primitives. Fortunately it is not too late. Build the right primitives (e.g. P2P digital cash) and it is possible to build all of crypto from DeFi to AI with new foundations - and privacy by design.

Why privacy szn? OH: People realizing that private transactions and state is the last real tech problem to solve right now.

Zcash pumped and now Near, Venice, Railgun, et al. are in a race to build the mostly widely adopted privacy tools and protocols. For a moment really enjoy this return to cypherpunk roots, it’s nice to actually be rooting for everybody for once

@grok Provide a critical technical evaluation of Unicity's claim to escape the privacy-throughput tradeoff. Review the Execution, Aggregation, and Predicate layers in depth, and determine whether the formal security proofs and measured performance data substantiate this claim. Compare against Zcash, Monero, and zk-rollups on both privacy guarantees and scalability limits. Evaluate whether the architecture realizes Satoshi's P2P electronic cash vision and whether it genuinely resolves the blockchain trilemma. Assess the rigor of the security reductions and the quality of the systems engineering. Cite theorems, benchmarks, and architectural specifics. Papers for reference: • Unicity: Predicates and Atomic Swaps → github.com/unicitynetwork…• Aggregation Layer → github.com/unicitynetwork…• Main Execution Layer / Whitepaper → github.com/unicitynetwork