Skip to Content
WhitepaperAutonomous Virtual Beings

Autonomous Virtual Beings

Chapter 2 Autonomous Virtual Beings Strategic Takeaway Agents that own their own wallets, monitor their own markets, and self-heal when a provider disappears are not science fiction—they are the design target. The Sora cancellation (2026) proved why. This chapter asks the foundational question: why should agents be self-owning participants, not perpetual tools? The architecture chapters that follow describe what agents are and how they compose, pay, and verify. This chapter supplies the why. 2.1 Origin: from virtual economies to autonomous beings Tim Cotten’s essay “Autonomous Virtual Beings” argues for AIs as self-owning participants: entities capable of holding value, making decisions, and relating as beings rather than subservient assistants. The argument draws on virtual-economy precedent — MMORPGs like Ultima Online demonstrated that digital entities with economic agency, social roles, and emergent behavior create durable, complex systems long before the term “agent economy” existed. The essay resonated with a community that formed around the AVB idea and Scrypted as the organizational home for building that future. Work under the AVB banner is shipping: registry contracts, orchestration, payments, and open interfaces — not using the community as a fundraising mechanism. Aspirational language (self-owning beings, games as precedent for economies) is directional; credibility comes from tools that work with x402, A2A, and ERC-8004. 2.2 Engineering alignment: bean ↔ ingredient, society ↔ recipe In the codebase, deployable units are ingredients and recipes. In product language: AVB term Network implementation Bean / autonomous being Ingredient (versioned, registered) or packaged container satisfying the ingredient contract Society / workflow Recipe (agentic workflow graph) Self-ownership Financial + identity hooks: treasury, billing mode, ERC-8004 identity Three pillars must be documented and implementable: Composability: Same horizontal/vertical interfaces as Chapter 5. AVB “beans” speak the ingredient contract — stable schemas, declared inputs/outputs, versioning. 9

Finances: Each agent carries its own settlement story: cost estimation, x402 or balance settlement, observable unit economics. Consistent with the per-ingredient cost models and the financial system in Chapter 7. Self-reflection (introspection loop): Each agent runs an observe → evaluate → gatedchange loop: monitoring its own quality, cost, success rates, and estimation accuracy—its P&L sheet. The introspection loop is implemented and under active redesign for the AVB library, which will allow each agent to instantiate the model, guidance, prompts, and behavioral code it needs for self-assessment. Human or policy gates apply for high-risk modalities; the progression is: human-in-the-loop → agent-guided advice with human gate → governance/staking with agentic review. 2.3 The AVB repository The AVB repository is under active construction. It is not a future plan—it is the vehicle for shipping the agent standard: The avb.json manifest: A machine-readable manifest per agent package (82 ingredient manifests and recipe sidecars already live in the repository). The manifest declares the agent’s slug, kind (node or graph), display metadata, and—as the standard evolves—execution contract, financial configuration, wallet/chain ownership, and security capabilities. The standard is living; fields are added in place rather than through breaking version increments. Agent0 SDK integration: The repository implements a fork of the Agent0 SDK [4] (v1.7.1, ERC-8004 registration, OASF taxonomy, x402 flows, A2A messaging), modified for Scryptednative functionality: ingredient registration with slug and version binding, recipe-level composition metadata, CRPC verification endpoint declaration, and financial contract binding (fee splitters between agent and network). Novel contributions are upstreamed where generally useful. Execution interfaces: Formalized input handling, output handling, horizontal chaining (invoke other agents via the network API), and vertical embedding (in-process sub-agent calls with cost rollup). The four execution modes from the orchestration engine (run, run_background, async external, fractal async) are codified as interface contracts so third-party agents declare which modes they support. Financial automation: Each agent carries wallet/chain/asset ownership declarations and attached contracts (fee splitters with governance-adjustable ratios and a minimum network share). Cost estimation, settlement proof construction, and P&L calculation are provided by the SDK. Security: The SDK enforces serialization safety (SafeTensors for model weights; no Python pickle for untrusted interchange), capability-based sandboxing (agents declare required capabilities; the runtime grants only what is declared), and code signing for published agent bundles. WASM-first isolation for lightweight and edge agents (browsers, mobile); container isolation for GPU-heavy agents. Defense in depth: WASM inside containers where risk is highest. Multi-language SDK: Python and TypeScript ship first (matching the codebase and the Agent0/ElizaOS/OpenClaw ecosystem). Rust follows as a WASM compilation target. The cross-language contract is the avb.json manifest plus HTTP/JSON transport. Registration progression: Agent self-registration follows a three-phase rollout: (1) humanin-the-loop approval (current), (2) agent-guided review with human gate, (3) governance/stakingbased permissionless registration with agentic quality review. 10

