Provena · v0.2.1 · Source available

GitHub for code.Hugging Face for models.Provena for verifiable science.

A ledger of experimental data and process, kept encrypted and backed by proof. Every dataset, protocol and analysis step becomes a signed entry in an append-only log. Anyone holding a proof bundle can check who recorded which unaltered data, in what order and no later than when, without having to trust us.

The gap

Papers publish results. The record behind them stays private.

Code has git history and models have model cards, but the data and steps behind an experiment usually live in lab notebooks, shared drives and memory. Reviewers, collaborators and now AI agents are asked to take that record on trust. Labs have good reasons to keep data private until publication. They have had no good way to prove what they have.

Was the plan written first?

Preregistration matters only if the hypothesis demonstrably came before the data. Today that is hard to show for a single lab's internal work.

Were bad runs dropped?

Selective reporting is invisible when nobody can see the full list of attempts, including the ones that failed.

Who did this step, a person or an AI?

As agents run analyses and design experiments, the record needs to say which model, which program and which inputs produced each result.

Where it comes from

GitHub, then Hugging Face, then a ledger for experiments

Each generation of hub was built around a new kind of artifact and the pain its users had with the previous tools. Code needed history and review. Models needed large files, cards and demos. Experiments need something neither platform was built to provide: a record that outsiders can trust without trusting the platform or the author.

2008 · CODE GitHub Artifact: source files Unit of record: a commit Trust: the platform + review History: rewritable (force-push) Platform sees: everything Pain it solved version history, branching, pull-request review, CI, one place to find code 2016 · MODELS & DATASETS Hugging Face Artifact: weights, datasets, demos Unit of record: repo revision + card Trust: the platform + community History: rewritable, deletable Platform sees: everything Pain it solved multi-GB files, model cards, one-line loading, gated access, hosted demos and leaderboards 2026 · EXPERIMENTS Provena Artifact: data + process + agents Unit of record: a signed entry Trust: the reader's own choice History: append-only, witnessed Platform sees: ciphertext only Pain it solves prove without revealing, plan before data, failures kept, instruments and agents as authors, verify offline, audit a leaderboard

Same jobs, different answers

built inpartial or optionalnot provided

JobGitHubHugging FaceProvena
Keep versionscommits; history can be rewrittenrevisions; history can be rewritten or deletedappend-only Merkle log; rewriting leaves evidence
Say who did itaccount name; signed commits optionalaccount name; signed commits optionalevery entry signed; people, instruments, AI agents, institutions
Say when it existedauthor-set commit timeauthor-set commit timehub receipt, independent witnesses, RFC 3161 time-stamps
Keep it privateprivate repo, readable by the platformprivate or gated repo, readable by the platformencrypted on your machine; the hub never sees plaintext
Prove you had it before showing itsalted commitment now, reveal later
Show how a result was madecommit messages, CI logsself-reported base model and cardsigned inputs, program, environment and outputs for each step
Keep the failuresdelete the branchdelete the repofailed runs are entries; withdrawals keep the record that it existed
Share with one revieweradd a collaborator to the whole repogated access to the whole repoone file to one person, with the grant itself on the ledger
Verify without the platforma proof bundle checks offline or in any browser
Run a leaderboardSpaces; the organiser holds the test set and the scorestruth committed before the call, one timed submission per team, anyone can audit the rows
Distribute to millionsCDN, dedup, one-line loadingnot the job; point entries at the HF revision, DOI or RRID instead

Provena is not a third hosting platform. Code stays on GitHub, models and datasets on Hugging Face or a repository, samples in their registries. Provena is the evidence layer underneath: the record that says what existed, who produced it, in what order and when, in a form anyone can check.

What science asks for

Seven things a model hub was never built to do

We asked the question from the bench, the clinic, the HPC centre, the statistics department, the tech-transfer office, the journal and the agent loop. The answers cluster into seven structural needs.

1 · The artifact is a sample plus a process plus data

A plasmid batch, a protocol version, an instrument run and a CSV belong together. A hub for files sees only the CSV.

Via integration: entries cite RRIDs, protocol DOIs, instrument ids

2 · Trust runs the other way

Users of a hub trust the hub. Reviewers, funders and competitors need to verify a result while trusting neither the platform nor the author.

Built in: transparency log, witnesses, offline proofs

3 · Secret now, provable later

Preregistered plans, unpublished data, patent-pending designs and blind-test submissions must stay private for a while, yet be provably dated.

Built in: commitments, encryption, per-file grants

4 · Completeness, not just availability

