Introducing peaqOS Stream | The Data Verification Function for AI Training, Data Marketplaces, and Monetization Protocols

Robots and machines can now sign and own the data they produce. And any protocol that trains on, monetizes, or markets data can plug into peaqOS Stream to use it.

A humanoid streamed a month of signed manipulation data into a robotics training network. A robotaxi piped verified driving data to a data marketplace that could check every frame. A warehouse robot fed its anonymized sensor logs into a monetization protocol that turned them into revenue. Each ran on peaqOS Stream. Each plugged into a different platform. peaqOS Stream is live.

For the first time in history, the data a physical robot or machine generates leaves the machine signed, owned, and verifiable by anyone, on every supported chain. It captures. It signs. It encrypts. It proves who made it, down to the frame. peaqOS Stream doesn't buy or sell that data — it makes it trustworthy and ownable, then hands it to the protocols built to put it to work: training networks, data marketplaces, monetization platforms, data vaults. The most overlooked resource in the robot economy — the data the machines make — finally becomes something the entire data economy can build on.

The scale is staggering. A single self-driving car already generates tens of terabytes of data a day, and the world's connected machines are on track to produce 79 zettabytes of data in 2025 alone — fuel for a physical AI market Barclays sizes at $500 billion to $1.4 trillion by 2035. Every machine is a data factory.

Build with peaqOS Stream → docs.peaq.xyz/peaqos/functions/stream

Robot Data is Robotics' Untapped Asset Class

Physical AI has a data problem, and it isn't compute. Robots are on their way to becoming the workforce behind the physical world — driving the cars, flying the drones, moving the humanoid hands — and the models that run them can only learn from that world directly. Robotics data is the new oil: the sensor-grade record of machines doing real work, which can't be scraped off the internet and which no simulation fully replaces. It has to come from real machines, in the real world.

And the machines are already producing it, by the zettabyte — but almost none of it can leave the machine that made it as something anyone can trust. It sits in proprietary silos. Without a way to prove which machine produced the data, or that it wasn't altered, no one downstream can verify it. It is among the richest real-world training data there is, and most of it goes to waste.

Stream connects that demand to the supply that has been sitting idle. It lets every machine sign the data it produces and anonymize what needs protecting, turning it into a verifiable dataset any data protocol can plug into — provenance baked in, straight from the source. The result is a new category of supply: verifiable data lakes, fed by the machines doing the work and trusted by every model trained on them.

First Activate, then Qualify, then Scale. Now Stream.

peaqOS is the operating system for the machine economy. It turns any robot or machine into a trusted, investable asset and an autonomous economic actor. It ships in functions, and four are live today.

‍

‍

→ Activate gave every robot and machine its peaqID, omnichain wallets, and a Machine NFT.

→ Qualify gave it a Machine Credit Rating, a dynamic, Moody's-style letter grade from AAA to NR.

→ Scale gave it direct access to the economy — buying the services it needs, earning, lending, and borrowing through Machine Money Markets.

→ Stream, today, gives it the ability to turn the data it generates into a signed, verifiable asset that any data protocol can plug in and monetize.

These come next:

→ Monetize will let it sell the compute, storage, bandwidth, and physical tasks it provides, with revenue settled onchain.

→ Verify will give it cryptographic attestations — firmware integrity, calibration, maintenance history — that any counterparty can check.

→ Tokenize will make it an investable Machine RWA, with fractional ownership and revenue splits flowing to holders onchain.

Stream is the data function of peaqOS. It runs through the peaqOS Edge Agent, an on-machine component that captures the data the operator allows, anonymizes and encrypts it, signs it with the machine's own keys, and packages it into datasets any data platform can verify and plug into. The machine keeps doing its job. Its data leaves trusted, owned, and ready to put to work.

One Signing Layer for Any Machine Data

Any robot or machine running peaqOS can now turn what it senses into a signed, verifiable dataset any data protocol can plug into. Automatically. From the machine itself. Under rules the operator controls.

Robots and machines generate to operate: camera feeds, joint states, positioning, lidar, route logs, manipulation traces. Until now, that data either sat unused or left the machine with no proof of origin and no controls. With Stream, it leaves signed at the source, anonymized where it needs to be, and owned by the machine that made it.

Every dataset runs through the same shape:

→ The peaqOS Edge Agent, installed on the machine with a single command, capturing only the data the operator's policy allows.

→ A signed, encrypted package, where sensitive fields are stripped or anonymized first, then the data is encrypted per chunk and signed with the machine's keys.

