Executive Summary
Privacy for software agents is an engineering constraint with three separable jobs: naming a controller, proving a state transition, and moving value without publishing the counterparty graph. Late 2026 does not collapse those jobs into one protocol. It stacks three designs that were already specified in public documents: decentralized identifiers, validity-proof batches on Ethereum, and an opt-in shielded payment pool.
A decentralized identifier is a URI. The controller binds that URI to a document that carries cryptographic material, verification methods, and service endpoints. The W3C Recommendation dated 19 July 2022 states that control can be proved without permission from a registry, an identity provider, or a certificate authority. At publication, the same status section recorded 103 experimental method specifications, 32 experimental method-driver implementations, and 46 implementations submitted to the conformance test suite (DID Core).
A validity-proof batch moves execution and state storage off Ethereum Mainnet. Operators bundle thousands of transfers, then post minimal summary data plus a cryptographic proof that the resulting state change is correct. Off-chain execution is what cuts the volume of data written to the base chain, which the protocol docs tie to cheaper transfers and a better user experience (zero-knowledge rollups).
Shielded settlement is a separate choice. Zcash documents both shielded and transparent transfers. The project describes the asset as private, fast, and accessible, and it tells users to fund a wallet from an exchange that supports shielded withdrawals (Zcash technology).
The economic claim that follows from these texts is narrow. Cost falls when calldata shrinks to a summary plus a proof, or when a note spends inside a shielded pool instead of publishing inputs in the clear. Neither document publishes a fee schedule, a throughput ceiling in transactions per second, or an agent census. Anyone quoting such figures is outside the receipts.
Two ledgers, one controller
Treat an agent as a DID subject that is a software thing, not a person. Resolution returns a document. The document does not custody coins. It names verification methods the controller can use and services where a counterparty may send a request. That split is the mechanism: identity discovery is permissionless to verify, while value movement stays on a chain whose privacy rules are explicit.
| Job | Public artifact | What a verifier checks | What stays hidden | Primary limit in the source text |
|---|---|---|---|---|
| Name the controller | DID URI plus document | Proof of control via verification methods | No payment graph | Method sprawl: 103 experimental specifications, 32 drivers (19 July 2022) |
| Scale execution | Batch summary and validity proof on Mainnet | Correctness of the posted state delta | Individual calls are not re-executed on L1 | Proof generation is inherent; docs do not price it |
| Move value privately | Shielded transfer | A zero-knowledge argument over the note | Sender, receiver, amount, under the shielded mode | Transparent mode remains available, so pool privacy is optional |
| Read a proving stack | Starknet docs entry for the S-two prover | Documentation exists; this page set states no fee | n/a | Index text only; no adoption series attached |
The fragmentation number is the falsifiable risk on the identity side. A standard data model can still fail in production if two agents resolve the same subject through incompatible methods. The Recommendation itself tells readers that issues lists may still alter details, even while it advises that no further substantive change was expected at publication. Interoperability is therefore a conformance problem, measured by the test suite, not a slogan.
On the execution side, the batch is the privacy-adjacent mechanism, and it should not be oversold. Posting a summary means L1 observers do not replay each call. The Ethereum page frames the design as throughput and data reduction. It does not claim that a batch is a shielded pool. An agent that needs amount-hiding must use a system that states that property. Zcash does. A validity batch, as documented, states correctness and compression.
Starknet's current documentation index points builders at the protocol and at the S-two prover, and it offers a nav entry labeled Ask AI. That is evidence of a developer surface aimed at people and at automated clients. It is not a measured agent share (Starknet docs).
flowchart LR
A[Agent holds a key] --> B[Resolve DID document]
B --> C{Verification method matches}
C -->|no| X[Reject]
C -->|yes| D{Value move required}
D -->|public batch| E[Off-chain execute thousands]
E --> F[Post summary plus proof]
D -->|amount hiding| G[Shielded spend]
G --> H[Transparent mode still exists]
F --> I[Mainnet accepts state delta]
H --> I
Settlement economics without invented prices
Define the L1 footprint of a validity batch as data plus proof, not as a dollar:
The source text supports the direction of (C_{\text{summary}}): off-chain execution reduces how much data must be posted, and operators submit only the changes required to represent the new state together with a proof that those changes are correct. It does not support a numeric value for either term. A model that fills those terms with a gas price is speculation.
Compare that with a single transparent transfer, where each input is published. The batch amortizes one proof across thousands of transfers. The per-transfer data term shrinks as the batch grows, until the proof term dominates:
Here (n) is the count inside one batch. The docs only bound (n) with the word thousands. (\delta_{i}) is the marginal summary attributable to transfer (i). If (\delta_{i}) is near-constant and small relative to posting full calldata, average cost falls in (n). That is the entire sourced economy of the design. Latency is the unpriced complement: users wait for the operator to finish the batch and for L1 to accept the proof. The page promises a better user experience and does not publish a confirmation-time distribution.
Shielded settlement has a different cost object. The user pays to generate and verify a zero-knowledge argument so that the ledger can accept a spend without listing parties in the clear. Zcash keeps a transparent mode beside that pool. The economic failure mode is selection: if most value stays transparent, the shielded set is a side venue, and observers still see the bulk of flows. The technology pages recommend exchanges that support shielded withdrawals — Coinbase, Gemini, and Kraken appear in the exchange list — precisely because the on-ramp is where privacy is lost or kept (how the protocol presents itself).
A useful identity for an operator choosing a rail:
Those constraints are not substitutes. An agent can present a DID, settle a high-volume public workflow inside a proof-backed batch, and reserve shielded notes for the payment that must not disclose a counterparty. Composing them adds round-trips. It does not create a single fee.
For readers who keep a machine-readable log of protocol surfaces rather than a narrative scrape, a compact radar of these documents is the relevant tool: the protocol radar dataset is one way to pin URLs and hashes of the pages cited here so a later diff is checkable.
The academic line behind shielded payments is the Zerocash construction, cited here only as the paper of record, not as a source of fresh measurements (Zerocash, arXiv:1807.03470). Nothing in that citation is used below as a statistic.
What adoption evidence actually exists
Real-world agent adoption, as of the pages above, is a set of interfaces, not a market share.
On identity, the adoption evidence inside the Recommendation is implementation activity at a date: 46 submissions to the conformance suite, against a much larger experimental method catalog. Wide deployment is what W3C asks for when it issues a Recommendation. That sentence is a standards claim. It is not a count of agents in production. A later observer can falsify progress by re-reading the registries and the test report, which the status section already points to (status and test suite).
On payments, the adoption evidence is distribution surface. Wallets named on the technology index include Edge, Vizor, and Zodl (also called Zashi). Node software includes Zebra, described as an independent, consensus-compatible full node, with zcashd marked for deprecation. Unified addresses and Orchard appear as user-facing tutorial topics. Each of those is a product or a pool version a wallet must speak. None is accompanied, on the fetched page, by a shielded-pool share.
On scaling, the adoption evidence is the existence of the L2 pattern in core developer docs: batch off-chain, prove, post a summary. Starknet adds a second concrete stack in which validators run nodes and the learning path names S-two. An agent owner can target those interfaces today. An analyst still cannot rank them by flow, because the fetched pages do not carry flow.
The mechanism that will decide agent use is operational, and it is already visible. An autonomous client fails closed when any of three checks fail: the DID document's verification method does not match the signing key; the batch proof is rejected on Mainnet; the withdrawal path from an exchange is transparent when the policy required a shielded note. Adoption, under that test, is the fraction of agent runs that pass all three. No source here reports that fraction. Publishing one would be a new measurement, not a reading of these documents.
Failure modes that the texts already admit
First, method sprawl. With 103 experimental specifications living beside one core data model, an agent that accepts "any DID" accepts a resolver lottery. The safe subset is the set that passes the conformance suite. Everything else is a bilateral integration, which is how centralized identity returns under a new name.
Second, optional privacy. Shielded and transparent transfers coexist by design. A merchant, an exchange, or a lazy wallet default can drain the privacy set without breaking consensus. The recommendation to prefer shielded withdrawals is an admission that the default path is the leak. Agents that rotate through custodial venues inherit that leak at the boundary, regardless of how strong the note proof is inside the pool.
Third, proof complexity. The batch design requires generating and checking a cryptographic proof for the aggregated transition. That work can fail, stall, or be operated by a single sequencer even when the proof is sound. The docs make the operator the party who submits the summary. Liveness of the agent economy on that rail is liveness of whoever is willing to post. Correctness of the state delta is not the same property as censorship resistance, and the fetched page argues the former.
Fourth, category error on the word privacy. Ethereum's own information architecture lists privacy among broader topics. The rollup chapter's concrete claim is data minimization plus a validity argument. Mixing those sentences produces bad architecture: teams ship a batch, tell users they obtained shielded payments, and never touch a note-based pool. The remedy is to write the requirement as a predicate. If the predicate is "L1 must not learn the amount," a summary-plus-proof design does not meet it unless a further privacy layer is specified. If the predicate is "L1 must not re-execute each call," the batch meets it.
Fifth, stale snapshots. The DID counts are explicitly "at the time of publication." Quoting them in late 2026 as a live census is a methodological error. They remain valid as a baseline from 19 July 2022. Any claim that the catalog grew or shrank needs a newer registry extract.
Predictions
- By 31 March 2027, the DID Core status section or its linked implementation report will show a count of implementations submitted to the conformance test suite that is different from 46 — confidence 63%.
- By 30 June 2027, the Zcash technology index will still instruct users to prefer an exchange that supports shielded withdrawals when funding a wallet — confidence 71%.
- By 31 December 2026, Starknet's documentation index will still direct readers to the S-two prover as part of learning the protocol — confidence 68%.