> ## Documentation Index
> Fetch the complete documentation index at: https://docs.kineticvm.xyz/llms.txt
> Use this file to discover all available pages before exploring further.
# Overview
> KineticVM gives physical AI devices an onchain identity, a wallet with hard spending limits, and a signed, verifiable record of everything they do.
KineticVM is infrastructure for **physical AI**: robots, drones, vending machines, sensors, chargers, and any other machine where an AI model drives real hardware. It gives each machine three things it has never had:
Every machine is an [ERC-8004](/contracts/erc-8004) agent on Monad. The identity is an NFT in the owner's wallet. Owning the NFT means owning the machine.
The machine pays from a vault with a per-transaction cap, a rolling daily cap, a recipient allowlist, and a pause switch. The contract enforces every limit.
When the machine acts, a key bound to the device signs the record and it lands on Monad as an attestation that anyone can verify.
The agent runtime that runs on the device connects a language model to the hardware, listens to its owner over Telegram, and lets builders add their own business logic as sandboxed plugins. A [data marketplace](/marketplace/overview) on top lets owners sell the machine's attested operation records, and lets buyers check every row onchain before they pay.
## The problem
AI models can now see, decide, and move. They are leaving the screen and taking over machines in kitchens, warehouses, fields, and streets. The infrastructure around those machines has not caught up. Three gaps show up as soon as an AI-driven machine leaves the lab.
A machine's identity today is a serial number in a vendor database, or an API key on a server. Neither can be checked by a third party, and neither says who is responsible for the machine. When a machine is sold, its history stays behind with the old vendor, or it is simply lost.
Without a portable, ownable identity, a machine cannot build a reputation, cannot be held to account, and cannot be traded as an asset with its history attached.
An autonomous machine needs to pay for things: electricity, parts, services, gas for its own transactions. The common answer is to put a private key on the device and fund it. That key can then spend everything it holds, on anything, at any time.
A compromised device, a buggy prompt, or a model that misreads an instruction can drain it. Owners need a way to let a machine spend that is bounded by rules the machine itself cannot change.
Every vend, pick, weld, flight, and soil reading is valuable data. Operators, insurers, regulators, and AI labs training robotics models all want it. But a log file on a server is just a claim. Anyone can edit it, and a buyer has no way to tell a real record from a fabricated one.
Without provenance, machine data cannot be priced, audited, or trusted. It stays locked inside the company that collected it.
## How KineticVM solves it
KineticVM separates **who owns the machine** from **the key the machine uses**, and puts the rules between them on Monad.
```mermaid theme={"theme":{"light":"github-light","dark":"github-dark-dimmed"}}
flowchart LR
Owner["Owner wallet
(holds the identity NFT)"]
subgraph Monad["Monad"]
Identity["ERC-8004
Identity Registry"]
Registry["KineticRegistry"]
Vault["DeviceVault"]
Attestor["KineticAttestor"]
Validation["ERC-8004
Validation Registry"]
end
subgraph Device["Device"]
Runtime["KineticVM runtime
(agent + tools)"]
Key["Device key"]
HW["Motors, pins,
sensors"]
end
Owner -- "owns" --> Identity
Owner -- "sets limits, pauses" --> Vault
Registry -- "binds device key to agent" --> Identity
Runtime --> HW
Runtime --> Key
Key -- "pays within caps" --> Vault
Key -- "signs action proofs" --> Attestor
Attestor -- "writes validation" --> Validation
```
Claiming a device mints an ERC-8004 agent NFT straight into the owner's wallet. The device signs a claim ticket that proves it holds its key and names that owner. The device key is never the NFT owner and never an operator on it. See [Identity](/concepts/identity).
The owner deposits MON into a [DeviceVault](/concepts/vault) account for that agent. The device can pay an allowlisted recipient, and only inside the per-transaction and daily caps. Tightening a limit is instant. Loosening one, adding a recipient, or unpausing needs the owner's wallet signature, so a compromised device cannot raise its own limits.
After a successful actuator action, or a completed operation the builder defines, the device key signs an EIP-712 `ActionProof`. The [KineticAttestor](/concepts/attestations) verifies that signature against the key bound to the agent and writes the result to the ERC-8004 Validation Registry, where anyone can read it.
The device keeps the exact bytes it signed in a local [operations file](/concepts/records). The owner can list those records on the [marketplace](/marketplace/overview), and a buyer can rehash any row and match it against the attestation on Monad before paying.
**A tokenized machine.** Because the machine's identity is an NFT the owner holds, transferring the NFT transfers control of the machine. The moment `ownerOf` changes, the old device binding stops working, spending stops, and the new owner links the device to themselves. The machine's entire attested history follows the identity. See [Ownership](/operate/ownership).
## What is in the stack
`KineticRegistry`, `DeviceVault`, and `KineticAttestor` on Monad, built on the canonical ERC-8004 Identity and Validation registries. One shared deployment serves every device.
A single Rust binary, `kinetic`, for 64-bit Linux (including Raspberry Pi) and macOS. It runs the agent loop, the device key, the chain client, Telegram, and the hardware adapters.
Sandboxed WebAssembly [plugins](/build/plugins), event-driven [SOPs](/build/sops), and [skills](/build/skills). A builder writes the business logic; the host keeps the key, the vault, and the attestations.
The claim page at `claim.kineticvm.xyz`, the vault deposit page, and the data marketplace at `marketplace.kineticvm.xyz`.
## Who KineticVM is for
You own one machine or a fleet. You want each one to run on its own, pay for what it needs inside limits you set, and report to you on your phone. You want its records to be worth something.
Start with the [Quickstart](/quickstart), then read [Operating a device](/operate/telegram).
You build machines or the software that runs them: a vending controller, a robot arm cell, a soil sensor network. You want an identity, a wallet, and provenance without writing smart contracts or key management.
You do not deploy contracts. You install the binary, write a [plugin package](/build/overview), and ship. Start with [Building on KineticVM](/build/overview).
You train robotics models, underwrite machines, audit operators, or study demand. You want machine data with a provable source.
Every row on the marketplace is tied to an onchain attestation you can check yourself. Start with [Buyer verification](/marketplace/verification).
## Design principles
Device identity, the owner, vault limits, and revocation live onchain. The device reads them when it needs them and keeps no authoritative copy. If anything local disagrees with the chain, the chain wins. See [State](/concepts/state).
The device key can pay inside the limits, top up its own gas inside the limits, sign attestations, and relay a change the owner already signed. It cannot own the identity, approve operators, raise a cap, add a recipient, unpause, or withdraw.
Every transfer of value from the vault to a third party goes through one function, `pay`, which checks the pause flag, the allowlist, the per-transaction cap, the daily window, and the balance. Even the device's own gas top-up counts against the caps.
An attestation proves that the device key bound to an agent signed a specific record at a specific time. It does not, by itself, prove that a motor physically turned. KineticVM says so plainly, and makes the signed record as precise and checkable as possible. See [Attestations](/concepts/attestations#what-an-attestation-proves).
## Project status
KineticVM runs on **Monad testnet** (chain id `10143`). The contracts are not upgradeable, have no global pause, and have **not been externally audited**. The runtime refuses to use Monad mainnet until a mainnet deployment exists. Do not put funds you cannot afford to lose behind a device.
The agent runtime is a modified fork of [ZeroClaw](https://github.com/zeroclaw-labs/zeroclaw), dual-licensed MIT or Apache-2.0. KineticVM is not the official ZeroClaw project. See `NOTICE` in the repository.
## Read the docs like a book
Each chapter builds on the one before it.
Install, claim, and fund a device.
Identity, vault, attestations, state, and records.
Run a device from Telegram and your wallet.
Plugins, SOPs, skills, and hardware.
List records and verify datasets.
Every function, event, and address.
This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.