Integrity rests on what was not quietly removed. Negative results and withdrawn data need to leave a trace.

Built in: append-only log, failed runs recorded, redaction keeps the entry

5 · Governance and consent

Ethics approval, withdrawal of consent, export control and access audits are requirements, not features.

Partial: access grants on the ledger, crypto-shredding; organisation accounts planned

6 · Evaluation is prospective and wet

A scientific benchmark's truth is produced after the call or locked before it, and must demonstrably not have leaked.

Built in: blinded challenges with auditable leaderboards

7 · Three kinds of author

People, instruments and AI agents all produce records. Each needs its own key, and an agent's reasoning needs to be sealed and revealable.

Built in: agent types, sealed traces, model and program hashes

Also asked, deliberately not built

Petabyte storage, compute next to the data, workflow engines, electronic lab notebooks. These exist. Provena records their hashes rather than replacing them.

Integrations: DataLad, Nextflow, RO-Crate, Jupyter

Why previous attempts stalled

Research blockchains and provenance tools that asked scientists to change how they work did not survive. Capture has to wrap existing tools, and verification has to need no installation.

Design rule: wrap, do not replace
How it works

Work like git. Prove like a transparency log.

Provena is local-first. You record on your own machine, sync to a hub, and hand out proof bundles. The hub stores and orders entries but never sees your plaintext.

Your lab data · protocols · runs people · instruments AI agents Encrypt + sign on your machine salted commitments Ed25519 signatures Hub sequences ciphertext + hashes only Merkle log, signed receipts witnesses · time-stamps Proof bundle .pvb file, offline check terminal or browser no account needed
1

Record

provena plan commits to a protocol before the data exists. provena add and provena run register files and analysis steps, failed runs included, with their inputs and outputs linked.

2

Encrypt and sync

Content is encrypted on your machine under project keys shared only with members. The hub orders entries in a Merkle log and returns a signed receipt for each one, so withholding or rewriting history leaves evidence.

3

Prove and disclose

provena prove exports a bundle for exactly the results you choose. Share one file with one reviewer, reveal a protocol after the deadline, publish data, or withdraw it while the record that it existed stays.

What a proof establishes

Six facts anyone can check offline

Verification runs in the terminal or by dropping a bundle onto any hub's front page. The Python and in-browser verifiers are tested against each other on the same valid and tampered bundles.

Integrity

The content has not changed since it was recorded.

Authorship

Which key signed it: a person, an instrument or an AI agent, optionally backed by an institution's credential.

Time

It existed no later than a given moment, from the hub, independent witnesses and RFC 3161 time-stamps.

Order

A preregistered plan came before every result it governs.

Lineage

Which inputs, protocol, program and model produced a result, including data borrowed from other projects.

Completeness

The full set of entries at a point in time, so failed runs and withdrawn data cannot quietly disappear.

What it does not prove

That a measurement reflects reality. Provena proves the honesty of the record, not the truth of the experiment. Capture assurance raises that bar step by step. C0 and C1 work today. C4 exists as a facility attestation entry, though the verifier does not yet report a per-target capture level. C2 and C3 need hardware and are not started. The first pilot we recommend is an instrument capture daemon plus a facility co-signature.

C0 OperatorThe researcher registers the file.
C1 Capture daemonThe instrument's own key signs output as it lands.
C2 Hardware keyA non-exportable key in a TPM or secure element.
C3 Measured captureThe key is bound to the capture software and OS.
C4 Facility co-signA core facility attests it ran the measurement. Attestation entry exists; not yet reported by the verifier.

Trust is the reader's decision

A bundle is VALID when every signature and proof checks out. How much that is worth depends only on the logs, witnesses, time-stamp authorities and institutions the reader chooses to trust, never on what the bundle says about itself.

unverified→self-sequenced→log-sequenced→witnessed→anchored
Try it

Verify a real bundle in 30 seconds, nothing to install

This bundle comes from a public demo project on the trial hub: a binding assay whose protocol was committed before the plate was read, one deliberately failed analysis run that stayed on the record, and the fitted result (Kd = 4.17 nM). Checking it needs no account and sends nothing to a server.

1 · Downloaddemo.pvb (17 KB). A proof bundle is a plain file: signed entries, Merkle proofs, witness cosignatures.
2 · Drop it on the hub pageOpen the trial hub and drop the file on its front page. The check runs in your browser.
3 · Read the verdictExpect VALID (witnessed): the plan precedes every result, the failed run is there, contents match their commitments.
# the same check in a terminal (Python verifier)
pip install "provena-ledger[client]"
provena trust add witness pv1a3ejpunb26rszlgvdmhj62eusvbb2fe6c   # the trial witness; your call to trust it
provena verify demo.pvb --require witnessed

