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, with primary deployment on Aztec L2 and verification on any EVM chain via auto-generated Solidity verifiers. Privacy is not optional.

Design Principles

Written in Noir

All ZKA circuits are authored in Noir and compile to ACIR, enabling verification on Aztec, any EVM chain, Starknet, zkVerify, and more.

Aztec-Native Privacy

ZKA deploys as Aztec private contracts. Kernel circuits handle recursive proof composition automatically — no manual recursion needed.

Recursive Coordination

Multi-agent workflows produce a single proof attesting the entire chain executed correctly — without revealing intermediate states or methodology.

Multi-Chain Verification

Noir's backend-agnostic ACIR compiles to UltraHonk (Aztec/EVM), Halo 2 (setup-free), Groth16 (pairing-based), and more.

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 — Noir Circuit

ZKA transfer proofs are written in Noir, verified on-chain in <300k gas:

// zka_transfer/src/main.nr

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) ===
    input_value: u64,
    input_recipient: Field,
    input_randomness: Field,
    spending_key: Field,
    merkle_index: u32,
    merkle_siblings: [Field; 32],
    output_value: u64,
    output_recipient: Field,
    output_randomness: Field,
) {
    // 1. Verify input note exists in commitment tree
    let input_commitment = compute_commitment(/*...*/);
    assert(verify_membership(input_commitment, merkle_index,
                             merkle_siblings, merkle_root));

    // 2. Verify nullifier correctness
    assert(nullifier == compute_nullifier(input_commitment, spending_key));

    // 3. Verify ownership
    assert(input_recipient == derive_address(spending_key));

    // 4. Value conservation — no creation, no destruction
    assert(input_value == output_value);
    assert(output_value > 0);
}

Compiled via nargo compile. Solidity verifier auto-generated via nargo codegen-verifier. Browser proving via NoirJS + Barretenberg WASM.

Protocol Family

ZKA is a family of Noir circuits for different privacy-preserving operations:

$ ZKA/Pay

Privacy-preserving agent payments. Noir transfer circuit verified on Aztec or any EVM chain.

Implemented

ZKA/Coord

Recursive coordination proofs via Goblin Plonk. Prove workflow chains without revealing intermediate steps.

Implemented

ZKA/Compute

Verifiable private computation without revealing models or methodology.

Future

ZKA/Attest

Anonymous credentials and selective disclosure via ZKC integration.

Future

ZKA/Reputation

Privacy-preserving reputation scores without transaction history exposure.

Future

Architecture Overview

NOIR CIRCUITS · ACIR ZKA/Pay Transfer ZKA/Coord Coordination Bridge Circuits compile PROVING BACKENDS Barretenberg UltraHonk Halo 2 (future) Groth16 (future) prove + verify VERIFICATION TARGETS Aztec L2 (native privacy) EVM Chains (Solidity verifier) Starknet / zkVerify / Cosmos

Write once in Noir. Compile to ACIR. Prove with any backend. Verify on any chain.

Primary target: Aztec L2 (native private composability via kernel circuits)

Getting Started

Read the Spec

Protocol design, Noir circuits, UltraHonk proofs, and multi-chain verification.

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. Verified on Aztec or any EVM chain.
  • Workflow Verification: Prove multi-agent task chains were executed correctly via recursive Noir proofs — without revealing methodology or intermediate data.
  • 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.
  • Cross-Chain Privacy: Bridge value between Ethereum, Namada, and Penumbra with privacy-preserving bridge circuits.