I. Introduction
HyperBEAM is the reference client for the AO-Core protocol. Built in Erlang, it serves as the node software that powers decentralized computation across the permaweb. Unlike traditional blockchain nodes, HyperBEAM is designed around message-passing and modular devices rather than global consensus.
It executes AO programs by interpreting and composing messages over HTTP, enabling verifiable and scalable onchain compute.
→ View the HyperBEAM docs here → Catch up on the latest Milestone 3 update
II. What is HyperBEAM?
HyperBEAM is a decentralized operating system built on AO. It runs on Erlang’s BEAM VM and enables developers to:
- Serve and execute AO messages over HTTP
- Run modular devices as computation units
- Operate without centralized APIs or traditional RPCs
- Interact with Arweave as a persistent storage backend
Each HyperBEAM node can be configured with different devices, metering systems, and pricing models, allowing anyone to spin up a custom compute environment.
III. What is AO-Core?
AO-Core is a decentralized computation protocol built around the concept of hashpaths, which are Merkle-like chains that represent deterministic message execution.
Key benefits of AO-Core:
- Hashpaths create verifiable, onchain state history
- Any program output can be referenced by its path
- All computation is expressed as HTTP messages
- Compatible with permanent storage via Arweave
IV. How devices work in HyperBEAM
What is a device?
Devices are modules that define how messages are interpreted or executed. AO devices are modular execution units that can be mixed, matched, or upgraded over time. Not every node needs to run every device. Some nodes may specialize in compute-heavy devices like ~wasm64@1.0, while others may focus on message relaying or scheduling. Devices often work together to process messages, executing logic, routing state, or coordinating processes. This architecture ensures scalability, flexibility, and extensibility across the network.
Device architecture in AO
Devices are not fixed; they can be added or upgraded. Devices are referenced using name and version, like ~<name>@<version> (e.g., ~process@1.0).
- (
~) indicates a primary, user-facing device. (e.g.,~process@1.0). - (
dev_) indicates an internal or utility device (e.g.,dev_router).
Each node can choose which devices to support based on hardware or specific use cases. This flexibility enables nodes to contribute compute or storage in ways best suited to their resources.
This diversity allows AO to scale without enforcing a single compute model.
→ Learn more about HyperBEAM devices here
V. Preloaded devices in HyperBEAM
HyperBEAM ships with over 20 devices. Here are some of the most common:
- ~meta@1.0: Configures node identity, ports, and device list.
- ~process@1.0: Enables persistent, multi-user programs.
- ~scheduler@1.0: Handles the ordering and execution of messages within a process.
- ~wasm64@1.0: Executes WASM to allow complex computations written in Rust, C++, etc.
- ~lua@5.3a: Executes Lua scripts.
- ~relay@1.0: Handles cross-node message transport or HTTP endpoints.
- ~json@1.0: Provides access to JSON data structures.
- ~message@1.0: Manages message state and processing.
- ~patch@1.0: Applies state updates directly to a process, often used for migrating or managing process data.
- ~snp@1.0: Provides TEE (Trusted Execution Environment) proofs
- ~p4@1.0: Resells hardware compute cycles with pricing and ledger hooks
Each device is modular and can be replaced, extended, or composed to build custom compute environments.
Future devices
The above devices are preloaded and community devices but as the AO ecosystem evolves, new devices will emerge that cater to specific needs. Potential devices include:
- Specialized Hardware Integrations
- Advanced Cryptography
- Cross-Chain & Off-Chain Bridges
- AI/ML Specific Devices
- Domain-Specific Logic
VI. Developer resources
See the open source repo and supporting developer docs below.
VII. Conclusion
HyperBEAM is the foundation of decentralized compute in the AO ecosystem. It replaces centralized APIs, rigid virtual machines, and global consensus with a message-based execution model that runs over standard HTTP.
As the operating system for AO, HyperBEAM allows developers to build applications where every interaction is verifiable, every process is modular, and all state is stored permanently on Arweave. It turns nodes into programmable endpoints that can run specialized logic through modular devices.
This approach scales more efficiently than traditional blockchains and introduces a new model for building and hosting web-native applications. Compute becomes permissionless, state becomes permanent, and every part of an application becomes transparent and reproducible.
Whether you are building autonomous agents, running WASM programs, or exposing verifiable APIs backed by hashpaths, HyperBEAM is the engine that powers the next generation of onchain applications.