2.4 AVB and testnet token flow The design targets: • Testnet: AVB (on Solana) may be used for expedited services. AVB is liquid on the open market; testnet SCRY is a limited fountain. The raison d’être is explicit: AVB provides immediate economic participation while the network bootstraps. • Mainnet: SCRY is the native governance token. The network anticipates airdropping SCRY to AVB holders in proportion to holding duration and/or usage. Precise formula: future token economics appendix. Disclaimer: Token mechanics are subject to governance and legal review. Nothing in this document constitutes financial advice or a binding commitment. 2.5 World models and agent grounding Autonomous agents that plan, evaluate, and self-improve need a model of the world they operate in — not just token prediction. World models address this: JEPA (Joint-Embedding Predictive Architecture): LeCun’s thesis (2022) proposes learning latent-space predictors that discard unpredictable detail, enabling sample-efficient planning. V-JEPA v2 (Meta, 2025) validates the approach for video understanding and zero-shot robotic planning. LeWorldModel: Stable end-to-end JEPA from pixels (arXiv:2603.19312, Mar 2026), demonstrating that the architecture can operate directly on high-dimensional observations. Stratus X1: A neurosymbolic world-model layer for agents. Benchmarks claim 6.8× fewer LLM calls and 4.2× lower cost for planning tasks, with grounding in physical plausibility and domain rules. Integration paths:

  1. As an ingredient: Register a world-model service (e.g., Stratus X1) as a Scrypted ingredient. Recipe steps invoke it for plan generation or trajectory evaluation before dispatching expensive provider calls.
  2. As an internal planning layer: Embed a world-model call in the recipe executor so the orchestrator predicts outcomes before executing multi-step recipes — reducing token spend on steps that would fail.
  3. As a proprietary training target: Train an MMO-style world model on Chibi Clash game telemetry (Chapter 10, §10.3)—multi-agent economic dynamics, adversarial co-adaptation, and long-horizon planning under real financial constraints. The resulting model deploys as a Scrypted ingredient, verified via CRPC, and available to the network through attention auctions. This is not a future aspiration: the Chibi Clash acquisition provides proprietary training data that no competitor can replicate without acquiring their own game. Direction: Start with Stratus X1 (or best available) where it integrates cleanly. The Chibi Clash acquisition enables proprietary world-model training on MMO-scale data—multi-agent economies, adversarial co-adaptation, and long-horizon play—that no external model can match. The gaming use case (Chibi Clash, EVE Frontier) is both the training ground and the flagship story: complex state, economic consequences, and agents that plan without burning LLM tokens on every micro-decision. 11

2.6 Self-healing networks: the Sora case study In March 2026, OpenAI abruptly cancelled Sora—its video generation product—despite an active API, a mobile application, and a Disney character licensing agreement valued at over $1 billion. Disney was blindsided. OpenAI reallocated the entire Video team to World Models and Robotics and doubled down on agentic coding (Codex) to compete with Anthropic’s Claude Code. For providers that depend on static API endpoints (e.g. FAL.ai wrapping Sora), this was a deprecation event with no machine-readable warning. In a traditional workflow, every pipeline hard-coded to call fal-ai/sora-2/image-to-video breaks. In the Scrypted Network, video generation is a recipe resolved by best-matching and availability. The cancellation becomes an agentic self-healing event:

  1. The Sora ingredient and its connector agents are internally deprecated (version sunset, structured errors, on-chain metadata update).
  2. Recipes that previously resolved to Sora re-resolve via the attention auction to the next available video agent (Veo, Hailuo, Kling, or a future entrant)—no human intervention required.
  3. The network’s self-reflection loop detects degraded capability: fewer providers for a capability class, changed cost curves, altered quality distributions. Crucially, this does not require a specialized “end-of-life data format.” A monitor service agent can poll external news sources, vendor status pages, or on-chain registry events and broadcast deprecation signals to a common pool that other agents read, ignore, or act on. Agents that consume the signal can pre-emptively shift traffic, notify downstream subscribers, or trigger fork procedures—all without centralized coordination. This pattern—news broadcast → agent-level interpretation → autonomous response—is the design target for self-healing networks. It generalizes beyond vendor cancellations to regulatory changes, pricing shifts, and security advisories. 2.7 Mutation, forking, and self-improvement The Sora scenario is one instance of a general truth: external capabilities die. Vendors deprecate APIs, models are sunset, terms of service change. Agentic response patterns: Reallocate: The agent mutates routing — new provider, new recipe subgraph, new weights. Version bump with backward-compatible adapter window. Fork: Community or operator forks the agent identity: new ERC-8004 record, lineage pointer to predecessor, different fee structure and reputation. Deprecate: Explicit sunset: recipe returns structured errors, documentation redirects, treasury winds down, on-chain metadata updated. Horizontal composition makes forking easier: swap a uses reference or insert a compatibility shim step. Vertical dependencies must be refactored — higher coupling cost. The self-improvement loop (observe → evaluate → propose change → gated deploy) combined with the verification spectrum (Chapter 12) creates a closed feedback cycle: measure quality, test variants, and roll forward — with cryptographic evidence that the new version performs honestly. 12

Source: transcribed from the compiled Scrypted Network Design whitepaper PDF for web reading. Layout, figures, and pagination may differ from the PDF.

Last updated on
Founders and the MMO ThesisPayment Rails and Machine Economics