ForgeSynapse
VaultTrace
Cryptographic proof that your AI did what it says it did
A cryptographic notary for AI compute — persistent, verifiable and independent by design. For organisations that cannot afford to take AI claims at face value.
- v0.1.0
- Apache-2.0 core
- ECDSA-384
- W3C Verifiable Credentials
- EU AI Act Annex IV

The problem
The auditor cannot be the audited
Any AI system can claim it ran model X, on data Y, at time Z. Today nobody can prove it independently. The logs sit on the provider’s servers. The audit trail is controlled by the same entity being audited. The evidence is, by construction, self-serving.
That is not only a compliance problem, although the EU AI Act, the NIST AI RMF and sector frameworks are making it urgent. It is a structural trust problem: no AI provider can audit its own model without a conflict of interest, and legal responsibility falls on the organisation deploying the system, not on the model vendor.
When an AI decision approves a loan, flags a transaction, drafts a clause or triages a patient, the organisation has to demonstrate exactly what happened — with evidence that holds up in front of a regulator, an auditor or opposing counsel, years later.
What it is
A notary, not a logger
Not a logger
Logs are plain text on infrastructure that can be edited, deleted or subpoenaed. A log tells you what someone says happened. A certificate proves what did happen.
Not a monitor
Monitoring observes in real time and leaves nothing permanent. When the window closes the evidence is gone. A certificate survives the session, the system and the vendor.
Not a dashboard
Dashboards aggregate and visualise. VaultTrace does not replace your observability stack — it sits beside it and makes every recorded event independently auditable.
A cryptographic notary
It binds model identity, execution environment, input and output hashes and policy evaluation into one signed certificate, anchored in an append-only ledger.
The certificate
Five proofs per session
- 01
Identity
Which exact model ran. For local models, the SHA-256 of the weights — not “Llama 3” but the precise checkpoint. For cloud models, the API-declared version with timestamp.
- 02
Environment
Hardware, operating system and dependency tree at the moment of execution, with the timestamp verified against independent NTP sources.
- 03
Confidentiality
Inputs and outputs are stored only as SHA-256 hashes. Enough to prove what was processed, never enough to reconstruct it. Privacy by cryptographic construction.
- 04
Correctness
The output was not altered after generation. Any change, however small, breaks the cryptographic link and is immediately detectable.
- 05
Governance
Which policies were evaluated against the session and whether they passed. This is what turns a technical record into a compliance artefact.
How it works
From API call to signed proof, asynchronously
- 01
Call intercepted
Request and response are captured in flight, without touching the return value of your function.
- 02
Five provers in parallel
Identity, environment, confidentiality, correctness and governance are evaluated at the same time.
- 03
Certificate signed
ECDSA-384 signature in W3C Verifiable Credentials format — interoperable, no proprietary tooling required to read it.
- 04
Chained into the ledger
Each certificate is hash-chained to the previous one in an append-only ledger. Altering one breaks the chain, and the break is mathematically detectable.
Integration
One decorator
The decorator captures the model call, hashes inputs and outputs, evaluates the policy, signs the certificate and stores it — without changing the logic or the return value of the function.
from vaulttrace import audit
@audit(policy="contract_review_v2", retention_days=2555)
def review_contract(document: str) -> dict:
response = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": document}],
)
return response.choices[0].messageThe certification pipeline runs asynchronously, so it does not sit on your critical path.
Provider-agnostic
- ClaudeAnthropic API
- GPT / o-seriesOpenAI API
- GrokxAI API
- GeminiGoogle AI
- OllamaLocal models, weight hash captured
Tiers
The proof mechanism is identical at every level
Every tier generates the same certificate, with ECDSA-384 signing and W3C Verifiable Credentials format. What changes is how the identity of the model is established, and how much of the compliance work is automated for you. Professional is also available in USD and EUR.
| — | Community | Professional | Enterprise |
|---|---|---|---|
| Price | Free forever | £500 / month | From £2,000 / month |
| Identity method | api_declared | api_declared + ledger anchoring | tee_attested — Intel TDX / NVIDIA |
| Sessions per month | 500 | Unlimited | Unlimited |
| Dashboard | — | Enterprise dashboard | Enterprise dashboard |
| Annex reports | Annex IV | Annex IV + Annex VIII | Annex IV + custom templates |
| GRC export | — | ServiceNow, IBM | ServiceNow, IBM |
| Support | Community, on GitHub | Email, 48h SLA | Dedicated, 4h SLA |
| Licence | Apache-2.0 | Commercial | Commercial + NDA |
| Ideal for | Developers and small teams evaluating compliance | Teams operating Annex III high-risk systems | Organisations where a provider-declared model ID is not enough |
Who it is for
Where a failed audit is a matter of when, not if
Legal services
Firms using AI to review contracts or draft clauses must show human oversight on every case. VaultTrace creates an auditable chain of custody for each AI-assisted output.
Financial services
Credit decisions, investment recommendations and fraud detection have to be justified to a regulator years later, under frameworks such as SR 11-7, EBA guidelines or MiFID II.
Healthcare
Proof that plaintext was never stored. Only hashes are retained: sufficient for audit, insufficient for reconstruction.
High-risk AI under the EU AI Act
Annex III systems face mandatory logging, human oversight and technical documentation. The five proofs map directly onto those obligations.
Limitations
What VaultTrace does not do
A tool that sells verifiability has to be honest about its own boundaries. These are ours.
- It does not make your AI correct. It proves what ran, on what, and under which policies. Deciding whether that was the right thing to run remains yours.
- It automates the technical evidence for Annex IV, not the organisational documentation around it. No tool can generate your governance processes for you.
- On cloud models, identity means the model ID declared by the provider’s own API. No major provider exposes hardware-independent model verification today, and we would rather document that than imply otherwise. Identity that does not depend on the provider requires TEE hardware attestation — which is why it sits in the Enterprise tier and not in the free one.
- The free tier is capped at 500 sessions per month, enforced by the licence validator. We would rather you read that here than discover it in production.
- The SDK is Python-first. Other runtimes integrate through the CLI and the export format, not through a native decorator.
Start with the free tier, before you need the proof
The core is open source and available today. Install it, generate your first certificate, and verify the chain yourself before deciding whether it belongs in production.