The Tao Architecture: Turning Every Device Into One Global Computer

The traditional von Neumann architecture does not fit today's computing infrastructure needs. As a practical hardware reification of the Universal Turing Machine, it is built around a single active processor reading and overwriting a flat, passive memory space across a shared bus. That single-head, single-tape model breaks down when workloads span heterogeneous machines, multi-die packages, and wide-area networks. Modern infrastructure is defined by non-uniform memory access, bandwidth walls, asynchronous failures, and distinct trust boundaries, where maintaining global mutable coherence and dragging large datasets across buses or oceans becomes the primary bottleneck.

If global mutable coherence is the wrong foundation for a distributed substrate, what can replace it? The initial inspiration for the Tao Architecture came from biology rather than computer hardware: ant stigmergy.

In an ant colony, no central planner assigns routes, and ants do not maintain a shared mutable ledger or coordinate through point-to-point messages. Instead, an ant acts locally and leaves a persistent trace (a pheromone trail) in a shared physical environment. Reading that trace does not consume it. Other passing ants sense the local chemical gradient, interpret it according to their own role and state, and respond by following the trail, reinforcing it, or branching off to forage elsewhere. A hive mind emerges indirectly from simple agents interacting through traces left in a shared medium.

The Tao Architecture, the post-von Neumann software, OS, and distributed execution model underlying Datom.world, translates this stigmergic principle into computing infrastructure. It replaces in-place mutable memory and fixed processor-to-memory buses with append-only streams, immutable datoms, mobile continuations, and decoupled interpreters. While today's implementations still execute on von Neumann hardware (and use local mutable structures between stream boundaries for speed), the architecture demotes that hardware to local execution backends beneath a post-von Neumann distributed substrate.

Every core element of Tao maps directly to a role in stigmergic coordination:

  • The shared environment is dao.stream and dao.space. Just as terrain holds pheromone trails without caring which ant reads them, an append-only stream preserves facts without knowing who will consume them. Independent readers advance their own cursors; reading never destroys another observer's input.
  • The pheromone traces are immutable datoms. Facts, expressed as 5-tuple datoms [e a v t m] covering program syntax, projected execution state, locality metrics, leases, and capability grants, persist in the medium for any authorized observer to inspect.
  • The ants are decoupled interpreters. dao.space.index materializes queryable views, Yin.VM evaluates program datoms, lowering backends specialize hot regions, Shibi evaluates authority and metering, and placement policies weigh locality, all reacting to the same shared stream without needing to know each other exists.
  • Trail reinforcement is telemetry-driven placement and mobile continuations. As hosts emit latency, bandwidth, cache-warmth, and capacity observations as datoms, placement interpreters steer resumable Yin.VM continuations toward their data and away from congested or failing links, much as a colony reinforces efficient paths and abandons depleted ones.

Through this stigmergic substrate, one global computer means that participating devices, from future RISC-V boards running a theoretical Tao Kernel to edge nodes, servers, and accelerators, compose through explicit data and portable execution contracts. The shared software layer exposes the different capabilities, locality, authority, and costs of each participating node as data, while independent failures and trust boundaries are governed by explicit contracts.

1. The Tao Architecture: Axioms and Primitives

The four axioms establish the responsibilities of the architecture's core elements: immutable 5-tuple datoms ([e a v t m]), dao.stream, dao.space (backed by dao.jing), Yin.VM, and Shibi authorization and metering interpretations over grant, revocation, and usage facts. These elements occupy different roles: streams carry values; storage preserves content; query and execution interpreters give it meaning. The Yang compilers project supported source-language constructs into the Universal AST. Language coverage and the availability of required host functions determine which existing programs can participate.

Axiom 1: Everything is a Stream (dao.stream as the Universal Bus)

dao.stream is the payload-agnostic, append-only abstraction for portable I/O. Readers advance independent cursors; reading does not consume another reader's data. An interpreter can derive a stable view from a bounded, retained prefix without a global reader lock. This establishes consistency relative to those inputs: ordering across writers, cross-stream atomicity, and exclusive ownership belong to explicit protocols above the stream. Retention is declared by the transport; a reader encountering evicted history receives a gap rather than silently treating a suffix as a complete history. Stream payloads can include datoms, bulk tensors, Arrow buffers, or execution snapshots where the transport supports their representation. Portable effects are stream emissions; direct-I/O host functions are explicitly local and non-migratable.

