Imagine a workflow with fifty signed receipts. An auditor asks a simple question: can I trust this whole thing, and what am I allowed to do next based on it? Answering that by hand means opening fifty receipts, checking each signature, finding the weakest one, and reasoning about what the group as a whole supports. That does not scale, and it is exactly the kind of manual work that gets skipped under pressure.
R3Pv, short for Receipt Relay, Recovery, and Routing Proof Vectors, is the layer that does that reasoning for you and signs the result. It groups the receipts into one proof vector: a single, verifiable object that summarizes the group's proof-state so a person or another system can act on it directly.
What a proof vector reports
A proof vector is not just a bundle of receipts stapled together. It is a computed summary, and each field answers a specific question about the group:
- Verification depth. How far the verification actually goes for the group, so you can tell a lightly witnessed batch from a deeply checked one.
- Weakest proof boundary. The most cautious read of the whole group. A chain is only as strong as its weakest link, so if one step is self-attested, the vector says so rather than averaging it away.
- Policy state. Whether the group meets the rules that apply to it, carried alongside the evidence instead of reconstructed later.
- Healing state. Whether an event is still recoverable or has already settled, which matters most for actions like payments that can sometimes be stopped before they finalize.
- Permitted next actions. Given everything above, what the group actually allows: proceed, pause for review, require a stronger check, or escalate.
The vector itself is signed, so it is a verifiable object in its own right. Anyone with the public key can check it without replaying every underlying receipt by hand.
The weakest link sets the ceiling
The most important field is the weakest proof boundary, because it is where honesty lives. Say a group has forty-nine relay-observed steps and one self-attested step. The tempting move is to call the whole thing verified, because almost all of it is solid. R3Pv refuses that. It carries the single self-attested step forward as the ceiling for the group, so the summary reflects the weakest evidence, not the average.
From summary to decision
Because the vector reports how solid a group is, it can also gate what happens next. A high-value action might require a strong boundary before it proceeds. A weaker boundary might only be allowed to pause, get reviewed, or trigger a stronger check first. This is the same idea as proof-state, scaled from a single event up to a whole workflow. The gate reads the same cautious boundary anyone else could check, so the decision stays honest and independently verifiable.
That makes R3Pv a natural fit under a judgment layer like Carnac. When Carnac needs to know how solid a group of events is before it routes a decision, the proof vector gives it a single, signed answer to read instead of a pile of raw receipts.
What R3Pv does not do
Being clear about the limits is what keeps the summary trustworthy. R3Pv groups and reports proof-state honestly. It does not manufacture verification that the underlying receipts do not already have, and it cannot undo events that have already settled. It will not upgrade a self-attested step into a chain-verified one just because it sits next to stronger evidence. What it gives you is an accurate, signed summary of what the evidence actually supports, never a stronger claim than the receipts earn.
A single receipt answers "what happened here?" R3Pv answers the harder question: "across all of this, how solid is it, and what am I allowed to do next?" and signs the answer.
Why this matters for buyers
Grouping proof into one readable vector changes what teams can do with it:
- Faster investigation, because a reviewer reads one signed summary instead of replaying every receipt in a workflow.
- Safer automation, because a system can gate high-stakes actions on the weakest boundary of a group, not just the last event it saw.
- Honest reporting, because the group's proof-state is computed and signed, so a strong-looking record cannot quietly hide one soft step.
- Portable proof, because the vector travels as one object that any counterparty can verify offline.
R3Pv is one primitive in the wider Hive Canon. It builds on the signed receipts that Receipt Relay produces at explicit evidence tiers, and it turns them into a single proof-state a machine can act on. It fits the principle that runs through all of it: the proof is in the provenance, and a vector you can check is worth far more than a summary you are simply asked to trust.
Explore how R3Pv groups receipts, carries the weakest boundary forward, and reports verification depth, policy and healing state, and the next action it permits.