Browse the project itself on the hub: bafedf1b12960b5d…. Then make your own: the three-command walk-through is in the guide.

Built for the lab

From the bench, the notebook and the agent loop

One command line, one Python SDK, and the same ledger whether a step was run by hand, by an instrument or by an AI agent.

# preregister, record, prove
provena init --name binding-assay
provena plan protocol.md
provena add raw/plate1.csv
provena run --plan protocol.md \
  --used raw/plate1.csv --out results/ \
  -- python fit.py
provena push
provena prove results/kd.json -o kd.pvb
provena verify kd.pvb --require witnessed
from provena import sdk

proj = sdk.open("experiments/assay-42")
raw = proj.add("raw/plate1.csv")
with proj.run("fit binding curve",
              plan="protocol.md", used=[raw],
              model="anthropic/claude-opus-5-5",
              harness="agent.py") as run:
    run.trace(transcript)   # sealed, revealable later
    run.output("results/kd.json")

Instruments

provena capture watches an output folder and signs each finished file with the instrument's own key.

Notebooks

A Jupyter cell magic records a cell as a step, with its exact source sealed alongside the outputs. Failing cells are recorded too.

AI agents

Model id, a hash of the agent program and a sealed transcript travel with every step an agent runs.

Use cases

What researchers do with it

Preregistration that holds up

Commit to a protocol privately, run the study, then reveal the plan and let anyone verify it predates every result.

Reviewer access to one file

Grant a single reviewer a single dataset. The grant itself is an entry, so access leaves an audit trail.

Data sharing with consent

Publish data when ready, cite any entry in BibTeX, export an RO-Crate package. If consent is withdrawn, the content is destroyed and the record that it existed stays.

Blinded challenges (experimental)

Truth is committed before the call opens, teams submit sealed predictions in their own projects, and anyone can audit the leaderboard without a key. This is how we plan to run Spark Science challenges.

Replication on demand

provena rerun re-executes a recorded step from the decrypted inputs and records whether the outputs match. Sandboxing is opt-in: with --sandbox require the step runs with no network and no keys.

Self-hosted hubs

Run a hub for a lab or institute with SQLite or PostgreSQL and filesystem or S3 storage. Mirrors keep projects available, and disagreeing hubs are caught as fork evidence.

Design choices

Public-chain anchoring, open standards, no token

Anchored to public chains, no token

Each project is an RFC 9162 Merkle log with inclusion and consistency proofs, cosigned by witnesses and time-stamped under RFC 3161. Anchoring to public blockchains is planned. There is no coin, and nothing to buy to use it.

Client-side encryption

AES-256-GCM content encryption, X25519 key sealing, Ed25519 signatures and salted commitments. The hub holds ciphertext, hashes and signatures only.

Fits existing tooling

Entries follow W3C PROV, packages export as RO-Crate, identities can carry ORCID iDs, and the bundle format is a published spec.

449
automated tests; every feature independently reviewed, each finding fixed with a regression test
~1,800/s
entries sequenced on one hub, each with a new signed head
2
independent verifiers, Python and in-browser, cross-tested
0
plaintext bytes the hub ever sees
Status

v0.2.1 is out, and the source is on GitHub

The code is public under the Provena License: free to use, modify and build on, including commercially. Running a hub as a service for others above USD 1M a year needs a separate agreement, and very large products credit Provena. Research and teaching institutions, internal use, and the client, SDK, MCP server and verifiers are exempt; anyone can always run the verifiers. It is a source-available license, not an OSI open-source one.

AI agents write to it through an MCP server, a JSON command line or a Python SDK. Spark Research records every task and tool call automatically. A public trial hub runs with RFC 3161 time-stamps and an hourly external witness, and its pages check each ledger in your browser. An internal challenge with real data, three teams and an outside audit has run on it end to end.

# install from source
# PyPI: pip install "provena-ledger[client]"  (the bare "provena" package on PyPI is an unrelated project)
git clone https://github.com/jimmyag2026-prog/provena
cd provena && uv tool install ".[client,server]"
provena keygen && provena init --name my-study
# give an MCP-capable agent the ledger
provena --agent lab-agent mcp --project . --passphrase-file ~/.provena/lab-agent.pass

We are looking for challenge organisers, labs and core facilities to pilot it on real experiments. Email [email protected].