1. Introduction

As decentralized computation evolves, HyperBeam emerges as a powerful client implementation of the AO-Core protocol, enabling distributed computation in a modular and verifiable way. By abstracting hardware resources and standardizing computation through devices, HyperBeam allows a wide range of computational models to operate seamlessly within the AO ecosystem.

At the core of this system lies the concept of Hashpaths, which serve as unique identifiers for computational state and ensure determinism, verifiability, and composability across the network.

This article explores the architecture of HyperBeam and highlights the fundamental role that Hashpaths play in both HyperBeam and the broader AO-Core protocol.

2. HyperBeam Architecture

HyperBeam is written in Erlang and acts as a decentralized node software that executes computations, manages state, and interacts with other nodes via standardized message formats.

2.1 Key Components

1. AO-Core Protocol

• Defines the underlying framework for decentralized computation.

• Introduces foundational concepts like Hashpaths, Devices, and Messages.

• Enables verifiable, persistent, and shared execution.

2. Devices

You can build a custom device yourself by referring to the article “Getting Started with HyperBEAM: Building Custom Device for Beginners.”

• Modular components that define the computational behavior of the node.

• Examples include:

  • ~wasm64@1.0 for executing WebAssembly

  • ~meta@1.0 for node configuration

  • ~simple-pay@1.0 for payment handling

  • scheduler@1.0 for assigning linear hashpaths with deterministic message ordering, enabling sequential execution patterns across users

  • stack@1.0 for orchestrating multiple devices as a single atomic unit over shared inputs, producing a unified hashpath for the entire operation.

  • ~process@1.0 for managing persistent, shared execution environments where multiple users contribute to a growing hashpath, with customizable execution and scheduling logic.

  • dev_message is used to represent and manage core messages — it handles basic key-value access, sets the message identity, and calculates the hashpath, either directly for simple data or via commitments/devices for map-based messages.

3. HyperBeam Node

• The physical or virtual host running the HyperBeam software.

• Can be configured to expose compute services with monetization, privacy, or security preferences.

• Supports features like RocksDB-backed storage, TEE validation, and HTTP/3 message routing.

4. Messages

• Represent computational requests.

• Follow a strict structure defined by AO-Core and are hashed into Hashpaths.

• Trigger device execution chains based on their content and routing.

5. ~meta@1.0 Device

• The entry point for configuring node behavior.

• Controls aspects such as port, wallet key, allowed devices, pricing models, and metering logic.

2.2 HyperBeam System Diagram

3. The Role of Hashpaths in HyperBeam and AO-Core

3.1 What Are Hashpaths?

Hashpaths are the fundamental cryptographic identifiers of computation in AO-Core. They represent the result of executing a message over existing data, serving as a commitment to a specific computational outcome.

Unlike a simple hash of inputs, a Hashpath is derived by cryptographically combining two prior states:

Hashpath(Message3) = Converve.apply(Hashpath-Alg, Hashpath(Message1), id(Message2))

Here:

• Hashpath-Alg: A cryptographic mixing function (typically SHA-256).

• Hashpath: A previous computational result (or another hashpath).

• id(Message2): The identifier of a new message to be applied.

This structure ensures that each piece of data produced within the system carries with it a traceable lineage of computation, forming a Merkleized execution tree. This tree can be partially reconstructed to verify the correctness of any output using only the relevant branches, making it efficient and highly verifiable.

3.2 Key Properties of Hashpaths

1. Deterministic

• Given the same inputs and messages, the same Hashpath is always produced.

• Enables anyone to independently reproduce and verify computation.

1. Verifiable

• Hashpaths are cryptographic commitments that can be verified

• Nodes can challenge invalid results, ensuring trust and security in the network.

1. Composable

• Hashpaths can be nested, allowing the output of one computation to be used as input to another.

• For example, computing add(2, 3) produces H1, which can be used to compute mul(H1, 4) producing H2.

1. Shardable

• Not all keys within a message need to be known or computed at once.

• Computation can be distributed across many nodes, each handling only part of a large message or dataset.

• This enables scalable, parallel execution in decentralized environments.

1. Compact and Efficient

• Despite representing entire computation trees, Hashpaths are only 32 bytes in size (with SHA-256).

• This makes them suitable as unique state addresses across a global decentralized system.

3.3 Applications of Hashpaths in HyperBeam

1. Decentralized Computation Indexing

• Every computation in HyperBeam results in a Hashpath, which acts as its unique fingerprint.

• Any node can use this Hashpath to retrieve or verify the computation result.

1. Distributed State Storage

• Computation states can be stored on decentralized networks like Arweave.

• Hashpaths allow direct lookup of a specific piece of data or state output.

4. Conclusion

HyperBeam is a modular and extensible runtime that embodies the principles of decentralized computation. Its architecture leverages a device-based model to execute and manage a wide variety of tasks, from WASM computation to pricing, access control, and secure enclave execution.

Within this system, Hashpaths serve as the backbone of computation — offering determinism, verifiability, and composability across all nodes in the network. Whether for public computation, private workflows, or secure TEE environments, Hashpaths ensure that every piece of work can be traced, verified, and trusted.

References

1. Getting Started with HyperBEAM: Building Custom Device for Beginners - Mirror.xyz

2. HyperBEAM GitHub Repository