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.
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.
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.
Same jobs, different answers
built inpartial or optionalnot provided
| Job | GitHub | Hugging Face | Provena |
|---|---|---|---|
| Keep versions | commits; history can be rewritten | revisions; history can be rewritten or deleted | append-only Merkle log; rewriting leaves evidence |
| Say who did it | account name; signed commits optional | account name; signed commits optional | every entry signed; people, instruments, AI agents, institutions |
| Say when it existed | author-set commit time | author-set commit time | hub receipt, independent witnesses, RFC 3161 time-stamps |
| Keep it private | private repo, readable by the platform | private or gated repo, readable by the platform | encrypted on your machine; the hub never sees plaintext |
| Prove you had it before showing it | salted commitment now, reveal later | ||
| Show how a result was made | commit messages, CI logs | self-reported base model and card | signed inputs, program, environment and outputs for each step |
| Keep the failures | delete the branch | delete the repo | failed runs are entries; withdrawals keep the record that it existed |
| Share with one reviewer | add a collaborator to the whole repo | gated access to the whole repo | one file to one person, with the grant itself on the ledger |
| Verify without the platform | a proof bundle checks offline or in any browser | ||
| Run a leaderboard | Spaces; the organiser holds the test set and the scores | truth committed before the call, one timed submission per team, anyone can audit the rows | |
| Distribute to millions | CDN, dedup, one-line loading | not 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.
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 ids2 · 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 proofs3 · 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 grants4 · 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 entry5 · 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 planned6 · 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 leaderboards7 · 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 hashesAlso 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, JupyterWhy 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 replaceWork 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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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].