Codename: Cargo Now Live on Canary

Cargo launches on Acurast Canary: Ship anything anywhere without constraints

Zug, April 27th — Acurast launches Cargo on the Canary Network today. It’s a Linux-based container model purpose-built for the mobile edge, and the most significant architectural upgrade since Mainnet launched in January.

 

With Cargo, developers can deploy any workload that runs on Linux across Acurast’s network of attested Android smartphones. Python, Go, Rust, C++, shell scripts, full binaries. If it builds for Linux, it runs on Acurast.

 

This is the upgrade that turns decentralized mobile compute from “interesting for JavaScript workloads” into a real alternative to the centralized cloud for almost every developer.

The Container Problem for Mobile Compute

Docker, Kubernetes, and the rest of the traditional container ecosystem were built for a specific kind of host: homogeneous, high-power, always-online servers with predictable RAM, deterministic networking, and uniform hardware. Mobile devices are none of those things.

 

Phones wake and sleep. Networks shift. Hardware varies wildly across chipsets, TEE implementations, OS versions, and attestation capabilities. A container model designed for a data center falls over the moment you try to run it across a fleet of consumer smartphones.

 

Cargo is the first container model built from the ground up to solve that heterogeneity. Before any workload is dispatched, the Acurast network runs a rigorous attestation process that verifies the device’s hardware capabilities, OS integrity, and support for hardware-backed secure execution. Only devices that pass get the job.

 

The attestation infrastructure Acurast built for Node.js workloads is the same infrastructure that now makes full Linux containers viable across a distributed phone network. Years of protocol engineering are paying off at the container layer.

What Cargo Unlocks for Developers

Language Freedom

Acurast is no longer a JavaScript network. Ship Python, Go, Rust, C++, or any language with a Linux toolchain. If it compiles, it deploys.

 

A VPS-Like Developer Experience

SSH into your deployment. Read logs. Debug in real time. Cargo is not a black-box function runtime. It’s a real Linux environment, running on an attested Android smartphone somewhere in the world.

 

Instant Access to the Linux Ecosystem

Every package, every library, every binary that runs on Linux is available from day one. No manual support required. The moment Linux supports it, Acurast supports it.

 

For builders, the practical consequence is that almost anything you’d deploy to a traditional cloud (backend API, scheduled job, ML inference endpoint, agent runtime) you can now deploy on Acurast. Same workflow. Very different trust model.

Confidential by Default

The property that makes Cargo different from a cheap VPS isn’t the price. It’s the privacy.

 

When a Cargo container runs, it executes inside the smartphone’s secure element: a hardware subsystem the operating system itself cannot see into. The data loaded into the container, the computation performed on it, the intermediate state. None of it is readable by the device owner, the OS, or anyone observing the device externally. When the job completes, the result is returned and the raw data is destroyed.

 

This is the critical unlock for two categories of work that have never been comfortable on hyperscaler infrastructure.

 

The first is workloads with sensitive inputs: medical records, financial models, proprietary datasets, user data that regulatory frameworks don’t want leaving a secure boundary. Cargo lets you run computation on that data without ever exposing it to the infrastructure operator.

 

The second is AI agent runtimes. As autonomous agents take on more responsibility, where they run becomes a security question. An agent running on centralized infrastructure gives the host provider visibility into every action it takes, every piece of context it processes, and every credential it handles. For most of the emerging agentic economy, that’s unacceptable. Cargo is infrastructure that runs your agent in an environment the host itself cannot inspect.

The Admission Layer

The Cargo guarantee is enforced at the protocol level through strict admission criteria.

 

Hardware Attestation

Android hardware key attestations (KeyMint/StrongBox) are the bare minimum for Cargo participation. Devices that cannot produce a signed attestation tied to a hardware secure element do not participate.

 

Locked Bootloaders Only

Acurast accepts attestations from devices running OEM-locked bootloaders. Modified firmware and custom ROMs with relocked bootloaders, including GrapheneOS, are not admissible.

 

Freshness Validation

Attestations are linked to the processor’s identity and expire between 7 days and 3 months, preventing replay attacks from previously compromised devices.

 

StrongBox Priority

Where available, Acurast uses the strongest hardware-backed key storage the device supports. Where it isn’t, developers see this in the attestation and can route workloads accordingly.

 

The net effect: only real, attested, hardware-integrity-verified Android devices can execute Cargo containers. Fake devices, emulated environments, and compromised devices are rejected at the protocol layer before they ever see a workload.

 

What This Means for Developers

The full Linux ecosystem is now available on a decentralized compute network. Deploy what you were already going to deploy, in the language you were already going to use, with the same familiar tools. SSH into your instance. Run your own stack. Ship containers.

 

The trust model is what changes. Your workload runs inside a secure element that the host can’t inspect. That opens up use cases (regulated data, autonomous agents, sensitive ML inference) that have always been forced onto centralized infrastructure, because that’s the only place the execution environment could be reasoned about.

 

Now there’s another option.

 

What This Means for the Network

Cargo expands the addressable surface of Acurast by orders of magnitude. Every Linux workload becomes a candidate for decentralized execution. That drives deployment volume. Deployment volume drives compute fee burn under the dynamic pricing model the community activated earlier this year. Every processor running Cargo workloads contributes to the network’s benchmark rewards.

 

More languages. More workloads. More utilization. More burn. More rewards.

Live on Canary Today

Cargo is deployed on Canary Network today, available on the network’s attested Android devices. Canary is Acurast’s pre-mainnet environment where real workloads meet real devices under real conditions. It’s where the Acurast team stress-test the protocol at scale before rollout to the full network.

 

Once Canary clears, Cargo rolls out to Mainnet across the Android side of the network.

 

The Container for the Mobile Age

Mobile compute isn’t a curiosity anymore. With Cargo, Acurast becomes a viable alternative to the hyperscaler stack for almost any workload a developer would deploy, and does it with a trust model the hyperscalers cannot match.

 

The revolution isn’t coming. It’s live on Canary today.

관련 블로그