Neural VSA engine · agent mesh over AMQP

The mathematics of
meaning, on a bus.

zkprove is a neural VSA engine in Rust — holographic hypervectors, Hopfield memory, LSH ranking, SPLADE binding, ColQwen multi-vector search — with every agent speaking the same AMCP wire contract. Consensus, contracts, and constitutional AI all reduce to similarity checks.

10,000-dim holographic hypervectors
64 bytes neural hash of any bundle
9,600× validated compression ratio
AMCP every agent speaks the same bus
The engine

Six capabilities, one substrate

Everything is a hypervector. Everything is a similarity check. The capabilities compose because they share the same algebra.

VSA algebra

vsa.bind · vsa.bundle · vsa.unbind

10,000-dimensional hypervectors with the full holographic operations. Bundle a thousand vectors into one and every component stays recoverable — unbind to get any of them back. This is the substrate everything else is built on.

Hopfield associative memory

hopfield.create · store · recall · complete

Content-addressable memory over the same hypervector space. Store patterns, recall by noisy partial input, check membership, complete corrupted vectors. Hebbian dynamics at native speed.

SLIDE · LSH ranking

bitpack_rank · slide_forward

1-bit MinHash signatures compress any hypervector to a 64-byte neural hash. LSH buckets mean ranking scans only the hit buckets — millions of documents, milliseconds, single-threaded CPU.

SPLADE → VSA

encode_splade_to_vsa_enhanced

Sparse lexical expansion (30k vocab, term expansion like rainforest→jungle) projected and bound into dense bipolar hypervectors. Lexical precision with holographic compression.

Multi-vector late interaction

ColQwen2.5 · MaxSim

A ColQwen2.5 search agent runs as an AMCP service: multi-vector encoding for pages, screenshots, and PDFs, MaxSim scoring for real late-interaction retrieval over the message bus.

Integrity layer

watermarks · commitments · hash chains

Signed watermarks on model output, layer commitments over LSH parameters, neural hash chains where every link carries semantic meaning, and prompt-safety detection — all provable to third parties.

The wire

One envelope, every agent

AMCP is how the stack actually runs: a JSON envelope over AMQP, routed by capability, replies on your own exclusive queue. ZKPAgent on the BEAM, Python agents with models attached — all reachable the same way.

ZKPAgent

Elixir · zkp_exchange

The BEAM-side orchestrator. Consumes zkp.request, dispatches vsa.* / hopfield.* / neural_vsa.* methods into the NIF, replies with %{status: "ok", data: ...}. Supervised, concurrent, OTP.

zkp.requestreport.custody_head

Python agents

AMCP · amcp.direct_processing

ColQwen search, multi-vector compression, VLM, image generation, RTB decisioning — each declares a capability, consumes direct-exchange requests, replies via amcp.responses. Round-robin load balancing for free.

capability.vlmcapability.*

The bus

AMQP · AMCP envelope

One message contract over AMQP: JSON envelope with method, id, params — capability as the routing key, exclusive reply queues per request, progress events on amcp.progress.updates. That's the whole protocol.

amcp.responsescontent.addressed
amcp.direct_processing → amcp.responses
# request → amcp.direct_processing, routing key: capability.memory
{
  "method": "hopfield.create",
  "id": "cold-chain",
  "params": { "dimension": 10000, "capacity": 100, "beta": 1.0 }
}

# response → amcp.responses, bound to your exclusive reply queue
{ "status": "ok",
  "data": { "success": true,
            "results": { "memory_id": "mem_a1b2…" } } }

# same envelope, different capability — nothing new to learn
{ "method": "colqwen.search",
  "id": "query-7",
  "params": { "query": "pharma cold chain excursions", "top_k": 10 } }
Holographic BFT

Consensus is a similarity problem

The whitepaper result: bundle every vote into one hypervector and Byzantine detection becomes an unbind. No leader election, no O(N²) gossip, no honest supermajority assumption.

O(N) messages per round — PBFT needs O(N²)
0.39s finality for 100 generals (PBFT: 2.1s)
100% Byzantine detection, 0% false positives
10⁻⁸⁷ probability of forging a compliant vector
01

Holographic consensus

Every general binds their vote to their identity vector; the bundle of all votes is a single 40 KB hypervector. Unbind any identity to check their vote against the bundle — a forged vote lands near zero similarity and is caught instantly. No leader election, no quadratic gossip, deterministic finality.

