Isonomic
A Sovereign Application Stack — User-Owned Data at Every Scale
Contents
- 1Abstract
- 2The Problem
- 2.1The custody bargain
- 2.2Symptoms of a structural defect
- 3Prior Art and Its Limits
- 3.1Blockchains as data stores
- 3.2Decentralized compute marketplaces
- 3.3The cost of generality
- 4Design Principles
- 4.1The user as root of trust
- 4.2Guarantees over generality
- 4.3Coordination without custody
- 4.4Usability as a security property
- 5The Stack
- 5.1The six services
- 5.2The Capsule as the unit of sovereignty
- 5.3The interface contract
- 5.4Versioning and reproducible builds
- 6The Three Tiers
- 6.1Tier 1 — the sovereign node
- 6.2Tier 2 — the Cluster
- 6.3Tier 3 — the Isonomic network
- 6.4Composition and migration between tiers
- 7Threat Model and Confidentiality
- 7.1Threat model
- 7.2Hardware confidential computing and remote attestation
- 7.3Client-rooted encryption
- 7.4The key-release protocol
- 7.5Scope and non-claims
- 8The Chain
- 8.1An L2 on Ethereum: rationale
- 8.2The five on-chain objects
- 8.3What never touches the chain
- 9Identity and Access
- 9.1Isonomic ID and key derivation
- 9.2Capabilities
- 9.3Revocation and key rotation
- 9.4Account recovery
- 10The Application Platform
- 10.1The inverted deployment model
- 10.2Mechanically verified guarantees
- 10.3Application lifecycle and longevity
- 10.4Applications
- 11The Studio
- 11.1Opinionation as a generation target
- 11.2From description to signed application
- 12Network Economics
- 12.1Operator compensation
- 12.2Collateral and accountability
- 12.3Exit as the pricing mechanism
- 12.4Governance and neutrality
- 13Scope
- 13.1Non-goals
- 13.2Relation to adjacent systems
- 14Roadmap
- 14.1Phase 1 — the sovereign node
- 14.2Phase 2 — the Cluster
- 14.3Phase 3 — the network
- 14.4Phase 4 — the platform
- 15Conclusion
1Abstract
Contemporary software rests on an arrangement in which the party that writes an application and the party that holds its users' data are one and the same. To use nearly any application, a user surrenders custody of their data to its developer, who in turn delegates that custody to a small number of cloud providers. The familiar consequences — surveillance-based business models, platform lock-in, data loss when services shut down, and recurring breaches — are not failures of particular companies. They are the equilibrium behavior of the architecture.
This paper presents Isonomic, a system that separates application logic from data custody. Isonomic defines a single, opinionated application stack of six services — relational, graph, and vector databases, a headless content service, application hosting, and language-model inference — that executes identically on hardware a user owns, on a replicated mesh of hardware owned by a team, or on an open network of independent operators. On operator-owned hardware, workloads run inside hardware-attested confidential computing environments and remain encrypted under keys derived from the user's self-custodial identity, such that operators can neither identify nor read the workloads they host. Coordination — the registration of applications and nodes, the recording of hardware attestations, the issuance and revocation of access grants, the placement of workloads, and the settlement of service — is performed by a Layer 2 network on Ethereum. User data and application state are never written to the chain.
On this foundation we describe an application platform in which software is delivered to the user's data rather than the reverse. A developer may distribute an application to any number of users while remaining structurally incapable of reading their data. In Isonomic, data ownership is not a policy commitment; it is a verifiable property of the system.
2The Problem
2.1The custody bargain
Every networked application must store its users' data somewhere. In the prevailing model, that place is a database operated by the application's developer, which is in turn hosted by a cloud provider. The user, who generates the data and is its natural owner, is the only party in this chain that holds no keys to it. The developer can read it, analyze it, sell it, and delete it. The cloud provider can, under its own policies and the laws of its jurisdictions, be compelled to produce it. The user's control is limited to whatever the developer's terms of service permit, and those terms can change unilaterally.
This arrangement was never chosen deliberately. It emerged because, for most of the history of networked software, there was no practical alternative: running a database required operating a server, operating a server required expertise and capital, and the developer was the only party with both. The cloud reduced the cost of operating servers by orders of magnitude, but it did not change who operates them. It consolidated custody further.
2.2Symptoms of a structural defect
Most of what users dislike about the modern internet follows directly from this fusion of developer and custodian. Advertising-driven surveillance exists because developers hold behavioral data and must monetize it. Lock-in exists because leaving an application means abandoning the data accumulated within it, and because cloud providers charge for data egress and offer proprietary services that resist migration. Products degrade over time because a captive user base tolerates degradation. When a company fails or is acquired, its users' data is deleted, transferred as an asset, or exposed in the process.
These outcomes are frequently attributed to the conduct of individual firms, and addressed through regulation, privacy policies, and promises of good behavior. Such measures treat symptoms. The underlying defect is architectural: as long as the party that writes the software is also the party that holds the data, the incentives and the capabilities that produce these outcomes remain in place. Correcting the defect requires separating the two roles at the level of the system itself.
3Prior Art and Its Limits
3.1Blockchains as data stores
Blockchains were the first widely deployed systems to give users self-custody of something of value. A user who holds the private key to an account controls its assets, and no intermediary can override that control. It is natural to ask whether the same model can be extended to application data.
It cannot, for three reasons. Blockchains are designed for small, high-value, globally agreed state, while application data is large, frequently updated, and mostly irrelevant to anyone but its owner. Storing and updating it on-chain is prohibitively expensive and slow. More fundamentally, blockchains are public by design: every node replicates every byte of state. A chain is an excellent instrument for recording agreements and ownership, and a poor container for private data. Self-custody of assets has therefore not produced self-custody of data, because the chain was never the appropriate place to hold it.
3.2Decentralized compute marketplaces
A second line of work has decentralized the supply of computing infrastructure. Decentralized compute marketplaces allow anyone with server capacity to sell it, and anyone with a workload — typically an arbitrary container — to purchase it. These systems lower costs and reduce dependence on a few providers.
They do not, however, change who can read the data. A conventional container deployed to a third party's machine is fully visible to that machine's operator, who can inspect its memory, its disk, and its network traffic. Unless confidential computing is applied and verified, the marketplace substitutes many unknown operators for one known provider; the custody problem is redistributed rather than solved. Decentralizing the supplier of hardware is a different objective from decentralizing the custody of data.
3.3The cost of generality
General-purpose platforms share a further limitation. A system that will run any workload — any database engine, any runtime, any configuration — can make very few guarantees about what those workloads do, because the space of possible behavior is unbounded. A platform cannot promise that an arbitrary container does not exfiltrate data; it can only promise to execute it.
Strong guarantees require constraint. A system that runs a small, fixed, audited set of components can make precise statements about the behavior of every workload it hosts, verify those statements mechanically, and extend them to the applications built on top. The central design decision of Isonomic is to accept this constraint deliberately.
- Who holds the data keys
- Hyperscale cloud
- Developer and provider
- Decentralized compute marketplaces
- Deployer; operator has access
- Smart-contract platforms
- No one (state is public)
- Isonomic
- The user
- Can the infrastructure operator read workloads
- Hyperscale cloud
- Yes, restricted by policy
- Decentralized compute marketplaces
- Generally yes
- Smart-contract platforms
- Yes, by design
- Isonomic
- No — attested enclave and user-held keys
- Scope of the platform
- Hyperscale cloud
- Hundreds of services
- Decentralized compute marketplaces
- Arbitrary containers
- Smart-contract platforms
- One virtual machine, on-chain state
- Isonomic
- Six fixed services
- Suitable for application data
- Hyperscale cloud
- Yes
- Decentralized compute marketplaces
- Yes
- Smart-contract platforms
- No — cost, throughput, privacy
- Isonomic
- Yes
- Guarantees about deployed applications
- Hyperscale cloud
- Contractual
- Decentralized compute marketplaces
- None
- Smart-contract platforms
- Code transparency
- Isonomic
- Mechanically verified confinement
- Exit
- Hyperscale cloud
- Costly — egress fees, proprietary APIs
- Decentralized compute marketplaces
- Possible, manual
- Smart-contract platforms
- Not applicable
- Isonomic
- Native migration between tiers
| Hyperscale cloud | Decentralized compute marketplaces | Smart-contract platforms | Isonomic | |
|---|---|---|---|---|
| Who holds the data keys | Developer and provider | Deployer; operator has access | No one (state is public) | The user |
| Can the infrastructure operator read workloads | Yes, restricted by policy | Generally yes | Yes, by design | No — attested enclave and user-held keys |
| Scope of the platform | Hundreds of services | Arbitrary containers | One virtual machine, on-chain state | Six fixed services |
| Suitable for application data | Yes | Yes | No — cost, throughput, privacy | Yes |
| Guarantees about deployed applications | Contractual | None | Code transparency | Mechanically verified confinement |
| Exit | Costly — egress fees, proprietary APIs | Possible, manual | Not applicable | Native migration between tiers |
4Design Principles
4.1The user as root of trust
Every key that can decrypt a user's data derives, ultimately, from an identity that the user alone holds. No developer key, operator key, or key held by Isonomic's developers sits above the user's key on any path to the user's data. Any mechanism that would require such a key — including account recovery — is designed so that it does not.
4.2Guarantees over generality
Isonomic supports exactly one stack. Every workload in the network is composed of the same six audited, versioned services. This uniformity is the source of the system's guarantees: because every workload is known, the network can make, and verify, statements about confidentiality, confinement, portability, and integrity that no general-purpose platform can make about arbitrary code.
4.3Coordination without custody
The blockchain coordinates the network; it never holds its contents. On-chain state is limited to what must be globally agreed and publicly verifiable. User data, application state, and anything derived from them remain off-chain and encrypted.
4.4Usability as a security property
A system that is secure but difficult to use will be abandoned in favor of systems that are insecure but convenient, and its security will then protect no one. Usability is therefore treated as a requirement of the security model, not a concession to it. Key management, recovery, migration between tiers, and application installation must be at least as simple as their conventional equivalents.
5The Stack
5.1The six services
An examination of modern applications reveals a small number of recurring layers: structured records, relationships, semantic retrieval, content, delivery, and, increasingly, inference. Isonomic implements these layers as six named services with stable interfaces, and no others. Each is built on a mature open-source engine selected for stability, and each is exposed only through its Isonomic interface.
- Isonomic SQL is a relational database for the structured, transactional core of an application: accounts, records, orders, and anything governed by a schema and constraints.
- Isonomic Graph is a graph database for relationships: social graphs, permission structures, knowledge graphs, and provenance chains.
- Isonomic Vector is a vector database for embeddings and similarity search, the basis of semantic search, recommendation, and retrieval-augmented generation.
- Isonomic Content is a headless content service in the tradition of Sanity and Strapi: schemas, documents, assets, drafts, and localization, delivered over a structured API.
- Isonomic Host serves web applications and their server-side functions. It is the only point through which application code enters a user's stack, and that code is signed, versioned, and sandboxed.
- Isonomic LLM provides completion and embedding interfaces over open-weight language models executing within the user's stack. Prompts, documents, and outputs are processed where the data already resides, under the same protections as storage.
The inclusion of Isonomic LLM is significant. In the prevailing model, the most sensitive material users produce — their questions, drafts, and private documents — is transmitted in plaintext to third-party inference providers. In Isonomic, inference is a local service of the user's own stack, and private inference is the default rather than a premium feature.
5.2The Capsule as the unit of sovereignty
A single user's or team's instance of the six services, together with all of its data, is called a Capsule. The Capsule is the unit in which Isonomic reasons about ownership. It is deployed, encrypted, replicated, backed up, migrated, and, if its owner wishes, destroyed as one object. A user's entire application infrastructure is therefore a single coherent, portable, encrypted artifact, rather than data scattered across the accounts of many providers.
5.3The interface contract
Developers build against the interfaces of the six services and nothing else. There are no machines to configure, regions to select, or instance types to choose. An application cannot open arbitrary network connections, spawn processes outside the stack, or address storage except through the services.
This constraint is what makes the guarantees of the application platform (Section 10) possible. Because an application can communicate only with the services of the Capsule in which it is installed, it can be shown, mechanically, to have no other channel through which data could leave. A platform that permits arbitrary code cannot make this statement; Isonomic can, because it does not.
5.4Versioning and reproducible builds
The stack is released as a single versioned artifact. Each release R is built reproducibly from public source code, producing a boot image whose cryptographic measurement M(R) is identical for anyone who performs the build. Approved measurements are published to the attestation ledger (Section 8).
This allows any party to verify a node's claim to be running the authentic stack. A node attests to running M(R); any observer can rebuild release R from source, compute M(R), and confirm that the two match. No party, including Isonomic's developers, is trusted to vouch for the binaries; the binaries are checked against the source.
6The Three Tiers
The same Capsule runs at three scales. The stack, the data format, and the applications are identical at each; only the mechanism that establishes trust in the hardware differs. Moving a Capsule between tiers is an operational migration of encrypted state, not a change of architecture.
6.1Tier 1 — the sovereign node
In the simplest deployment, the entire Capsule runs on a single machine that the user physically owns, such as a small desktop computer. The user's other devices — phones, laptops, tablets — connect to it as clients over an authenticated, encrypted channel. The user's data never leaves their premises.
At this tier, confidentiality is established by possession, supplemented by full-disk encryption so that a stolen device yields only ciphertext. No other party is involved, and no other party need be trusted. Tier 1 also serves as the reference against which the other tiers are measured: every mechanism described for Tiers 2 and 3 exists to reproduce, on hardware the user does not physically control, the guarantees that physical ownership provides at Tier 1. Its limitation is availability. A single machine can fail, be lost, or be unreachable.
6.2Tier 2 — the Cluster
A team in which each member operates their own node may join those nodes into a Cluster: a private network across which the team's shared Capsule is replicated in full. State changes are recorded in an encrypted, consensus-replicated log, so that every member node holds a complete and consistent replica, and the Capsule remains available as long as a quorum of nodes is reachable. A team of five members in five locations obtains five-fold geographic redundancy on hardware it owns, with no recurring infrastructure cost and no third party in the chain of trust.
Tier 2 assumes that members trust one another's hardware to the degree that they trust one another. Finer-grained secrecy among members — a collection visible only to two of five members, for example — is provided by scope keys (Section 9.2), so that holding a replica does not imply the ability to read every part of it. Membership in the Cluster is itself a capability, issued and revoked through the same mechanism as any other grant.
6.3Tier 3 — the Isonomic network
The third tier generalizes the first two to an open, global network in which independent operators contribute qualifying hardware and are compensated for hosting Capsules owned by others. To its users, the network behaves like a conventional cloud: elastic, continuously available, and professionally redundant. Structurally, it differs from a cloud in one decisive respect. No operator knows whose Capsule it hosts, and no operator can read the contents of a Capsule, whether through administrative access, physical access, or sustained effort.
A Capsule hosted on the network is placed across a set of nodes chosen to span distinct operators, regions, and hardware vendors, so that no single failure — or single compromised party — affects every replica. Capsules are addressed on the network by placement identifiers that cannot be linked to their owners' identities, and every sealed Capsule is indistinguishable from every other from the operator's perspective. The mechanisms that make these claims hold are the subject of Section 7.
6.4Composition and migration between tiers
The tiers compose. A user may operate a Tier 1 node at home while maintaining encrypted replicas on the network for durability. A team may run a Tier 2 Cluster that extends to network capacity under load. Because the Capsule is a single portable object with a fixed format, moving it between tiers requires transferring encrypted state and re-establishing keys, not modifying applications.
The ability to leave is not incidental. A user who can always withdraw their Capsule to hardware they own holds a standing alternative to the network, and that alternative disciplines the network's pricing and conduct permanently (Section 12.3).
7Threat Model and Confidentiality
7.1Threat model
Isonomic's confidentiality design is evaluated against the following adversaries and required properties.
- The curious operator. An operator with administrative and physical access to a node must learn nothing about a hosted Capsule beyond its resource consumption: neither its contents nor the identity of its owner.
- The compromised node. If the hardware isolation of a single node is defeated, the exposure must be bounded: data at rest must remain encrypted, other Capsules on the same node must be unaffected, and exposure must be limited to material actively in use during the compromise.
- The network observer. A party observing network traffic must see only encrypted channels, and must be unable to link Capsules to the identities of their owners.
- The malicious application. An installed application must be unable to read data outside the capabilities granted to it, and unable to transmit any data outside the Capsule.
- The malicious publisher. A developer must be unable to deliver code to a user that differs from the code recorded in the application registry, or to expand an application's permissions without the user's renewed consent.
- The coerced intermediary. No party other than the user — including Isonomic's developers and any foundation stewarding the protocol — may hold keys that would permit it to produce a user's data under compulsion.
- Usability. All of the above must hold without requiring users to perform key management that is more demanding than conventional account management (Section 4.4).
The following are outside the scope of the confidentiality design and are addressed elsewhere or acknowledged as limitations: compromise of the user's own devices; availability attacks, which are addressed economically rather than cryptographically (Section 12.2); and the residual risks described in Section 7.5.
7.2Hardware confidential computing and remote attestation
Modern server processors provide trusted execution environments at the level of an entire virtual machine. The processor encrypts the memory of a protected virtual machine with keys held in silicon and inaccessible to the host operating system, the hypervisor, and the machine's operator. Technologies in this class include Intel TDX, AMD SEV-SNP, and Arm CCA, together with GPU confidential computing modes that extend the protected boundary to accelerators, allowing language-model inference to execute under the same protection. On the Isonomic network, every Capsule executes entirely within such an environment. The operator hosts a sealed workload that it can power, meter, and terminate, but not inspect.
The same hardware provides remote attestation. A protected environment can produce a quote — a statement signed by keys rooted in the processor manufacturer's hardware — that reports the measurement of the code it booted. Isonomic requires every network node to submit such quotes to the attestation ledger before it may receive placements, and to renew them continuously. A node is eligible to host Capsules only while its most recent attestation reports an approved stack measurement M(R). Node integrity is therefore not asserted by the operator or certified by an auditor; it is demonstrated by the hardware and recorded publicly.
7.3Client-rooted encryption
Hardware isolation is the strongest available protection for data in use, but it should not be a single point of failure; attacks on specific trusted execution implementations are an active area of research and have succeeded in the past. Isonomic therefore applies a second, independent layer. All Capsule data is encrypted at rest under keys derived from the owner's identity (Section 9.1), which the network never holds in persistent form. A replica stored on a network node is ciphertext to every party except the Capsule's owner and the parties to whom the owner has granted access.
The two layers fail independently. Defeating the encryption does not defeat the hardware isolation, and defeating the hardware isolation does not yield the keys protecting data at rest. To read a Capsule, an adversary must defeat both, on a node it cannot identify as hosting any particular user's Capsule.
7.4The key-release protocol
Data at rest is encrypted, but a database cannot answer queries over data it cannot decrypt. The key-release protocol governs how a Capsule's keys reach a network node for use, such that they reach only an authentic, attested environment, and remain there only while needed. When Alice opens a session with her Capsule, hosted on node N:
- On boot, the enclave on node
Ngenerates an ephemeral keypair (enclave_priv,enclave_pub) inside protected memory. It produces an attestation quote that reports the stack measurement and bindsenclave_pubinto the quote's report data. The node submits this quote to the attestation ledger. - Alice's device retrieves node
N's current attestation and verifies it independently: the quote's signature against the hardware manufacturer's root of trust, the reported measurement against the approvedM(R)recorded on the ledger, and the binding ofenclave_pubto that measurement. - If and only if every check succeeds, Alice's device wraps her
capsule_keytoenclave_pub, together with a session lease that specifies an expiry time, and transmits the result to the enclave. - The enclave unwraps
capsule_keywithin protected memory and uses it to decrypt Capsule data as queries require. The key is never written to disk, never exported, and never visible to the host. - When the session ends or the lease expires, the enclave erases
capsule_key. Subsequent access requires a new lease, and therefore a fresh verification of the node's attestation.
Some workloads must run while their owner is offline, such as a website served from Isonomic Host or a scheduled task. For these, the owner may issue a standing lease: a renewable lease limited to specific services and data scopes, which any of the owner's devices can renew or revoke. Standing leases make explicit, and bound, the portion of a Capsule that is accessible to its host environment while the owner is absent.
This protocol performs the role that an ephemeral decryption service performs in end-to-end encrypted communication systems: plaintext exists only within a verified environment, only for the duration of a specific purpose, under a key that is then discarded.
7.5Scope and non-claims
Precision about what the system does not guarantee is part of its security model.
Fully homomorphic encryption. Computing on data that is never decrypted remains orders of magnitude too slow for the interactive, general-purpose workloads the Capsule executes. Isonomic does not rely on it. The stack's service boundaries allow such techniques to be adopted for specific operations as they mature, without changes to applications.
Hardware trust roots. Remote attestation depends on the integrity of the processor manufacturers' attestation infrastructure. Isonomic mitigates this dependency by supporting multiple vendors and by placing a Capsule's replicas across hardware from different vendors where possible, so that a failure in any one vendor's implementation does not affect every replica.
Side channels. Trusted execution environments have been subject to side-channel attacks. Client-rooted encryption bounds the consequences of such an attack to data in active use on the affected node, and leases bound the duration of that exposure, but neither eliminates the class of attack.
Metadata. An operator can observe a sealed Capsule's resource consumption: its storage volume, compute utilization, and the timing of its activity. Placement identifiers prevent this information from being linked to an owner's identity, but the information itself is visible.
8The Chain
8.1An L2 on Ethereum: rationale
Isonomic requires a coordination layer that no single party controls: a shared record of which applications and nodes exist, which nodes have proven their integrity, who has granted what to whom, and what service has been rendered. A blockchain provides this property. Isonomic's coordination layer is a purpose-built Layer 2 network on Ethereum, built on the OP Stack. Settling to Ethereum allows the network to inherit the security of the most widely relied-upon smart-contract platform, while executing at the cost and throughput that continuous coordination requires. The OP Stack provides mature, widely deployed rollup infrastructure and shared tooling.
8.2The five on-chain objects
The chain's role is deliberately narrow. It maintains five records and nothing more.
- The application registry. Every application is recorded with its identifier, its publisher's identity, and the measurements of each released version. Installation consists of verifying a signed package against this registry, which no marketplace operator can alter unilaterally.
- The node registry and attestation ledger. Network nodes register with their hardware class and collateral. The approved stack measurements
M(R)are published here, and nodes' attestation quotes are anchored here on a continuing basis. A node's eligibility to host Capsules is a publicly verifiable function of this record. - Capability commitments. Grants and revocations that must be globally enforceable — an owner authorizing an application, admitting a member to a Cluster, or revoking a former collaborator — are recorded as compact commitments (Section 9.2). The current public keys of each identity are recorded here as well, so that key rotation, like revocation, takes effect globally.
- Placement commitments. The assignment of sealed Capsule replicas to nodes, under stated redundancy and availability terms, is recorded so that operators are accountable for their commitments and failures are provable.
- Settlement. Metering of service rendered, compensation of operators, and the posting and forfeiture of operator collateral are settled here (Section 12).
8.3What never touches the chain
User data never touches the chain, in plaintext, encrypted, hashed, or fragmented form. Application state never touches the chain; applications read from and write to the Capsule at the speed of a local database. Capability commitments reveal that a grant exists and when it was revoked, but not what data it covers. The chain records the structure of the network — what exists, what has been proven, what has been granted, and what is owed — and nothing of its contents.
9Identity and Access
9.1Isonomic ID and key derivation
Every participant in Isonomic is identified by an Isonomic ID: a self-custodial cryptographic identity generated on the user's own device. An Isonomic ID is not an account issued by any party, and there is no password-reset mechanism operated by any party.
On creation, the user's device generates a random root_secret. From it, using a standard key-derivation function, the device derives an identity signing keypair (id_sign), used to sign grants and authorize devices, and an identity encryption keypair (id_enc), used to receive keys from others. The Isonomic ID is derived from the public signing key, and the identity's current public keys are recorded with the capability commitments on the chain (Section 8.2).
Beneath the identity, the hierarchy continues:
- Each Capsule has a random symmetric
capsule_key. The Capsule stores it only in wrapped form,wrapped_capsule_key, encrypted to the owner'sid_enc. Fromcapsule_key, a distinctservice_keyis derived for each of the six services, so that a key released for one service does not decrypt another. - Each of the user's devices holds its own
device_key, authorized by a grant signed withid_sign. Thecapsule_keyis wrapped separately to each authorized device, so that losing one device neither exposes nor loses the Capsule. - Access granted to others is expressed through capabilities and
scope_keys, described below.
Tracing any path to any byte of a user's data upward through this hierarchy, one arrives at root_secret, which only the user holds.
9.2Capabilities
Access in Isonomic is expressed through capabilities: signed, scoped, expiring grants issued by one identity to another identity or to an application. A capability specifies its issuer, its subject, its scope (a service and a set of collections, tables, or documents within it), the operations it permits, and its expiry. It is signed with the issuer's id_sign, and a commitment to it is recorded on the chain.
A capability establishes permission; a key establishes the ability to decrypt. Isonomic couples the two. Data subject to sharing is encrypted under a scope_key specific to that scope. Suppose Alice wishes to give Bob read access to one workspace in her Isonomic Content service:
- Alice's device creates a capability with issuer Alice, subject Bob, scope
content/workspace-7, operationread, and an expiry of thirty days, and signs it with herid_sign. - Alice's device retrieves Bob's current
id_encpublic key from the chain and wraps the workspace'sscope_keyto it, producingscope_key_bob. - The capability and
scope_key_bobare stored with Alice's Capsule, and a commitment to the capability is recorded on the chain. - When Bob requests the workspace, Alice's Capsule verifies the capability's signature, scope, and expiry, and confirms that the chain records no revocation. Bob's device unwraps
scope_key_bobwith his private key and decrypts the content.
As in end-to-end encrypted document systems, all parties with access to a scope hold the same scope_key, each in a copy wrapped to their own public key. Applications receive capabilities in the same way, scoped to the services and data their manifest declares and the user has approved.
9.3Revocation and key rotation
Revoking access must accomplish two things: preventing future authorization, and preventing future decryption. When an owner revokes a capability, a revocation record is committed to the chain, after which every Capsule and every enclave rejects the capability. The owner's device then rotates the affected scope_key, generating a new version and wrapping it only to the remaining authorized parties. New writes to the scope are encrypted under the new key, and existing data in the scope is re-encrypted in the background.
Revocation cannot cause a party to forget what it has already read; no system can. What Isonomic guarantees is that a revoked party gains access to nothing further, from the moment of revocation, everywhere. This addresses one of the most persistent problems in organizational security — the removal of a departing member's access across every system they used — at the level of the protocol.
9.4Account recovery
Self-custody implies that keys can be lost, and a system intended for general use cannot respond to that risk by placing it entirely on the user. Isonomic provides recovery without introducing any party that could exercise control over the account.
At setup, the user's device splits root_secret into n shares using a threshold secret-sharing scheme, such that any k shares reconstruct it and any fewer reveal nothing about it. The user chooses where the shares reside: on their other devices, with guardians of their choosing (each share encrypted to the guardian's id_enc), on a hardware security key, or on paper. A typical configuration distributes five shares and requires three. To recover, the user collects k shares on a new device, which reconstructs root_secret, re-derives the identity keys, and issues a new device grant.
No share is ever held by Isonomic's developers or by any foundation stewarding the protocol. A party able to restore a user's access would be a party able to take it; the recovery design ensures that no such party exists. Users who prefer a simpler arrangement may hold every share themselves across their own devices and hardware keys.
10The Application Platform
10.1The inverted deployment model
In every prevailing application platform, using software means sending data to the infrastructure of the party that wrote it. Isonomic reverses the direction of travel: the application is delivered to the user's data.
An Isonomic application is a signed package containing interface code, functions for Isonomic Host, schemas and queries for the data services, and a capability manifest declaring exactly which services and operations it requires. It has no backend of its own. When a user installs it, the package is verified against the application registry, instantiated within the user's Capsule on whichever tier the Capsule runs, and issued capabilities matching the manifest as approved by the user. The developer operates no server, holds no key, and receives no copy of any user's data.
10.2Mechanically verified guarantees
Because applications are confined to the interface contract (Section 5.3), the platform's guarantees are properties checked by software rather than judgments made by reviewers. For every installed application, the following hold:
- Confinement. The application can communicate only with the services of the Capsule in which it is installed. Its sandbox provides no other network or system access, and therefore no channel through which data could leave the Capsule.
- Integrity. The code executing in the Capsule matches the measurement published in the application registry for the installed version.
- Least privilege. The application holds only the capabilities in its manifest that the user approved, and can read nothing outside them.
- Consent on change. An update that requests capabilities beyond those previously approved cannot take effect until the user approves the change.
Conventional application stores promise to review applications for misconduct. The Isonomic application store makes no such promise, because none is required: misconduct of the kind that matters most — the exfiltration of user data — is not possible within the runtime.
10.3Application lifecycle and longevity
Publishers release new versions by recording their measurements in the application registry; users' Capsules install updates according to each user's preferences and the consent rule above. Because an application executes entirely within the user's Capsule and depends on no service operated by its publisher, it continues to function if its publisher ceases development or ceases to exist. The software a user relies on is no longer contingent on the survival of the company that wrote it, and the data the user accumulated with it was never anywhere but in the user's Capsule. If a user uninstalls an application, its data remains in the Capsule, in documented schemas, available to the user and to any other application they authorize.
10.4Applications
The following examples illustrate the kinds of applications that the platform makes practical.
- A private health record. A journal of symptoms, medications, and test results detailed enough to be genuinely useful — and, in the hands of any third party, genuinely dangerous. In Isonomic no third party holds it, so it cannot be sold, breached, or compelled from a provider.
- A team's operating system. A five-person company runs its customer records, accounting, documents, and internal tools on a Cluster across its members' machines, with greater redundancy than many funded competitors and no recurring hosting cost.
- A personal AI assistant. An assistant that retains everything its user tells it, retrieves across the user's documents through Isonomic Vector, and performs inference through Isonomic LLM, without its memory ever leaving the user's Capsule.
- An independent publication. A writer publishes through Isonomic Content and Isonomic Host, retaining ownership of both the archive and the subscriber list rather than leasing them from a platform.
- An orphaned application that still works. An application whose publisher stopped development years earlier continues to serve its users unchanged, because it never depended on its publisher after installation.
11The Studio
11.1Opinionation as a generation target
The constraint that makes Isonomic's guarantees possible has a second consequence: it makes Isonomic an unusually tractable target for software generated by language models. Every Isonomic application uses the same six services, the same capability model, and the same deployment form. There are no infrastructure decisions to make, no authentication system to design, and no deployment topology to configure — the categories of decision in which generated software most often fails. The entire platform can be described as a well-specified generation target.
11.2From description to signed application
Isonomic Studio is a conversational development environment built on this property. A user describes the application they want; the Studio generates the schemas for the data services, the functions and interface for Isonomic Host, and the capability manifest, and presents the result for review. The user signs the package and installs it into their own Capsule, or publishes it to the application registry for others.
Applications built in the Studio are subject to exactly the same guarantees as applications written by hand, because those guarantees derive from the runtime rather than from the tools that produced the code. The Studio lowers the threshold for producing private-by-construction software from an engineering team to a clear description, and extends the platform's intended end state from developers shipping applications to users, to users producing applications for themselves.
12Network Economics
12.1Operator compensation
A decentralized network must explain why independent operators participate. In Isonomic, operators are compensated for service rendered. Owners of Capsules hosted on the network pay for compute, storage, bandwidth, and inference, metered by the protocol and settled on the chain. Prices are set by the open market of operators rather than by the protocol, which enforces only that service is rendered as committed.
12.2Collateral and accountability
Operators post collateral when registering a node. Provable failures — breach of an availability commitment recorded in a placement commitment, failure to maintain a valid attestation, or violation of protocol rules — result in forfeiture of a portion of that collateral, applied automatically. Accountability on the network is therefore economic and mechanical rather than reputational, and availability, which cryptography cannot guarantee, is secured by incentives.
12.3Exit as the pricing mechanism
Tiers 1 and 2 impose no protocol-level cost: a user who hosts their Capsule on their own hardware pays nothing to the network. Because every Capsule can be migrated to hardware its owner controls at any time, the network must remain cheaper, more convenient, or more reliable than owned hardware in order to retain the Capsules it hosts. The right to leave is not only a protection for users; it is a permanent constraint on the network's pricing and conduct.
12.4Governance and neutrality
The protocol is stewarded by an independent foundation whose mandate is credible neutrality. The protocol layer — the stack specification, the five on-chain records, and the rules of attestation, placement, and settlement — is maintained as a commons that no company may capture, including companies that build commercial products on Isonomic. Every participant in the layer above the protocol, whether publisher, operator, or service provider, operates on identical terms. The name Isonomic is drawn from isonomia, the Greek principle that all stand equal under the same law; the protocol applies that principle to its own participants.
13Scope
13.1Non-goals
Isonomic is not a general-purpose compute marketplace. Workloads requiring an arbitrary container, database engine, or runtime are served by other systems, and Isonomic's guarantees exist precisely because it declines that generality. It is not a platform for on-chain computation; applications execute within Capsules at native speed, and the chain coordinates without computing. It is not a storage network; its unit of value is a running, queryable stack rather than archived data. Finally, it is not intended to be experienced by its users as a blockchain product. The chain and the cryptography are essential and, for the user, largely invisible, in the way that transport-layer encryption is essential and invisible to the users of the web.
13.2Relation to adjacent systems
Isonomic is designed to complement, rather than replace, adjacent infrastructure. Decentralized storage networks can serve as archival layers for encrypted Capsule backups. Isonomic IDs are designed to be expressible as decentralized identifiers under emerging open standards, and to interoperate with smart accounts secured by passkeys, so that a user's Isonomic identity can coexist with their existing wallet and authentication arrangements. Confidential computing capacity offered by other networks can, where it satisfies Isonomic's attestation requirements, participate as node capacity.
14Roadmap
14.1Phase 1 — the sovereign node
The complete six-service stack packaged for deployment on a single owned machine, with Isonomic ID, capabilities, encrypted Capsule state, and multi-device access. The quality of this phase determines the credibility of every subsequent one, because Tier 1 is the reference against which the other tiers are measured.
14.2Phase 2 — the Cluster
Consensus-based replication of a Capsule across member-owned nodes, Cluster membership expressed as capabilities, scope keys for intra-team secrecy, and operation that is transparent to the failure of individual nodes.
14.3Phase 3 — the network
Launch of the Layer 2 network with the node registry, attestation ledger, placement commitments, and settlement, with confidential-computing requirements enforced from the first placement. Encrypted network replicas for Tier 1 and Tier 2 users precede full network hosting, establishing durability as the first service the network provides.
14.4Phase 4 — the platform
Launch of the application registry, the application store, and Isonomic Studio, enabling publishers to distribute applications that cannot access their users' data, and enabling users to produce applications of their own.
15Conclusion
The defining defect of the networked software era has been the fusion of two roles that need not be fused: the party that writes software and the party that holds the data it processes. That fusion persisted because separating the roles required three things that did not exist together: an application stack an individual could own and operate, a means of running workloads on others' hardware without trusting those others, and a coordination layer that was not itself a company.
Each of these now exists. Commodity hardware can run a complete application stack in a device that fits on a desk. Confidential computing allows hardware to host workloads that its own operator cannot read, and to prove what it is running. A decade of blockchain development has produced coordination infrastructure that no single party controls. Isonomic assembles these components into a single system: a stack that anyone can own, a network that anyone can join and no one can read, and a chain that records the structure of the network without ever holding its contents.
In such a system, the statement that only the user can access their data is no longer a promise made by a provider. It is a property that anyone can verify.