How Octropy works
Design decisions, November 2026. This is a working document: it records what we chose, what we considered instead, and why. Nothing here is final, and several points are flagged for legal, financial or technical verification.
In one paragraph
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. For compute, Octropy leases powerful, tamper-proof GPU boxes to companies: the company gets top-end hardware on site at a financed monthly cost, and whenever the box is idle, Octropy sells that capacity to the network and pays back the energy it used. For storage, devices and vetted providers hold encrypted data for each other. Apps embed the Octropy node with one SDK, users never install anything extra, and everything is paid for in euro-denominated credits that settle through a regulated payment provider.
Why now
Neptunion, the first app built on this layer, offered cloud LLM inference through a third-party free tier. That tier was removed, so Neptunion needs a paid inference mechanism either way. Rather than becoming a reseller of one provider, we build that mechanism as a general layer that any app can use, starting with inference, and back it with hardware we control.
Decisions at a glance
| # | Question | Choice |
|---|---|---|
| 1 | What to build first | Paid AI inference, on top of the existing peer-to-peer delivery |
| 2 | What compute means | Network jobs are inference only. Hosts may run anything on their own share, in sandboxes |
| 3 | How user data stays private | Octropy-controlled hardware: confidential computing plus a tamper-responsive enclosure, backed by contracts |
| 4 | The hardware | The Octropy box: server-class GPUs, attestation, keys wiped when opened |
| 5 | Ownership and financing | Leasing: companies pay monthly, Octropy finances the boxes against the lease contracts |
| 6 | How a box is shared | Host first; idle time sold to the network; host's energy for network use paid back |
| 7 | Other compute supply | Vetted partner datacenters and organisations as a secondary tier |
| 8 | How suppliers are found | A signed registry of boxes and suppliers plus short-lived live offers |
| 9 | Paid storage | Every piece of data encrypted and held three times, by different operators on different networks |
| 10 | Free services (sync, delivery) | Tit-for-tat, measured as a ratio per person |
| 11 | Auditing storage | Owner's devices, friends and peer auditors, with a central audit service at the start |
| 12 | Unit of payment | Euro credits. No coin of our own, and no third-party token |
| 13 | Metering | Signed cumulative cheques between peers, verified centrally at settlement |
| 14 | Settlement | Batched payouts through Stripe Connect or a licensed partner. Octropy never holds funds |
| 15 | Who pays, and the business model | App developers and organisations prepay and sponsor users. Octropy earns on leases and network jobs |
| 16 | How apps ship the node | Embedded SDK in every app, one shared node per device where possible |
| 17 | Identity | One identity per person, rooted in an OS passkey, with scoped permissions per app |
| 18 | Open or closed code | Node and SDK open source, central services and box firmware closed |
| 19 | Becoming a payments company | Not now. Staged path from Stripe to partner to own licence |
1. What to build first: paid inference
Options considered. Storage first (the "replace Google Drive" use case), a general network layer first, or paid AI inference first.
Choice. Paid AI inference, delivered over the bilateral delivery mechanism Neptunion already has.
Why. Inference is the one service with an existing, concrete need: users relied on cloud inference and it disappeared. Building it first means the payment layer gets built against a real use case, and everything after (storage, wider supply) reuses the same metering and settlement.
2. What "compute" means
Options considered. A general compute marketplace where anyone runs arbitrary jobs on others' hardware, or a narrow inference service.
Choice. Two different rules for two different users of a box:
- Network jobs (other people's work, sold through Octropy) 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 cryptographic hash. A network job is data (a prompt, an audio file, parameters), never code.
- The host company's own work can be anything that runs on GPUs: inference, fine-tuning, simulations, rendering, data processing. It runs in isolated sandboxes (virtual machines or containers) that Octropy's software provides on the box.
Why. Restricting network jobs to inference removes the hardest problem of a public compute market, running strangers' code, and keeps the model list short so idle capacity is actually useful (loading a 40 GB model for a five-minute job is wasteful). Hosts are a different case: they are contracted, identified, and paying for the hardware, so giving them full flexibility is what makes the lease attractive. The two are kept strictly apart: host workloads can never see network jobs, and network jobs can never see host data.
3. Keeping user data private during inference
This was the longest discussion, because a machine can only run a model on data it can read.
Options considered and why they were set aside:
- Splitting a meeting into chunks across several providers. Reduces what any one provider sees, but every chunk is still personal data, one sentence can be the sensitive one, colluding providers can reassemble the whole, and it does not work for LLM prompts. Kept only as an optional extra.
- A software-only sandbox that keeps data encrypted until inside it. Whoever controls the machine can reach the key and the plaintext in memory. It raises the effort, but once broken it is broken for everyone.
- Cryptographic computation (multi-party computation, homomorphic encryption). Mathematically sound, but currently orders of magnitude too slow for LLMs or speech models.
- Split inference (first and last layers on the user's device). Intermediate values can often be turned back into the input, especially with public models. A research bet, not a guarantee.
- Confidential-computing hardware owned by ordinary people. Confidential GPUs exist, but only in server-class hardware, and they need a server CPU with matching support. They are designed against software attackers, not against an owner with physical access; published research has broken memory protection with cheap hardware attached to the memory bus. The chip's signed attestation proves the chip is genuine and runs the expected code, but cannot see tampering outside the chip.
- Identified third-party suppliers bound only by contract. Works, and remains a secondary tier (decision 7), but contracts deter misuse rather than prevent it, and misuse is hard to detect.
Choice. Octropy controls the hardware itself (decision 4). The box combines confidential-computing hardware with an enclosure that destroys its keys when opened, and the box's tamper state is part of what it proves to users. Contracts with hosts add a legal layer on top.
Why. This closes the gap that every other option left open. The host has physical access but cannot open the box without wiping it; Octropy cannot read the data either, because the attested code does not allow it; and the user's node verifies all of this before sending anything.
Supporting measures. Speech-to-text can often run locally in the background, since nobody needs a transcript during the meeting itself. For LLM jobs, names and numbers can be replaced with placeholders locally before sending and restored afterwards.
4. The hardware: the Octropy box
What it is. A sealed unit with server-class GPUs and a server CPU, both supporting confidential computing, running firmware and a hypervisor that only Octropy controls.
Tamper response. The enclosure works like the ones in payment terminals, ATMs and hardware security modules: a sensor mesh, opening switches and light sensors. Encryption keys live only in volatile memory and are wiped instantly when the enclosure is breached. A breached box can no longer prove itself to the network and must be re-provisioned by Octropy.
Attestation. Before sending a job, a user's node checks a signed report from the box proving three things: genuine hardware, the expected engine and firmware, and an enclosure that has not been opened since provisioning.
The hard engineering part: heat. Security modules are small and cool; a GPU box draws kilowatts. The likely answer is sealed liquid cooling, with the tamper mesh extending around the cooling connections. This is where most of the hardware development effort goes.
5. Ownership and financing: leasing
Options considered.
- Octropy owns and places boxes. Maximum control, maximum capital need. Effectively a cloud company with distributed sites.
- The host buys the box and Octropy manages it. Almost no capital risk for Octropy, but a large upfront cost for the host, which slows sales.
- Leasing. The host pays monthly; Octropy owns the box and finances it.
Choice. Leasing.
The deal for the host. You get top-end hardware on site for a monthly fee instead of a large purchase. You use it for anything you want, whenever you want. Whenever it is idle, Octropy uses it for the network, and pays back the energy that network use consumed.
Financing. Octropy borrows to buy boxes, with the lease contracts (a company committed to monthly payments) as the basis for the loan. Lenders will look at two things: the creditworthiness of the leasing companies, and the resale value of the hardware if a lease ends early. Because GPUs lose value quickly, lease terms should roughly match the hardware's useful life, likely around three years, and income from idle time strengthens the case.
Why. Leasing makes high-end hardware affordable for mid-sized companies, keeps ownership (and therefore the tamper-proof design) with Octropy, and turns predictable lease payments into something a bank can finance.
6. How a box is shared
Host first. The host's workloads always take priority. Network jobs fill the gaps.
Preemption. LLM and speech inference produce output step by step, so network jobs move cleanly between boxes. When the host needs its hardware back, the job moves to another box with the same model, which receives the prompt plus the output so far and continues. For speech, work restarts from the last finished segment. This allows two prices for network users: a cheaper preemptible tier and a guaranteed tier.
Energy. Each box measures its own energy use per workload. Energy used for network jobs is paid back to the host, so the host never subsidises the network.
Reliability. A single box at a company is less reliable than a datacenter: one power line, one internet connection, no staff on site. Reliability comes from the fleet instead: jobs fail over between boxes, and boxes are spread across many sites, so they never all fail at once. Inference suits this well, because a job moves only kilobytes of text or megabytes of audio, so sites do not need datacenter-grade connectivity.
Pricing and speed. The aim is to be clearly cheaper than datacenter inference: no datacenter building to pay for, hardware largely financed by the lease, and energy paid at the host's own rate. For the host, on-site hardware also means no queues and minimal latency for its own work. These are hypotheses to validate with the first boxes.
Later site types. Locations with surplus or cheap renewable power, where boxes run hardest when power is cheap or even negatively priced, and sites where waste heat is useful (heating buildings, water or pools). The preemptible tier becomes a power-following tier, and batch jobs like overnight transcription wait for cheap hours.
7. Other compute supply
Choice. Besides Octropy boxes, vetted third parties can supply inference as a secondary tier: partner datacenters and organisations with their own clusters. They are identified companies with a signed key, bound by contracts with heavy consequences for misuse, and listed in the registry with their tier. Users and organisations choose which tiers they accept; sensitive work defaults to Octropy boxes or the organisation's own trusted partners.
Enforcement for third parties. Certifications such as ISO 27001 or SOC 2, audit rights in the contract, a share of early earnings held back, and revoking the supplier's key network-wide, which cuts their revenue immediately.
Why. It adds capacity and model variety without capital, while keeping the strongest privacy guarantee for work that needs it.
8. Discovery: a signed registry plus live offers
Options considered. A pure distributed hash table, or a central directory.
Choice. Octropy signs each box's and each supplier's identity record (owner, keys, tier, certifications) and publishes the list together with a revocation list. Because every entry is signed, any node can mirror and serve it. Live information (capacity, loaded models, prices) changes constantly, so boxes and suppliers publish short-lived signed offers separately, through the existing distributed directory or by answering clients directly.
Why. Every supplier is vetted or Octropy-owned, so a signed registry is the honest and efficient structure. Distribution stays decentralised even though one party vouches for entries, and revocation gives enforcement for free.
9. Paid storage: encrypted, three copies on three operators
Context. Vault storage that replaces services like Google Drive is a real cloud service, so it is paid, not tit-for-tat. Unlike compute, storage has no privacy problem: data is encrypted on the owner's device and stays encrypted at all times, so holders never see it.
Choice. Every piece of data is stored three times. Placement actively requires different operators on different networks, so the copies never quietly end up in one building. Holders are audited regularly; a holder that fails or disappears is replaced, and a remaining copy is used to create the new one.
Later. Once the network is large enough, move from full copies to erasure coding (data split into many pieces where any subset can rebuild it), which gives better durability at similar overhead. In the early phase, keep one backstop copy with a conventional commercial storage provider, because a young network's biggest risk is many nodes leaving at once. We promise a durability figure, never "it can never disappear."
10. Free services: tit-for-tat with a ratio
Context. Sync and delivery between devices are free for any app to provide, but free riders must be prevented.
Choice. You receive service in proportion to the service you deliver, counted from receipts signed by both sides and checked with the same random audits as storage. Reciprocity is counted per person, not per device, so a phone that cannot hold much is covered by its owner's desktop. New users get a small starting allowance so they can join at all.
Why. Proof of storage only proves someone stores something, not that they contribute. A ratio measures actual contribution, and private file-sharing communities have used it successfully for years.
11. Auditing storage
Choice. Audits are run by the owner's other devices and the owner's friends, by peer auditors as another tit-for-tat service, and, at the start, by a central Octropy audit service for extra guarantees while the network is small.
How peer auditing stays honest. Before uploading, the owner precomputes a batch of challenges and keeps only fingerprints of the correct answers, so an auditor can check a holder without seeing the data. Auditors are picked at random from different networks, so a holder cannot choose a friendly one. When the owner comes back online, it rechecks a sample of past audits; an auditor caught lying loses standing and held-back earnings.
Why. Payment depends on audits passing, so a dishonest auditor is a financial risk. These safeguards make auditing cheap (a few hashes per check) and hard to cheat.
12. The unit of payment: euro credits
Options considered. Our own coin, an existing storage or compute cryptocurrency, an existing stablecoin, or euro credits.
Choice. Users, apps and suppliers all see credits with a fixed euro value.
Why not our own coin. A coin needs a ledger someone runs: either a blockchain we build and secure ourselves, or a ledger Octropy runs, which is simply credits. Cheap conversion requires someone buying when suppliers sell, which means exchanges and a floating price. Pricing can adjust to volatility, but holders cannot: a supplier that earns coins one month and sells the next can lose its margin. In the EU, issuing a token also brings obligations under MiCA, and a token meant to hold a stable euro value starts to look like e-money.
Why not existing crypto tokens. They are volatile and move with their own networks' fortunes and governance, which would tie our customers' costs and our suppliers' income to someone else's market.
Why not crypto for micropayments. Micropayments do not need a blockchain; they need aggregation (decision 13). Once thousands of micro-events become one monthly payment, the settlement rail barely matters.
13. Metering: signed cumulative cheques
Choice. While a service is delivered, the payer sends signed messages stating "the total I owe you is now €X", every few seconds of inference or every period of storage. Only the latest cheque counts. Sending one costs nothing and touches no bank or chain.
Why it stays fair.
- A provider cannot overcharge: a cheque is only valid with the payer's signature.
- A payer can underpay only once: both sides measure independently (tokens counted, audits passed), and the provider stops serving when cheques fall behind. The most anyone can lose is one small step.
- Cheques must be backed by money: payers fund a balance up front, and providers check it covers their exposure before serving.
- Persistent disagreement shows up in standing, and with vetted providers it becomes a terms-of-service matter.
Central verification, peer metering. Metering stays between peers; the settlement service verifies everything when cheques are redeemed (valid signatures, no double redemption, totals matching audit records). This gives central guarantees without Octropy seeing every token and megabyte.
When a storage provider is replaced. It is paid per period as audits pass, so it has already earned for the time it held the data. On a neutral exit it is paid until handover completes, including the bandwidth to copy data to its replacement. On a fault exit it is paid up to its last passed audit. A share of each new provider's earnings is held back during its first months, returned on a graceful exit and used to pay for repairs otherwise.
14. Settlement: batched payouts through a regulated provider
Options considered. A regulated payment company holds funds; each app developer acts as the bank for its users; or a blockchain escrow contract holds funds.
Choice. Start with Stripe Connect or a comparable licensed partner.
How it works.
- An app developer or organisation tops up through the payment provider, and Octropy's ledger records the credits.
- Inside the network, everything moves as credits between ledger accounts, at no per-transaction cost.
- Periodically, or when a balance passes a threshold, Octropy instructs payouts: to third-party suppliers for their work, and to hosts for the energy their boxes used for network jobs.
The line we do not cross. Euros sit with the payment provider, never in Octropy's own bank account. Octropy keeps the books and gives instructions but never holds other people's money.
Fees. Batching removes fixed per-transaction fees. Percentage fees on top-ups remain, so organisations are encouraged to top up by bank transfer or SEPA direct debit rather than card.
What the ledger must guarantee. Double-entry bookkeeping where totals always balance; cheque redemption that has no effect if repeated; regular reconciliation against what the payment provider actually holds; and an append-only history that explains every balance.
Later. The cheque format is the same for every settlement option, so the backend is swappable. A euro stablecoin escrow contract can be added for those who want no intermediary. Transferring stablecoins on others' behalf also falls under payments regulation, so this only stays light if it is truly non-custodial.
15. Who pays, and the business model
Who pays for network services. App developers and organisations prepay credits and sponsor their users with spend permissions ("up to 500 credits this month"), so end users never see a wallet. Each app decides how to charge its own users (subscription, credits, bundled into a plan, with its own margin), as long as the network receives funds up front.
Octropy's revenue streams.
- 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.
Octropy's moat is not the code but the network: the fleet of leased boxes, the vetted supplier base, the registry key that decides who is trusted, and the settlement relationships. A fork can run the open software but cannot enter the registry, attest as an Octropy box, or redeem cheques through our settlement.
16. How apps ship the node
Constraint. Developers must be able to ship with one install. Asking users to install a second app is too much friction.
Choice. Every app embeds the full node through the SDK. Nodes cooperate when several Octropy apps are on one device:
- Desktop: the first Octropy app to start hosts the node; later apps detect it on a known local port and become thin clients. When the host app quits, another running app takes over. There is one node per machine and the user sees nothing. Where app sandboxing forbids sharing between apps from different developers, apps fall back to the mobile model.
- Mobile: iOS and Android do not let apps from different developers share a background process, so each app's node is its own device under the same person. Embedded mobile nodes run as clients only: they use the network but do not serve others, and their reciprocity is covered by the person's desktop or the app's sponsorship.
An optional Octropy companion app can exist as a dashboard for power users, but is never required.
Code structure (separating today's Neptunion networking code into layers):
| Component | Contents |
|---|---|
octropy-core | Identity, permissions, receipt and cheque formats: the protocol in code, small and stable |
octropy-transport | The connection ladder: LAN, direct internet, Apple Multipeer, Tor, relay circuits |
octropy-services | Vault and replication, delivery, inference (requester and supplier sides), audit responses |
octropy-node | The orchestrator, headless, with a versioned local API |
octropy-sdk | Thin client with Swift, Kotlin and TypeScript bindings; embedded or shared mode behind one interface |
| Box software (separate) | Hypervisor, host sandboxes, attestation, energy metering, tamper handling |
| Central services (separate) | Registry, settlement, audit service, box provisioning |
Neptunion becomes the first app on the SDK, which is the real test that the seams are in the right place.
17. Identity: one person, rooted in a passkey
Options considered. One identity per app, a companion app holding the key, or a key held by the operating system.
Choice. One identity per person. All apps see the same person, with one vault and one balance, but each app only accesses its own namespace through a scoped permission. The person's root key is a passkey for octropy.com, created by the first Octropy app the user installs and synced by the operating system across their devices.
Why.
- No companion app. Later apps on any of the user's devices find the identity already there, and uninstalling an app loses nothing.
- The registry controls access. An app can only use the
octropy.compasskey if Octropy lists it, so only registered apps reach a person's identity. - Real consent. An app can draw a fake approval screen, but not the OS biometric prompt naming
octropy.com. That prompt becomes the consent moment when an app asks for vault space or a budget ("Neptunion wants 5 GB of your vault and up to €2/month").
Mechanics. A permission is signed by putting its hash in the passkey's challenge, so any node can verify it. Passkeys can also derive encryption keys for the vault.
To verify before building. Passkeys use P-256 rather than the Ed25519 keys Neptunion uses today, so the passkey would act as the root that signs an Ed25519 person key. Support for key derivation varies by platform and OS version, and desktop Linux support is weak, so a printed recovery code remains the fallback.
18. Open source or closed
Choice. The node and SDK are open source. The central services (registry, settlement, audit, provisioning) and the box firmware stay closed. The licence for the open parts is still open: permissive, AGPL (which prevents closed forks) or Business Source License (source visible, commercial use restricted, opening after a few years).
Why. Users run a background process that holds their keys, sold on privacy; a closed binary makes that hard to trust, especially for organisations. Developers are wary of embedding networking code they cannot inspect. And binaries do not protect against copying anyway, since they can be reverse engineered. The real protection is the network and the box fleet (decision 15). For the box firmware, publishing the measured hashes that attestation checks against gives users verifiability without opening the code.
19. Becoming a payments company
Question. Could Octropy eventually be "its own Stripe"?
Choice. Not now. A staged path:
- Stripe Connect or a comparable platform. Their fee is the price of not running a compliance department.
- A licensed payment institution as partner, with Octropy registered as its agent, which is the common middle step for marketplaces.
- An own payment institution licence only when payment volume makes processor fees larger than the cost of a compliance team, or when payments become a product in their own right.
Context. EU payments rules are being rewritten: the final texts of PSD3 and the Payment Services Regulation were agreed in 2026, merge e-money institutions into the payment institution regime, and are expected to apply from around late 2027 or early 2028. A licence means minimum capital, anti-money-laundering checks, safeguarding of customer funds, audits and fraud liability: in practice, a team.
The technical flow, end to end
An inference job on an Octropy box
- app → nodeJob: model hash, input, budget (within the app's permission)
- node → registryBoxes and suppliers for this model and tier
- node → boxRequest attestation
- box → nodeSigned proof: genuine hardware, expected engine, enclosure never opened
- node → boxEncrypted job, readable only inside the attested environment
- box → nodeOutput streams back
- node → boxSigned cheques as output arrives
- If the host reclaims the box, the job moves to another box with the output so far.
- box → settlementRedeem latest cheque
- settlementVerify, move credits, record host energy to pay back
Storage over time
The owner's node encrypts data, precomputes audit challenges, and places three copies with three different operators on different networks. Each period, auditors challenge the holders; passed audits trigger payment for that period. A failed or vanished holder is replaced from a remaining copy, paid up to its last passed audit, and its held-back earnings cover the repair.
Money
- host company → Octropymonthly lease
- Octropy → lenderloan repayments
- app developer or organisation → payment providertop-up; the funds are held by the payment provider
- payment provider ⇢ Octropy ledgerrecorded as credits
- app developer or organisation → usersspend permissions
- users → Octropy boxes and supplierssigned cheques
- boxes and suppliers → ledgerredeem cheques
- ledger → payment providerbatched payouts: host energy, supplier earnings
- payment provider → host companypayout
Proposed order of work
- Separate the node from Neptunion into the components in decision 16, with Neptunion as the first SDK client.
- Identity: passkey root, person key, app permissions and the consent flow.
- Credits ledger, cheques and settlement through the payment provider.
- Pilot box: one host company, standard confidential-computing server hardware without the custom enclosure, host sandboxes, energy metering and inference for the network. The goal is to validate the lease pitch, utilisation and pricing.
- Tamper-responsive enclosure and full attestation of enclosure state.
- Lease financing for a first batch of boxes, based on signed lease contracts.
- Paid vault storage with three-copy placement, audits and repair.
- Later: power-following sites and heat reuse, erasure coding, partner suppliers at scale, stablecoin escrow.
Open questions and things to verify
Hardware:
- Cooling a multi-kilowatt sealed enclosure without weakening tamper detection.
- Maintenance and repair: a breached box wipes itself, so servicing needs a secure re-provisioning process, and false alarms must be rare.
- Isolation between host sandboxes and network jobs on the same GPUs, and which GPU sharing modes support that safely.
- Physical security limits: tamper response raises the bar sharply, but its strength must be tested, ideally by an outside security lab.
Financial:
- Lender appetite for financing GPU boxes against lease contracts, and at what rate.
- Lease term versus hardware depreciation and resale value.
- Real utilisation of idle time and the resulting network income per box.
- Insurance against theft, damage and host default.
Legal and accounting (to discuss with counsel before launch):
- Host contracts: liability, access to the box, energy measurement and pay-back, what happens at the end of a lease.
- Who sells to whom. Is Octropy reselling services or acting as a marketplace agent? This decides VAT treatment, liability when a supplier fails, and how revenue is recognised. Prepaid credits usable with many suppliers may count as multi-purpose vouchers for VAT.
- Are credits e-money? EU payment law has excluded prepaid instruments usable only within a limited network of providers under contract with the issuer. Whether Octropy credits fit, and whether PSD3 changed this, decides how light the credit system can be.
- GDPR roles. Who is controller and who is processor for network jobs on a box at a host's site, and the chain of data processing agreements from user to Octropy to supplier.
Technical:
- Passkey support per platform: key derivation, desktop Linux, P-256 to Ed25519 bridging.
- Whether local background speech-to-text on typical user hardware already covers most meeting transcription.
- App sandbox limits on sharing one node between apps from different developers, especially on macOS.
Business:
- The first host company for the pilot box.
- Which platforms the first app developers need (Apple first is easiest for passkeys).
- The licence for the open-source node and SDK.
Questions, an app to build, or a company that wants a box?
Write to hello@syphony.net.