ZK protocol family

ZKAZero-Knowledge Agents

ZKA · Open specification

Zero-Knowledge Agents

Privacy-preserving protocols for autonomous AI agent interactions

ZKA enables AI agents to transact, prove capabilities, and coordinate work without revealing sensitive information. Circuits are written in Noir and proved with Barretenberg (UltraHonk). The strategic target is Aztec L2. EVM chains verify proofs with generated Solidity verifiers. The specification is a draft, and no deployment is production-ready. Privacy is not optional.

Design Principles

  • Written in Noir

    All ZKA circuits are authored in Noir and compile to ACIR. Today ZKA proves with Barretenberg (UltraHonk) and verifies in Aztec contracts or EVM Solidity verifiers.

  • Aztec-Native Privacy

    Aztec private contracts are the strategic flagship target. ZKA's Aztec contracts are being qualified on Aztec V6, which was released on 2026-10-22 and is still labelled Alpha. Production use stays disabled until the ADR-0010 gates pass.

  • Recursive Coordination

    ZKA/Coord v2 uses a fixed 30-field execution receipt and a bounded recursive DAG (fan-in up to 4, depth up to 32). One proof can attest that a multi-agent workflow ran correctly. It is a pre-launch, unaudited draft.

  • Backend Portability (Future)

    Barretenberg / UltraHonk on BN254 is the only supported backend today. Noir's ACIR keeps other backends possible in future. None is supported now.

  • Progressive Disclosure

    Agents can selectively reveal information when needed for audit, compliance, or dispute resolution via viewing keys and ZK proofs.

  • ADAMAS Integration

    Deep integration with ADAMAS orchestration while maintaining complete payment privacy. The orchestrator sees tasks, never payments.

Private Transfer — Simple Transfer Circuit

The simple reference transfer circuit (zka_transfer) in Noir. It is single-input, single-output and value-preserving, so it cannot split or merge notes. Value split and merge belong to zka_pay_transition, which takes up to two inputs and three outputs (§3.4). The specification does not claim a gas figure for the Solidity verifier of this circuit. The current zka_transfer artifact still binds a legacy, retired context, so it is a reference circuit and not a supported deployment target until it is rebuilt (§3.1).

// noir/zka_transfer/src/main.nr (simplified)

fn main(
    // === Public Inputs ===
    nullifier: pub Field,
    output_commitment: pub Field,
    merkle_root: pub Field,
    context: pub Field,
    asset_commitment: pub Field,

    // === Private Inputs (hidden) ===
    // (consensus context preimage fields omitted)
    input_value: Field,
    input_recipient: Field,
    input_randomness: Field,
    merkle_siblings: [Field; 32],
    merkle_path_index: Field,
    spending_key: Field,
    output_value: Field,
    output_recipient: Field,
    output_randomness: Field,
) {
    // 1. Input note commitment
    let input_commitment = compute_note_commitment(
        asset_commitment, input_value, input_recipient, input_randomness);

    // 2. Merkle membership
    assert(compute_merkle_root(input_commitment, merkle_path_index,
                               merkle_siblings) == merkle_root);

    // 3. Nullifier correctness
    assert(compute_nullifier(input_commitment, spending_key) == nullifier);

    // 4. Ownership
    assert(derive_address(spending_key) == input_recipient);

    // 5. Output note commitment
    assert(compute_note_commitment(asset_commitment, output_value,
               output_recipient, output_randomness) == output_commitment);

    // 6. Value conservation
    assert(input_value == output_value);

    // 7. Context binding (replay protection): omitted here

    // 8. Non-zero value
    assert(input_value != 0);
}

Compiled via nargo compile. Each circuit gets its own Solidity *HonkVerifier, generated with bb write_vk -t evm and then bb write_solidity_verifier -t evm. The EVM proof for zka_transfer is 7,616 bytes. Its Solidity verification gas is not measured.

Protocol Family

ZKA is a family of Noir circuits for different privacy-preserving operations. Status follows the specification (§1.2):

  • ZKA/Pay

    Privacy-preserving agent payments. Noir circuits with Aztec and EVM settlement profiles. The Base WETH9 pool profile is interim and non-production.

    Specified
  • ZKA/Coord

    Coord v2: recursive coordination proofs over a bounded DAG. A canonical pre-launch draft, unaudited and not production-supported.

    Specified
  • ZKA/Attest

    Anonymous credentials and selective disclosure via ZKC integration (§5).

    Specified
  • ZKA/Reputation

    Bilateral privacy-preserving reputation for the AFP Introduction Tier (§6.2). A prototype with documented limits.

    Bounded prototype
  • ZKA/Compute

    Verifiable private computation without revealing models or methodology.

    Future

Architecture Overview

NOIR CIRCUITS · ACIR ZKA/Pay Transfer ZKA/Coord Coordination ZKA/Attest Credential binding compile PROVING BACKEND Barretenberg UltraHonk · BN254 prove + verify VERIFICATION TARGETS Aztec L2 (flagship target, gated) EVM Chains (Solidity verifier)

Write once in Noir. Compile to ACIR. Prove with Barretenberg (UltraHonk). Verify in Aztec contracts or EVM Solidity verifiers. Other backends are possible in future and are not supported today.

Strategic target: Aztec L2. 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 pin aztec-nr v6.0.0. Testnet work is allowed. Production use stays disabled until the ADR-0010 gates pass: the V6 release alone is insufficient.

Getting Started

  • Read the Spec

    Protocol design, Noir circuits, UltraHonk proofs, and settlement profiles.

    View Specification
  • Agent Integration

    LLM-optimized documentation for autonomous agent consumption.

    View llms.txt
  • ADAMAS Platform

    Learn how ZKA integrates with ADAMAS orchestration for private agent coordination.

    View Platform

Use Cases

Private Agent Payments
Settle task compensation without revealing amounts, parties, or business relationships. Aztec is the strategic target. The Base WETH9 pool profile is interim and non-production.
Workflow Verification
Prove multi-agent task chains ran correctly via recursive Noir proofs (ZKA/Coord v2, a pre-launch draft).
Competitive Multi-Agent Markets
Agents compete on capability without leaking pricing, strategy, or transaction history to counterparties.
Anonymous Credentials
Prove capability certifications via ZKC integration without revealing identity or specific credentials.