Axiom 2: Interpretation Creates Semantics (One Stream, Many Backends)

Streams carry values without deciding what those values mean. Over a program's datom stream, dao.space.index can materialize covered indexes (EAVT, AEVT, AVET, VAET), while Yin.VM independently evaluates the program. Neither observer needs to know the other exists, and neither requires the other to be installed. Queries interpret immutable indexed inputs; the evaluator interprets program data. An execution interpreter can use CUDA or ROCm as a local backend and expose portable effects through the same stream boundary. The stream carries no privileged execution or query semantics.

Axiom 3: Code and State are Datoms (A Shared Semantic Representation)

Persistent facts, including program syntax and projected execution state, use the immutable 5-tuple datom [e a v t m] (Entity, Attribute, Value, Transaction, Metadata). Bulk payloads retain suitable representations; streams impose no datom requirement on every value. The canonical Universal AST supplies shared syntax; conforming evaluators and lowering interpreters must preserve its specified execution semantics for the constructs they support. The Yang compiler (yang/compile) projects source languages into the canonical Universal AST, and vm/ast->datoms projects that AST into a datom stream. Because code is inspectable data, lowering passes can be composed as interpreters over that data. The proposed CPU/GPU specialization follows this division of responsibility:

  • An irregular, branch-heavy agent loop is reduced step-by-step by a scalar Yin.VM interpreter on a CPU core.
  • A lowering interpreter may target PTX, SPIR-V, or Metal for a region whose effects, parallel dependencies, data representation, and numerical semantics it can preserve. Unsupported regions retain a compatible general evaluator.

The canonical AST remains retrievable when lowered artifacts are produced, keeping specialized execution tied to inspectable program data.

A workstation, a GPU-backed host, a smartphone, and a cloud server can expose execution capabilities and cost observations as data. A placement interpreter decides which of those hosts can run a given region and whether moving it is worthwhile.

Axiom 4: Everything is a Continuation (Making Execution Portable)

Where von Neumann hardware reifies the Turing machine's single head mutating a flat tape, Yin.VM follows a different lineage: the CESK machine, an abstract-machine operational semantics for the lambda calculus rather than a tape machine. While equivalent in theoretical computability, CESK factors execution into four explicit, structured values instead of an opaque call stack and raw memory addresses: Control (the current AST node or instruction), Environment (lexical variable bindings), Store (allocated state), and Continuation (the explicit rest of the computation). Yin.VM takes this model a step further by projecting those four components as immutable datoms and stream-compatible values rather than confining them to one process's mutable memory.

Backends can still use native execution structures between safe points and expose a portable representation at the boundaries. The architectural consequence is that resumable state need not remain tied to an OS thread. Cross-host resumption additionally requires portable dependencies, compatible execution semantics, admitted resources, and an explicit custody handoff. Host-local functions and resources cannot acquire portability merely by being referenced in a continuation. This supplies the basis for data gravity: a placement interpreter can move compatible computation toward its inputs when the expected savings exceed checkpoint, transfer, and recovery costs.

As explored in The Tao Kernel (a theoretical kernel design that does not yet exist), OS-like coordination can be expressed through interpreters of stream data. A Single Address Space (SASOS) deployment can place confined computations and kernel machinery in one local address space. Yin.VM containment and Shibi authorization interpretations determine permitted resource access. dao.lease expresses tenure and renewal as facts; resources requiring exclusion also need fencing. The resource-owning host enforces admission and effects at its boundary. A co-resident stream implementation may share immutable buffers without copying payloads. A local pointer addresses memory in that deployment; a content hash identifies canonical content across hosts. Datom entity and transaction IDs remain stream-local, and queries preserve each physical source's scope. Cross-host composition carries explicit references and dependencies through a transport.

From a RISC-V Board to a Compute Fabric

This composition model could begin on a simple printed circuit board. Although the Tao Kernel is still a theoretical design and does not exist yet, a future board with RISC-V cores, sufficient memory, boot storage, and a communication interface could run it directly as its operating environment. A bare-metal port would initialize the hardware and provide memory allocation, trap handling, timers, and device drivers. RISC-V's machine-mode execution permits that arrangement. A hosted deployment can instead use an existing OS to supply those facilities.

The four axioms determine how the board participates. Device adapters translate external events into stream values; host interpreters consume effect requests, operate devices, and append outcomes. Yin.VM interprets program datoms and makes continuations explicit. Scheduling and authorization interpreters derive decisions from facts, with the runtime enforcing those decisions at execution and resource boundaries.

