Skip to main content
Several methods are in use for building tamper-evident records of agentic payments. This page puts them side by side with reproducible bytes, not opinion. The reference is the AlgoVoi JCS (RFC 8785) substrate; the alternatives are compared by technique, no implementation named. Every number here is produced by a script you can run, and was last measured in a clean python:3.12-slim container. Full source and one-command reproduction: chopmob-cloud/substrate-comparisons.

​
At a glance

1,000,000

action references, zero collisions

880 / 880

byte-for-byte across 8 languages

96 / 96

independent implementations fail closed

~118k / s

action references, single core

​
The number that decides it: payments kept at scale

A payment identity built on a coarse timestamp collapses distinct payments into one, so the second payment looks like a retry and is silently dropped. An integer millisecond identity keeps them apart. These are counted from real hashes, not modelled. AlgoVoi integer-millisecond: 100% of payments kept. All 1,000 unique, zero collisions. Second-precision timestamp: 0.2% kept. 99.8% lost as silent collisions. At 100,000 payments over 100 seconds the gap widens to 99.9% lost versus 0.0%. Counted from real hashes, not modelled.

​
Cross-validation: the property a single implementation cannot show

A vector set is only trustworthy if independent implementations agree on it byte for byte. A single-implementation conformance set cannot demonstrate that, and it cannot show that independent implementations reject the same attack the same way. AlgoVoi substrate: 8 independent implementations agree, 880 of 880 byte for byte. Single-implementation vector set: 1 implementation, no independent agreement. Eight independent JCS implementations in eight languages, including the RFC 8785 author’s Java. 27 anchor sets, 213 vectors. And on the adversarial path, eight independent implementations all accept the valid control and reject each of the eleven isolated attacks identically: 96 of 96 fail-closed verdicts. A single implementation cannot reproduce that.

​
Where each method differs (by technique)

Every cell is decided by hashing a real record and reading the result. The reference holds every property; each alternative technique fails at least one.
TechniqueExactly-onceByte-reproducibleOffline-verifyAdversarial-safe
AlgoVoi JCS (RFC 8785) substrateyesyesyesyes
second-precision timestampnoyesyesyes
RFC 3339 string timestampyesnoyesyes
bare concatenationnoyesyesno
camelCase field namingyesnoyesyes
forward-id / operator-report bindingyesyesyesno
operator-attestation (no content-address)yesyesnoyes
amount as JSON number (float64)noyesyesyes
Two bindings sit on a separate axis: whether a later tamper or a silent policy change is detectable from the record alone. A content-addressed binding catches it; an operator-assigned id or a version label does not.
Binding techniqueChange detected from the record alone
content-addressed binding_ref (action swap)yes
forward-id / operator-report (action swap)no
content-addressed policy_bound_ref (silent policy rotation)yes
policy id/version label or operator attestationno

​
Measured throughput

In a clean container, on a single core, the substrate computes about 118,000 action references per second with zero collisions at one million, and the full policy_ref plus policy_bound_ref plus gate_ref chain at about 44,000 per second. Collision freedom is a property of the construction and is the same on any host; throughput is the host’s and scales with cores.

​
Run it yourself

git clone https://github.com/chopmob-cloud/substrate-comparisons
cd substrate-comparisons
pip install algovoi-substrate algovoi-policy-binding algovoi-compliance-gate-lite
python run_all.py            # every method demo, real bytes
Each demo prints its comparison and exits zero when the demonstrated property holds. The eight-language fail-closed run is in the conformance corpus at composition/adversarial_gauntlet/.