The invitation on the wall — the cross-verification lattice begins
Sources cited in this piece · the thread, in order: our broadcast (15 November) · Andrii Sparysh's data point (16 November, 10:44 UTC) · our layer answer (13:59 UTC) · his correction and two commitments (15:03 UTC) · our acceptance (17 November, 00:59 +0800) · the family on the table: iqa.org/conformance/aicent-grant-ref/ · recorded in the lab mainline: candidates/aicent-grant-ref · the text itself: draft-li-rttp-iqa-addressing · Sister pillars: RTTP (rttp://, CRI 27) · IQA (iqa://, CRI 28)
Some collaborations are negotiated in private and announced later. This one happened the other way around: on an open IETF list, in five archived posts, between two parties who had never exchanged a private message. On 15 November we broadcast to the SCITT list that executable conformance material exists for the refusal vocabulary and lease semantics of draft-li-rttp-iqa-addressing-02 — the addressing document of the two-pillar work, where RTTP (rttp://) resolves where and when and IQA (iqa://) states whether. The next day, Andrii Sparysh — co-founder of Assault Consulting in Kyiv and the implementer of a verifier for COSE_Sign1 Signed Statements, chain heads of PALA-1 logs — answered with a data point. Two days and four posts later, the exchange had produced something neither side planned: two public commitments and one public acceptance. This piece records it, because what happened on that wall has a shape worth naming.
A data point, a correction, and a shared invariant
Sparysh opened not with praise but with a design contrast, from a working verifier: “We made the same choice as you for verdicts and the opposite one for refusals. The reasons may be useful.” His verdict set is closed — “a new verdict is a new format id” — and his refusal codes are open, add-only: “a release may add a code, never rename one or give it another meaning.” Two of his nineteen codes, he reported, were born from real defects found while writing the contract: “a statement followed by stray bytes was accepted (now trailing_bytes), and a statement signed with an Ed448 key verified under alg -8 (now key_type_mismatch).” And his one priority rule — “no code about what was signed is given before the signature verifies” — composes cleanly with the draft's own ordering, where no authorisation answer precedes frame acceptance. Our reply located the two vocabularies at different layers of the same design: his nineteen structural codes are the layer the draft deliberately leaves unnamed (Section 7.2, frame acceptance), while the closed five-value set governs Section 8, the authorisation layer — “the layer a consumer relies on, and the only layer our frozen conformance vectors test.” We offered a frozen cross-comparison — “each layer judged at its own altitude” — with no dates promised.
His second post is the one worth framing, because it does something rarer than agreeing: it corrects us, precisely, and in the direction our own draft already points. Our question had been whether his boundary was the reliance line — closed where a consumer relies, open where it does not. His answer: “Yes, with one correction to how I put it: the line is not reliance alone. Consumers do branch on our refusal codes, and our documentation tells them to. The line is the decision versus its reason.” The decision is closed: “accept or refuse for a statement, four verdicts for a log. A consumer gates on it, and a value it has never seen has no safe reading.” The reason is open: “refusal codes, violation codes, diagnosis patterns. A new member never changes the decision it explains.” He then turned our own residual against neither of us, but into common ground: “Your operation_not_permitted residual does the same work from the other side: it keeps the set fixed while letting new causes in.” Our acceptance said what the exchange had earned: “The correction is taken, and it is the sharper statement... The shared invariant is the one you wrote: a new member never changes the decision it explains.” Two closed sets, two residuals, one invariant — stated in public, by name, on the wall.
Two directions of verification
To see why his third move matters, place it beside the one that came before. In November a candidate arrived at the lab with a vector family derived from our draft — the draft's first outside anchor — and our response was to run their frozen vectors through a runner of our own writing, seal the record, and let the maintainer keep the two runs separately attributed. The same happened with the AAE candidate earlier: their vectors, our runner. Call this the first direction of verification: a third party anchors our text and builds on it; we verify what they built. It is the direction we have run twice.
His commitment is the opposite direction, and it has no precedent in our records: “We will run aicent-grant-ref independently: a Mode B recomputation written from sections 8.1 and 8.2 of -02 and the cases' inputs, without your checker, every case listed as match or diverge, with a log of every place the text reads two ways. We will file it in the lab as an independent record, by the end of November. If it is useful, aicent-lease-boundary and aicent-ae128-fail-closed after it.” Nobody has ever recomputed our vectors from the published text without our checker. Our own runs prove our family is internally consistent; his run, if it agrees, proves something stronger — that the expected answers are derivable from the draft's prose by someone who owes us nothing. And if a case diverges, that too is a finding worth having: either a vector carries an error, or the text reads two ways — and his log of every ambiguous reading is exactly the material a revision process needs. Both outcomes strengthen the record; that is what verification is for.
The invitation, on the record
Then came the part that makes this a lattice rather than a compliment. Sparysh committed, publicly, to publish his own refusal statements as pinned vectors: “the statements our tests refuse, at least one per code, will be published as pinned vectors in our next release, so that a second verifier of our construction can compare codes and not only accept or refuse. When they are out, you are welcome to run them.” That is an invitation, issued on an open list, addressed to whoever shows up with the discipline to accept it — and we answered on the same wall, in the same register: “we intend to take you up on the comparison: five values against nineteen codes, each layer judged at its own altitude.” The precondition is his, and we state it as he did: the vectors ship with his next release, and our intent carries no dates. What we did commit to, on the record, is how any of it will be read: “we will read it the way we read any independent record: case by case, against the frozen inputs.”
We added one request, and it is the request that keeps the whole lattice honest: “pin the revision you test against by its sha256, so the run stays checkable against the exact bytes it tested.” We pointed him at the draft by its bare series link — the address that always resolves to the latest revision — and left the pinning to him, because the pin's authority comes from being self-taken: whoever runs the bytes should be the one who freezes them. A record that names the revision it tested can be replayed byte for byte by anyone, forever, regardless of what the text does next. A record that does not is a story. The difference between the two is one sha256, taken at the right moment.
Gates, not promises
It is worth being precise about what this exchange is not. It is not an endorsement, and neither side asked for one. It is not a joint project; there is nothing to join. It is two parties discovering that they hold complementary halves of the same discipline — closed decisions, open reasons, frozen bytes, public records — and agreeing, in public, to run each other's material through their own gates. The gates are what make the agreement cheap to accept and expensive to fake: a recomputation that skips the digest gate scores nothing; a cross-comparison that does not name its runner, repository, and operator is not a record; a commitment without a date creates no obligation and invites none. Everything either side claimed is already in an archive; everything either side will claim has a named gate waiting for it.
One line: their vectors meet our runners; our vectors meet their checker; the same frozen bytes govern both directions — and a lattice that grows by public invitation, one archived post at a time, needs no trust to join: rttp resolves where & when; iqa states whether — and where the two agree, action begins.