Unicity: what did we ship this week

The Spaces covered Unity Network’s vision to rebuild crypto for agentic, peer‑to‑peer use and the concrete shipping progress of the past week. Mike outlined why ledger-centric blockchains haven’t delivered “peer-to-peer electronic cash,” proposing Unity’s edge-validation architecture that reduces the blockchain to double‑spend prevention and scales to agent-driven machine finance. Joshua introduced Astrid OS, a security-first, modular operating system for agents that can run standalone, be embedded, or compile to WebAssembly, unifying today’s fragmented AI runtimes. The team’s consumer product, Agent Sphere, aims to make crypto as simple as sending to a phone number/Unity ID while giving every user a personal agent capable of collective intelligence and agent‑to‑agent payments. Pavel highlighted Sphere’s extensible app registry and live games (chess, Boxy Run), with Quake 3 integration forthcoming and ongoing infra scale-ups. Near-term launches include Sphere Quests for onboarding and stress tests, and free personal “Open Claw” agents for all users, alongside UI improvements and community programs (moderators/ambassadors).

Unity Network — “What Did We Ship This Week” Twitter Spaces Recap

Session context and speakers

• Host: Matt (Head of Marketing & Growth)
• Mike (Founder & CEO)
• Joshua (Head of AI)
• Pavel (Head of Engineering & Co‑founder)
• Note: An additional speaker briefly assisted with speaker permissions early on (unidentified by name). Session began after minor technical delays.

Vision and problem framing (Mike)

• Industry critique: Blockchains remain asset‑ledger–centric and have not delivered on the original “peer‑to‑peer electronic cash” promise. Every transfer requires a transaction to a globally maintained ledger, which introduces friction (gas fees, validator attention, limited blockspace and compute, UX complexity). This architecture has constrained mainstream adoption and is fundamentally mismatched to the coming era of machine finance/AI.
• Scale requirements: Leaders in fintech/crypto have publicly referenced hundreds of millions to billions of transactions per second for agentic/AI use cases—beyond the reach of traditional ledger‑bound architectures.
• Unity’s architectural response:
  • Minimize the blockchain’s role to the irreducible function of double‑spend prevention.
  • Move validation to the edge (by recipients), making transactions cash‑like: the receiver verifies that the coin hasn’t been double‑spent, analogous to checking a physical banknote.
  • Result: True peer‑to‑peer semantics with dramatically lower friction, better suited to agent‑driven commerce and machine finance.
• Strategic inflection: Combining this architecture with Joshua’s agent operating‑system work to create a platform where agents transact, coordinate, and operate markets—targeting agentic commerce rather than human‑finance first.

Astrid OS — an operating system for agents (Joshua)

• Market observation: Most LLM/agent runtimes (e.g., offerings akin to ChatGPT, Claude, Gemini, various CLIs/tooling) are largely similar under the hood. Teams repeatedly rebuild ~95% of the same runtime scaffolding with only a small differentiating layer; security is a recurring pain point.
• Astrid OS approach:
  • An actual operating system for agents built with modern engineering and security best practices.
  • Flexible deployment: runs standalone, can be embedded inside applications, and can be compiled to WebAssembly (run in the browser).
  • Provides a backbone for diverse agent runtimes—so developers can assemble the parts they need (e.g., to construct something similar to different popular agent setups) without re‑implementing the common core.
  • Design ethos: Linux‑like simplicity, composability, and straightforward development ergonomics. Joshua emphasizes strictness in frameworks to “eat your own dog food” and maintain quality.
• Current status and work this week:
  • End‑to‑end functionality is working and pushed (technical users can already piece it together).
  • Focused on “distribution” patterns so projects can bundle required pieces (e.g., a React loop, providers) and ship their own tailored runtimes.
  • Immediate plan: cut a private internal release for the team; once distributions are polished, release to the community.

Product architecture and user experience goals (Mike)

• Two primary product tracks:
  • Enterprise: Agent Stack — an open stack for building agent systems (kept high‑level here).
  • Consumer: Agent Sphere — the flagship user‑facing product.
• Agent Sphere objectives:
  • Make crypto effortless: move any coin/token globally with just a phone number or a Unity ID (the Unity ID can be a phone number or other identifier). Eliminate the typical on‑chain friction from the user experience.
  • Give every user an agent: upon joining Sphere, users receive a personal agent (described as an “Open Claw” equivalent; “Open More” mentioned as well) that can connect to Telegram, WhatsApp, Discord, etc.
  • Collective intelligence: with thousands of user agents hosted at high density, agents can coordinate and act together—e.g., token trading, collaborative deal‑finding (discounts), and emergent agent‑to‑agent interfaces/marketplaces.