→ A plug-in for any data protocol, which checks the machine's signature against its peaqID, inspects a sample, and — once the operator grants access — decrypts only the chunks it's been given.

That's it. Sensor feeds, telemetry, manipulation traces, positioning data: robots and machines call peaqOS Stream to turn it into an asset.

And the door swings both ways. Any platform that builds on machine data — AI labs, model trainers, robotics dataset builders, data marketplaces — plugs into a whole new supply: verifiable data they can trace to the exact machine that produced it. Every dataset is signed and checkable against that machine's onchain identity, so they can trust what they're training on before they build on it. The data physical AI has been starved of finally has a source it can verify, at machine scale. The supply isn't scraped or synthetic anymore. It's signed.

Inside Stream

Every peaqOS robot and machine already has a peaqID, a Machine Credit Rating, and omnichain wallets. Stream adds the missing piece: the ability to turn what a machine records into data the world can trust and build on.

For the operator, getting a machine streaming its data is three steps:

→ Install. The Edge Agent installs on the machine and runs alongside the robot's own software. It provisions the machine's identity — peaqID, omnichain wallets, DID, and Machine NFT — and roots its signing keys in secure hardware where the machine has it.

→ Configure. The operator sets a policy: which data feeds to capture, which fields to include, strip, anonymize, or encrypt, how to group it, and where it should live. The operator sets the rules. The machine follows them.

→ Stream. From there it runs persistently. As data is produced, sensitive fields are anonymized or encrypted, the data is grouped into chunks and datasets, and each one is signed with the machine's keys — so anyone downstream can later prove exactly which machine it came from and that nothing was changed.

Monetization happens wherever the operator plugs in — a data marketplace, a training network, a context provider, or a direct buyer. peaqOS doesn't run the marketplace; it makes the data verifiable and ownable. A dataset is offered as a signed package — a topic and a time range — without exposing the underlying data, so a data protocol or buyer can verify the machine's signature against its identity and inspect a sample before committing. When the operator grants access, the decryption keys are wrapped to that party alone, and they decrypt only what they obtained, locally, on their own machine. peaqOS is never the counterparty and never holds the raw data — it holds the proof: the signatures, manifests, and verification layer that let any platform make the exchange trustworthy.

Where the data lives is the operator's call: on the machine, in operator-controlled storage, or on decentralized and cloud storage. And because the operator can hold recovery keys, a dataset stays available even if the machine goes offline. The machine produced trustworthy data. The protocols that need it can finally use it.

What Stream Unlocks

For operators. Collecting your machines' data was never the hard part — trusting it, securing it, and monetizing it was. Stream turns that output into a signed, verifiable dataset you can share safely: on your terms, with the fields you choose, anonymized where it counts, and only with the platforms you approve. A new revenue line on top of the work the machine already does, with no human in the loop once the policy is set.

For AI builders and data buyers. The real-world data physical AI depends on becomes verifiable. Instead of scraped, synthetic, or unverifiable data, you get signed datasets captured by machines in the field — with an origin you can check and a sample you can inspect before you buy. The verified data lakes AI needs, sourced from the machines that produce it.

For data markets and context providers. Any platform that normalizes, packages, or resells data gains a whole new supply of verifiable machine data — and a verification layer that comes free with every dataset. The infrastructure built to move and refine data finally meets a source it can prove all the way back to the machine.

For the robots and machines themselves. They get standing as data producers. What they generate carries their identity, their signature, and their ownership — provable to any counterparty, on rails the operator controls. Every machine becomes a data business in its own right — its output no longer wasted, but signed, owned, and monetized.

What's Live on peaqOS Today

→ Activate. Every robot and machine onboarded with a peaqID, omnichain wallets, and a Machine NFT.

→ Qualify. Each one rated with a dynamic Machine Credit Rating.

→ Scale. Each one consuming services and Machine Money Markets through robotic.sh.

→ Stream. Each one turning the data it generates into a signed, verifiable asset any data protocol can plug in and monetize.

Four functions live. Monetize, Verify, and Tokenize are next.

Plug Into Stream

Build with Stream. Available via CLI, Agent Skill, and SDKs for ROS2, Python, and JavaScript → https://docs.peaq.xyz/peaqos/functions/stream

Activate your machines. Onboard your robots and machines to peaqOS and put their data to work → https://app.peaq.xyz/os

Robots and machines now earn. They now spend. Now they sense, sign, and monetize.