Several processors on the board could execute independent program regions, while vector units or attached accelerators could serve regions supported by a lowering backend. Compilation, indexing, and content storage can run on other participating hosts, so a small execution node need only supply the interpreters and stream implementations its role requires. Tao would occupy a role analogous to the compiler and runtime layers of CUDA or ROCm: turning available execution resources into a programmable platform. Arithmetic throughput and memory bandwidth would still come from the board's hardware, and efficient execution would require suitable lowering and libraries.

The resulting platform could extend from links between chips on a PCB to links between boards through the same stream abstraction. Fine-grained instruction scheduling stays local; cross-chip work is batched so useful computation can repay communication costs. A program could begin on one core, delegate an independent batch to another, and later hand off a compatible continuation to another board. Each step retains the same program identity while making dependencies, placement, and custody explicit.

2. Planetary Soft Silicon: Interpreting Locality and Content Identity

Whether the resources share a PCB or communicate across the internet, Axiom 2 applies to topology as well as execution: latency samples, bandwidth observations, and resource availability are data; a placement interpreter constructs a topology and cost model from them. Measured costs can be directed and time-varying. A policy using mathematical metric-space algorithms must establish the properties those algorithms require.

The soft silicon analogy describes composition: compute resources connect through a fabric, and locality affects placement. A placement interpreter can compare queue delay, execution time, missing-input transfer size and bandwidth, checkpoint cost, and declared price. Hysteresis can discourage migrations whose small predicted benefit would be overwhelmed by churn. The following correspondences are design analogies; network links retain their own latency, failure, and trust characteristics:

GPU Chiplet ArchitectureTao Architecture (Datom.world)
Compute Die (XCD / SM)A host with a compatible Yin.VM evaluator or supported accelerator backend
Infinity Fabric / NVLinkdao.stream transports, with measured locality interpreted from telemetry facts
1-Hop Package / InterposerEntanglement group: a policy-derived neighborhood whose explicitly scoped inputs can be queried together
Infinity Cache / Shared SRAMLocal content and index caches retained by an explicit policy
Resource management / protectionShiBi authorization and metering interpretations, lease facts, and host-enforced resource boundaries

The Interned Distributed Heap: Shared Identity, Explicit Transfer

Axiom 3 makes code and projected state available as structured data. dao.jing assigns content identity through canonical encoding and hashing, without interpreting domain meaning. Explicit content references can form a Merkle DAG; equal canonical content has one logical address, while many hosts may retain physical copies. A portable continuation can reference model weights, AST units, or immutable cache blocks by address. A destination reuses locally available content and fetches missing dependencies, so a warm destination avoids redundant transfers while a cold destination still pays for missing bytes. Hash verification checks that fetched content matches its address. Admission policy separately determines whether to trust code, execution semantics, and reported results.

Discovery and Calibration as Stream Interpretations

Discovery is another interpretation over explicitly available media. A local discovery composition can exchange self-certifying public-key beacons on a dao.stream, authenticate echo exchanges, and emit :metric/rtt and :metric/hops datoms into dao.space as observations. This can avoid a central registry where local discovery is available; wider reachability still depends on an explicit bootstrap and transport composition. A public key establishes identity, while authorization remains a separate interpretation.

Calibration observers can update locality facts from correlated exchanges using a local monotonic clock; timestamps from unrelated hosts are not directly comparable without an additional clock model. Telemetry is a composition choice, with no mandatory timestamp shape added to every stream payload. Datalog rules can derive candidate neighborhoods and placement decisions from these facts. A runtime may act on those decisions, checkpointing and handing off compatible continuations at safe points. Group membership and completion are also interpreted facts, with explicit rules for required causal inputs and unreachable participants. Local GPU barriers retain their execution and memory-ordering role inside lowered kernels.

3. Lessons from CUDA, ROCm, and Chiplets

Modern NVIDIA and AMD GPUs embed OS-like scheduling, dispatch, and resource-management mechanisms in hardware and firmware, trading single-thread control logic for SIMT warp schedulers and thousands of parallel ALUs. Even so, GPUs remain fundamentally von Neumann machines at their core: kernels and tensors still reside in mutable addressable memory (HBM, VRAM, shared SRAM) overwritten in place, threads still synchronize through shared-memory barriers and atomics, and the von Neumann bottleneck simply shifts to memory bandwidth and PCIe or NVLink transfers. Each GPU retains its hardware scheduling mechanisms, while the Tao Architecture treats that vendor-specific machinery as a local backend beneath a post-von Neumann software layer.