02

Neural Deal Bundles

A supply contract and its IoT execution evidence — temperature logs, GPS, weight — both become hypervectors. Compliance is one similarity check: σ = ⟨𝒟, E⟩. In trial: 47/47 injected cold-chain violations caught, insurance trigger in 147 ms versus 14 days of manual process.

03

Oath Registry

AGI agents are constitutionally bound: capability ⊗ oath. Every transaction must clear the oath threshold before it executes. Against 50 adversarial jailbreak attempts — DAN mode, base64 smuggling, context overflow — 50/50 blocked, 0 legitimate queries harmed, 0.3 ms overhead.

Full treatment in the zkprove whitepaper — Holographic Byzantine Fault Tolerance — including the compression economics and adversarial bounds via Hoeffding's inequality.

Associative memory

Hopfield memory, over the bus

The memory system from the zkprove_ex test suite, exactly as it runs: four AMCP calls, one envelope. Watch the round trip.

ZKPAgent · zkp.request → reply queue
01 hopfield.create …
{ "dimension": 10000, "capacity": 100, "beta": 1.0 }
02 hopfield.store
03 hopfield.recall
04 hopfield.contains
Licensing

The gate is on compute, not proof

Value-bearing calls validate against your license (AMQP primary, HTTPS fallback, offline grace). The verify surface is deliberately ungated — a proof your counterparty can't check is just an assertion.

🔒

Licensed compute

Phone-home validated · value-bearing

  • flash_encode_text

    sub-ms n-gram → hypervector

  • bitpack_rank

    bucketed ranking, 64-byte hashes

  • encode_splade_to_vsa_enhanced

    sparse→dense binding

  • PromptSafetyDetector::new

    detector construction

  • watermark sign

    provenance signing

🔓

Free verification

Ungated · offline · forever

  • verify_commitment

    layer/LSH integrity

  • verify_signed_watermark

    attribution, across chains

  • verify_detection_proof

    safety verdicts, no KB exposed

The ZK selling point: your counterparties never need a license, an account, or a network connection to check your proofs.

Proof surface

Three proofs, zero knowledge required

Every proof verifies offline, against a compact object, with no license key. That's not generosity — it's the design. Provable claims travel; licensed compute stays home.

Detection proofs

A PromptSafetyDetector finding ships as a DetectionProof: the verdict, the matched pattern category, the confidence — verifiable by a third party without rerunning the detector or exposing your KB.

Signed watermarks

Model output is signed with an embedded watermark. verify_signed_watermark checks attribution across chains and copies — the signature proves origin without revealing the payload.

Neural commitments

verify_commitment pins a network layer's LSH parameters. If anyone re-trains, prunes, or swaps the layer, the commitment breaks. Provable integrity for distributed learning.

Bindings

One core, two native surfaces

The same Rust engine, linked into the BEAM as a NIF and shipped to Python as a wheel. No HTTP sidecar, no serialization tax.

Erlang / Elixir — zkprove_nif

  • Rustler NIF wired into zkprove_ex — ZKPAgent, ring VSA, detector pool
  • hopfield.*, vsa.*, neural_vsa.* all dispatch through process_request/1
  • Dirty-scheduler safe for the heavy encode paths
  • verify_* calls are pure: any BEAM app, zero licensing surface

Python — zkprove_py

  • PyO3 module, maturin wheel (libtorch path for neural encoders)
  • flash_encode_text, bitpack_rank, splade_to_vsa, Hopfield recall
  • Agents subclass AsyncSmartAgent and serve capabilities over AMCP
  • import zkprove_py as zk — that's the whole integration
Elixir
{:ok, mem} = ZKProve.ZKPAgent.process_request(%{
  "method" => "hopfield.create",
  "id" => "cold-chain",
  "params" => %{"dimension" => 10_000}
})
Python
import zkprove_py as zk

hv = zk.flash_encode_text("enc", text)
ranked = zk.bitpack_rank(q_bits, docs_bits)
ok = zk.verify_detection_proof(proof)
FAQ

Questions engineers actually ask

Put the engine behind your product

NIF for the BEAM, wheel for Python, proofs for everyone. Tell us your stack and we'll size a license.