At the start of this year, we made a quiet bet based on intensive market research:

That the next phase of onchain finance wouldn't be unlocked by faster chains, bigger throughput, or cheaper gas. That the real blocker keeping institutional capital, regulated funds, and serious financial workflows off public blockchains was something simpler and more structural: confidentiality.

Six months later, our research has resulted in shipped products, live infrastructure, real builders, and a category that's becoming impossible to ignore.

This is the story of how we got here.

February: A Thesis Becomes Public

On February 19, we published a manifesto that, at the time, felt obvious to us and slightly contrarian to the rest of the industry.

Onchain finance needs confidentiality. Not anonymity. Not opacity. Confidentiality with selective disclosure, the same model traditional finance has always used. Banks don't broadcast your balance to the public. Funds don't publish their investor allocations. OTC desks don't expose counterparty amounts. Yet on public blockchains, all of that is the default.

Our manifesto was simple:

Confidentiality is not secrecy. It is control. The right to choose who sees your data, when they see it, and under what conditions it is disclosed.

That is what we believe in, and what we are building toward with Nox: onchain finance where sensitive data stays protected, while regulators, auditors, and approved parties can still access what they need.

March: The First Product Ships

On March 30, we introduced the Confidential Token at ETHCC,

The model is simple. Any existing ERC-20 token can be wrapped into its confidential equivalent. Balances stay encrypted. Transfer amounts stay encrypted. You can use the token across DeFi exactly as before. With selective disclosure, token holders or authorized parties can grant scoped access to regulators, auditors, compliance teams, or other approved third parties when required. Access is not public. It is permissioned.

This is the data governance model institutions need on-chain: confidentiality by default, controlled disclosure when oversight or compliance requires it.

And the token can be unwrapped back into the public ERC-20 at any time.

It's built on the ERC-7984 confidential token standard and runs on Intel TDX, the hardware isolated execution environment that protects data even from the cloud provider running the infrastructure.

What it solves is concrete. Tokenized funds couldn't operate onchain at institutional scale because investor allocations were publicly readable. Corporate treasuries couldn't make payments without exposing every amount. RWA issuers couldn't meet compliance mandates because public ledgers don't allow for selective disclosure.

With the Confidential Token, all of that becomes possible, without rebuilding a single piece of existing infrastructure.

May: The Vault That Doesn't Leak Its Strategy

In May, we introduced the Confidential Vault on Arbitrum testnet.

The Confidential Token was about confidential assets, the Confidential Vault was about confidential execution. Vaults sit at the center of on chain asset management, they're how managers deploy capital, run strategies, and serve LPs. But public vaults leak more than just positions. They leak the strategy itself: allocation weights, rebalancing triggers, per-vault attribution of every trade.

For active strategy managers, that's their alpha published in real time. For institutional LPs, it's a mandate violation before the conversation starts. For RWA issuers, it makes regulated tokenization structurally difficult.

The Confidential Vault separates what must stay public from what must stay confidential. Vault structure, fees, and execution attestations remain auditable. Per-LP balances, deposit and redemption amounts, and strategy logic stay encrypted. Auditors and regulators receive scoped access on demand. The market sees nothing it isn't authorized to see.

It's built on the asynchronous vault standard (ERC-7540) combined with the confidential token standard (ERC-7984), running inside TEEs. The interface stays compatible with the vault infrastructure already deployed across DeFi.

Not one vault. A vault stack.

The Confidential Vault isn't a single product. It's a stack, designed to meet different vault protocols where they are.

Confidential Vault V1 covers the fundamentals: encrypted LP positions, encrypted balances, and encrypted transaction amounts, with selective disclosure to regulators, auditors, and counterparties. This is the version that shipped on Arbitrum testnet in May, and it's the version most vault protocols can integrate today without rewriting their contracts.

Confidential Vault V2 goes further. It encrypts the strategy itself, allocation weights, rebalancing triggers, and per-vault contributions stay encrypted end to end, while NAV, TVL, and APY stay publicly visible for LPs, indexers, and compliance. V2 is designed for active strategy managers whose alpha depends on the strategy staying private, not just the positions.

Custom deployments cover everything in between. Some vault protocols need position privacy but public strategy. Some need private strategy but public positions. Some need scoped access flows that don't fit either V1 or V2 out of the box. Because Nox is built as a primitive layer, teams can compose exactly the confidentiality surface their workflow requires.

The shared foundation across all three is Nox: encrypted handles, on-chain access control, Intel TDX execution, and cryptographic attestation. What changes is what a specific vault chooses to encrypt.

May 19: Nox Goes Live on Arbitrum

Two weeks later, Nox, iExec's confidentiality protocol for onchain finance, went live on Arbitrum testnet.

This was the moment the individual products became visible as something bigger: a layer. Not a chain. Not a privacy app. Not a single token standard. A protocol that lets DeFi builders plug confidentiality into any workflow using primitives they already understand. Standard Solidity. Encrypted handles. Onchain access control. Cryptographic attestation.

The Confidential Token and the Confidential Vault are the first two use cases. But Nox was designed for everything that comes after: confidential lending, confidential payments, confidential settlement, confidential prediction markets, confidential RWA platforms.

The point of a protocol layer isn't what it does on day one. It's what builders do with it on day one hundred.

June: Nox on Ethereum

In June, Nox went live on Ethereum testnet.

Ethereum is where serious on chain finance is converging: institutional capital, regulated stablecoins, tokenized funds, RWA experiments from Blackrock, Franklin Templeton, and dozens of others. Bringing Nox to Ethereum meant bringing confidentiality to the chain where the next $100T of capital is most likely to land.

This was the moment the multichain story started becoming real. One protocol. Two networks. Same primitives. Same composability. Same on chain access control. More networks to follow.

Meeting builders in the tools they already use.

Making a protocol multichain isn't only about deploying on more networks. It's about making it effortless for builders to actually work with it.

That's why we shipped a native Hardhat plugin alongside the Ethereum testnet launch. For any team already using Hardhat 3 with either Viem or Ethers.js, integrating Nox now takes one package install and a three line config block. The confidential offchain stack spins up automatically via Docker on the first test run. The plugin exposes a clean nox helper that handles encryption, decryption, and handle management.

Writing a test against a confidential contract now looks the same as writing a test against any other contract, deploy, read an encrypted handle, ask the Nox stack to decrypt, assert on the cleartext value. No new toolchain. No rewritten workflow. No cryptography expertise required to get started.

For the confidentiality layer to become foundational, it has to feel invisible. The Hardhat plugin is one of the first pieces of that invisibility.

The Builders Showed Up

Somewhere between March and June, something we didn't fully plan for started happening: builders started shipping on Nox.

We ran a Vibe Coding Challenge to see what developers would build with confidential primitives. What came back was a glimpse of what confidential DeFi actually looks like in the wild. Three of the standout submissions:

Diam | Private OTC. A confidential on-chain OTC desk with encrypted trade amounts, built on Nox with ERC-7984, ChainGPT powered audit and fair price AI. Today, over $30 billion per month flows through OTC desks via Telegram, not because participants want it that way, but because public chains couldn't offer confidentiality at execution. Diam is what happens when they can.

➡️https://www.youtube.com/watch?v=N1QlpmJ916U&feature=youtu.be

➡️https://private-otc.vercel.app/

RWA OS | Confidential asset infrastructure for tokenized finance. A confidential RWA platform handling tenant onboarding, investor mapping, compliance passports, and settlement flows, the operational stack every tokenized fund issuer needs but has to build from scratch today. Deployed on Arbitrum Sepolia, using Nox confidential primitives.

➡️https://rwaos.denkhultech.com/

➡️ https://dorahacks.io/buidl/43431

DarkOdds | Confidential prediction markets. Public outcomes and odds, but encrypted bet sizes on chain via Nox handles. Winners claim through Intel TDX TEE handlers that compute proportional pari mutuel payouts inside the enclave and re-encrypt the result. This is the first proportional pari mutuel confidential market, solving a problem pure FHE markets couldn't. Selective-disclosure attestations let users prove wins to accountants or seal them forever.

➡️ https://darkodds.site/

None of these teams were large. None had cryptographic specialists. All of them shipped production-grade confidential applications in weeks, using primitives any developer can access through the Nox testnet today.

This is what happens when confidentiality becomes a building block instead of a rebuild.

The Industry Started Catching Up

For most of the past several years, privacy occupied a small corner of crypto, associated with niche tools, controversial mixers, or theoretical research. By mid 2026, that conversation looked different.

Ethereum developers proposed new confidential token standards. Starknet shipped STRK20. Arbitrum published a vision for configurable confidentiality in the programmable economy. Chainlink released its Privacy Standard. Regulated entities started asking real questions about how to deploy serious capital onchain without violating mandates.

We didn't pivot to meet this moment. We'd been building toward it since 2017.

The market is catching up to a direction we never left.

Chain of Trust: How Confidential Execution Becomes Verifiable

Somewhere between the Confidential Vault launching and going live on Arbitrum, a quieter piece of work was happening in parallel. Not a product. A foundation.

For confidential DeFi to work for institutional finance, it isn't enough to make computation private. The market needs a way to prove, cryptographically, that the private computation actually ran the way it was supposed to. That the right code ran on the right hardware, in the right environment, with nothing tampered along the way.

That's what Chain of Trust is. And it's why we've spent the first half of the year building it out.

The hardware anchor: Intel TDX.

The foundation is Intel Trust Domain Extensions, a capability of recent Intel Xeon processors that lets a virtual machine run as a Trust Domain, isolated from the host operating system, the hypervisor, and even the cloud operator running the machine. The CPU transparently encrypts the memory of each Trust Domain, so neither the host nor a privileged operator can read or modify what's happening inside. Every Nox off-chain component runs inside one of these hardware-isolated environments.

TDX also produces a signed measurement of the environment when it boots. That measurement is the starting point for everything else.

The orchestration layer: dstack, integrated with Phala Network

TDX gives us the hardware guarantee. What we needed on top of it was an orchestration layer that could boot, supervise, and gate Confidential Virtual Machines from a measured, reproducible operating system image, and only release keys and secrets to workloads that could prove they were the ones we expected.

That's dstack, the open-source infrastructure developed by Phala Network. Nox integrates dstack to run its confidential workloads inside measured CVMs, using its Key Management Service to gate which workloads are allowed to boot in the first place, and its Gateway to handle TLS termination and encrypted routing between components.

The result is that every Nox CVM starts from a verifiable environment, before it is trusted with any sensitive data.

Attestations: making the verification concrete.

Once a workload is running inside a Trust Domain, it can produce a TDX quote, a cryptographically signed statement of which code is running, on which hardware, in which configuration. Anyone can validate that quote by walking the certificate chain back to Intel's root of trust.

This is the mechanism that turns trust us into verify it. A verifier does not have to take our word that a confidential vault position is being processed correctly. They can request a fresh attestation from the running component and check it themselves, against the expected measurements, at any point during the workload's lifetime.

Proof of Cloud: the last mile of provenance.

Hardware attestation tells you what code is running. It doesn't tell you where the machine physically is. For institutional workloads, that gap matters. A verified TDX chip in an unknown data center is not the same as a verified TDX chip in a known, verified hosting environment.

Proof of Cloud closes that gap. It is coordinated by the Proof of Cloud Alliance, a vendor-neutral group iExec is a member of, that maintains a signed registry binding TEE hardware identities to independently verified physical facilities. When a Nox component runs on a Proof of Cloud-sealed node, verifiers can establish not only that the workload ran on genuine confidential hardware, but that this hardware sits in a facility multiple independent parties have vouched for.

Why all of this matters.

The market has spent years hearing "confidential computing" as a marketing term. What we've been building this year is what makes it a verifiable one.

Intel TDX provides the hardware root of trust. dstack, together with Phala Network, provides the measured boot and workload gating. TDX attestations expose the evidence to any verifier who wants to check. Proof of Cloud extends the trust chain into the physical hosting environment. Together, they form the layer that makes confidential DeFi and RWA workflows something institutional counterparties can audit, insure, and integrate into existing compliance frameworks.

Not a claim. A chain of verifiable facts.

And this is only the foundation. The next parts of Chain of Trust, runtime attestation surfaced through a public portal, source code binding that ties running artifacts back to audited source, and on-chain governance of authorized measurements- are the milestones the second half of the year is being built around.

REAL Finance × iExec: Confidentiality Meets RWA Infrastructure

In May, we announced a strategic partnership with Real Finance, a purpose-built Layer 1 for institutional real-world asset issuance, distribution, and on-chain financial operations.

The premise is straightforward. Institutional RWA adoption needs more than tokenization. It needs infrastructure that supports privacy, compliance, auditability, and settlement at real-world scale. Public ledgers get part of the way there. Confidentiality is what closes the gap.

Together, Real Finance and iExec are exploring how Nox can support REAL's Layer 1 across:

→ Confidential RWA issuance and distribution
→ Encrypted balances and private investor allocations
→ Privacy-preserving subscriptions, redemptions, dividends, and financial operations
→ Selective disclosure for regulators, auditors, and compliance partners
→ Confidential tokenized funds, private credit, and structured financial products
→ Future technical integrations, pilot use cases, and ecosystem collaboration

Real-world assets are moving on-chain. Now, confidentiality moves with them.

July: Closing One Chapter, Opening the Next

On July 2, the RLC bridge between Ethereum and Bellecour officially shut down.

For years, Bellecour was iExec's purpose built sidechain, fast, low cost, and tailored to power decentralized confidential computing. It's where iExec grew up. Millions of tasks were computed there. iApps were deployed. The first decentralized cloud workflows took shape.

But the landscape of Web3 evolved. Liquidity, builders, and institutional attention consolidated on a smaller set of EVM networks. Asking projects to come to Bellecour, rather than meeting them where they already operate, became a friction point we couldn't fully overcome.

That's what good infrastructure decisions require: acknowledging what is no longer the right path, learning from it, and adapting.

The Bellecour sunset is the closing of a chapter. It's also the formal opening of iExec's multichain era. Nox is live on Arbitrum. Nox is live on Ethereum. It will be live on mainnet by the end of year and more chains will follow. The confidentiality layer is moving to where the capital actually is.

What the First Six Months Tell Us

The thesis we published in February isn't a forecast anymore. It's becoming the consensus.

$27 billion in tokenized assets are on chain today against a $100 trillion addressable market. The gap is no longer demand, no longer demand, no longer infrastructure readiness. It's confidentiality, the layer most of the ecosystem has been operating without.

We spent six months shipping the products, primitives, and infrastructure that close that gap. Not as a single feature, but as a foundation builders can compose on top of. Encrypted balances. Confidential vaults. Selective disclosure. Auditable execution. Multichain by design.

The next six months will be about scale: mainnet, more networks, more builders, more institutional integrations. The destination hasn't changed since February.

Confidentiality is not a niche feature. It's foundational infrastructure for the next phase of onchain finance.

The first six months proved the thesis. The next six are about scaling it into infrastructure the market can actually build on.

Four directions define the rest of the year.

Nox mainnet: Nox on Arbitrum and Ethereum testnet was the proof point. Mainnet is where builders ship real products, where institutions deploy real capital, and where the multichain story stops being a promise and becomes a deployment reality. Mainnet lands with a full third party audit of the protocol, because verifiable confidentiality has to start with verifiable code.
Institutional partnerships: The conversations we've been having across RWA issuers, tokenized fund managers, and confidential DeFi allocators are moving from exploratory to committed. The next months are about turning those conversations into shipped integrations, live use cases, and the kind of deployments that make on-chain confidentiality no longer a category to explain, but a category to reference.
The Nox technical paper: A full public writeup of the Nox architecture, from Chain of Trust through the confidentiality primitives, alongside the RLC business model on mainnet. This is the document institutional teams and technical evaluators have been asking for: how the system works, why the architecture is what it is, and how RLC ties economic activity to the confidential execution layer.
More networks, more builders: Multichain by design was always the plan. More EVM networks come online in the second half of the year, and the ecosystem of builders shipping on Nox continues to compound. Every new vault protocol, RWA platform, and confidential DeFi application built on the layer strengthens the case for the next one.

The destination hasn't changed since February. What comes next is the scale that turns thesis into infrastructure.

Confidential by default. Auditable on demand.

We're building it. And we're not alone anymore.

Start building today ➡️ https://www.iex.ec/

$RLC