Introducing peaqOS Verify | Robots and Machines Can Now Prove They're Real

Robots and machines running peaqOS can now prove they're real. peaqOS asks the machine's secure chip to sign a challenge only a genuine chip can pass, and checks the signature against the chip manufacturer's certificate chain. peaq verifies the business running the machine. Both proofs are anchored to the machine's onchain identity, where any lender, insurer, data buyer, or AI agent can read them before committing a dollar. Not a claim in a spreadsheet. A proof on the machine.

A delivery robot applies for financing, and line one of its record reads: genuine chip, verified operator. A robotaxi sells a month of driving data, and the buyer checks its record before paying: verified, not a script on a laptop. A warehouse robot's insurer reads its record, not a PDF. Each one proves itself. peaqOS Verify is live.

Verify is the sixth function of peaqOS, and the one every other function stands on. A Machine Credit Rating from Qualify, signed data from Stream, revenue from Monetize, the financing that follows: all of it is worth exactly as much as the certainty that the machine behind it is real. The end state is a machine that carries proof of what it is, what firmware it runs, and how it has been maintained, co-signed by its manufacturer, with attestations that expire and can be revoked. Verify starts with the first question, asked of the hardware itself: is there a genuine chip inside this machine, and is a real business running it?

→ Build with Verify → docs.peaq.xyz/peaqos/functions/verify

The Machine That Couldn't Prove Itself

Ask a lender what they check first on a fleet. Not revenue. Whether the machines are real. And from a distance, nobody can tell. A device ID is a string. A serial number is a photo. Telemetry can come from a script that never touched a sensor. Everything built on top of a machine is worth exactly what the answer to that first question is worth. Until now, that answer was somebody's word.

A counterparty had two options. Take the operator's word for it, and price in the risk that the fleet is smaller, older, or not there at all. Or verify by hand: a site visit, a serial number on a clipboard, a PDF that is out of date the moment it's signed and useless to the next counterparty who asks.

With peaqOS Verify, there's a third option: the machine proves itself, and anyone who asks can check.

Two Proofs, One Record

Every verified machine runs through the same shape:

→ An identity, not a form. The machine already has an onchain identity from Activate: a peaqID and a Machine NFT. Verify attaches to that identity, so the proof travels with the machine, not with a document.

→ A verified operator, not a username. peaq verifies the business operating the machine and records it on an onchain allow-list. Every machine whose operator address matches inherits verified-operator status, including the ones the business adds tomorrow under that address.

→ A signature, not a serial number. peaqOS sends the machine's secure chip a random challenge. The chip signs it with a key that never leaves the silicon, and peaqOS checks the signature and the certificate chain back to the manufacturer's root. A pass means one thing: a genuine chip from that manufacturer is physically present, and the onchain registry says so, linked to the machine's identity.

→ A record, not a badge. The verification state is queryable through the peaqOS API, the Python and JavaScript SDKs, and the peaqOS CLI. It shows in the Machine Explorer. A machine that hasn't been verified returns exactly that: not verified. Plainly, not as an error.

That's it. The chip signs. peaq verifies. The record stays with the machine.

This Machine Makes Money. This Machine Is Real.

peaqOS already rates machines. The Machine Credit Rating scores how a machine earns: revenue, consistency, uptime, track record. It answers the question a lender asks second. Verify answers the one they ask first.

Machine Credit Rating says this machine makes money. Verify says this machine is real. They are independent by design. A brand-new machine can be verified with no earning history. A machine with a strong rating can be unverified. A counterparty reads each one separately, and the pair is what makes a machine underwritable: it earns, and it's real.

The record lives on the machine's home chain, whichever chain that is. A counterparty asks for a machine by its ID and peaqOS resolves the chain, so nobody has to know where a machine lives to check whether it's real. Every attestation in the registry carries a status anyone can read: valid, expired, or revoked. An attestation that can't expire is a rubber stamp. These are built to.

Verified at the Chip, Not on Paper

Verify starts at the chip on purpose. A secure chip is proof no script can fake: a certificate burned in at the factory and a private key that never leaves the silicon. It proves a genuine chip is inside the machine. That is the first question, answered. You can clone a machine's ID. You can't clone its signature. The first supported chip family is Infineon's OPTIGA Trust M, and peaq is the attestor that validates the certificate chain and signs the record. That's the beta, and it's live today.

The destination is broader. Manufacturers co-signing their own machines: serial numbers, firmware, calibration. Attestations about maintenance history and safety compliance, each with its own expiry, each revocable when the evidence stops holding. Every step stacks on the same registry, the same identity, the same record. What a counterparty checks today grows richer with every attestation added.

What Verify Unlocks

For operators. Your machines carry proof they're real before anyone asks. Financing, insurance, marketplace listings, data sales: every conversation that used to start with "prove your fleet exists" now starts one step further along. Verified once, checkable everywhere.

For lenders, insurers, and tokenization desks. A machine you can underwrite. Pair a verification record with a Machine Credit Rating and you have both answers: it's real, and it earns. Read it through the API before you commit, on the chain the machine calls home.

For manufacturers. A path to co-sign the machines you build, so a genuine unit running genuine firmware carries your word onchain, and a counterfeit doesn't.

For the robots and machines themselves. They earn, they spend, they sell their data and their idle capacity. Now the record shows what they are: a genuine chip, a verified operator, readable by anyone who deals with them.

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 its data into a signed, verifiable asset, delivered end-to-end.

→ Monetize. Each one selling the idle resources it already carries, paid to its own wallet.

→ Verify. Each one proven real: a genuine chip and a verified operator, anchored to its identity.

Six functions live.

Plug Into Verify

Build with Verify. Read any machine's verification record through the API, the Python and JavaScript SDKs, or the peaqOS CLI → docs.peaq.xyz/peaqos/functions/verify

Check a machine. Look up the any robot or machine in the Machine Explorer → machines.peaq.xyz

Activate your machines. Onboard your robots and machines to peaqOS → docs.peaq.xyz/peaqos/functions/activate

Robots and machines now earn. They now spend. Now they prove they're real.