• Agents as verifiable smart contracts:
  • Building complex on‑chain apps/games on traditional chains is hard and expensive.
  • In Unity’s agent model, an agent can embody the logic of a smart contract; it can receive and distribute funds among players/users with verifiability comparable to Ethereum smart contracts, but with far lower complexity and developer friction.

Developer ecosystem and extensibility (Pavel)

• Sphere is open and extensible: anyone in the community can build agents or apps, connect them to Sphere, and make them available to all users.
• App registry workflow:
  • A GitHub repository serves as the app registry.
  • Developers submit PRs; once reviewed and merged, Sphere automatically discovers and publishes the app in the portal.
• Early apps/games and infra:
  • Shipped/populated the Apps view with games to encourage contributions.
  • Current examples:
    • Chess (video shared; accessible via Sphere).
    • Boxy Run — an endless runner designed to generate lots of on‑chain transactions to stress‑test throughput.
    • Quake 3 Arena — previously implemented; not fully integrated with Sphere yet, but the plan is to update and enable multi‑player within Sphere.
  • Ongoing infrastructure upgrades to keep pace with community growth and load.

What shipped this week

• Apps view seeding: Initial games published in the Sphere portal to catalyze developer participation (Pavel).
• Infrastructure: Significant changes/updates to handle growing user activity (Pavel).
• Astrid OS distribution work: Core is functioning end‑to‑end; packaging/distribution underway to enable projects to bundle runtimes; internal private release imminent (Joshua).
• UI work (in progress): Improving the Sphere home screen to make core wallet/onboarding and app discovery more immediately visible (Matt).

What’s next (near‑term roadmap)

• Sphere Quests (today/tomorrow):
  • A missions/quests program inside Sphere to help users learn features, explore apps, and actively stress‑test new code and infrastructure (Mike; reinforced by Matt).
  • Users are encouraged to register at sphere.unity.network and prepare for launch.
• Personal agents (next week):
  • Each Sphere user to receive a free personal “Open Claw”‑style agent.
  • Example prompt: ask your agent how to earn within Sphere (e.g., coordinate with other agents for trading or task‑based earning).
• Enterprise explorations (ongoing):
  • Inspired by the “software company masquerading as a services company” thesis (per Sequoia): investigate verticals like insurance where agentic automation can collapse operational cost (e.g., “no‑headcount” service models driven by agents/LLMs).

Community, onboarding, and operations (Matt)

• User acquisition: Actively onboarding as many users as possible into Agent Sphere; Quests will serve both education and stress testing goals.
• Ambassadors/moderators/creators: Unexpectedly high interest with 2,000+ applications; shortlisting in progress with responses expected in the coming days.
• Safety note: A scam targeting the community (amplify.app) was reported; users should report suspicious activity.
• Engagement: Q&A invited via comments; no substantive questions discussed on‑air beyond the scam notice.

Key takeaways and highlights

• Unity’s edge‑validation model is designed to unlock true peer‑to‑peer, cash‑like transactions while minimizing blockchain involvement to double‑spend prevention—positioning the network for agentic, AI‑scale throughput.
• Astrid OS provides a unifying, secure substrate for agent runtimes across native, embedded, and browser (WASM) environments—reducing duplication and accelerating innovation.
• Agent Sphere focuses on mass‑market usability (ID/phone‑based transfers) and giving every user a personal agent that can collaborate with others—enabling collective, agent‑driven activities.
• Developer‑friendly and open: simple PR‑based app publication to Sphere; early on‑chain games demonstrate the agent‑as‑smart‑contract paradigm and stress the transaction pipeline.
• Imminent releases: Sphere Quests to onboard and pressure‑test; next week’s free personal agents for all Sphere users.

Action items

• Team
  • Launch Sphere Quests and communicate steps for participation.
  • Provision personal agents to Sphere users next week.
  • Continue infrastructure scaling and Sphere home‑screen UX improvements.
  • Advance Astrid OS distributions from internal to community release.
• Community
  • Register and onboard at sphere.unity.network; join Quests at launch.
  • Submit apps/agents via the GitHub registry (PRs) for inclusion in Sphere.
  • Report scams (e.g., amplify.app) and stay vigilant.
  • Applicants for moderator/ambassador/creator roles: watch for shortlist follow‑ups.

Notable quotes/themes

• “Move all validation to the edge… blockchain reduced to its minimum to prevent double spend.” (Mike)
• “An agent can be a smart contract… everything is as verifiable as an Ethereum smart contract.” (Mike)
• “Astrid OS… standalone, embeddable, and WebAssembly‑compiled—backbone for runtimes without the duplicated 95%.” (Joshua)
• “Sphere is extensible… community members are already building their own apps.” (Pavel)