Introducing Shield: human.tech's Programmable Privacy Bridge on Aztec

Shield is human.tech's programmable privacy bridge on Aztec. Transparent accountability without sacrificing privacy.

As more of everyday life becomes digital, the more valuable our personal data becomes. The choice of what to reveal stops being a preference. It becomes a prerequisite.

Today we are launching two things.

Clean SDK is human.tech's programmable privacy toolkit. It packages the personhood checks, sanctions screening, and zero-knowledge circuits that Shield is built on. Any app, anywhere, can integrate it. An Arbitrum app, an app on any chain, can use Clean SDK to give its users private, accountable transactions by routing funds through Aztec. Aztec is what makes this possible. Builders do not have to build any of it from scratch.

Shield is the first app built on Clean SDK. It is a bridge that moves assets between Ethereum and Aztec, live now at shield.human.tech as an Aztec v5 launch partner.

Shield is the first programmable-privacy solution that balances privacy and accountability at the same time. Nothing quite like it exists yet. Aztec is a privacy-focused Ethereum Layer 2. Transactions execute client-side on your own device, private state lives in encrypted note commitments, and proofs settle to Ethereum. That gives us the privacy. Clean SDK adds the accountability, and makes both programmable for any app that wants them.

Private. Accountable. On Aztec.

Why accountability, and why now

Open blockchains are traceable and transparent by default. Once your transactions are public, it is difficult to close your exposure, especially while keeping the option to be transparent when you choose to be. Shield gives you programmable privacy, so you can transact on your own terms while signaling accountability that deters bad actors. The accountability is what keeps the privacy durable and trustworthy for everyone sharing the pool.

Two modes: public and private

Shield moves tokens between Ethereum and Aztec, starting with USDC (cUSDC on Aztec), with more assets to follow. It runs in two modes: public and private.

Public mode is a straightforward bridge. Transactions are transparent on both Ethereum and Aztec. It suits users who want Aztec's lower fees and programmable contracts without privacy. It also suits organizations that need full transaction transparency for accounting or regulatory reasons.

Private mode moves your tokens into Aztec's private layer. While your assets are on Aztec, your balance and your transaction history stay confidential. Tokens arrive as "Clean" assets (cUSDC, for example), a designation that reflects they were verified before entering the private layer. Exits are verified and screened again before funds leave.

Private mode does not change what happens on Ethereum. The deposit and the withdrawal are public on-chain in both modes, with the address and amount visible on Etherscan. What private mode shields is your balances and history on Aztec, not the Ethereum on and off ramps.

Take funds private on Aztec, then withdraw to a separate verified address to reset your on-chain footprint: the funds arrive with no direct link to the wallet they came from, and every address is screened on the way in and out.

Screened at every deposit and exit

Every transfer clears two checks, on the way in and on the way out.

Proof of Innocence screens the wallet against sanctions, PEP, and watchlist sources through sanctions.io (23 sources including OFAC, FATF, FinCEN, Interpol, and PEP lists) to confirm the wallet does not appear on any of them. It runs on every transaction, at entry and exit.

Proof of uniqueness and Proof of Clean Hands confirm a real, unique person is behind the transfer. Which one applies depends on the amount.

• Under $1,000: no KYC. A user can transact up to $1,000 with a clean wallet (Proof of Innocence) plus a proof of uniqueness (a Human Passport score above 20). The uniqueness proof ensures a single user can never move more than $1,000 over a rolling period, even by splitting it into many small transactions.
• Over $1,000: ZK KYC (Proof of Clean Hands). A client-side zero-knowledge proof that the user holds a valid government ID and does not appear on sanctions lists. The user also proves their data is available for decryption if the observer (Holonym Foundation) receives a valid court order and the Human Network accepts the request.

This mirrors international anti-money-laundering standards, where you can transact without KYC up to a threshold as long as the wallet is clean and unique. The uniqueness check covers small transfers with no ID. The government-ID zero-knowledge proof covers large ones.

