Why signatures are not enough
Our bet is on evidence that survives time, movement and changing assumptions, so another system can assess a claim without depending on the application that created it.
On this page
A public ledger gives records a shared point of reference.
It can prove that something was anchored at a given time.
That matters. But it is not the same thing as proving that the thing anchored was true.
Anyone can post anything. Any system can emit a hash. Any actor can claim that an anchor settles a fact.
It does not.
An anchor can strengthen ordering. It can strengthen permanence. It can strengthen public visibility.
It cannot, on its own, establish who originated the claim, whether they were authorised, or whether the evidence supports it.
That is the missing layer.
The real question is not whether something was anchored. The real question is what structure sits behind the anchor, and whether that structure can still be checked later by another system, under different assumptions, without trusting the application that created it.
That is the boundary we design for.
An anchor proves that something was posted. It does not prove that the thing posted was true.
A signature needs context
This is where many systems stop too early.
They store a signature. Or they store a boolean that says verified: true. Or they keep the current state and assume that is enough.
It is not enough.
A signature without context is fragile. A verification result without preserved proof is weaker still.
What matters is not that verification succeeded once. What matters is whether another verifier can check the claim again later, outside the original system, with enough preserved context to understand what was actually being proven.
That means a signature is one part of the proof package. Its context defines what another verifier can establish.
Actor.
Key.
Algorithm.
Bound content.
Unique challenge or nonce.
Timestamp.
Authority context.
Evidence links.
Optional public anchor.
Without that, the system may remember that verification happened. It will not be able to explain why the claim should still be trusted.
Verification Result
Stored result — cannot re-verify independently
Proof Package
Select a layer to see what breaks without it
Nine layers of context for checking a claim again later.
Hover or tap any layer above to see what breaks when that element is missing.
A proof package preserves the context needed to repeat a verification, rather than only its recorded result.
Proof of origin requires context binding
A valid signature is still not enough if it is not bound to a specific action.
This is where unique challenges, nonces, or single-use context binding matter.
Without that binding, a valid proof from one context can be reattached to another. The bytes may still verify. The fact claim may still be false.
That is a serious failure.
Proof of origin means more than a valid signature. It binds a signing key, exact content, a specific action and its context, with an explicit basis for attributing that key to an actor.
Single-use binding and replay checks prevent a valid submission being accepted again in the wrong context.
Context binding
Without: None — reusable
With: Nonce bound — single use
Replay protection
Without: Vulnerable
With: Protected
Without context binding, a valid proof from one action can be reused against another.
Key custody changes what a signature proves
A system may say an actor signed something. That claim depends on who controlled the key.
An actor-held key supports attribution to that actor. A platform-held key establishes platform signing; attribution to a person depends on the authorisation records around it.
That is a meaningful difference.
Self-custody, delegated custody, institutional custody, and platform custody each require a different account of who controlled the key and who authorised its use.
This is not just a security detail. It is an attribution detail.
If the wrong custody assumption is hidden, the system may overstate what its signatures actually prove.
Self-custody
The actor controls the signing key. Linking the signature to that person still depends on the identity binding and key security.
The custody model determines what a signature says about the actor behind it.
Evidence is assembled by many actors
In multi-party work, one final signature does not explain the whole decision.
The record is built cumulatively. One actor submits. Another adds evidence. A reviewer verifies. An authority approves. A public network anchors ordering. A later actor may revoke, supersede, or countersign.
If the system only preserves the final state or final signature, the contributions behind that decision have been flattened.
That is why multi-actor proof chains matter. Not because every actor must sign everything. But because systems should preserve the structured chain of who asserted what, at what stage, under which proof conditions.
Full proof chain — claim history reconstructable from origin to anchor
Proof package detail — click any node to inspect
A claim can accumulate evidence and approvals. The record preserves who contributed each part and in what order.
Algorithm agility is part of proof survival
The distinction matters for long-lived records.
The problem is not merely whether a signature verified at the time. The problem is whether it can still be interpreted correctly later.
That requires preserved algorithm context. Which algorithm was used. Which key type. Which verification assumptions applied. Whether dual signatures existed. Whether the proof package can survive a world where preferred algorithms have changed.
We expect records to outlive applications, storage choices and preferred algorithms. That is why we design for explicit algorithm context and migration paths, including post-quantum signatures, from the outset.
Preserved context keeps the original proof interpretable. Migration, renewed attestations and evidence retention determine what remains verifiable as assumptions change.
At creation
Verified
After migration
Uncertain — context lost
Preserved algorithm context supports later checks and migration. It does not restore security to a compromised algorithm.
Large signatures should not force re-architecture
We design the proof envelope to accept larger signatures without rebuilding the surrounding record model.
The system should treat signatures and proof artefacts as variable-length, algorithm-agnostic payloads inside a proof package.
Do not hard-code assumptions around signature size.
Do not hard-code one algorithm.
Do not require every proof to fit inside one narrow
transport or storage primitive.
Instead: store proof packages as detached, content-addressed artefacts. Allow variable-length signature blobs. Support chunking or segmented transport where needed. Anchor only the manifest root, content hash, or Merkle root publicly. Keep the proof package self-describing with algorithm identifier, key type, content hash, signature payload, and context metadata. Make verification routing depend on metadata, not on one fixed cryptographic stack.
Allow dual-signature periods during migration. Treat proof as an envelope that can carry different algorithms over time.
Our starting point is a design that does not assume proof artefacts will remain small.
Larger proofs
Requires redesign
Signature size
Hard-coded
Dual signature
Not supported
Algorithm identifiers and variable-length proofs keep algorithm-specific assumptions out of the record format.
Proof has to survive boundaries
Most systems do not live in one place. They cross applications, storage layers, APIs, ledgers, downstream clients, and sometimes chains or trust domains.
If proof can only be verified inside the original system, its usefulness depends on that system remaining available and trusted.
A stronger design preserves portable proof packages that can survive those boundaries. Not because every part is public. Not because every system must use the same chain. But because the proof remains interpretable outside the original application.
That is the difference between local verification and portable evidence.
Proof depends on original system
Survives system removal
No
Independent verification
Not possible
Cross-boundary audit
Requires original system
Portable proof preserves the context for checks outside the system that created it.
Where this fits in the wider architecture
Authority needs proof that survives time. Workflow needs proof that survives state changes and collaboration. Containers need proof that survives movement. Replayability needs proof that survives system change.
The common requirement is preserved proof context.
Not the anchor. Not the signature. Not the verification result. The structured package behind all of them that lets another system, at another time, under different assumptions, still check whether the claim was valid.
That is the real frame.
The anchor records a commitment. The signature binds signed content to a key. The proof package preserves the context needed to assess the claim.
We are building around preserved origin, context, authority, evidence, algorithm information and ordering, in a form that travels across systems and time.
The aim is to let another party assess the recorded claim without having to inherit the original application's judgement.
Portable evidence is the foundation we are investing in.