Skip to content
ForgeSynapse

London, UK

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

  1. 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.

  2. 02

    Environment

    Hardware, operating system and dependency tree at the moment of execution, with the timestamp verified against independent NTP sources.

  3. 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.

  4. 04

    Correctness

    The output was not altered after generation. Any change, however small, breaks the cryptographic link and is immediately detectable.

  5. 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

  1. 01

    Call intercepted

    Request and response are captured in flight, without touching the return value of your function.

  2. 02

    Five provers in parallel

    Identity, environment, confidentiality, correctness and governance are evaluated at the same time.

  3. 03

    Certificate signed

    ECDSA-384 signature in W3C Verifiable Credentials format — interoperable, no proprietary tooling required to read it.

  4. 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].message

The 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.

CommunityProfessionalEnterprise
PriceFree forever£500 / monthFrom £2,000 / month
Identity methodapi_declaredapi_declared + ledger anchoringtee_attested — Intel TDX / NVIDIA
Sessions per month500UnlimitedUnlimited
DashboardEnterprise dashboardEnterprise dashboard
Annex reportsAnnex IVAnnex IV + Annex VIIIAnnex IV + custom templates
GRC exportServiceNow, IBMServiceNow, IBM
SupportCommunity, on GitHubEmail, 48h SLADedicated, 4h SLA
LicenceApache-2.0CommercialCommercial + NDA
Ideal forDevelopers and small teams evaluating complianceTeams operating Annex III high-risk systemsOrganisations 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.

← Index