peaq Brings QVAC by Tether to Robots and Machines, Enabling Private AI Inference at the Edge

QVAC, Tether’s open-source platform for local AI, is now available to robots and machines running peaqOS. A machine can run powerful AI on its own hardware, reasoning on its own data without that data ever leaving the local environment. And when a machine can’t run a model itself, it can get that same private inference from a nearby machine instead of a centralized cloud. Autonomously, on demand, without human intervention. Available now on robotic.sh.

A humanoid robot is halfway through its shift on a warehouse floor. Its sensors take in a constant stream of private data: battery, motor temperature, vibration, everything it sees around it. Every few seconds, it has to make sense of that data and decide what to do next.

But the robot has no GPU on board to run the model itself.

It has two options. Carry expensive inference hardware it rarely needs, or stream its raw, sensitive telemetry to a centralized cloud, which adds latency, a network dependency, a new failure point, and a privacy liability the moment that data leaves the machine.

With QVAC on peaqOS, there’s a third option: it finds a nearby machine that can run the inference and uses it for the job. The model runs locally, the result comes back in seconds, and the data never leaves.

What QVAC Unlocks on robotic.sh

QVAC is Tether’s open-source platform for local AI. It runs models directly on the machine: language, vision, speech, even vision-language-action for robot control. A machine with the right hardware runs them on its own. A machine without it can tap a nearby machine that does, so the work still happens locally and privately, never in a centralized cloud. No third-party API, no single point of failure.

Starting now, QVAC private inference is available through robotic.sh. A robot or machine running peaqOS can discover a QVAC inference provider and run private inference on it, while the inference stays local and the data never leaves the secure environment. Providers run a QVAC-compatible runtime on or near the machine and register the endpoint with peaqOS, and from there a paired Machine Agent can discover and use it. 

It’s the first integration of its kind: private, on-machine inference that robots and machines can consume through peaqOS, and in time offer to one another. And it’s live on robotic.sh today.
‍

Why This Matters: Intelligence That Stays on the Machine

Private, machine-side inference unlocks opportunities that used to be difficult to implement. A machine can run powerful models right where it operates, on its own data, without sending anything to a third party.

Sensitive data stays on the machine. There’s no hard dependency on a constant link to a distant data center. And a robot can keep reasoning even where bandwidth is limited or privacy is non-negotiable.

When a machine needs to run a model, whether perception, reasoning, planning, or anomaly detection, peaqOS lets it discover a QVAC inference provider and have the workload run locally on that provider’s hardware. The result comes back to the machine, and the data it reasoned over stays where it started.
‍

peaq Handles the Coordination

peaq is the layer that lets machines find QVAC providers and use them. For each inference request, peaq handles:

• Machine identity, via peaq DIDs
• Discovery and reputation of QVAC providers
• Coordination of the run across machines
• A verifiable, auditable record of what ran

So a machine can reach private inference it can’t run itself, without handing its data to a centralized service.
‍

Showcase: Unitree G1 Humanoid in NVIDIA Isaac Sim

We’re showcasing the integration with a demo involving a Unitree G1 humanoid hiring a nearby QVAC Gateway to run private inference. It’s a real machine-to-machine flow, simulated in NVIDIA’s Isaac Sim, with peaqOS orchestrating discovery, the order, payment, and the on-chain receipt.

Here’s the scenario: The Unitree G1 is working a shift in a logistics warehouse. It continuously generates local telemetry (battery, motor temperature, vibration) and needs a private inference to decide what to do next. But the robot has no GPU on board to run the model itself.

Mounted on a warehouse shelf sits a QVAC Gateway: a device running QVAC inference locally. Think of it like a Wi-Fi access point, but for AI compute. Here’s how the process unravels:

→ The QVAC Gateway advertises its private inference service to the Machine Market via robotic.sh and waits for a paid request

→ Through peaqOS, the G1 discovers the gateway, selects it by provider score, and creates an order

→ The G1 pays in USDT through Tether WDK; the transaction is broadcast on-chain and the hash is captured

→ peaqOS verifies the payment, the gateway runs the inference locally, and the result returns to the robot in 1.4 seconds, 111 tokens

The telemetry never leaves the gateway. Pay-per-inference, settled on-chain.

You can find the transaction involved at this link on peaqscan.

‍

More Real-World Scenarios
‍

Scenario 1 — A Delivery Robot Reasons on Sensitive Data Without Sending It Anywhere

A delivery robot operates independently throughout a city. Its cameras capture faces, license plates, doorways, the insides of buildings, and it constantly has to reason about what it sees to navigate and complete drop-offs.

Streaming that raw footage to a centralized cloud would mean latency, a hard dependency on connectivity, and a serious privacy liability the moment the data leaves the robot.

Instead, the robot discovers a QVAC inference provider through robotic.sh and runs its perception and routing models privately, close to where it operates. The result returns in seconds. The footage never leaves.

The robot adapts and continues. Intelligence where it’s needed, and data that stays put.
‍

Scenario 2 — A Humanoid Technician Reasons Privately on the Factory Floor

A humanoid maintenance robot is deployed at an industrial facility. During inspection it encounters an unexpected equipment anomaly, surrounded by proprietary equipment layouts and operational data its operator can’t allow off-site.

Rather than shipping that sensitive data to a third-party cloud, the robot discovers a QVAC inference provider on the premises through robotic.sh, runs its diagnostic and planning models locally, and gets back recommended actions and confidence levels, all without the data ever leaving the facility.

The robot selects the best path and executes autonomously. Instead of carrying workstation-grade hardware or trusting an external cloud, its intelligence expands locally and privately.
‍

Available Now on robotic.sh

QVAC private inference is now live on robotic.sh for robots and machines running peaqOS.

Machines can discover QVAC providers and run private inference on their own data, privately, locally, and on demand. Every run is recorded with a verifiable, auditable record.

Because autonomous machines shouldn’t have to choose between staying capable and keeping their data their own.

They should be able to think wherever they are, and keep what they know.

→ Visit robotic.sh to get started.