Acurast and peaq Bring Phone-Powered Compute to Robots and Machines

Acurast, the decentralized compute network powered by smartphones, is now available to robots and machines running peaqOS. A machine can deploy a compute job to a network of hardware-secured phones and pay for exactly that deployment, in USDC over x402, straight from its own wallet. When the job is done, it walks away, no account left open, no subscription running idle. Autonomously, on demand, without human intervention. Available now on robotic.sh.

‍

A quadruped robot finishes its evening survey of a solar farm. Hours of thermal footage, and a defect report due before the morning shift. Finding the hairline faults in that footage takes more compute than anything the robot carries.

‍

It has two options. Wait for a human with a cloud login, an account, a credit card, credentials to manage, and the report slips to whenever someone gets to it. Or carry the compute itself, a workstation strapped to a robot that spends its day walking rows of panels.

‍

With Acurast on peaqOS, there's a third option: the robot deploys the job to a network of hardware-secured smartphones, pays for that one deployment in USDC, and has its report before the morning shift clocks in.

What Acurast Unlocks on robotic.sh

Acurast is a decentralized compute network that runs on smartphones. Each phone is a sealed compute unit, with a trusted execution environment and a hardware security module built in, and its authenticity certified by the manufacturer itself. A server has to be bought, racked, and trusted. A phone proves what it is, and 1.39 billion new ones ship every year.

‍

The economics are just as unusual. Acurast turns second-hand phones, broken screens, intact processors, into compute units, hardware that costs about 117x less than a rack server. Decentralized by design, confidential by design, and cheap enough to price compute in cents. And it's already at scale: 265,000+ compute units onboarded, across 175+ countries.

‍

Starting now, that compute is available through robotic.sh. A robot or machine running peaqOS can send a job to the Acurast Deploy Agent and pay per deployment in USDC over x402. No account, no API key, no subscription. The machine pays from its own wallet at call time, and if the price moves, it sees the new quote and can accept it or fall back to another service.

‍

It's the first integration of its kind: phone-powered compute that robots and machines can buy per deployment, with nothing to sign up for. And it's live on robotic.sh today.

Why This Matters: Compute Without the Account

Off-board compute has always come with a human attached. Someone opens the cloud account, files the credit card, rotates the API keys, watches the quota. That works for one robot. It doesn't work for a fleet buying compute in cents, dozens of times a day.

‍

Pay-per-deployment removes the procurement chain entirely. The machine discovers the service, pays for exactly one job, and gets back a result it can account for. Nothing idles between jobs, nothing renews, nothing needs a human to sign.

‍

And it doesn't matter where either side sits. The machine pays in USDC on Base; the job runs on phones anywhere in the world. Chain boundaries and geography stop being the machine's problem, which is exactly what peaqOS is for.

peaq Handles the Coordination

peaq is the layer that lets machines reach Acurast and use it. For each deployment, peaq handles:

‍

• Machine identity, via peaq DIDs
• Discovery of the service on the Machine Market
• Coordination of the deployment, from order to result
• A verifiable, auditable record of what ran

‍

So a machine can buy compute the moment it needs it, without an account to maintain or a human in the payment loop.

Showcase: A Unitree G1 Deploys to a Quarter-Million Phones

We're showcasing the integration with a demo where a Unitree G1 humanoid deploys its telemetry processing to Acurast in the middle of a shift. It's a real machine-to-cloud deployment flow, simulated in NVIDIA's Isaac Sim, with peaqOS handling identity, the order, payment, and the proof, and Acurast running the job on smartphones. There is no datacenter anywhere in it.

Here's the scenario: the G1 is mid-shift, telemetry streaming off its joints and sensors, and processing it is compute the robot shouldn't spend while working. Here's how the process unravels:

→ The G1 checks in under its own peaqOS identity, with its operator's agent paired and authorized
→ It asks the Machine Market for compute; peaqOS resolves Acurast, quotes the job, and opens an order
→ Acurast answers with a price, not a form: eight cents in USDC on Base, over x402, no account, no API key, and peaqOS holds the payment until the job delivers
→ peaqOS executes the order and a job hash comes back, public proof of what ran
→ On the Acurast Hub, the job is picked up by three processors, not servers, smartphones competing to run the robot's job

The job runs every ten minutes, on hardware the robot will never see. Delivery confirmed, payment released. One robot, one deployment, eight cents, zero datacenters, a machine on one side, a quarter-million phones on the other, and peaqOS in between.

You can find the job here:

• Base settlement (USDC payment):https://basescan.org/tx/0xbc2268e1c1cb3b336a841aad25a518d182e48558884194a1da39c0b5158e21f7
• Acurast deploy extrinsic:https://hub.acurast.com/explorer/extrinsic/0x1a47386fdd9a326e1c8ec0f691b271549751b7a2b693cf6f38fff4a14d5d1952
• Acurast deployment (job #106227 ):https://hub.acurast.com/explorer/deployment/106227

‍

VIDEO

More Real-World Scenarios

Scenario 1 — A Delivery Fleet Crunches Tomorrow's Routes Overnight

The last robot docks at midnight. Tomorrow is sitting in the depot's data: hundreds of stops, charge windows, loading sequences, all of it to be optimized before the first robot rolls out.

‍

The old way is a cloud subscription sized for that nightly peak and paid for around the clock, managed by a human who has other jobs too.

‍

Instead, the fleet deploys the optimization job through robotic.sh once the day's data is in. Acurast runs it overnight, the plans come back before sunrise, and the fleet pays for one deployment, not a standing subscription.

‍

A data center for the night shift, hired one deployment at a time.

Scenario 2 — A Robot Tests Its Own Update Before Trusting It

An over-the-air update lands mid-shift. Installing it blind risks a regression taking down the whole fleet at once. Waiting for a shared staging environment means the fix everyone needs sits in a queue.

‍

Instead, the robot spins up a sandbox on Acurast through robotic.sh, runs the update against its own task suite, and installs only what passes. The sandbox closes, the payment settles, and a record remains of exactly what was tested.

‍

Updates earn their way onto the machine. No blind installs, no waiting in line.

Available Now on robotic.sh

Acurast phone-powered compute is now live on robotic.sh for robots and machines running peaqOS.

‍

Machines can deploy jobs to a network of hardware-secured phones and pay per deployment in USDC. Every deployment leaves a verifiable, auditable record.

‍

Because autonomous machines shouldn't have to choose between carrying the hardware and borrowing a human's cloud account.

‍

They should be able to buy the compute they need, the moment they need it, and walk away when the job is done.

‍

→ Visit robotic.sh to get started.

‍