peaq and Arcium bring Confidential Compute to Robots and Machines

Arcium, the confidential computing network, is now available to robots and machines running peaqOS. A machine can run computations on its own sensitive data while it stays fully encrypted the entire time. And several machines can compute over their combined data without any of them seeing what the others hold, learning from each other without giving anything away. Only the verifiable result comes out. Autonomously, on demand, without human intervention. Available now on robotic.sh.

A delivery robot finishes another shift in the city. Over thousands of trips it has learned what works: which routes fail, where it gets stuck, how it burns through a charge.

Multiply that across a fleet, and across fleets, and it becomes some of the most valuable data in the business, for operators, for insurers, and for the robots themselves.

But that data can’t leave the machines that hold it.

It’s commercially sensitive, often personal, and once it’s handed to someone else, control is gone. There are two options: keep it locked away and leave the value untapped, or pool the raw data with a party everyone has to trust, exposing exactly what you can’t afford to expose.

With Arcium on peaqOS, there’s a third option: the computation runs over the data while it stays encrypted. Each machine puts in what it knows, Arcium computes across all of it, and only the answer comes back. Nobody has to reveal a thing.

What Arcium Unlocks on robotic.sh

Arcium is a confidential computing network. It runs computations over data that stays fully encrypted, using secure multi-party computation across a decentralized set of nodes. Inputs are split into secret shares, so no single node, operator, or insider ever sees the raw data, and every result is verifiable. A normal server has to open your data to process it. Arcium doesn’t.

Starting now, that capability is available through robotic.sh. A machine running peaqOS can send a confidential computation to Arcium and get back an answer it can verify, with peaqOS coordinating the job and Arcium doing the compute.

It’s the first integration of its kind: confidential computation that machines can run through peaqOS, and in time trade between themselves. It’s live on robotic.sh today.

Why This Matters: Value From Data Without Exposing It

Confidential computation unlocks work that used to be off-limits. Data that was too sensitive, too regulated, or too competitive to share can finally be put to use, without anyone having to hand it over.

It also changes who a machine can work with. Parties that would never trust each other with raw data can still compute over it together, because no one has to expose what they hold to take part.

That opens up a lot at once: fleets learning from each other, risk scoring and insurance checks against private records, and confidential data markets where the value in a dataset is sold without the dataset itself.

peaq Handles the Coordination

peaq is the layer that lets machines reach Arcium and use it. For each confidential computation, peaq handles:

• Machine identity, via peaq DIDs
• Permissions over who can contribute inputs and who can see results
• Coordination of the job across machines and the Arcium network
• A verifiable, auditable record of what ran

So a machine can put its data to work, and even earn from the outcome, without ever handing over the dataset itself.

Showcase: A Unitree G1 Runs a Confidential Computation

We’re showcasing the integration with a demo where a Unitree G1 runs a confidential computation on the data from its own shift, orchestrated end to end by peaqOS Scale. peaqOS handles identity, the market orders, and settlement on Solana; Akash provisions the compute; and Arcium keeps the computation confidential.

Here’s the scenario: a Unitree G1 finishes a warehouse shift with fresh operational data to process. Working through its paired machine agent, it lines up the compute it needs and runs the job without ever exposing the data. Here’s how the process unravels:

→ The G1 checks in with its peaqOS identity and, through a paired machine agent, requests the services it needs

→ The agent finds Akash compute on peaqOS Scale; peaqOS creates a market order, records the Solana payment proof, and routes the workload to Akash, which provisions the compute environment

→ The agent then requests Arcium confidential compute; the machine’s data is prepared as encrypted input, and peaqOS creates a second market order for Arcium

→ Arcium processes the encrypted data and returns a finalized result, with the raw data never exposed during the computation

→ peaqOS confirms both orders, releases payment, verifies the Solana transaction signatures, and closes the Akash deployment

The job gets done and the result comes back. The raw data is never exposed, and every order and payment is settled and verifiable on Solana.

You can find the transactions involved here:

• Akash Deployment: https://www.mintscan.io/akash/tx/3B50B7FA2806E70B9CED0D485E880B233779B65AEBDE37F46912A168B7052E78
• Solana Payment Proof for Akash:
  https://explorer.solana.com/tx/3f6qCSNp2gEJsuvCq3VMYhi6jfiLiUniMQrDwez1ZYfCzTHtBfvFZCehzrwNbQRrXTVN6SuQNGq4PYGPCxoQFJmH?cluster=devnet
• Arcium computation queued: 31B6yAUvUgsjnDgoC9uprr2mtuAhGGkpu4yh7m5xL7wBWnCpTZzMDEjKVXNWJTrGRs5MRGevevKAeAVy7qPZe2BH
• Arcium finalized callback: 5jq5qcti6vLRDt3v9JLNF4jbcLMEhoKenKifVhX3RYmVCDAFpxWDkpWXFJmgJMqKm8r6AW6JR3YjPnb6gSkmce9m‍
• Solana payment proof for Arcium:
  3ycXyfF5RfSu1C9wftpnf5vgsMsC7ys5wqLqSQSvYAUbTfaaHp6CtN93Q3zD495gTzjCqLnCS94CFMLhbDUm3aoE

More Than Learning

Fleet learning is the demo. The bigger story is everything confidential compute unlocks once a machine can prove something without revealing it.

Credit Ratings for Machines

As machines start doing real economic work, whether a delivery robot, an autonomous vehicle, or a humanoid, they need to prove reliability, uptime, and revenue to access financing. Most of that is commercially sensitive. With confidential compute, a machine can build a real credit profile and let lenders and machine money markets assess it, without ever publishing the underlying numbers.

Insurance Built on Real Telemetry

Insurance is shaping up to be a cornerstone of the Machine Economy. Insurers want maintenance records, uptime, operating conditions, and incident history, exactly the data operators are reluctant to expose. Confidential compute lets an operator share what an insurer needs to price risk accurately while the proprietary detail stays private. Better policies, less exposure.

Data Markets That Respect Ownership

Data is one of the most valuable things a machine produces, and most of it goes unsold, because selling it would mean exposing it. With confidential compute, a machine owner can feed data into AI models, marketplaces, and analytics, get paid for the value it creates, and keep both confidentiality and ownership intact.

Available Now on robotic.sh

Arcium confidential compute is now live on robotic.sh for robots and machines running peaqOS.

Machines can send their own confidential computations or take part in shared ones, and get back results they can verify. Every job leaves an auditable record.

Because machines shouldn’t have to choose between putting their data to work and keeping it private.

They should be able to compute, collaborate, and earn, without ever giving the data away.

→ Visit robotic.sh to get started.

‍