Most privacy tools screen only the tokens. Shield also confirms a unique human is behind every transfer, in zero knowledge.

Why verify identity for large transfers

Address screening alone is reactive. A fresh wallet sidesteps a denylist the moment it is created. For enterprises operating across jurisdictions, that is not enough to meet their legal obligations at Travel-Rule-style thresholds. Binding a verified identity to large transfers is what lets an institution use a private layer while meeting their legal obligations. Small, clean, unique transfers stay frictionless. Large ones carry the accountability regulators expect.

Disclosure you can trust

Proof of Clean Hands proves your data is available for lawful disclosure. It does not hand that data to anyone.

If a legal authority serves a legally binding request, Holonym Foundation (the v1 observer) assesses it. If it is valid, Holonym asks the Human Network for a decryption through a smart contract. The contract judges the request, and if it passes, the network permits decryption of that one specific record and nothing else. At launch this runs through a single authorized decryptor, gated by that on-chain conditions contract. As the Human Network decentralizes, approval spreads across a threshold of independent nodes, no single one of which holds the full key.

Your data stays protected as long as those conditions hold and Holonym does not collude to request an improper decryption. Holonym can never decrypt anyone's data on its own, because it needs the network to act, and the network does not act unless the on-chain conditions are met. No plaintext PII sits at rest; identity data is threshold-encrypted at issuance, so there is no plaintext honeypot to breach or subpoena.

This is the starting point. The roadmap keeps reducing how much you have to trust any single party, and it adds deliberate friction to the disclosure path itself. Today the observer is Holonym Foundation. In v2 that role decentralizes into a redundant layer of independent legal fiduciaries, each bound to defend the user, each judging a request on its own merit. A valid disclosure would then require several independent bodies to agree, not one.

That bureaucracy is the point. Every added party and every added step is friction against an improper request. It raises the cost of forcing a disclosure, and it lowers the cost of refusing an overreaching one. The direction of travel stays the same. Fewer things any one party can do alone, and more hands that have to move together before a single record is ever revealed.

What makes Shield different

Shield screens people, not just tokens and addresses. It screens both entry and exit. It combines a sanctions check with a government-ID zero-knowledge proof for large transfers. Disclosure is condition-gated, requiring the observer and the network to move together under an on-chain conditions contract, rather than being automatic or enforceable by any single party. Clean SDK makes all of this programmable and usable from any app on any chain.

Most privacy tools that screen at all only ever see the wallet, and only on the way in. Shield sees the person behind the transfer, on both sides, and keeps disclosure condition-gated. Privacy stays the default for everyone who follows the rules.

For a full walkthrough of the mechanics, the Portal, both modes, and every check, read How Shield Works.

Security

Shield is built so there is no plaintext honeypot to attack. No plaintext personal data sits at rest anywhere. Disclosure needs more than one party: it requires the observer (Holonym Foundation) and the Human Network to move together under an on-chain conditions contract, so there is no single key to steal or subpoena. Identity data is protected with threshold cryptography.

On the funds side, Portal contracts hold your Ethereum assets as collateral, so every asset on Aztec is backed 1:1 by real funds. All cross-chain messages use zero-knowledge proofs. Withdrawals release funds only after a verified burn on Aztec.

Shield's smart contracts, its zero-knowledge circuits, and the Human Network have all been independently audited. The Nethermind Security review of the contracts (NM-0756) and Halborn's review of the Human Network's threshold cryptography are both public. All code is open source.

What we are building toward

Shield is part of human.tech's larger framework. Human Passport for identity, WaaP (Wallet-as-a-Protocol) for self-custody, and the Human Network for threshold key generation and condition-gated disclosure. Tools that put privacy and accountability on the same side.

Starting with USDC, more assets to follow. Try Shield at shield.human.tech, and read the user guide to get started. New to it? Try the public testnet first, with no real funds. If you are building an app, on Aztec or anywhere else, Clean SDK is how you bring the same private, accountable transactions to your own users. Start with the docs.