---
# System prepended metadata

title: '[Draft] Hyperbeam and AO-Core'

---

# Hyperbeam & AO-Core - DRAFT

## 1. Introduction & Context

HyperBEAM is a **decentralized environment** for executing processes on top of **AO-Core**, an actor-oriented protocol anchored by Arweave’s permanent data layer. This environment brings together a broad range of computational possibilities—ranging from large language model (LLM) hosting to trustless big data workflows—while maintaining cryptographic proofs of correctness. HyperBEAM focuses on high-performance parallelism and flexible resource usage, allowing processes to operate at scale in ways that typical single-threaded “smart contract” architectures cannot.

The system is built to address key challenges in decentralized compute: controlling resource usage without capping performance, ensuring verifiability via cryptographic attestations, and offering a straightforward path for advanced use cases like AI or data-heavy agent-based applications. By extending AO-Core’s message-passing foundation with a robust OS-like structure, HyperBEAM allows developers to define how processes run, schedule tasks, and store or load large data from Arweave in a trust-minimized setting.

### Key Motivations

Several core design goals guide HyperBEAM’s development:

- **Unbounded Data & Computation**  
  HyperBEAM leverages Arweave as a large-scale storage back end. Each node can retrieve extensive datasets or code modules, enabling tasks such as machine learning, data analytics, or multi-step pipelines.

- **Verifiable Execution**  
  The AO-Core model of messages and cryptographic linking ensures state transitions can be replayed. HyperBEAM nodes can add TEE support (e.g., AMD SEV) to produce strong hardware attestations, reassuring participants that node operators cannot tamper with in-flight computations.

- **Actor-Oriented Parallelism**  
  Each workload runs as an “AO process” that exchanges messages with others. Processes do not block or throttle each other, allowing concurrency on many nodes simultaneously. The approach also resembles large-scale distributed systems, offering more flexibility than global-state smart contracts.

- **Modularity & Device Ecosystem**  
  HyperBEAM supports “devices,” each of which can define a virtual machine, scheduling approach, or security model. This architecture accommodates specialized devices for LLM workloads, DeFi logic, or domain-specific computations, all sharing a unified network interface.

### Potential Use Cases

HyperBEAM targets a wide spectrum of decentralized applications such as:

- **LLM in Decentralized Smart Contracts**  
  Model weights can be stored on Arweave. A HyperBEAM node loads these weights, runs inference via WASM, and produces attested outputs. Developers can build AI-driven services with minimal trust in node operators.

- **Autonomous Agents for DeFi**  
  Agents can observe on-chain events, aggregate market data, and finalize trades or liquidity moves. Attestation mechanisms ensure that an agent’s code cannot be covertly modified or halted.

- **Interconnected Processes and Network Effects**  
  Multiple processes can link together, each ingesting or transforming data. Outputs become inputs to subsequent tasks, with each step verified through AO-Core’s cryptographic logs. The pipeline scales horizontally, unconstrained by a single global state engine.

HyperBEAM serves as the OS-like backbone enabling these diverse workloads, combining a flexible resource model with strong verification features and the capacity to integrate large datasets from Arweave.

## 2. AO-Core at a Glance

AO-Core is the protocol layer that underpins HyperBEAM’s operations on AO and Arweave. It defines the fundamental data structures and methods for storing, referencing, and verifying computational steps across a network of distributed processes. The following subsections introduce the main concepts that AO-Core provides, which will enable HyperBEAM to extend these components into a fully realized operating environment.

### Messages and Devices

AO-Core represents every interaction as a signed message, recorded in Arweave’s permanent ledger. This approach ensures that all operations—whether user calls, intra-process commands, or scheduled events—are preserved. Devices interpret and handle these messages. In HyperBEAM, devices can run different virtual machines (for example, a WASM runtime) or perform higher-level orchestration (for instance, a process controller). This modular design allows any custom or domain-specific logic to be integrated, as long as it adheres to AO-Core’s message format.

### Hashpaths and Holographic State

Each message processing step updates a cryptographic link, or hashpath, which references previous inputs. Hashpaths form a verifiable chain of computations, making it possible to confirm that a particular state transition is derived from the correct inputs. Because AO-Core logs these transitions permanently, the system supports a “holographic state” model: a node that needs to confirm or recreate a state can replay the relevant messages from Arweave. This structure eliminates the need for every node to compute every process, enabling concurrent execution at scale.

### Attestations and Caching

AO-Core permits nodes to sign the outcomes of message evaluations, generating attestations that confirm the correctness of a result. If a node is trusted or if multiple attestations converge, others can accept the findings without recomputation. This mechanism supports distributed caching: nodes can share verified partial states or results to avoid redundant processing. The combination of cryptographic logging on Arweave and flexible attestation fosters a cooperative environment where computations can be transparently validated.

This high-level view of AO-Core explains how its fundamental concepts create a reliable foundation for decentralized parallel computing. HyperBEAM leverages these features to provide an operating environment that handles everything from managing device code to building complex processes, described in detail in the following technical sections.

## 3. Architecture of HyperBEAM

HyperBEAM builds on AO-Core's message-driven foundation, adding system-level components for device management, node orchestration, and execution oversight. This architecture provides a complete environment in which nodes load specified devices, process incoming requests as AO-Core messages, and generate cryptographically verifiable outputs.

### 3.1 Device-Oriented Runtime

AO-Core defines the notion of devices, each responsible for interpreting or generating messages. HyperBEAM packages these devices in a framework that allows a node to activate and configure the logic needed for specific tasks, such as WASM code execution or advanced process coordination. Node operators specify which devices are enabled at startup, forming a modular runtime environment that can accommodate different workloads.

Devices in HyperBEAM can implement varied functionalities:

* A WASM execution module that runs user-provided binaries from Arweave.
* A scheduling module for assigning monotonically increasing slot numbers to messages within a process.
* A process orchestration module that coordinates multiple sub-devices or complex interactions.

This arrangement gives HyperBEAM flexibility. Developers can write or select devices to handle domain-specific tasks, so long as each device follows AO-Core's message specification.

### 3.2 Node Lifecycle

A HyperBEAM node does not follow a conventional operating system boot sequence. Instead, it reads a "boot message" that declares which devices to load, relevant trust or TEE parameters, and configuration details. This boot message exists within the AO-Core framework, typically referencing code modules or data items stored on Arweave.

1. **Boot Message Initialization** The node locates the boot message—through an environment variable or a local record—and ingests the device information, TEE settings, and environment variables it contains.
2. **Module Setup** Each device loads its code or dependencies, potentially pulling binaries from Arweave or reading advanced configuration from prior logs. The node merges these instructions to finalize its internal state.
3. **HTTP Handling** After the startup phase, the node starts an HTTP listener. Incoming paths and query parameters are converted into AO-Core messages, which are then directed to the devices that can process them.
4. **Attestation and Caching** If a device concludes a computation, the node can produce a signed attestation of the result. Output data might also be cached locally, reducing the need for re-computation in subsequent requests. In TEE configurations, the attestations may include hardware signatures that confirm trustworthy execution.

The entire lifecycle centers on reading and writing AO-Core messages. HyperBEAM thus remains flexible: it does not depend on a single file system or kernel setup, but rather on the configured devices and message-driven logic spelled out at boot.


### 3.3 Key Internal Modules

HyperBEAM is composed of several Erlang modules that coordinate device loading, HTTP request handling, scheduling, and other advanced features. Each module serves a specialized role but adheres to the AO-Core message format.


 #### 3.3.1 `hb_os` – HyperBEAM OS Tools  
This group of scripts and Dockerfiles (for example, `resources/initramfs.Dockerfile` and `launch.sh`) simplifies tasks such as building a kernel or initramfs, configuring QEMU with SEV-SNP support, and ultimately running the node with the proper environment variables. A typical deployment sequence might involve commands like:

```
./run init
./run build_base_image
./run build_guest_image
./run start
```

In this workflow, `init` sets up dependencies, `build_*` steps generate a VM image, and `start` launches QEMU with HyperBEAM running inside a TEE-enabled environment.

---

 #### 3.3.2 `hb_singleton` and HTTP Request Parsing 
The `hb_singleton` module converts incoming HTTP paths, query parameters, and typed keys into AO-Core messages. For instance:

```
GET /Init/Compute?wasm-function=fac&wasm-params=[5.0]
```

becomes one AO-Core message that instructs a WASM device to invoke `fac(5.0)`. Internally, `hb_singleton` handles tasks such as normalizing query parameters (for example, `key+int=123`), interpreting subpaths, and applying device specifiers before dispatching the completed message for execution.


#### 3.3.3 Scheduling: `dev_scheduler`, `dev_scheduler_server`, `dev_scheduler_registry`
HyperBEAM assigns each incoming message to a given AO process in strictly increasing order:

- **`dev_scheduler_server`** is a persistent Erlang process that ensures each process’s messages receive unique slot numbers and that a “hash-chain” is maintained.  
- **`dev_scheduler_registry`** locates or spawns this server for specific processes.  
- **`dev_scheduler_cache`** persists assigned messages, allowing the system to resume seamlessly after restarts.

Below is an example from `dev_scheduler_server.erl`:

```erlang
schedule(AOProcID, Message) ->
    ErlangPID = dev_scheduler_registry:find(AOProcID),
    ErlangPID ! {schedule, Message, self()},
    receive
        {scheduled, Message, Assignment} ->
            Assignment
    end.
```

In this snippet, the schedule function sends a `{schedule, Message, self()}` tuple to the scheduling server. Once the message is assigned a slot, the server returns the `{scheduled, Message, Assignment}` response.


#### 3.3.4 Execution and Processes: `dev_process` / `dev_process_cache`
The `dev_process` device provides higher-level orchestration for AO processes, possibly referencing multiple sub-devices (such as `Stack/1.0` or `WASM/1.0`) in a defined sequence. The `dev_process_cache` module stores partial or final states so that processes can be resumed quickly. This approach reduces the overhead of recalculating states from the full message log, especially for longer-running or complex processes.



#### 3.3.5 WASM Device: `dev_wasm`
The `dev_wasm` device executes WebAssembly modules via an Erlang bridge to the WAMR runtime (`hb_beamr`). This capability accommodates tasks beyond simple scripts. A developer can store extensive binaries (for instance, LLM models) on Arweave, then reference them in a message. The following code snippet from `dev_wasm` illustrates a compute call:

```erlang
compute(Msg1, Msg2, Opts) ->
    WASMFunction = hb_converge:get(<<"wasm-function">>, M1, Opts),
    WASMParams  = hb_converge:get(<<"wasm-params">>, M1, Opts),
    {ResType, Res, MsgAfterExec} =
        hb_beamr:call(
            instance(M1, M2, Opts),
            WASMFunction,
            WASMParams,
            ImportResolver,
            M1,
            Opts
        ),
    % Place results in /results/wasm/
    ...
```

In this sequence, the function extracts parameters (`wasm-function` and `wasm-params`) from the message, then calls `hb_beamr:call` to run the requested logic. Potential applications include LLM inference, CPU-intensive data transformations, or domain-specific computations that fit into a WASM model.


#### 3.3.6 TEE and Attestation
HyperBEAM optionally integrates with hardware-based Trusted Execution Environments (for example, AMD SEV-SNP). In such setups:

- **Memory and Execution Security**: Node operators cannot inspect or tamper with TEE-protected memory contents.  
- **Hardware Signatures**: The node can provide hardware-backed signatures as part of the attestation, demonstrating that computations ran in a validated enclave.  
- **Timed Inputs**: The node may rely on modules like `ar_timestamp` to keep track of Arweave block heights or timestamps.

When combined with AO-Core’s hashpath mechanism, TEE attestation provides end-to-end verification of each operation’s environment and state.

Below is the next section in the article’s outline, focusing on HyperBEAM deployment and high-level usage, while maintaining the established style.



## 4. Deployment & Usage Highlights

HyperBEAM does not rely on conventional installation or configuration flows. Nodes are typically assembled and launched using an automated tooling set, which includes scripts, Dockerfiles, and QEMU parameters for optional TEE modes such as AMD SEV-SNP. This section describes the broad approach to deploying and operating a HyperBEAM node, without delving into full tutorial instructions.

### 4.1 Host Preparation

Some hosts may require BIOS or kernel configuration for Trusted Execution Environments (e.g., enabling SEV-SNP). Host-level tasks often include:

- Enabling SEV-SNP in the BIOS if AMD hardware is employed.  
- Verifying that the OS recognizes SEV-SNP flags (`sev`, `sev_es`, `sev_snp`).  
- Ensuring the presence of a suitable Linux kernel or environment if QEMU-based virtualization is used.

Although TEE support is optional, it provides additional trust-minimized assurances. Hosts that do not enable a TEE can still run HyperBEAM in a standard virtualized environment.

### 4.2 Building the Base Image

The build process involves creating a minimal OS environment that includes:

- A kernel with the necessary AO-Core and HyperBEAM support modules.  
- An initramfs capable of booting into the HyperBEAM runtime.  
- Scripts and device references that define which code to load upon boot.

For instance, a typical set of commands might be:

```
./run build_base_image
./run build_guest_image
```

where the first step prepares a kernel/initramfs, and the second step integrates any user-defined logic or additional devices.

### 4.3 Running the Node

After generating the images, the node is started using a command such as:

```
./run start
```

This triggers QEMU to boot the image in a specified mode—standard or SEV-SNP. Once the node launches:

1. It reads a boot message that specifies which devices to load.  
2. It initializes each device, referencing code or data from Arweave if needed.  
3. It opens an HTTP interface, waiting for AO-Core messages to arrive.

If AMD SEV-SNP is active, the node can generate attestations containing hardware signatures. These attestations demonstrate that memory and execution remained secure from tampering.

### 4.4 Submitting Messages and Processes

Users or systems can submit AO-Core data items—representing messages or processes—to the node via HTTP endpoints. A request such as:

```
POST / 
(Content: AO-Core DataItem)
```

is processed by HyperBEAM, which schedules or executes the content as needed. If the data item describes a new process, the node registers it and associates it with a scheduler. If it describes a message for an existing process, the node dispatches it to the appropriate device and slot.

### 4.5 Example LLM Hosting Workflow

A potential usage scenario involves hosting a large language model:

1. **Model Storage**: A WASM binary containing the model is uploaded to Arweave, producing a TXID reference.  
2. **Process Deployment**: A new process references this TXID in its initialization message, instructing HyperBEAM to load `dev_wasm` with the model.  
3. **Requests**: External or on-chain services call:

   ```
   GET /LLMProcess/Compute?wasm-function=generateText&wasm-params=[{"prompt": "Hello"}]
   ```

   HyperBEAM’s `dev_wasm` device runs the model, returning an attestation of the generated text.

4. **Attestation Validation**: Callers can trust the result if they consider the node’s hardware attestation or rely on multi-node confirmations.

By following this high-level approach, developers can integrate advanced ML tasks without exposing their code or data to a centralized host operator’s interference.

### 4.6 Summary of Deployment

Deployment and usage revolve around:

- Preparing a kernel and environment that can run HyperBEAM.  
- Launching a node in QEMU, optionally with SEV-SNP.  
- Providing AO-Core data items via HTTP for scheduling or execution.  
- Retrieving attestations or outputs through the same message-based interface.

Additional topics such as distributing loads across multiple nodes, configuring advanced device sets, or verifying hardware-level attestations can be addressed based on each application’s performance and trust requirements. The final section examines real-world examples in more detail.

## 5. Practical Applications and Further Use Cases

HyperBEAM’s architecture enables a wide range of decentralized compute scenarios that exceed traditional limitations. The following examples illustrate how developers can leverage its device-based runtime, concurrency model, and TEE integration in practical applications.


### 5.1 Large Language Models in Decentralized Smart Contracts
Hosting a large language model (LLM) on-chain on smart contract platforms typically faces constraints in storage, execution speed, and verifiability. HyperBEAM bypasses these challenges in the following manner:

1. **Model Upload**  
   A compiled WASM binary containing the LLM is stored on Arweave. The binary may exceed typical on-chain sizes, but Arweave’s storage model accommodates it. 
2. **Node Boot** 
   A HyperBEAM node loads its boot message referencing `dev_wasm`. The node identifies the WASM binary’s Arweave TXID as part of a process initialization. 
3. **Inference Requests**  
   Systems or users send HTTP requests converting into AO-Core messages:
   
   ```
   GET /LLMProcess/Compute?wasm-function=inferText
   &wasm-params=[{"prompt":"What is HyperBEAM?"}]
   ```
   
   The node calls `hb_beamr` through `dev_wasm` and runs the model.  
4. **Attested Output**  
   Results may be accompanied by cryptographic attestations, which can include TEE signatures if AMD SEV-SNP is used. Verifiers can trust the outcome, relying on hardware-level proof.

This workflow enables advanced AI capabilities (for example, chatbots or data summarization) without depending on centralized GPU hosts or unverified runtime processes.