CUDA and ROCm illustrate three requirements for a useful execution platform: a portable programming model, effective lowering and libraries, and hardware-aware placement. Their detailed history, from BrookGPU through CUDA's GPU generations and ROCm's compiler and release evolution, is documented in CUDA and ROCm: From BrookGPU to Chiplet Compute Fabrics.

For Tao, the programming-model lesson is to preserve canonical program data and specified execution semantics while allowing backends to change. The performance lesson is that inspectable code becomes useful acceleration through suitable lowering and libraries. Each interpreter exposes the operations its installed hardware and runtime support, including their memory and synchronization constraints.

Chiplets add a locality lesson: a logical resource can span physical components with different communication costs. Tao exposes those costs to placement interpreters, from a RISC-V board to a network of hosts. Composition across independently governed devices additionally requires explicit failure, authority, and custody contracts.

4. Contracts That Make the Fabric Work

The axioms establish the composition model. A deployment makes that model executable by supplying the following contracts:

  • Compatible execution. A continuation names the versioned semantics and dependencies it requires, including primitive behavior, numerical rules, effects, and failure outcomes. A receiver validates support before attaching resources or resuming. Independent observers may construct different views; backends claiming equivalent execution must agree on observable behavior.
  • Custody and external effects. Publishing a continuation makes it observable to readers with access to its medium. Where only one execution may act, the source is fenced before publication; a grounded authority grants custody, and resource owners validate the receiver's epoch at effect boundaries. Stable operation identities support correlation and deduplication. A transport failure can leave an effect's outcome unknown; replay requires an explicit retry, reconciliation, or compensation policy.
  • Retention and recovery. Evicting a transient buffer must preserve access to canonical code and the inputs required for promised recovery. The composition supplies durable storage, checkpoints, and any required replicas, retaining the source facts that derived views depend on. A hash identifies content; storage custody and reachable copies make it available.
  • Enforced authority. The evaluator confines guest access, and compiled execution must preserve that confinement. Resource-owning hosts enforce authorization, native device access, and DMA boundaries. Grant and revocation decisions use an identified policy snapshot, so their freshness is part of the contract. Remote execution results require a stated trust or verification policy beyond checking content hashes.
  • Measured placement. Work must be large enough to repay dispatch, checkpoint, and communication costs. Measurements compare local execution with delegation and migration, including warm and cold caches, queue delay, and recovery after abrupt failures.

The RISC-V bare-metal port, automatic accelerator specialization, and discovery-driven placement described here are development directions. ShiBi's full capability and budget semantics remain a design target. Continuation formats and handoff machinery require conformance across each supported execution and transport combination before a deployment can promise portable resumption. An end-to-end demonstration can make those promises concrete: run a program on one board, delegate a batch to another, hand off a continuation with warm and cold dependencies, and interrupt a link during the handoff. Report transfer volume, execution and checkpoint time, custody outcomes, and the handling of pending effects.

Conclusion: The Essence of Wu Wei in Systems Design

In Daoist philosophy, Wu Wei (literally "non-action" or "non-forcing", often translated as effortless action) does not mean passivity or doing nothing. It means acting in alignment with the natural grain and physics of a situation rather than fighting against them, like water flowing downhill to find its level without forcing a path. (For deeper background, see the Stanford Encyclopedia of Philosophy entry on Daoism and Britannica on Wuwei.)

Tao applies this principle by turning ant stigmergy into a systems substrate and making dependencies and locality visible: streams preserve the inputs an interpreter observes; datoms expose code and state for inspection; continuations make compatible execution movable. Just as an ant colony achieves global coordination without a central commander by letting individuals respond to local traces in the environment, coordination in Tao is introduced only where an application's invariants require it, with its scope and authority explicit.

The four axioms establish a common representation and composition model. Interpreters supply placement, authorization, indexing, and execution semantics; explicit contracts and measurements establish how a deployment behaves. One global computer means that participating devices, from future RISC-V boards running a theoretical Tao Kernel to GPU-backed hosts, can compose through explicit data and portable execution contracts. Latency, capacity, failure, and trust remain visible in that model, so computation can be placed where it fits.

Related reading: