What is shipping

Roadmap

01

Origin

Hides who is asking, and the metadata that gives it away

Anonymous RPC

Arti, the Tor Project's Rust client, compiled to WebAssembly and running in the browser, so a wallet or dApp can reach Ethereum without handing its network location to whoever answers.

Now

  • Wallet, SDK and light-client integrationsQ3 2026

    Integrating tor-js upstream by pull request, with ethers.js as the first target and dependent wallets after it.

  • Upstream to the Tor ProjectIn progress

    The WASM compatibility work merging back into Arti itself, so the browser build stops being a fork.

  • WebRTC transportQ3 2026

    A transport that browsers can actually dial, for infrastructure that cannot present a CA-issued certificate.

Next

  • Broader SDK and light-client rolloutQ3 2026

    Past the first integration, into the clients that depend on it.

  • Messenger protocol surveyQ3 2026

    What the messaging world already solved for metadata resistance, and what transfers.

Later

  • External security auditQ3 2026

    Independent review before anyone should depend on this in production.

  • Edge-to-P2P transaction broadcastingQ3 2026 and beyond

    Sending a transaction without the first hop learning who sent it.

  • Hybrid post-quantum key exchange

    Undated. Tracked because the anonymity guarantee has to outlive the transport.

Access layer

One pluggable interface over anonymity networks, so the edge can swap Tor for a mixnet or anything else without the application changing. The same shape extends to reaching peer-to-peer networks generally.

Now

  • Architecture and the anon-RPC standardIn progress

    Published as "Power to the Edges", with a draft standard and a browser demo you can run.

Next

  • Unified WebRTC transport specQ3 2026

    One transport spec that works in the browser and in Node, with standardised validation of the WASM binary.

  • Pilot deploymentQ3 2026

    The wallet to Tor to execution-node path, exercised end to end by somebody outside the team.

Exploratory

  • Formal methodsQ3 2026

    Lean-based verification starting from rustls-rustcrypto primitives and our PIR cores, with Leo Alt at Powdr Labs.

  • Privacy-preserving RPC aggregation

    With the Protocol State team: an aggregation layer that strips addresses and mixes queries, alongside the anonymity-network path.

02

Content

Hides what was asked: address, slot, access pattern

Private information retrieval

Reading Ethereum state without the server learning what was read. The focus is doubly-stateless schemes, which hold no per-client state on either side, so the database can update every block and queries stay unlinkable over anonymous RPC. Serving is GPU-accelerated.

Now

  • Live demo on mainnetQ4 2026

    Working with the Kohaku team to route Kohaku's wallet reads through PIR served from GPUs. The curated state, kept current block by block, covers ETH balances and nonces for every account, balances of top ERC-20 tokens, and ENS, GNS and WNS names.

  • Batch PIRQ4 2026

    Research: batch PIR in the doubly-stateless setting. Applications such as wallets often retrieve many entries together, and a batch scheme can use that to cost less in communication and computation than retrieving them one at a time.

Next

  • Production-ready PIR2027

    Performance tuning and further engineering, so that others can run PIR in production.

  • Verifiable PIRQ1 2027

    Research: private Merkle proof retrieval. Each value comes back with its Merkle proof, without the server learning which one was asked, so the client can check the answer against the state root instead of trusting the server.

Later

  • PIR on home nodes

    Exploring home nodes without a GPU as PIR servers, each answering private reads for one shard of the state small enough for its CPU. Thousands of home nodes already run without serving state to anyone else, though they would also need a reason to serve, such as payment.

03

Correctness

Hides nothing; it ensures the answer and its context are authentic

Verifiable binary trie

An execution-layer node running a binary trie (EIP-7864) and provably equivalent to mainnet, so retrieval servers, wallets and light clients can consume binary state before the protocol adopts it.

Paused since Q3 2026 following a team change. A mainnet binary-trie node was built in Q2; the work is on hold pending re-scoping.

Now

  • Binary-trie sidecar on GethPaused

    A Geth-based node syncing mainnet. Blocked on inefficient binary conversion, with upstream optimisation underway.

  • Binary trie on EthrexPaused

    Initial implementation contributed via Lambda. Sync stable on Hoodi as of April 2026.

Next

  • Shadow-chain sync to mainnetPaused

    Full mainnet sync producing state roots equivalent to the canonical ones, block by block.

  • zkVM proving of state transitionsPaused

    Recursive proof that binary-trie updates match the canonical updates.

  • Binary trie into retrievalPaused

    Retrieval servers using provable binary state without trusting the node operator.

9 items carry a date that has passed. They are struck through until the next planning cycle confirms whether they landed. Why any of this is worth doing is in Foundations; what the team does not do is on the about page.