### 5.2 Autonomous Agents in Decentralized Finance
DeFi agents often manage liquidity, track multiple price feeds, or run arbitrage logic. AO-Core protocol enables these agents to function in an environment that can cryptographically assure correctness:

1. **Process Definition**  
   An agent process references a combination of scheduling (to retrieve regular market data) and WASM logic (to compute arbitrage opportunities).  
2. **Message Passing**  
   The agent receives feeds from oracles or aggregator processes. These feeds arrive as AO-Core messages—each assigned an atomic slot so the agent’s logic updates in sequence.  
3. **TEE Security**  
   When the agent runs in a TEE, external participants can verify that the agent’s rules have not been altered or halted. A DeFi aggregator can, for instance, require a hardware-backed signature on the agent’s trades.  
4. **Outbox Actions**  
   The agent issues messages (for example, trades on a DEX or updates to liquidity pools) that appear as new entries in the global log. These outbox messages pass through the standard AO scheduling pipeline to ensure guaranteed order and recordkeeping.


### 5.3 Big Data Pipelines
Data-intensive workflows may exceed on-chain storage or throughput limits. By distributing tasks across multiple HyperBEAM nodes, such pipelines can handle larger volumes of input data and intermediate results:

1. **Producer Node**  
   A node with the “producer” role ingests raw data from external sources and posts chunks to Arweave.  
2. **Transformer Nodes**  
   Each transformer process runs specialized WASM code or device logic that pulls relevant data from Arweave, processes it, and writes results to new AO-Core messages.  
3. **Chaining**  
   Messages can be directed to subsequent processes in the pipeline, ensuring an end-to-end link of transformations. Every step includes an attestation or TEE signature, confirming correctness without needing global chain-wide consensus.  
4. **Final Consolidation**  
   The last stage merges all transformations into a final result. Any consumer can replay the message logs to confirm the integrity of the overall pipeline.

This approach supports parallelization: multiple HyperBEAM nodes can independently handle fragments of data, each producing attested outputs that can be combined later, allowing for learning and adaptability as the processes evolve.



## 5.4 Additional Scenarios
HyperBEAM’s composability and cryptographic foundation open up further use cases:

- **Content Moderation**: Large-scale filtering or classification tasks, assured by TEE.  
- **Network Oracles**: Services that gather external data, sign it with hardware credentials, and feed it into AO-based processes.  
- **Cross-Domain Interactions**: Bridging LLMs with DeFi or data analytics so that financial contracts can reference advanced AI outcomes or large transformations without trusting a single operator.

Each of these examples showcases the potential for high-capacity, trust-minimized computation, distinguishing HyperBEAM from conventional single-threaded or entirely off-chain solutions.

## 6. Conclusion

In typical on-chain platforms, computation occurs within a single global thread, restricting each operation’s scope and limiting parallelism. Conversely, HyperBEAM’s multi-process concurrency model allows processes to run at full capacity without stalling one another, more closely resembling the behavior of standard cloud VMs. However, unlike most clouds, HyperBEAM provides cryptographic attestations and verifiable message logs, enabling trustless execution with a decentralized market for compute.

The HyperBEAM approach to scheduling and concurrency extends the parallelization benefits. HyperBEAM nodes assign strictly incrementing slot numbers, link each input via hashpaths, and record data on Arweave, ensuring that nodes can replay or verify states as needed. This design, coupled with a TEE, offers a compelling paradigm for large-scale distributed compute, where operators cannot covertly modify or interrupt execution. Processes can run anything from LLM inference sessions to highly specialized HPC workloads, returning signatures that prove correctness of results.

Existing public blockchain ecosystems can view HyperBEAM as a trust-minimized HPC back end. Rather than running entire tasks within a fixed block gas limit or saturating a global ledger, external chains or rollups can offload demanding or data-heavy tasks onto HyperBEAM nodes. Those nodes return attested outcomes, preserving the tamper-evident properties of on-chain execution while achieving higher throughput and more flexible resource usage.

In sum, this new environment achieves a novel synthesis of actor-based concurrency, cryptographic verification, and modular device logic. By eliminating single-thread constraints and introducing a secure, verifiable message pipeline, AO contributes significantly to the field of decentralized compute systems. The platform accommodates use cases ranging from AI, DeFi, social apps, games, and data-driven operations alike, delivering on the vision of a scalable, trust-minimized, and parallel computing world.