Octropy Get early access

The cloud without the data center.

Octropy is a network layer that lets any app give its users cloud services: AI inference, file storage, sync and delivery, without a big cloud company in the middle.

Simulated. Small squares are people's devices; framed ones are Octropy boxes at host companies, dark while the host uses them, blue while they run a job for the network.

What you stop renting.

ServiceInstead ofPaid withStatus
Paid, in euro credits
InferenceLLM chat and completion, speech-to-text and text-to-speech, run on sealed Octropy boxes that prove what they are before any data is sent. Cloud AI APIs Credits, as the output arrives. Next
VaultFile storage, encrypted on the owner's device and held three times, by different operators on different networks. Cloud drives Credits, each period, as audits pass. Planned
Free, tit-for-tat
SyncA person's and a team's devices keep shared data in step. Sync backends In kind. You receive in proportion to what you deliver. In production
DeliveryChanges reach devices that are offline, and arrive when they come back. Message queues In kind. Counted per person, not per device. In production
IdentityOne identity per person, in every app, rooted in a passkey, with a scoped permission for each app. Sign-in services and account databases Nothing. Next

A sealed GPU box, leased to companies.

The company gets top-end hardware on site at a financed monthly cost. Whenever the box is idle, Octropy sells that capacity to the network and pays back the energy it used.

Host first

The host uses the box for anything that runs on GPUs: inference, fine-tuning, simulations, rendering, data processing, in sandboxes Octropy's software provides. Its own work always takes priority, and network jobs fill the gaps.

Each box measures its energy per workload. What network jobs used is paid back, so the host never subsidises the network.

Lease a box

Inference for the network

Network jobs are inference only: LLM chat and completion, speech-to-text such as meeting transcription, and text-to-speech. They run on a fixed set of engines Octropy ships, on models identified by their hash. A network job is data, never code.

Two prices: a cheaper preemptible tier and a guaranteed tier. Vetted partner datacenters can supply inference as a second tier.

Octropy boxAt a host company, leased monthly
HardwareGenuine, confidential computing
Engine and firmwareAs expected
EnclosureNot opened since provisioning
RunningHost sandbox: rendering
Network energyPaid back to the host
Design preview.

It proves itself before any data is sent.

The box combines server GPUs and a server CPU that support confidential computing with an enclosure that works like a payment terminal's: a sensor mesh, opening switches and light sensors. Its keys live only in volatile memory and are wiped the moment it is opened. A breached box can no longer prove itself and goes back to Octropy to be provisioned again.

Before sending a job, the user's node checks a signed report from the box: genuine hardware, the expected engine and firmware, and an enclosure that has not been opened. The host cannot open it without wiping it, and Octropy cannot read the data either.

  1. An inference job on an Octropy box
  2. jobmodel hash, input, budget within the app's permission
  3. registryboxes and suppliers for this model and tier
  4. attestgenuine hardware, expected engine, enclosure never opened
  5. sendencrypted, readable only inside the attested environment
  6. outputstreams back, with a signed cheque as it arrives
  7. movehost takes the box back: another box continues from the output so far
  8. redeemlatest cheque settled; the host's energy recorded to pay back

One SDK. Nothing extra to install.

Every app embeds the full node. On a desktop the first Octropy app to start hosts one node for the whole machine; on phones each app's node is a client. Bindings for Swift, Kotlin and TypeScript.

const octropy = await Octropy.start({ app: "neptunion" });

// A model is named by its hash. The budget stays within
// what the person allowed this app to spend.
const job = await octropy.infer({
  model: "sha256:4f1c…",
  input: { audio: meeting },
  budget: credits(0.40),
});
for await (const part of job.output) show(part);
  1. registryboxes and suppliers for this model and tier
  2. attestsigned proof checked before anything is sent
  3. outputthe transcript streams back
  4. chequea signed running total, only the latest counts

SDK preview in TypeScript, in development.

Euro credits. No coin.

App developers and organisations prepay credits and sponsor their users with spend permissions, so people never see a wallet. The euros sit with a regulated payment provider. Octropy keeps the books and never holds other people's money.

Metered between peers, settled in batches.

While a service is delivered, the payer sends signed messages stating the total it now owes, every few seconds of inference or every period of storage. Only the latest counts. A provider cannot overcharge, because a cheque needs the payer's signature, and a payer can underpay only once, because the provider stops serving when cheques fall behind.

Settlement verifies every cheque when it is redeemed, then pays out in batches: suppliers for their work, hosts for the energy their boxes used.

  1. Cheques from a user's node to a box
  2. chequethe total I owe you is now €0.0012
  3. chequethe total I owe you is now €0.0019
  4. chequethe total I owe you is now €0.0031
  5. redeemsignatures valid, not redeemed before, totals match
  6. payoutbatched through the payment provider

Storage is paid. Sync and delivery are free.

Vault

Planned

Every piece of data is encrypted on the owner's device and stored three times. Placement requires different operators on different networks, so the copies never quietly end up in one building. Holders are audited regularly, and one that fails or disappears is replaced from a remaining copy.

While the network is young, one copy also stays with a conventional storage provider. We promise a durability figure, never "it can never disappear."

Sync and delivery

In production

Free for any app to provide, and kept fair by tit-for-tat: you receive service in proportion to the service you deliver, counted from receipts both sides sign and checked with the same random audits as storage.

It is counted per person, not per device, so a phone that cannot hold much is covered by its owner's desktop. New people get a small starting allowance so they can join at all.

How Octropy earns.

Leases

Monthly payments from host companies, above the cost of financing the hardware.

Network inference

What network users pay for jobs on Octropy boxes, minus the energy paid back to hosts.

Fees

A percentage on paid services supplied by third parties, inference and storage, passing through settlement.

The moat is the network, not the code: the fleet of leased boxes, the vetted suppliers, the registry key that decides who is trusted, and the settlement relationships. The node and SDK are open source; the central services and box firmware stay closed.

Where it stands.

In production

  • Sync and delivery between devices
  • Connections over LAN, direct internet, Apple Multipeer, Tor and relay circuits
  • Neptunion, the first app

Next, in this order

  • The node separated from Neptunion, with Neptunion as the first SDK client
  • Identity: passkey root, person key, app permissions and consent
  • Credits ledger, cheques and settlement
  • A pilot box at one host company
  • The tamper-responsive enclosure and full attestation
  • Lease financing for a first batch of boxes
  • Paid vault storage

Later

  • Sites with surplus or cheap renewable power, and waste heat put to use
  • Erasure coding for storage
  • Partner suppliers at scale
  • A euro stablecoin escrow, for those who want no intermediary

Build on Octropy.

Early access for app developers, and for companies that want a box on site.