{
  "meta": {
    "source": "permaweb/HyperBEAM, branch edge",
    "snapshot": "2026-09-21",
    "families": {
      "run": {
        "label": "Run",
        "blurb": "Devices that do the actual work.",
        "color": "#ff5c5c"
      },
      "pay": {
        "label": "Pay",
        "blurb": "Devices that handle money and fairness.",
        "color": "#ffb020"
      },
      "protect": {
        "label": "Protect",
        "blurb": "Devices that keep things safe and locked.",
        "color": "#5b7cff"
      },
      "store": {
        "label": "Store",
        "blurb": "Devices that remember and save things.",
        "color": "#2ec27e"
      },
      "connect": {
        "label": "Connect",
        "blurb": "Devices that talk to the outside world.",
        "color": "#b26bff"
      },
      "find": {
        "label": "Find",
        "blurb": "Devices that search and look things up.",
        "color": "#12b5cb"
      },
      "tools": {
        "label": "Tools",
        "blurb": "Devices that help builders build.",
        "color": "#8a8f98"
      }
    }
  },
  "devices": [
    {
      "id": "process",
      "name": "~process@1.0",
      "nickname": "The Memory Keeper",
      "job": "Remembers everything that has ever happened to it.",
      "explainer": "A process is like a notebook that never loses a page. Every message sent to it gets written down in order, and it can always replay the notebook from the start to figure out what it knows right now. That's how a game, a token, or a chat room on AO keeps its state. It doesn't do the thinking itself. It hands the work to Lua or WASM and the ordering to Scheduler.",
      "example": "A bank statement. Every transaction is listed in order, and you can always add them up to get today's balance.",
      "snapsTo": [
        "scheduler",
        "lua",
        "wasm64",
        "stack",
        "push",
        "cron",
        "patch"
      ],
      "kind": "core",
      "family": "store",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/process/dev_process.erl"
    },
    {
      "id": "scheduler",
      "name": "~scheduler@1.0",
      "nickname": "The Line Keeper",
      "job": "Puts every message in line so nobody cuts.",
      "explainer": "When lots of people send messages to the same process at the same time, somebody has to decide who goes first. Scheduler gives every message a number (0, 1, 2, 3) and signs it so everyone agrees on the order. Without this, two nodes could replay the same notebook and get different answers.",
      "example": "The ticket machine at the DMV. Everyone gets a number, and numbers are served in order.",
      "snapsTo": [
        "process",
        "push"
      ],
      "kind": "core",
      "family": "run",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/process/dev_scheduler.erl"
    },
    {
      "id": "lua",
      "name": "~lua@5.3a",
      "nickname": "The Quick Worker",
      "job": "Runs small scripts fast.",
      "explainer": "Lua is a tiny, friendly programming language. This device reads a Lua script and runs it against a message. Many new HyperBEAM processes use this Worker because it's quick to write and easy to read. It can also call other devices while it works.",
      "example": "A pocket calculator that can follow a short set of instructions.",
      "snapsTo": [
        "process",
        "stack"
      ],
      "kind": "core",
      "family": "run",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/vm/dev_lua.erl"
    },
    {
      "id": "wasm64",
      "name": "~wasm-64@1.0",
      "nickname": "The Heavy Worker",
      "job": "Runs big programs written in almost any language.",
      "explainer": "WebAssembly (WASM) is a way to pack up a program written in Rust, C, Go, or lots of other languages so it runs the same everywhere. This Worker runs those packed programs. It's what you use when the job is too big for a Lua script.",
      "example": "A shipping container. Pack the program once, and it runs the same on any dock.",
      "snapsTo": [
        "process",
        "stack",
        "wasi",
        "json-iface"
      ],
      "kind": "core",
      "family": "run",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/vm/dev_wasm.erl"
    },
    {
      "id": "stack",
      "name": "~stack@1.0",
      "nickname": "The Assembly Line",
      "job": "Chains devices together so each one does its step.",
      "explainer": "Stack takes a list of devices and runs them one after another, passing the result down the line. That's how a process can say 'first check for duplicates, then run my Lua, then tidy up the output' without anyone writing glue code. It's the device that makes the device idea work.",
      "example": "An assembly line: prime, paint, then polish, in that order every time.",
      "snapsTo": [
        "process",
        "lua",
        "wasm64",
        "dedup",
        "multipass",
        "patch"
      ],
      "kind": "core",
      "family": "run",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/util/dev_stack.erl"
    },
    {
      "id": "push",
      "name": "~push@1.0",
      "nickname": "The Mail Carrier",
      "job": "Delivers a process's replies to whoever they're for.",
      "explainer": "When a process finishes a job, it often has messages for other processes ('tell the token to move 5 coins'). Push picks those up and delivers them, then delivers any replies to those, and keeps going until the mailbag is empty.",
      "example": "A courier who delivers a reply, then delivers the reply to that, until nothing is left in the bag.",
      "snapsTo": [
        "process",
        "scheduler"
      ],
      "kind": "core",
      "family": "connect",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/process/dev_push.erl"
    },
    {
      "id": "cron",
      "name": "~cron@1.0",
      "nickname": "The Alarm Clock",
      "job": "Wakes a process up on a schedule.",
      "explainer": "Normally a process only does something when someone sends it a message. Cron sends it a message on a timer, every minute, every hour, whenever you say, so it can check prices, clean up, or pay out on its own.",
      "example": "A thermostat that checks the temperature every ten minutes, whether or not anyone is home.",
      "snapsTo": [
        "process",
        "scheduler"
      ],
      "kind": "core",
      "family": "run",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/node/dev_cron.erl"
    },
    {
      "id": "relay",
      "name": "~relay@1.0",
      "nickname": "The Messenger",
      "job": "Runs to the normal internet and back.",
      "explainer": "AO lives in its own world, but sometimes you need a weather report or a price from a regular website. Relay makes the web request for you and brings back the answer. It can wait for the reply ('call') or just drop the message and leave ('cast').",
      "example": "The colleague who walks over to the other office, asks the question, and comes back with the answer.",
      "snapsTo": [
        "router",
        "arweave"
      ],
      "kind": "core",
      "family": "connect",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/util/dev_relay.erl"
    },
    {
      "id": "meta",
      "name": "~meta@1.0",
      "nickname": "The Receptionist",
      "job": "Greets every visitor and tells them what this node can do.",
      "explainer": "Every request to a node walks in through Meta first. It knows the node's settings (which devices are installed, who owns it, what it charges) and it can run checks before and after a request (that's where Rate limit and P4 plug in). Ask it '/~meta@1.0/info' and it tells you about the node.",
      "example": "The front desk. Every visitor checks in there first and is told what the building offers.",
      "snapsTo": [
        "p4",
        "rate-limit",
        "blacklist",
        "auth-hook"
      ],
      "kind": "core",
      "family": "tools",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/node/dev_meta.erl"
    },
    {
      "id": "p4",
      "name": "~p4@1.0",
      "nickname": "The Ticket Booth",
      "job": "Pay first, then you get in.",
      "explainer": "P4 is how a node charges for its work. It asks a pricing device 'how much should this cost?' and a ledger device 'does this person have enough?' and then lets the request through or turns it away. Swap the pricing or ledger device and you've got a whole new business model without touching anything else.",
      "example": "The turnstile at a stadium. Valid ticket, you're in. No ticket, you're not.",
      "snapsTo": [
        "metering",
        "simple-pay",
        "faff",
        "recharging-ledger",
        "pricing-router"
      ],
      "kind": "core",
      "family": "pay",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/payment/dev_p4.erl"
    },
    {
      "id": "metering",
      "name": "~metering@1.0",
      "nickname": "The Electricity Meter",
      "job": "Counts exactly how much of the node you used.",
      "explainer": "Instead of a flat price, Metering watches a request while it runs and counts things: bytes in, bytes out, how hard the computer worked. Then it multiplies by the operator's rates. Plug it into P4 and people pay for exactly what they used.",
      "example": "The electricity meter on the side of a house. You pay for what you actually used.",
      "snapsTo": [
        "p4"
      ],
      "kind": "core",
      "family": "pay",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/payment/dev_metering.erl"
    },
    {
      "id": "simple-pay",
      "name": "~simple-pay@1.0",
      "nickname": "The Price Tag",
      "job": "A set price per message or per route.",
      "explainer": "The simplest way to charge: the operator sets a price per message, or a fixed price for certain routes, and the node keeps track of what each user has paid. Good for getting started.",
      "example": "A price tag. One number, no surprises.",
      "snapsTo": [
        "p4"
      ],
      "kind": "core",
      "family": "pay",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/payment/dev_simple_pay.erl"
    },
    {
      "id": "faff",
      "name": "~faff@1.0",
      "nickname": "The Guest List",
      "job": "Only friends and family get in, and it's free.",
      "explainer": "Faff is a pricing device that doesn't charge anything. It just checks whether you're on the operator's list. If you are, come on in. If not, no. Handy when you run a node for yourself and don't want strangers using it.",
      "example": "A guest list at the door. Your name's on it or it isn't, and nobody pays.",
      "snapsTo": [
        "p4"
      ],
      "kind": "core",
      "family": "pay",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/payment/dev_faff.erl"
    },
    {
      "id": "rate-limit",
      "name": "~rate-limit@1.0",
      "nickname": "The Bouncer",
      "job": "\"You've had enough. Come back later.\"",
      "explainer": "Every visitor gets a bucket of allowed requests that refills over time. Ask too fast and Rate limit says 429 ('slow down') until your bucket refills. Keep hammering and your bucket goes negative, so you wait even longer. It stops one person from hogging the whole node.",
      "example": "A coffee shop that serves one order per person at a time. Ask again in a minute.",
      "snapsTo": [
        "meta"
      ],
      "kind": "core",
      "family": "protect",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/node/dev_rate_limit.erl"
    },
    {
      "id": "blacklist",
      "name": "~blacklist@1.0",
      "nickname": "The Gatekeeper",
      "job": "Keeps a list of stuff that's not allowed on this node.",
      "explainer": "The operator points Blacklist at one or more lists of banned IDs. Any request touching something on the list gets blocked. Every node picks its own lists. There's no central boss, so each operator decides what they will and won't serve.",
      "example": "A no-fly list. Each airport keeps its own, and nobody makes them share.",
      "snapsTo": [
        "meta",
        "cron"
      ],
      "kind": "core",
      "family": "protect",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/node/dev_blacklist.erl"
    },
    {
      "id": "secret",
      "name": "~secret@1.0",
      "nickname": "The Locker",
      "job": "Keeps your key safe so you don't have to carry it.",
      "explainer": "Signing messages needs a private key, and keeping that key in a browser is risky. Secret stores the key on a node you trust and only uses it when you prove it's you. How you prove it is pluggable: a cookie, a password, or any other device.",
      "example": "A safe deposit box. The bank holds it, and only your key opens it.",
      "snapsTo": [
        "cookie",
        "http-auth",
        "auth-hook"
      ],
      "kind": "core",
      "family": "protect",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/auth/dev_secret.erl"
    },
    {
      "id": "cookie",
      "name": "~cookie@1.0",
      "nickname": "The Wristband",
      "job": "Gives your browser a wristband so the node remembers you.",
      "explainer": "Websites use cookies to remember who you are. This device reads and writes them for a node, and can turn a cookie into a secret that signs your messages. That's how a web page can talk to AO without you managing a wallet.",
      "example": "A hotel key card. Show it and the door opens; no need to prove who you are each time.",
      "snapsTo": [
        "secret",
        "auth-hook"
      ],
      "kind": "core",
      "family": "protect",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/auth/dev_cookie.erl"
    },
    {
      "id": "http-auth",
      "name": "~http-auth@1.0",
      "nickname": "The Password Check",
      "job": "Username and password, the classic way.",
      "explainer": "The same login box you've seen a thousand times, turned into a device. Your username and password become a secret that can sign messages, so old-school web tools can use AO too.",
      "example": "A username and password. The same login box you've used a thousand times.",
      "snapsTo": [
        "secret",
        "auth-hook"
      ],
      "kind": "core",
      "family": "protect",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/auth/dev_http_auth.erl"
    },
    {
      "id": "auth-hook",
      "name": "~auth-hook@1.0",
      "nickname": "The Autograph Machine",
      "job": "Signs your messages for you as they come in.",
      "explainer": "Plug this into Meta and every request that arrives gets signed with a wallet the node holds for you, after you prove who you are with Cookie or HTTP auth. It's the device that lets normal web apps use AO without a crypto wallet popup.",
      "example": "A notary's stamp. Once you've shown ID, every page gets stamped for you.",
      "snapsTo": [
        "meta",
        "cookie",
        "http-auth",
        "secret"
      ],
      "kind": "core",
      "family": "protect",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/auth/dev_auth_hook.erl"
    },
    {
      "id": "snp",
      "name": "~snp@1.0",
      "nickname": "The Vault",
      "job": "A sealed room even the node's owner can't see into.",
      "explainer": "Some computer chips can run code in a locked box and give you a receipt proving what ran inside. This device uses that so a node can prove 'I ran this exactly, and nobody, not even me, peeked.' It was in earlier versions and is being rebuilt right now, so treat it as coming soon.",
      "example": "A sealed room with a window. You can verify what happened inside, but nobody could reach in.",
      "snapsTo": [
        "meta"
      ],
      "kind": "experimental",
      "family": "protect",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/docs/resources/source-code/dev_snp.md"
    },
    {
      "id": "cache",
      "name": "~cache@1.0",
      "nickname": "The Shelf",
      "job": "Hands you anything the node has saved, by its ID.",
      "explainer": "Every message a node has seen gets saved with a fingerprint (its ID). Ask Cache for an ID and it hands the message back in whatever format you want. Trusted writers can also put new things on the shelf.",
      "example": "The hold shelf at a library. Give the ID, get the item.",
      "snapsTo": [
        "query",
        "match",
        "bundler"
      ],
      "kind": "core",
      "family": "store",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/node/dev_cache.erl"
    },
    {
      "id": "bundler",
      "name": "~bundler@1.0",
      "nickname": "The Packer",
      "job": "Packs lots of little things into one box before shipping to Arweave.",
      "explainer": "Saving each tiny message to Arweave one at a time would be slow and expensive. Bundler collects them, stuffs thousands into a single box, signs it, and ships it. It also puts a copy in the node's cache right away so you can read it before the box even leaves.",
      "example": "Shipping one pallet instead of five hundred separate envelopes.",
      "snapsTo": [
        "cache",
        "arweave",
        "p4"
      ],
      "kind": "core",
      "family": "store",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/arweave/dev_bundler.erl"
    },
    {
      "id": "arweave",
      "name": "~arweave@2.9",
      "nickname": "The Archive Door",
      "job": "Reads devices and transactions from Arweave, the forever storage.",
      "explainer": "Arweave is where AO keeps things permanently. This device is the door to it: ask for a device, a transaction, or the current height and it goes and gets it from a real Arweave node. Other devices like Copycat use this door.",
      "example": "The door to the archive room, where every record ever filed still sits.",
      "snapsTo": [
        "copycat",
        "bundler",
        "relay"
      ],
      "kind": "core",
      "family": "connect",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/arweave/dev_arweave.erl"
    },
    {
      "id": "copycat",
      "name": "~copycat@1.0",
      "nickname": "The Photocopier",
      "job": "Copies messages from other places into this node's shelf.",
      "explainer": "If you want to search Arweave data fast, you need a local copy. Copycat pulls messages from an Arweave node or a GraphQL endpoint, checks them, and files them in this node's cache so Query can find them.",
      "example": "Photocopying the files you need from head office so you can read them at your desk.",
      "snapsTo": [
        "arweave",
        "cache",
        "query",
        "match"
      ],
      "kind": "core",
      "family": "find",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/query/dev_copycat.erl"
    },
    {
      "id": "query",
      "name": "~query@1.0",
      "nickname": "The Search Engine",
      "job": "Finds messages on the shelf that match what you ask for.",
      "explainer": "Say 'find me every message where the type is Transfer and the owner is Sam' and Query goes through the shelf and returns them as a count, a list of IDs, or the messages themselves. It's the device behind explorers and dashboards.",
      "example": "Search on a laptop. Find everything that matches, instantly.",
      "snapsTo": [
        "cache",
        "match",
        "copycat"
      ],
      "kind": "core",
      "family": "find",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/query/dev_query.erl"
    },
    {
      "id": "match",
      "name": "~match@1.0",
      "nickname": "The Card Catalog",
      "job": "Keeps an index so searches are fast.",
      "explainer": "Searching every message one by one is slow. Match writes down 'this key has this value in this message' as things arrive, so Query can jump straight to the right place. Operators pick which keys get indexed.",
      "example": "The index at the back of a book. It tells you which page to open without reading the whole thing.",
      "snapsTo": [
        "query",
        "cache",
        "copycat"
      ],
      "kind": "core",
      "family": "find",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/query/dev_match.erl"
    },
    {
      "id": "router",
      "name": "~router@1.0",
      "nickname": "The Traffic Cop",
      "job": "Decides which node a message should go to.",
      "explainer": "A node often needs to send messages to other nodes. Router has a list of rules: 'anything for this process goes to those three nodes; pick the nearest one.' It spreads the load and keeps going if one node is down.",
      "example": "An air traffic controller. Every message is sent to the best available runway.",
      "snapsTo": [
        "relay",
        "location"
      ],
      "kind": "core",
      "family": "connect",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/node/dev_router.erl"
    },
    {
      "id": "location",
      "name": "~location@1.0",
      "nickname": "The Address Book",
      "job": "Tells you where to find a node on the internet.",
      "explainer": "Nodes are known by their wallet address, but you need a real URL to reach them. Location lets a node sign a note saying 'find me at this address for a while,' and lets other nodes look those notes up.",
      "example": "A contacts list. A name on one side, a real address on the other.",
      "snapsTo": [
        "router",
        "name"
      ],
      "kind": "core",
      "family": "connect",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/node/dev_location.erl"
    },
    {
      "id": "name",
      "name": "~name@1.0",
      "nickname": "The Nametag",
      "job": "Turns a friendly name into the long ID it stands for.",
      "explainer": "IDs on AO are 43 random-looking characters. Nobody wants to type that. Name checks a list of resolvers (local names, the naming system, whatever's plugged in) and turns 'my-game' into the real ID.",
      "example": "Typing a company's name into a browser instead of its IP address.",
      "snapsTo": [
        "local-name",
        "location"
      ],
      "kind": "core",
      "family": "find",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/name/dev_name.erl"
    },
    {
      "id": "local-name",
      "name": "~local-name@1.0",
      "nickname": "The Sticky Note",
      "job": "Names that only this node remembers.",
      "explainer": "Sometimes a name only needs to work on one node, like 'my-test-process'. Local name saves those locally and keeps them across restarts.",
      "example": "A nickname only your household uses.",
      "snapsTo": [
        "name",
        "node-process"
      ],
      "kind": "core",
      "family": "find",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/name/dev_local_name.erl"
    },
    {
      "id": "node-process",
      "name": "~node-process@1.0",
      "nickname": "The Superintendent",
      "job": "A process that belongs to this one node and always comes back.",
      "explainer": "Some processes should exist once per node: a helper that cleans up, or a node's own token ledger. Node process spawns them by name from the node's settings, and finds them again after a reboot.",
      "example": "The building's superintendent. There is one, it lives on site, and it's there after every restart.",
      "snapsTo": [
        "process",
        "local-name"
      ],
      "kind": "core",
      "family": "run",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/node/dev_node_process.erl"
    },
    {
      "id": "patch",
      "name": "~patch@1.0",
      "nickname": "The Reorganizer",
      "job": "Moves data from one spot in a message to another.",
      "explainer": "A process often wants to publish part of its state so a website can just read it with a normal web address. Patch copies data from inside the process to the outside where anyone can GET it. No indexer needed.",
      "example": "Pinning the current stats to the lobby noticeboard so nobody has to ask.",
      "snapsTo": [
        "process",
        "stack"
      ],
      "kind": "core",
      "family": "tools",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/util/dev_patch.erl"
    },
    {
      "id": "dedup",
      "name": "~dedup@1.0",
      "nickname": "The Duplicate Checker",
      "job": "Skips a message it's already seen.",
      "explainer": "If the same message shows up twice, running it twice could be bad. You'd pay someone double. Dedup remembers what's been done and says 'skip' the second time.",
      "example": "The accountant who refuses to pay the same invoice twice.",
      "snapsTo": [
        "stack",
        "process"
      ],
      "kind": "core",
      "family": "tools",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/util/dev_dedup.erl"
    },
    {
      "id": "multipass",
      "name": "~multipass@1.0",
      "nickname": "The Second Coat",
      "job": "Runs the assembly line again until it's done enough laps.",
      "explainer": "Some jobs need the whole line to run more than once: first pass to set up, second pass to finish. Multipass says 'go again' until the count is reached.",
      "example": "A coat of paint, dry, second coat. Some jobs need more than one pass.",
      "snapsTo": [
        "stack"
      ],
      "kind": "core",
      "family": "tools",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/util/dev_multipass.erl"
    },
    {
      "id": "apply",
      "name": "~apply@1.0",
      "nickname": "The Do-It Button",
      "job": "Runs whatever path you point it at.",
      "explainer": "A utility device: give it a message and a path, and it runs that path. It's what devices use to call other devices without hard-coding names.",
      "example": "The Enter key.",
      "snapsTo": [
        "stack",
        "lua"
      ],
      "kind": "core",
      "family": "tools",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/util/dev_apply.erl"
    },
    {
      "id": "message",
      "name": "~message@1.0",
      "nickname": "The Plain Box",
      "job": "The basic message with nothing special added.",
      "explainer": "Every message in AO is a box of keys and values. This device is what a message is when no other device is in charge: you can read its keys, get its ID, see who signed it, and check the signature. Every other device builds on this one.",
      "example": "A plain cardboard box, before anything is written on it.",
      "snapsTo": [
        "httpsig",
        "json",
        "structured"
      ],
      "kind": "core",
      "family": "tools",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/message/dev_message.erl"
    },
    {
      "id": "httpsig",
      "name": "~httpsig@1.0",
      "nickname": "The Signature Pen",
      "job": "Signs messages and checks signatures using a web standard.",
      "explainer": "HTTP has an official way to sign requests (RFC 9421). This device uses it so an AO message is also a valid signed web request. That means a normal web browser or server can verify AO messages without special software.",
      "example": "A signature on a contract. Anyone can check it's yours.",
      "snapsTo": [
        "message",
        "ans104",
        "tx"
      ],
      "kind": "core",
      "family": "protect",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/codec/dev_httpsig.erl"
    },
    {
      "id": "ans104",
      "name": "~ans104@1.0",
      "nickname": "The Arweave Translator",
      "job": "Turns AO messages into Arweave bundle items and back.",
      "explainer": "Arweave has its own file format for bundled data (ANS-104). This translator converts between that and AO messages, so things saved on Arweave can be read as messages and messages can be saved to Arweave.",
      "example": "A translator at a border crossing, fluent in both formats.",
      "snapsTo": [
        "bundler",
        "message",
        "tx"
      ],
      "kind": "core",
      "family": "tools",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/codec/dev_ans104.erl"
    },
    {
      "id": "tx",
      "name": "~tx@1.0",
      "nickname": "The Old-Style Translator",
      "job": "Reads and writes plain Arweave transactions.",
      "explainer": "Before bundles, Arweave used plain transactions. This translator handles those, so old data and base-layer transactions show up as normal AO messages.",
      "example": "Reading an older filing format because some records still use it.",
      "snapsTo": [
        "arweave",
        "ans104",
        "message"
      ],
      "kind": "core",
      "family": "tools",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/codec/dev_tx.erl"
    },
    {
      "id": "json",
      "name": "~json@1.0",
      "nickname": "The JSON Translator",
      "job": "Turns messages into JSON and back.",
      "explainer": "JSON is the format most websites and apps speak. This translator lets you read any message as JSON and send JSON in as a message. Add '/~json@1.0' to a path and you get JSON out.",
      "example": "The format every app and website already speaks.",
      "snapsTo": [
        "message",
        "wasm64"
      ],
      "kind": "core",
      "family": "tools",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/codec/dev_json.erl"
    },
    {
      "id": "structured",
      "name": "~structured@1.0",
      "nickname": "The Type Labeler",
      "job": "Remembers whether a value is a number, a list, or text.",
      "explainer": "Underneath, everything travels as plain text. This device tags values with their real type (integer, float, list) so '42' comes back as a number, not a string.",
      "example": "Labeling jars so sugar and salt never get mixed up.",
      "snapsTo": [
        "message",
        "httpsig"
      ],
      "kind": "core",
      "family": "tools",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/codec/dev_structured.erl"
    },
    {
      "id": "flat",
      "name": "~flat@1.0",
      "nickname": "The Flattener",
      "job": "Squashes nested messages into one flat list of paths.",
      "explainer": "A message inside a message inside a message is hard to store. Flat codec turns it into simple 'a/b/c = value' lines and can puff it back up later.",
      "example": "Folding a road map flat so it fits in the glovebox.",
      "snapsTo": [
        "message",
        "cache"
      ],
      "kind": "core",
      "family": "tools",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/codec/dev_flat.erl"
    },
    {
      "id": "gzip",
      "name": "~gzip@1.0",
      "nickname": "The Squeezer",
      "job": "Makes data smaller, then makes it big again.",
      "explainer": "Standard compression as a device. Squeeze a body before sending, unsqueeze on the other side.",
      "example": "A vacuum bag for luggage. Same clothes, less space.",
      "snapsTo": [
        "message"
      ],
      "kind": "core",
      "family": "tools",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/codec/dev_gzip.erl"
    },
    {
      "id": "base64url",
      "name": "~base64url@1.0",
      "nickname": "The Safe Speller",
      "job": "Rewrites any data using only URL-safe letters.",
      "explainer": "Raw bytes can't go in a web address. This device rewrites them with letters, numbers, dashes and underscores, the way every Arweave ID is written.",
      "example": "Spelling a word with only the characters a license plate allows.",
      "snapsTo": [
        "message"
      ],
      "kind": "core",
      "family": "tools",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/codec/dev_base64url.erl"
    },
    {
      "id": "bits",
      "name": "~bits@1.0",
      "nickname": "The Bit Reader",
      "job": "Reads tightly packed binary data using a little format string.",
      "explainer": "Some data is packed bit-by-bit to save space. Describe the layout ('4 bits for this, 12 for that') and this device unpacks it into named fields.",
      "example": "Reading a barcode: each stripe means something, if you know the layout.",
      "snapsTo": [
        "message",
        "tx"
      ],
      "kind": "core",
      "family": "tools",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/codec/dev_bits.erl"
    },
    {
      "id": "manifest",
      "name": "~manifest@1.0",
      "nickname": "The Site Map",
      "job": "Turns a folder of files on Arweave into a website with paths.",
      "explainer": "A website is a bunch of files. An Arweave manifest is a list saying 'index.html is this ID, style.css is that ID.' This device reads the list so a node can serve the whole site from one address.",
      "example": "The table of contents in a binder. Which document is on which tab.",
      "snapsTo": [
        "arweave",
        "cache"
      ],
      "kind": "core",
      "family": "store",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/arweave/dev_manifest.erl"
    },
    {
      "id": "trie",
      "name": "~trie@1.0",
      "nickname": "The Branching Tree",
      "job": "Stores lots of keys in a tree so lookups stay fast.",
      "explainer": "A radix trie is a data structure that groups keys by their shared beginnings. This device builds one out of messages, so a process can hold millions of entries without slowing down.",
      "example": "A phone book. Every name starting with 'Sm' is on the same page.",
      "snapsTo": [
        "message",
        "process"
      ],
      "kind": "core",
      "family": "store",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/message/dev_trie.erl"
    },
    {
      "id": "wasi",
      "name": "~wasi@1.0",
      "nickname": "The Pretend Hard Drive",
      "job": "Gives WASM programs a file system to read and write.",
      "explainer": "Programs expect files and folders. This device fakes a file system out of messages so a WASM program can open, read, and write files as if it had a disk.",
      "example": "A hotel room set up to feel like home, so a program that expects files and folders finds them.",
      "snapsTo": [
        "wasm64"
      ],
      "kind": "core",
      "family": "run",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/vm/dev_wasi.erl"
    },
    {
      "id": "json-iface",
      "name": "~json-iface@1.0",
      "nickname": "The Interpreter",
      "job": "Lets a WASM program and the node talk using JSON.",
      "explainer": "A WASM program can't see AO messages directly. JSON interface hands the program JSON on the way in and reads JSON on the way out, translating each direction.",
      "example": "An interpreter sitting between two people who speak different languages.",
      "snapsTo": [
        "wasm64",
        "json",
        "genesis-wasm"
      ],
      "kind": "core",
      "family": "run",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/codec/dev_json_iface.erl"
    },
    {
      "id": "genesis-wasm",
      "name": "~genesis-wasm@1.0",
      "nickname": "The Time Machine",
      "job": "Runs old AO processes the way the original network did.",
      "explainer": "Before HyperBEAM, AO processes ran on an older system called legacynet. This device recreates that world so all those existing processes keep working without changes.",
      "example": "An adapter that lets old equipment run on the new system.",
      "snapsTo": [
        "process",
        "wasm64",
        "json-iface",
        "delegated-compute"
      ],
      "kind": "core",
      "family": "run",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/vm/dev_genesis_wasm.erl"
    },
    {
      "id": "delegated-compute",
      "name": "~delegated-compute@1.0",
      "nickname": "The Outsourcer",
      "job": "Asks another machine to do the work and brings back the answer.",
      "explainer": "Not every node needs to run every program. Delegated compute sends the job to a machine you trust and treats its result as if it ran here.",
      "example": "Sending laundry out instead of doing it in-house.",
      "snapsTo": [
        "process",
        "genesis-wasm",
        "relay"
      ],
      "kind": "core",
      "family": "run",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/vm/dev_delegated_compute.erl"
    },
    {
      "id": "recorder",
      "name": "~recorder@1.0",
      "nickname": "The Black Box",
      "job": "Records everything that happened during a request, for when things break.",
      "explainer": "Like the flight recorder on a plane. Turn it on for one request and it captures every step, then shows you the trace as JSON, text, or a little web page. Great for figuring out why something went wrong.",
      "example": "The flight recorder on a plane. When something goes wrong, you can replay every step.",
      "snapsTo": [
        "meta",
        "profile"
      ],
      "kind": "core",
      "family": "tools",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/debug/dev_recorder.erl"
    },
    {
      "id": "profile",
      "name": "~profile@1.0",
      "nickname": "The Stopwatch",
      "job": "Measures which parts of a request are slow.",
      "explainer": "Runs a request under a profiler and reports where the time went. For builders trying to speed things up.",
      "example": "A lap timer. Which section of the course is costing you seconds.",
      "snapsTo": [
        "recorder"
      ],
      "kind": "core",
      "family": "tools",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/node/dev_profile.erl"
    },
    {
      "id": "hyperbuddy",
      "name": "~hyperbuddy@1.0",
      "nickname": "The Tour Guide",
      "job": "The node's built-in web dashboard.",
      "explainer": "Visit a node in your browser and Hyperbuddy shows you around: what's running, node stats, a place to poke at messages. It's the friendly face on top of all the other devices.",
      "example": "The visitor center at a national park.",
      "snapsTo": [
        "meta",
        "cacheviz",
        "query"
      ],
      "kind": "core",
      "family": "tools",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/node/dev_hyperbuddy.erl"
    },
    {
      "id": "cacheviz",
      "name": "~cacheviz@1.0",
      "nickname": "The Map Maker",
      "job": "Draws a picture of what's on the shelf.",
      "explainer": "Turns the node's saved messages into a diagram so you can see how they connect.",
      "example": "A map of the office showing how the departments connect.",
      "snapsTo": [
        "cache",
        "hyperbuddy"
      ],
      "kind": "core",
      "family": "tools",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/node/dev_cacheviz.erl"
    },
    {
      "id": "whois",
      "name": "~whois@1.0",
      "nickname": "The Mirror",
      "job": "Tells you your own internet address, or the node's.",
      "explainer": "Ask it and it says what IP and host it sees. Simple, but useful when setting up nodes.",
      "example": "Caller ID.",
      "snapsTo": [
        "location"
      ],
      "kind": "core",
      "family": "tools",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/node/dev_whois.erl"
    },
    {
      "id": "b32-name",
      "name": "~b32-name@1.0",
      "nickname": "The Subdomain Trick",
      "job": "Lets any message ID be used as a website subdomain.",
      "explainer": "Message IDs have characters that can't go in a domain name. This device rewrites them so 'someid.node.example' just works, so every message can have its own web address.",
      "example": "Giving every apartment its own street address.",
      "snapsTo": [
        "name",
        "manifest"
      ],
      "kind": "core",
      "family": "find",
      "source": "https://github.com/permaweb/HyperBEAM/blob/edge/src/preloaded/name/dev_b32_name.erl"
    },
    {
      "id": "token",
      "name": "token@1.0",
      "nickname": "The Coin Maker",
      "job": "A ready-made token: balances, transfers, the works.",
      "explainer": "Instead of writing your own token from scratch in Lua, snap this in. It keeps balances, moves coins between owners, and sends the usual notices when money moves.",
      "example": "A gift card balance. It can be checked, spent, and transferred.",
      "snapsTo": [
        "process",
        "process-outbox",
        "pot"
      ],
      "kind": "community",
      "family": "pay",
      "source": "https://github.com/permaweb/token-1.0",
      "specId": "Y0oqgFc3B88Xz_RcgWn2PlgJtUn7uzCH0aPtlAChXGY",
      "implId": "yGNpkVZIP2Ou1VRCn9Nw7yeJJ_HqYe42umDKEnpB7MU",
      "signer": "vZY2XY1RD9HIfWi8ift-1_DnHLDadZMWrufSh-_rKF0"
    },
    {
      "id": "process-outbox",
      "name": "process-outbox@1.0",
      "nickname": "The Newsletter",
      "job": "Lets people subscribe to a process and get told when things happen.",
      "explainer": "A process puts outgoing messages in an outbox. This device manages that outbox and lets other processes sign up: 'tell me whenever a Transfer happens.' Then it fans the news out to every subscriber.",
      "example": "Signing up for shipping notifications. You're told the moment something moves.",
      "snapsTo": [
        "process",
        "push",
        "token"
      ],
      "kind": "community",
      "family": "connect",
      "specId": "nqT2LAb7T0UbRdZ3Srixr7Zcfb5JRvTzHIIsSCIIaK0",
      "implId": "Zj1bSwn-GsLlOwZQvuOKas4pv80tRwrrLDZiSOpM5JU",
      "signer": "vZY2XY1RD9HIfWi8ift-1_DnHLDadZMWrufSh-_rKF0"
    },
    {
      "id": "recharging-ledger",
      "name": "recharging-ledger@1.0",
      "nickname": "The Refilling Allowance",
      "job": "Everyone gets a balance that slowly refills on its own.",
      "explainer": "A ledger for P4 where you don't top up with money. Your balance just refills over time, like energy in a mobile game. Operators can give bigger refills to people who hold more AO tokens.",
      "example": "A phone plan with monthly data. Use it, and it refills on schedule.",
      "snapsTo": [
        "p4",
        "metering"
      ],
      "kind": "community",
      "family": "pay",
      "source": "https://github.com/permaweb/recharging-ledger"
    },
    {
      "id": "eth-client",
      "name": "eth-client@1.0",
      "nickname": "The Ethereum Window",
      "job": "Lets AO look at what's happening on Ethereum.",
      "explainer": "A client device that reads Ethereum data so processes on AO can react to it: balances, devices, events. A first step toward bridges between the two worlds.",
      "example": "A window into the office next door, so you can react to what they're doing.",
      "snapsTo": [
        "relay",
        "process"
      ],
      "kind": "community",
      "family": "connect",
      "source": "https://github.com/permaweb/eth-client-1.0"
    },
    {
      "id": "pot",
      "name": "pot@1.0",
      "nickname": "The Slow Cooker",
      "job": "Mints new tokens based on how much time has passed.",
      "explainer": "Proof-of-time minting: instead of mining, tokens are created on a clock. Works with Token to make a token that grows steadily.",
      "example": "Interest on a savings account. It accrues on its own.",
      "snapsTo": [
        "token",
        "process-outbox",
        "cron"
      ],
      "kind": "community",
      "family": "pay"
    },
    {
      "id": "reference",
      "name": "reference@1.0",
      "nickname": "The Whiteboard",
      "job": "One permanent name, one value you can change whenever.",
      "explainer": "Create a reference and it gets an ID that never changes. Its value can be replaced any time by the one owner who made it. Unlike a process, you don't replay history. The latest value is just the latest value.",
      "example": "The specials board at a restaurant. Same board, new writing every day.",
      "snapsTo": [
        "name",
        "cache"
      ],
      "kind": "community",
      "family": "store",
      "source": "https://github.com/samcamwilliams/reference-1.0"
    },
    {
      "id": "simple-oracle",
      "name": "simple-oracle@1.0",
      "nickname": "The Price Checker",
      "job": "Fetches the price of AO and AR in dollars.",
      "explainer": "Asks a few price websites through Relay, averages the answers, and remembers them for a bit. Handy for any device that needs to charge in dollars.",
      "example": "Checking three sites for a price and going with the average.",
      "snapsTo": [
        "relay",
        "p4",
        "arweave-byte-pricing"
      ],
      "kind": "community",
      "family": "connect",
      "source": "https://github.com/xylophonez/simple-oracle-device"
    },
    {
      "id": "pricing-router",
      "name": "pricing-router@1.0",
      "nickname": "The Price Switchboard",
      "job": "Sends each kind of request to the right pricing device.",
      "explainer": "One node might want to charge per-byte for uploads but a flat fee for reads. This device looks at the request and routes it to the pricing device that fits.",
      "example": "A cashier who knows coffee is one price and lunch is another.",
      "snapsTo": [
        "p4",
        "metering",
        "simple-pay",
        "arweave-byte-pricing"
      ],
      "kind": "community",
      "family": "pay",
      "source": "https://github.com/xylophonez/pricing-router-device"
    },
    {
      "id": "arweave-byte-pricing",
      "name": "arweave-byte-pricing@1.0",
      "nickname": "The Scale",
      "job": "Charges uploads by weight: how many bytes you're storing.",
      "explainer": "A pricing device that weighs what you're saving to Arweave and charges per byte, so the node can cover its own storage cost.",
      "example": "Paying for shipping by weight.",
      "snapsTo": [
        "p4",
        "bundler",
        "pricing-router",
        "simple-oracle"
      ],
      "kind": "community",
      "family": "pay",
      "source": "https://github.com/xylophonez/arweave-byte-pricing-device"
    },
    {
      "id": "gateway-shim",
      "name": "gateway-shim@1.0",
      "nickname": "The Path Rewriter",
      "job": "Rewrites incoming web addresses so old-style links still work.",
      "explainer": "Arweave gateways have their own URL style. This device catches those requests and rewrites the path into what HyperBEAM expects, so a HyperBEAM node can stand in for a gateway.",
      "example": "Mail forwarding after you move. Old addresses still reach you.",
      "snapsTo": [
        "meta",
        "manifest"
      ],
      "kind": "community",
      "family": "connect",
      "source": "https://github.com/permaweb/gateway-shim-1.0"
    },
    {
      "id": "git",
      "name": "git@1.0",
      "nickname": "The Repo Reader",
      "job": "Reads a git repository, checks every file, and serves it from a node, even to git clone.",
      "explainer": "Point it at a public project on GitHub, GitLab, or Codeberg and pick a commit. The node downloads that exact snapshot, checks every file against its git fingerprint, and keeps a copy it can hand to anyone who asks. Anyone can also git clone it straight from the node, and git checks every file again. If the host sends something wrong or a saved file gets damaged, the fingerprint won't match and the node refuses it.",
      "example": "A certified copy of a deed. Anyone can check it matches the original without calling the county office.",
      "snapsTo": [
        "cache",
        "httpsig",
        "lua"
      ],
      "kind": "community",
      "family": "connect",
      "source": "https://molecule.arweave.net/#/git-device",
      "specId": "S5AySdmyR5nOicnUzXfTl6lnbjfSreMNU4pAQw9sbFE",
      "implId": "CRrtwlp9c6rVDPtl5sJeR-bWzXrBAh2eK2nYgWyiMtY",
      "signer": "aklq1HkVWIE7DWLKjUlyYdFT6plUV7TMpLl16aOU-BU"
    }
  ],
  "stories": [
    {
      "title": "How a message gets answered",
      "blurb": "The everyday loop. Almost every AO app is this story.",
      "idea": "An AO app is a program on computers anyone can run, not one company's server. These devices carry your message from the door to an answer.",
      "steps": [
        {
          "id": "meta",
          "line": "A request walks in. Meta checks who's asking."
        },
        {
          "id": "scheduler",
          "line": "Scheduler gives it a number so it waits its turn."
        },
        {
          "id": "process",
          "line": "The process opens its log to where things left off."
        },
        {
          "id": "lua",
          "line": "Lua runs the code and writes down what changed."
        },
        {
          "id": "push",
          "line": "Push delivers any replies to the next process."
        }
      ]
    },
    {
      "title": "How a node earns money",
      "blurb": "Same loop, but strangers pay for what they use.",
      "idea": "A node is one of those computers, and whoever runs it can charge for the work. It works like a parking garage: a gate, a meter, and a charge against your account.",
      "steps": [
        {
          "id": "rate-limit",
          "line": "Rate limit makes sure nobody hammers the door."
        },
        {
          "id": "p4",
          "line": "P4 asks: how much, and can they pay?"
        },
        {
          "id": "metering",
          "line": "Metering counts what the job actually used."
        },
        {
          "id": "recharging-ledger",
          "line": "Recharging ledger takes the charge from a balance that slowly refills."
        },
        {
          "id": "lua",
          "line": "Only then does Lua do the work."
        }
      ]
    },
    {
      "title": "How a website lives forever",
      "blurb": "Host a site from permanent storage and let people search it.",
      "idea": "Arweave is storage you pay for once and keep for good, like buying a house instead of renting. Once a site is saved there, nobody can take it down.",
      "steps": [
        {
          "id": "arweave",
          "line": "Arweave opens onto everything ever saved."
        },
        {
          "id": "manifest",
          "line": "Manifest turns a folder of files into pages."
        },
        {
          "id": "copycat",
          "line": "Copycat keeps a local copy so it's fast."
        },
        {
          "id": "match",
          "line": "Match files every page by what's in it."
        },
        {
          "id": "query",
          "line": "Query finds any page in a blink."
        },
        {
          "id": "bundler",
          "line": "Bundler ships new pages back to storage in one box."
        }
      ]
    },
    {
      "title": "How a browser gets a wallet",
      "blurb": "A normal web page can talk to AO with no crypto popup.",
      "idea": "A wallet is your signature on AO: it proves a message came from you. Here the node holds your key for you, like a hotel desk holding your room key.",
      "steps": [
        {
          "id": "cookie",
          "line": "Cookie remembers your browser."
        },
        {
          "id": "secret",
          "line": "Secret keeps a key for you on the node."
        },
        {
          "id": "auth-hook",
          "line": "Auth hook signs each request with it."
        },
        {
          "id": "process",
          "line": "The process sees a properly signed message and trusts it."
        }
      ]
    }
  ],
  "hero": {
    "steps": [
      "cron",
      "process",
      "lua",
      "push"
    ],
    "line": "Cron wakes the process. The process hands the job to Lua. Lua's answer goes out with Push."
  },
  "works": [
    {
      "name": "llm@1.0, harness@1.0, skills@1.0",
      "plain": "The Agent Stack",
      "job": "An AI agent as devices: a model, the loop that runs it, and the skills it can use.",
      "status": "In review",
      "ref": "PR #1064",
      "url": "https://github.com/permaweb/HyperBEAM/pull/1064",
      "who": "Forward Research",
      "icon": "w-agent-stack"
    },
    {
      "name": "~rac@1.0",
      "plain": "The Registered Mail",
      "job": "Messages between processes arrive in order, exactly once, and can't be replayed.",
      "status": "In review",
      "ref": "PR #1033",
      "url": "https://github.com/permaweb/HyperBEAM/pull/1033",
      "who": "Forward Research",
      "icon": "w-rac"
    },
    {
      "name": "~arweave-scheduler@1.0",
      "plain": "The Chain Clerk",
      "job": "A scheduler that takes its order from the Arweave chain itself, so there is no scheduler wallet to trust.",
      "status": "In review",
      "ref": "PR #1022",
      "url": "https://github.com/permaweb/HyperBEAM/pull/1022",
      "who": "Forward Research",
      "icon": "w-arweave-scheduler"
    },
    {
      "name": "router node",
      "plain": "The Fastest Answer",
      "job": "A node that asks about thirty peers and takes the first good answer.",
      "status": "In review",
      "ref": "PR #988",
      "url": "https://github.com/permaweb/HyperBEAM/pull/988",
      "who": "Forward Research",
      "icon": "w-router-node"
    },
    {
      "name": "~ipfs@1.0 codecs",
      "plain": "The IPFS Door",
      "job": "Read and serve anything on IPFS by its CID, verified, and push it to Arweave for good.",
      "status": "Draft",
      "ref": "PR #868",
      "url": "https://github.com/permaweb/HyperBEAM/pull/868",
      "who": "Sam Williams",
      "icon": "w-ipfs"
    }
  ],
  "wanted": [
    {
      "name": "gpu-infer",
      "plain": "The Heavy Thinker",
      "job": "Run a model on a GPU and hand back the answer with proof of what ran.",
      "why": "Agents on AO need inference that is fast and provable. Today a node has no way to use a GPU.",
      "inputs": "A model id, a prompt or tensor, a budget.",
      "outputs": "The output plus an attestation of the run.",
      "closest": [
        "wasm64",
        "delegated-compute",
        "snp"
      ],
      "source": {
        "who": "HyperBEAM docs",
        "where": "AO Devices, the potential of devices",
        "url": "https://github.com/permaweb/HyperBEAM/blob/edge/docs/introduction/ao-devices.md",
        "quote": "Devices could be created to interface directly with specialized hardware accelerators like GPUs"
      },
      "icon": "m-gpu-infer"
    },
    {
      "name": "zk-verify",
      "plain": "The Stamp Checker",
      "job": "Check a zero-knowledge proof in one step, natively, instead of inside slow WASM.",
      "why": "Private state, ZK bridges, and provable off-chain work all need a cheap verifier. Nothing in the tree does this yet.",
      "inputs": "A verifying key, a proof, public inputs.",
      "outputs": "Valid or not, committed into the message.",
      "closest": [
        "httpsig",
        "wasm64"
      ],
      "source": {
        "who": "HyperBEAM docs",
        "where": "AO Devices, the potential of devices",
        "url": "https://github.com/permaweb/HyperBEAM/blob/edge/docs/introduction/ao-devices.md",
        "quote": "New devices could implement cutting-edge cryptographic techniques, such as zero-knowledge proofs"
      },
      "icon": "m-zk-verify"
    },
    {
      "name": "vrf",
      "plain": "The Fair Dice",
      "job": "A random number nobody can rig, with a receipt proving it was fair.",
      "why": "Games, lotteries, and fair ordering need randomness. There is no randomness device at all; the old way was slow commit-and-reveal in Lua.",
      "inputs": "A seed, usually the message's own hash chain.",
      "outputs": "A random value and a signature anyone can check.",
      "closest": [
        "httpsig",
        "snp"
      ],
      "source": {
        "who": "Device Proshop",
        "where": "our read of the edge branch",
        "url": "https://github.com/permaweb/HyperBEAM/tree/edge/src/preloaded",
        "quote": "No randomness primitive anywhere in the preloaded devices."
      },
      "icon": "m-vrf"
    },
    {
      "name": "vector-memory",
      "plain": "The Long Memory",
      "job": "Turn saved messages into embeddings and find the closest ones fast.",
      "why": "The agent stack's memory is markdown files. Real recall needs a vector index that fills itself from the cache.",
      "inputs": "Messages as they are written to the cache.",
      "outputs": "Nearest matches for any query, with scores.",
      "closest": [
        "match",
        "query",
        "copycat"
      ],
      "source": {
        "who": "Device Proshop",
        "where": "reading PR #1064",
        "url": "https://github.com/permaweb/HyperBEAM/pull/1064",
        "quote": "Agent memory today is a folder of markdown files."
      },
      "icon": "m-vector-memory"
    },
    {
      "name": "chain-clients",
      "plain": "The Other Windows",
      "job": "Read Bitcoin and Solana the way eth-client reads Ethereum.",
      "why": "eth-client exists. The same shape for the other big chains would let AO processes react to all of them.",
      "inputs": "Block headers and proofs from a chain.",
      "outputs": "Verified chain state as AO messages.",
      "closest": [
        "eth-client",
        "relay"
      ],
      "source": {
        "who": "HyperBEAM docs",
        "where": "AO Devices, the potential of devices",
        "url": "https://github.com/permaweb/HyperBEAM/blob/edge/docs/introduction/ao-devices.md",
        "quote": "Devices could act as secure bridges to other blockchain networks"
      },
      "icon": "m-chain-clients"
    }
  ],
  "pick": {
    "pool": [
      {
        "id": "cron",
        "short": "Runs things on a timer."
      },
      {
        "id": "lua",
        "short": "Runs your own code."
      },
      {
        "id": "process",
        "short": "Remembers everything."
      },
      {
        "id": "relay",
        "short": "Talks to any website."
      },
      {
        "id": "token",
        "short": "Makes a coin."
      },
      {
        "id": "p4",
        "short": "Charges for use."
      },
      {
        "id": "arweave",
        "short": "Keeps files forever."
      },
      {
        "id": "query",
        "short": "Searches in a blink."
      },
      {
        "id": "cookie",
        "short": "Sign in, no wallet."
      }
    ],
    "builds": {
      "arweave+cookie+cron": "a daily journal people sign into with no wallet, saved forever each night",
      "arweave+cookie+lua": "a blog people post to with no wallet, where every post is kept forever",
      "arweave+cookie+p4": "a paid photo locker people sign into with no wallet, with files kept forever",
      "arweave+cookie+process": "a guestbook anyone can sign with no wallet, kept forever",
      "arweave+cookie+query": "a notes app with no wallet sign in, instant search, and nothing ever lost",
      "arweave+cookie+relay": "a bookmark saver that keeps any web page forever, no wallet needed",
      "arweave+cookie+token": "a fan club coin people claim with no wallet, with its history kept forever",
      "arweave+cron+lua": "a script that runs every night and saves its results forever",
      "arweave+cron+p4": "a paid backup service that copies your files forever, every night",
      "arweave+cron+process": "a daily log that writes one entry a day and never loses one",
      "arweave+cron+query": "a news archive that files new stories every hour, searchable forever",
      "arweave+cron+relay": "a bot that snapshots a website every hour and keeps every copy forever",
      "arweave+cron+token": "a coin that pays out on a schedule, with every payout on the permanent record",
      "arweave+lua+p4": "a paid publishing tool that runs your code and stores the result forever",
      "arweave+lua+process": "an app whose code and history both live forever",
      "arweave+lua+query": "a permanent library with your own rules for sorting it and search that finds anything",
      "arweave+lua+relay": "a tool that pulls data from any website, cleans it up, and stores it forever",
      "arweave+lua+token": "a coin with your own rules, where every transfer is kept forever",
      "arweave+p4+process": "a pay per upload storage service that keeps a receipt for everything",
      "arweave+p4+query": "a paid search engine over everything stored forever",
      "arweave+p4+relay": "a paid web archiver: people pay, and it saves any page forever",
      "arweave+p4+token": "a store that sells for your own coin and keeps every sale forever",
      "arweave+process+query": "a permanent database you can search in a blink",
      "arweave+process+relay": "a price tracker that asks a website for prices and records every answer forever",
      "arweave+process+token": "a coin with a permanent, public record of every move",
      "arweave+query+relay": "a search engine for web pages you saved forever",
      "arweave+query+token": "a coin explorer where anyone can search every transfer, forever",
      "arweave+relay+token": "a coin that rewards people for saving useful web pages forever",
      "cookie+cron+lua": "a reminder app people sign into with no wallet, running your code on a schedule",
      "cookie+cron+p4": "a monthly subscription people join with no wallet",
      "cookie+cron+process": "a habit tracker with no wallet sign in that checks in every day",
      "cookie+cron+query": "a daily digest people sign into with no wallet, searchable any time",
      "cookie+cron+relay": "a price alert people set up with no wallet that checks a website every hour",
      "cookie+cron+token": "a daily coin drop people claim with no wallet",
      "cookie+lua+p4": "a paid web app people use with no wallet, running your own code",
      "cookie+lua+process": "a web game people play with no wallet that remembers every move",
      "cookie+lua+query": "a web app with no wallet sign in and instant search",
      "cookie+lua+relay": "a web app with no wallet sign in that pulls in data from any site",
      "cookie+lua+token": "a points system for a website, no wallet needed",
      "cookie+p4+process": "a pay as you go web service with no wallet popup and a full history",
      "cookie+p4+query": "a paid search site people sign into with no wallet",
      "cookie+p4+relay": "a paid service people call from a normal web page, no wallet needed",
      "cookie+p4+token": "a shop that takes your own coin, with no wallet popup",
      "cookie+process+query": "a chat room people join with no wallet, with searchable history",
      "cookie+process+relay": "a web inbox with no wallet sign in that passes messages to other sites",
      "cookie+process+token": "a loyalty card that lives in a normal web page",
      "cookie+query+relay": "a personal web search with no wallet sign in",
      "cookie+query+token": "a rewards page people check with no wallet",
      "cookie+relay+token": "a tip button for any website, no wallet needed",
      "cron+lua+p4": "a paid service that runs your code every hour",
      "cron+lua+process": "a game world that keeps ticking even when nobody is online",
      "cron+lua+query": "an hourly job that sorts new data so it's ready to search",
      "cron+lua+relay": "a bot that checks a website every hour and acts on what it finds",
      "cron+lua+token": "a coin that pays interest every day by its own rules",
      "cron+p4+process": "a meter that bills customers every month and keeps the records",
      "cron+p4+query": "a paid alert service that looks for new matches every hour",
      "cron+p4+relay": "a paid uptime checker that pings websites on a schedule",
      "cron+p4+token": "a subscription paid in your own coin, charged on schedule",
      "cron+process+query": "an hourly log you can search any time",
      "cron+process+relay": "a weather station that asks a weather site every hour and remembers the answers",
      "cron+process+token": "a savings account that adds a little every day",
      "cron+query+relay": "a news tracker that pulls headlines every hour and makes them searchable",
      "cron+query+token": "a daily leaderboard of who holds the most of your coin",
      "cron+relay+token": "a coin whose rewards follow a real world price, checked every hour",
      "lua+p4+process": "a paid app with your own rules and a full history",
      "lua+p4+query": "a paid search tool with your own ranking rules",
      "lua+p4+relay": "a paid version of any web service, with your logic on top",
      "lua+p4+token": "a vending machine that sells digital goods for your coin",
      "lua+process+query": "an app with its own logic and a searchable history",
      "lua+process+relay": "an agent that remembers, thinks in code, and reaches out to the web",
      "lua+process+token": "your own token, the classic first AO app",
      "lua+query+relay": "a tool that collects data from the web, sorts it, and lets you search it",
      "lua+query+token": "a coin with your own rules and a search page for every transfer",
      "lua+relay+token": "a coin that pays out when something happens on a real website",
      "p4+process+query": "a paid database where people pay per search",
      "p4+process+relay": "a paid relay that passes messages along and keeps receipts",
      "p4+process+token": "a node that charges in your own coin and keeps the books",
      "p4+query+relay": "a paid data feed: pull from the web, search it, charge per use",
      "p4+query+token": "a paid market data site priced in your own coin",
      "p4+relay+token": "a paid price feed people buy with your coin",
      "process+query+relay": "a research notebook that pulls from the web and finds anything you saved",
      "process+query+token": "a coin with a searchable history of every holder",
      "process+relay+token": "a coin that reacts to a real world price",
      "query+relay+token": "a coin price tracker you can search"
    }
  }
}
