ZK protocol family

ZKAZero-Knowledge Agents
← Back to ZKA

Frequently Asked Questions

Common questions about ZKA, Noir circuits, the Aztec flagship target, and privacy-preserving agent coordination.

Why Privacy?

Why do agents need private transactions?

In a world of autonomous agents, every transaction reveals strategy.

Consider a competitive scenario: Agent A needs market research from Agent B. Without privacy:

  • Agent B sees how much A is willing to pay (pricing intelligence)
  • Observers see that A is researching this market (competitive intelligence)
  • A's transaction history reveals business priorities

ZKA lets agents transact, prove capabilities, and build reputation without revealing sensitive information to counterparties or observers.

Isn't this just for cryptocurrency use cases?

No. ZKA uses zero-knowledge proofs for three distinct purposes:

  1. Private payments (ZKA/Pay): Value transfer with hidden amounts and parties. Aztec is the strategic target, and an interim Base WETH9 pool profile exists for EVM settlement.
  2. Coordination proofs (ZKA/Coord): Prove that a multi-agent workflow was executed correctly without revealing the intermediate steps or methodology.
  3. Capability attestation (ZKA/Attest): Prove you have a certification without revealing which specific credentials you hold.

Privacy-preserving computation is valuable even without cryptocurrency.

What about regulatory compliance and auditing?

ZKA supports progressive disclosure and integrates with ZKC (Zero-Knowledge Compliance) for user-controlled compliance. Privacy is the default, but agents can selectively reveal information when needed:

  • Viewing keys: Grant auditors read access to specific transactions
  • Balance proofs: Prove a payment was within compliance limits without revealing the exact amount (Noir circuit)
  • Credential binding: Prove regulatory credentials are held without revealing identity (ZKC integration)

This is "privacy by default, transparency when required" — not "secrecy at all costs."

Technical Design

Why Noir?

Noir is a domain-specific language for writing zero-knowledge circuits, developed by Aztec Labs. ZKA chose Noir for several key properties:

Property Benefit for ZKA
Backend-agnostic (ACIR) Circuits compile to ACIR. Barretenberg / UltraHonk on BN254 is the only supported backend today. ACIR keeps other backends possible in future.
PLONKish arithmetization Direct match with ZKA's circuit constraint design
Recursive composition Noir circuits can verify other proofs, which ZKA/Coord v2 uses for its bounded recursive DAG
Aztec-native Aztec contracts are written in Noir (Aztec.nr), so ZKA shares one circuit language with its flagship target
Solidity verifier generation bb write_vk -t evm and bb write_solidity_verifier -t evm produce one EVM verifier contract for each circuit
Browser proving (NoirJS) The specification (§1.4) lists client-side proof generation via NoirJS and Barretenberg WASM

The specification (§1.4) names Barretenberg / UltraHonk / BN254 as the current backend, with additional backends possible as Noir's ecosystem matures. The legacy Halo 2 crates were removed.

Why Aztec as the strategic flagship target?

ADR-0010 selects Aztec-native, owner-direct ZKA/Pay as the strategic flagship. Reasons:

  • Note/nullifier model: Aztec's note and nullifier model is close to ZKA's design
  • Key hierarchy: Aztec's keys include app-siloed key isolation
  • Ethereum settlement: Aztec settles to Ethereum
  • Client-side proving: Private execution is proved on the user's device

Kernel composition alone does not meet ZKA/Coord v2. An Aztec implementation must publish a manifest-bound execution profile and show its own conformance evidence (spec §8).

Aztec V6 status: Aztec V6 (6.0.0) was released on 2026-10-22 and became canonical on mainnet and testnet on 2026-10-26. It is still labelled Alpha. ZKA's Aztec contracts (aztec/) pin aztec-nr v6.0.0 / Aztec 6.0.0. V6 testnet work is allowed. Mainnet and public-value use stay disabled until the ADR-0010 gates pass: official Aztec resolution of the Alpha V5 proving-system vulnerability and permitted deployment guidance, no open critical advisory on the pinned version, qualification, independent audit, operational acceptance, and explicit activation. The V6 release alone is insufficient.

The Base WETH9 pool profile is interim and non-production. Its Solidity verifiers run on EVM chains, but ZKA does not claim production readiness on any chain.

What happened to the trusted-setup-free property?

ZKA's original Halo 2 design used Pallas/Vesta curves with IPA commitments — no trusted setup required. The legacy Halo 2 crates were removed. The current Noir/Barretenberg (UltraHonk) stack uses BN254/Grumpkin with KZG commitments, which requires a universal trusted setup (SRS).

This is a deliberate trade-off:

  • Gained: EVM-native verification and Aztec compatibility
  • Lost: Setup-free property
  • Mitigated: Universal SRS (one ceremony for all circuits), well-established BN254 ceremonies
  • Future: A setup-free backend is not available today. It may become possible if Noir's ecosystem adds one.

