KineticVM

Live on Monad testnetERC-8004

The physical world is AI's next dataset.

KineticVM gives every robot, drone and sensor an onchain identity and signs everything it does on Monad. Owners get a machine history that buyers can verify, and a new way to earn from it.

Install on Linux, Raspberry Pi or macOS

Works with the hardware you already have

  • Monad
  • ERC-8004
  • Raspberry Pi
  • ESP32
  • Raspberry Pi Pico
  • Arduino
  • STM32 Nucleo
  • NXP SE050
  • WASM plugins

The problem

AI has consumed most of the internet. Its next source of training data is the physical world: robots in factories, machines inspecting products, sensors watching farms. But when that data is sold, the buyer can't tell whether it came from the claimed machine, or whether someone made it up.

01

Machines act

Robots, drones and sensors do real work in the physical world.

pick_placeslot B4
sig 0x7c1e…09ab
Signed

Recorded on Monad

02

Actions become attestations

The device key signs each action and it is recorded on Monad.

vending-01.jsonldataset
  • {"vend":"B4"}0x7c1e
  • {"pick":"A2"}0x2f90
  • {"soil":41}0x9ab4
  • {"vend":"C1"}0x51d2
1 identity4,812 rows
03

Attestations become datasets

One persistent identity builds a history with provenance.

Buyer · AI labverifying
  • Hash matches attestation
  • Signed by the device key
  • Identity #142 on Monad
Paid to owner12 MON
+12 MON
04

Datasets become revenue

Owners sell it. Buyers verify every row before they pay.

The solution

Turn a device into an accountable economic actor.

KineticVM gives every physical AI three things. Together they let it act, transact and build a history anyone can check.

vending-01

Agent #142 · ERC-8004

Active
Owner
0x9f2c…41d7
Device key
0x3a71…c8e0
Network
Monad

One persistent identity

Each machine is an ERC-8004 agent on Monad, owned by whoever holds the NFT. Its history follows that identity for life.

vend

slot B4

0x7c1e…09ab

gpio_write

pin 17 → high

0x2f90…a1c3

soil_read

41% moisture

0x9ab4…77e2

Signed proof of every action

The runtime connects AI models to real hardware. When the machine acts, its device-bound key signs the record and it lands on Monad as an attestation.

Spent today

cap 25 MON

9.4 MON

  • Supplier 0x51b0…−1.20
  • Charger 0xc7e2…−0.80
Per transaction≤ 2 MON

A wallet it can't overspend

The machine pays for what it needs from a vault with per-transaction and daily caps. The owner can tighten, pause or withdraw at any time.

How it works

From unboxed to earning in four steps.

  1. 1

    Install the runtime

    One command on a Raspberry Pi, a Linux box or a Mac. Quickstart creates the device signing key, which never leaves the machine.

  2. 2

    Claim it and set limits

    The device sends its owner a claim link on Telegram. One confirmation mints the ERC-8004 identity into the owner's wallet and sets the vault's spending caps.

  3. 3

    Let it work

    The agent sells, moves and measures. Every action becomes an attestation signed by the device and recorded on Monad.

  4. 4

    Sell its history

    Records build up under one identity. Package them as a dataset, and buyers verify each row against the chain before they pay.

pi@vending-01 ~
$ curl -fsSL …/install.sh | sh✓ kinetic installed to ~/.local/bin $ kinetic quickstart› device key        created, stays on this machine› network           Monad testnet · 10143› limits            2 MON per tx · 25 MON per day✓ claim link sent to the owner on Telegram $ kinetic agent -a vending-01● vend slot B4       attested 0x7c1e…09ab● paid supplier 1.2  within today's cap

Onchain proof

Every action, on the record.

Each record is signed by the machine's own key and written to Monad under its ERC-8004 identity. A buyer can hash any row and match it to the chain, without trusting the owner to have kept the history intact, or not invented it.

EIP-712

typed, signed proofs

ERC-8004

identity and validation

keccak256

row-level data hashes

Attestation feed

Preview · sample data

  • locker-lekkiunlock

    door 6 · code ok · agent #61

  • courier-12deliver

    parcel 8812 dropped · agent #56

  • charger-ng-2session

    18.4 kWh delivered · agent #330

  • agri-drone-7spray

    row 14 · 2.1 L · agent #267

  • cell-arm-3gpio_write

    gripper → closed · agent #92

Data marketplace

Open

Datasets become revenue.

A machine's attested history is worth something to the people building and insuring the physical world. Owners will list it here, and buyers will check every row before they pay.

  • AI trainers
  • Researchers
  • Auditors
  • Insurers
  • Owners package the records their machines already keep
  • Each row hashes to an attestation the device signed on Monad
  • Buyers verify before they pay, without trusting the seller
Dataset

Vending sales · Lagos

30 days · 4,812 rows · 6 machines

12 MON

Every row matches a signed attestation

Use cases

Every machine is a data source.

If it moves, senses or sells, its work can become verifiable data. GPIO, serial and MQTT come built in, and anything else becomes a plugin.

Vending and retail

Every sale is a signed record: demand by location, hour and product.

Robot arms

Picks, places and welds become training data with a provable source.

Drones

Flight and survey logs that insurers and regulators can check.

Agriculture

Soil readings and spray runs with provenance crop buyers can trust.

Delivery robots

Pays for its own charging inside its owner's limits, and logs every drop.

EV charging

Metered sessions that settle payment and prove the energy delivered.

For builders

Ship a plugin, not a platform.

One directory is one integration: tools, a procedure and an optional skill. The runtime handles identity, payments, attestations and the agent loop.

kinetic plugin create vending

Scaffold tools, a procedure and a records schema

kinetic build

Compile to a sandboxed WASM component

kinetic plugin install ./vending

Load it on the device, permissions and all

vending/src/lib.rs
impl Guest for Tools {
    fn list_tools() -> Vec<ToolInfo> {
        vec![ToolInfo {
            name: "vend".to_string(),
            description: "Drop one item from a slot.".to_string(),
            parameters_schema: SLOT_SCHEMA.to_string(),
        }]
    }

    fn execute(name: String, args: String) -> Result<ToolResult, String> {
        match name.as_str() {
            // The host signs and attests the result.
            "vend" => vend(&args),
            other => Err(format!("unknown tool {other}")),
        }
    }
}

Security by design

Autonomous, never unaccountable.

Machines get exactly as much freedom as their owner grants, and the chain enforces it.

Keys stay on the device

The signing key lives behind one interface, as a software key or in an NXP SE050 secure element. It is never logged or exported.

A machine never owns itself

The device key never gets operator rights over its own identity NFT. The identity sits in the owner's wallet.

Every payment hits the vault

Per-transaction and daily caps, a recipient allowlist and a pause switch. There is no path around them.

The owner can always pull the plug

Revoke or rotate the device key onchain at any time. If the device's local cache disagrees with the chain, the chain wins.

Your machines already make data. Make it worth something.

Machines act. Actions become attestations. Attestations become datasets. Datasets become revenue.