ao (@aoTheComputer): PermawebOS LapEE Alpha: Verifiable AO compute from abundant consumer hardware

PermawebOS LapEE Alpha: Verifiable AO compute from abundant consumer hardware Laptop-native, TPM-backed permaweb infrastructure where the machine signs what it did. TL;DR It is now possible to boot a laptop directly into PermawebOS as a dedicated AO-Core appliance. LapEE, the Laptop Execution Environment, is a laptop architecture release of PermawebOS which turns abundant consumer hardware into a secure, verifiable computer where every AO-Core output is an attestation. Boot LapEE from a USB stick and the laptop starts the runtime, shows a QR code for the node URL, and serves a hardware-backed measurement envelope. LapEE devices can participate in AO as bundlers and get paid for verifiable work. This is very early! Only boot LapEE from a device you are willing to dedicate to the experiment. AO-Core is a primitive that offers a simple service: a way for computers to attest that they performed some computation, received a certain result, and link those two facts cryptographically. It does this across any virtual machine, with any program, over HTTP semantics: the semantics of the web. PermawebOS implements AO-Core and extends it with devices that let users decide how much they trust those attested results. Some devices provide staking-style or authority-based liveness guarantees, as with NASA. Others use trusted execution environments (TEEs) to strengthen computation correctness. But trust is not binary. TEEs are expensive, limited in supply, and, historically, even advanced current-generation hardware has repeatedly faced practical breaks. Sophisticated cryptography faces the same reality: it is still exposed to software bugs, implementation mistakes, and flaws in the underlying mathematics. Computation trustworthiness is a spectrum without absolutes. LapEE builds on that idea by widening the set of machines that can usefully provide computation for the permaweb: from a scarce pool of expensive, current-generation TEE hardware to ordinary consumer computers using hardware security features already present in many laptops made in the last five years. What is LapEE? Running a useful, trustworthy AO HyperBEAM node no longer needs specialized server hardware. With LapEE, it can be as simple as booting from a USB stick. Beyond basic financial transactions, AO is the infrastructure of the permaweb itself: gateways, bundlers, indexers, schedulers, and other specialized nodes. This is how AO becomes decentralized in practice: not only by distributing tokens or validators, but by making useful, attestable computation available from the machines people already have. With the launch of NASA, the move towards total permaweb decentralization is underway. Beyond protocol design, this requires infrastructure that normal people can actually run, with low hardware requirements instead of esoteric and expensive bare metal. It requires machines that do useful work that is attestable, end to end. In an effort to make it possible for anyone to run verifiable AO nodes -- as gateways, indexers, bundlers, and more -- we’re shipping PermawebOS images for specific hardware, starting with laptops. LapEE is a bootable software image that turns an ordinary laptop into a dedicated PermawebOS machine: a small, physical, network-connected computer whose inputs and outputs are cryptographically linked, signed, and attestable back to the environment it is running in. It is a new kind of computer for AO, installed like a dedicated OS. Boot it, put it on a shelf, and it becomes a piece of tamper-resistant permaweb infrastructure. Out of the box, the base LapEE image boots up as a bundling service and becomes discoverable on the network. Over time, we’ll roll out more services that work out of the box, bootstrapping a fleet of lightweight consumer-grade nodes that can handle many of the AO network roles we’d previously set aside for TEEs. What LapEE unlocks On a normal computer, the machine has a key and the operator has the machine. For trust-minimized infrastructure, that’s not enough. If the operator controls the system, they could read secrets, sign false data, or silently run something different from what remote peers believe they are running. AO already gives us a model for attested computation: machines can attest to the work they performed. But if the key is sitting inside a normal server, the attestation is only as strong as the operator's custody of that key. The way around that has previously been to buy a TEE, typically costing several thousand dollars. LapEE takes a different route: it turns the whole machine into a narrow appliance environment built around HyperBEAM, then exposes the hardware and boot evidence needed for callers to decide whether they trust it. LapEE uses consumer hardware features that already exist in modern laptops: TPM 2.0, Secure Boot, and, where available, TME/SME/SNP-style memory encryption. It can also expose evidence for machines whose RAM is practically difficult to access, such as LPDDR or tightly integrated soldered-memory designs. Instead of running a normal general-purpose operating system and then launching a service inside it, LapEE boots the whole machine into a dedicated appliance. If the whole machine boots as a single-purpose appliance, and if the boot chain can be measured, and if memory is encrypted or physically difficult to interpose, and if the only meaningful interface is the PermawebOS kernel (HyperBEAM), then ordinary laptops become useful for a large class of AO workloads. With this setup, running verifiable AO nodes becomes broadly accessible, and we can roll out another wave of incentive programs to decentralize AO with an even lower barrier to entry. LapEE's first use cases Its hardened verifiability is what makes LapEE useful for infrastructure roles where liveness, correctness, and payment accountability matter: bundlers schedulers paid HyperBEAM services eventually, agent execution environments Since it can run entirely in RAM and does not need to touch internal storage, LapEE devices are best suited to being conduits for data that is accepted, validated, and submitted to the network. Bundling is the most obvious initial use case, followed by indexers and process executors. Other paid AO services can follow the same pattern: advertise what the node can do, what it charges, and what attestations it returns. LapEE bundlers Out of the box, LapEE ships with the capability to join the first decentralized bundler network on AO. Recent improvements to Arweave and AO have enabled cacheless bundlers that live inside the AO network, and with that comes the opportunity for node operators to earn staking rewards for liveness and charge per byte bundled. The reality of bundling on Arweave today is that it is managed by a handful of centralized services. The long-term direction is a bundler swarm, and LapEE makes this easy to bootstrap and incentivize. Building the base LapEE image with the bundler device package adds devices to the node which allow it to call AR/AO price oracles and charge AO to bundle data to Arweave. Once running, operators can join a zone and stake AO tokens here to be discoverable as a paid bundler. “Secure enough” LapEE is not a magic cloud TEE and does not make arbitrary multi-tenant Linux safe. It takes a different trade-off: make the whole laptop one auditable appliance OS/node, keep local inputs and writable runtime storage out of the production path, and let AO-Core get tenancy by distributing work across HyperBEAM workers. Single-tenant here means one appliance OS/node; it is not a proof that arbitrary AO workloads are safely isolated from each other by LapEE itself. The TPM quote, firmware event log, Secure Boot state, node identity, and system probes let a verifier ask: what actually booted, what key is speaking for it, and what hardware evidence is available? LapEEs are an acknowledgement that for many low-economic-impact tasks on the decentralized web -- bundling, gateway routing, simple paid services, and other AO computations -- the cost of attacking even a non-encrypted LPDDR or tightly integrated machine may be higher than the value that the attacker could usefully gain from it. LapEEs are not perfectly secure. They are designed to be secure enough for useful work, while making their assumptions explicit. They are also abundant. Almost everyone has a machine they can turn into a LapEE. Getting started with LapEE Warning: only install LapEE on a laptop you're willing to dedicate to the experiment. Once running, the laptop becomes single-purpose, with LapEE as the only program running on the machine. In alpha, there are no guarantees that the laptop will not be bricked. Uninstall any storage (SSDs, etc.) before booting into LapEE unless you want to provision a dedicated hard drive for the node. This improves stability for long-term bundling, but requires the drive to be wiped as part of the setup process. Do not install this on your daily driver. Assume it can wipe or brick the machine. Good targets are modern laptops or mini PCs with TPM 2.0, Secure Boot, and hardware memory-protection or hard-to-access memory layouts such as TME/SME/SNP, LPDDR, or tightly integrated soldered RAM. The exact evidence a machine provides varies by model and firmware. For the fearless: Get the LapEE USB image and start setup here Then what? Refer to the LapEE docs for help configuring your node and getting it onto the public internet. Once you're up and running, stake here to register as a bundler. You can also try your LapEE's public URL in this HyperBEAM bundling UI demo; fund your node with some AR, and start bundling. During the final stages of the alpha, a portion of upload requests to up.arweave.net will be routed to LapEE operators -- this is the path to migrating centralized bundlers to a new decentralized model. Read this on the Permaweb: https://ao.arweave.net/#/blog/lapee