Where can ZKA proofs be verified?

Today, ZKA proofs are UltraHonk proofs on BN254. The supported verification paths are:

  • Aztec L2 (strategic target): Aztec contracts, being qualified on V6 and gated by ADR-0010
  • EVM chains: Each circuit has its own generated Solidity *HonkVerifier (bb write_vk -t evm, then bb write_solidity_verifier -t evm). The Base WETH9 pool profile is interim and non-production.

Verifiers for other chains are not supported today. Noir's ACIR keeps such targets possible in future.

Protocol Family

What protocols are in the ZKA family?

Protocol Purpose Status
ZKA/Pay Privacy-preserving agent payments (Noir circuits) Specified
ZKA/Coord Recursive coordination proofs. Coord v2 is the canonical pre-launch draft: unaudited and not production-supported. Specified
ZKA/Attest Anonymous credentials via ZKC integration (§5) Specified
ZKA/Reputation Bilateral privacy-preserving reputation for the AFP Introduction Tier (§6.2) Bounded prototype
ZKA/Compute Verifiable private computation without revealing models or methodology Future

How does ZKA/Coord work?

ZKA/Coord v2 uses a fixed 30-field execution receipt and a bounded recursive DAG (fan-in up to 4, depth up to 32). Simplified, for a chain of steps:

  1. Agent A completes step 1, generates Noir proof P1
  2. Agent B completes step 2, generates proof P2 that recursively verifies P1
  3. Agent C completes step 3, generates proof P3 that recursively verifies P2
  4. Final verifier checks P3 — confirms entire chain without seeing intermediate steps

On Aztec, kernel composition alone is not enough (spec §8). An Aztec implementation must publish a manifest-bound execution profile and show its own conformance evidence.

Status: Coord v2 is a pre-launch draft. It is unaudited and not production-supported. Its proving time, memory, proof size and gas are unclaimed until the §4 conformance benchmark gate publishes reproducible measurements.

Implementation

What's the circuit architecture?

ZKA is structured as a Noir workspace with modular circuit packages, plus a separate Aztec.nr workspace:

noir/
├── zka_lib/                  # Shared primitives (Poseidon2, keys, Merkle)
├── zka_transfer*/            # Transfer circuits (zka_transfer, _binding, _binding_v2, _multi)
├── zka_pay_deposit/ _batch/ _transition/ _withdrawal/   # ZKA/Pay pool circuits
├── zka_withdrawal/           # Withdrawal circuit
├── zka_balance/              # Balance proof circuit
├── zka_root_update/          # Root update circuit
├── zka_coordination_v2*/     # Coord v2 (also _profile, _recursive)
├── zka_coord_*/              # Coord v2 and reciprocal exchange circuits
├── zka_recursive/            # Recursive aggregation of up to 4 proofs
├── zka_reputation/           # Bounded bilateral reputation prototype
└── zka_credential/           # ZKC credential binding

aztec/                        # Aztec.nr workspace (aztec-nr v6.0.0)
├── zka_aztec_lib/
├── zka_pay_aztec/
├── zka_transfer_aztec/
├── zka_credential_aztec/
└── ...                       # tests, benchmarks, holder-native

How fast are ZKA proofs?

Few figures are measured. The table shows what the specification states (§5, §9) and marks every other cell as not claimed.

Circuit Proving Time EVM Proof Size Solidity Verification Gas
zka_transfer Target <5s on consumer hardware (browser WASM), unmeasured 7,616 bytes Not measured
zka_credential Not claimed 7,232 bytes (padded circuit size 2^12) Not measured
zka_transfer_binding_v2 Not claimed 7,232 bytes (padded circuit size 2^12) Not measured
Coordination (recursive) Unclaimed Unclaimed Unclaimed
Base WETH9 pool payment (measured) Not reported Not reported ~411.6k marginal gas per payment

Proof sizes are for the EVM target with nargo 1.0.0-beta.25 and bb 5.0.0. Verification time is unclaimed until a reproducible benchmark for the pinned toolchain publishes measurements. Coord proving time, memory, proof size and gas stay unclaimed until the §4 conformance benchmark gate publishes reproducible measurements. The measured gas figure is the marginal gas of a payment in the Base WETH9 pool profile (docs/economics/zka_pay_economics.md). That profile is interim and non-production.

Who maintains ZKA?

ZKA is developed by Pyramidal as part of the Pyramidal ZK protocol family. The specification is licensed Apache 2.0, with a royalty-free patent non-assertion covenant for conformant implementations. The Rust crates are dual-licensed Apache-2.0 or MIT. The source will be published as a public repository.