deedlog

Open source, verifiable records

Every deed,
on the record

deedlog records what a system did in an append-only chain, and anchors it with independent witnesses and trusted timestamps. Deleted it, moved it, did only what it was meant to do: you can show it in a form anyone can check, without trusting the operator.

Talk to us View on GitHub

Currently v0.1. Expect breaking changes until v1.0.

Why deedlog, and why now

What leaks is what was left behind

Contact form submissions kept for years on a third-party service. An export left on a shared drive. Many recent breaches exposed data that no longer needed to be where it was. The defense is tiering: delete what is no longer needed, and move what must be kept to a safer place.

The evidence is held by the organization itself

Today the record that says "we deleted it" is kept by the organization that says so. It can edit the record, leave things out, or show different people different versions. To be believed, it needs a record it cannot change either.

Agents now do the work

AI agents and low-code automations act with real credentials: they read documents, send email, change records. A log that is meant to show an agent did only what it should is no evidence while it sits on the same systems the agent can reach.

How it works, in three minutes

Take a contact form whose submissions are deleted after they have been answered.

The operator'ssystems Chain andcheckpoints Anyonechecking Witnesses, time-stamping append events publish, verify cosign and attest time Anyone can check, without trusting the operator
  1. Record each deed as it happens

    Received, moved to the archive, deleted: each event appends one line to the chain. Every line holds the hash of the line before it, so changing one line in the middle breaks everything after it. A record holds only the hash of the evidence, never the text of the inquiry.

  2. Sign a checkpoint and have it witnessed

    The operator signs a value that sums up the whole chain (the root of a Merkle tree). That is a checkpoint. Independent witnesses check that it is consistent with the history they saw before and cosign it, and a time-stamping authority attests the time. Witnesses never see what the records contain.

  3. Anyone verifies, later

    With the chain, the checkpoint and the public keys, anyone can check it with dlog verify: offline, or in a browser. Declare "moved within 7 days, deleted after 3 years", and a deletion that should have happened and did not shows up as a gap in the record.

Rewrite it or leave something out, and it can be proved

An operator that keeps the record could rewrite history, or leave out an event it would rather not show. Instead of trusting the operator, deedlog makes sure this always comes to light.

No two histories for two audiences

A witness cosigns only a checkpoint that is consistent with the ones it saw before. deedlog follows the C2SP witness protocol, so any conforming witness works, including the public witness network, and anyone can run one.

A rewrite is proved by the signatures themselves

If the operator rewrites history, two contradicting checkpoints carry its own signature. Whoever holds the older one can prove the misbehavior with nothing but the operator's public key (dlog misbehavior). Witnesses need not be trusted: one copy kept anywhere in the world is enough.

Leaving a record out shows up against a receipt

People an event concerns can be given a receipt: the operator's signed promise that the event is recorded at a given position in the chain. If something else turns up at that position, the receipt and the checkpoint side by side prove it. A receipt travels as a link or a QR code and is checked entirely in the browser.

What can be proved is that this hash existed at this time and has not changed since. Whether what was recorded was true in the first place is something neither deedlog nor a blockchain can prove. Where it matters, have a party whose interests differ from the operator's, such as the service provider that did the deleting, sign what goes on the record.

Who runs a witness

These organizations cosign checkpoints from a position independent of the operator. A witness can be shared by many operators: once a chain's name and verification key are in its registry, the chain can be cosigned.

Anyone with an interest in a chain can run a witness. If your organization runs one and would like to be listed here, talk to us.

What goes on the record, and what does not

Not recorded

  • The evidence itself (a log line, a screenshot, an API response, the text of an inquiry)
  • Personal data. Bodies are stored apart and can be deleted without breaking the chain
  • Guessable identifiers. A ticket number goes in as a keyed hash (HMAC)

Recorded

  • The hash of the evidence (SHA-256 or HMAC-SHA-256) and its size
  • The kind of event, the time it was recorded, the name of the system that recorded it
  • The hash of the previous record, which is what makes it a chain

The chain is designed to be published. Publishing it reveals nothing of what the evidence contains.

Use cases

deedlog itself is domain-neutral. It is adopted by the party that wants to be trusted. Each use case comes with a sample you can run.

Data tiering and deletion

That data is moved and deleted on schedule, and that nothing outlives its tier. It backs up a retention policy, and what you say after a breach.

AI agents and automations

Every tool call an agent made, held against the tools it may use. Samples include an MCP proxy and Claude Code hooks.

Operator commitments

That an operator keeps its public promises, such as deletion and non-identification. It sits next to privacy policies and audits.

Data sharing and consent

On a municipal data platform, that consent preceded each provision of personal data. Between dataspace connectors, the contracts, transfers and policy enforcement.

Content and device data

Data signed by the device that produced it, the capture, editing and publication of media (C2PA), and official videos made only from registered footage.

Payments and proof of value

What was requested and delivered for each agent payment (x402). Reward vouchers settled without a customer database. The metering and verification behind carbon credits.

Each is described, with how to run it, under examples on GitHub. There is also a demo built into a site that publishes political funds, on fictitious data (in Japanese).

Compared with audit logs and blockchains

An audit log you keep yourselfA blockchaindeedlog
What prevents rewritingThe operator's controls and good faithConsensus among participantsA hash chain, the operator's signature, independent cosignatures
If it is rewritten laterNobody outside can tellIn practice it cannot beIt can be, and signed proof of it remains
Who can checkAuditors, and whoever is shown itThose who run a node or trust an explorerAnyone, offline or in a browser
Where time comes fromThe server's clockBlock timeRFC 3161 time-stamping authorities, accredited ones where needed
What is recordedThe log text, often with personal dataThe transaction. Once written it cannot be removedHashes only. Bodies are stored apart and can be deleted
What it takes to runA logging stack and storageNodes, consensus, usually a tokenOne file and the dlog command. No consensus, no token
Where the cost isStorage and auditsFees, or running nodesThe software is free (Apache-2.0). Accredited timestamps are charged per stamp

What it takes

By role: what each one holds and what each one runs.

The operator (the party that wants to be trusted)

  • Append one line to the chain from wherever events happen. A chain is a single JSON Lines file
  • Create an operator key, and on a schedule (say, hourly) sign a checkpoint and have it cosigned and timestamped
  • Publish the chain, the checkpoints and the public key, along with the rules you declare you keep (retention periods, inventory cadence)
  • Where it helps, give receipts to the people an event concerns

Whoever runs a witness

  • Register the operator's public key and run dlog witness. A witness never sees what records contain
  • All it keeps is a copy of the checkpoints it cosigned, a few hundred bytes each
  • An auditor, an industry body, a consumer organization, a competitor: anyone with an interest in the chain

Whoever checks

  • Verify the published chain and checkpoint with dlog verify. No registration and no permission
  • A person holding a receipt just opens the link. The check runs entirely in the browser
  • Hold the record against the declared rules, and point out where they were not kept

What the current version does

Now

  • The chain format and its verifier
  • Checkpoints in the C2SP format (Merkle tree), inclusion and consistency proofs, proofs of misbehavior
  • RFC 3161 timestamps and their verification
  • A witness client and server (c2sp.org/tlog-witness)
  • Receipts, links for QR codes, publication with dlog serve, a verification page in the browser
  • A runnable sample for each use case, including an MCP proxy and Claude Code hooks for AI agents

Next

  • Libraries for embedding in products, and a collector for other languages
  • An SD-JWT VC envelope for receipts (OpenID4VCI / OpenID4VP)
  • ML-DSA-44 cosignatures (post-quantum)
  • Renewal of timestamps for long-term retention
  • Declared scope and cadence, source signatures, references between chains
  • Exporters: OSCAL assessment results, a legal evidence bundle

For developers

go install github.com/eucassoc/deedlog/cmd/dlog@latest

dlog keygen -name example.com/log -out operator
dlog checkpoint -key operator.key chain.jsonl > checkpoint
dlog cosign -key operator.vkey -witness w1.vkey=https://w1.example -out checkpoint.cosigned chain.jsonl checkpoint
dlog timestamp -tsa https://timestamp.sectigo.com -out checkpoint.tsr checkpoint
dlog verify -checkpoint checkpoint.cosigned -key operator.vkey -witness w1.vkey -quorum 1 chain.jsonl
Install
go install github.com/eucassoc/deedlog/cmd/dlog@latest. Go 1.24 or later. No dependencies outside the standard library.
Chain format
JSON Lines. One line is one record, with seq, prev (the SHA-256 of the previous line's bytes), source, subject (the digest of the evidence) and meta. Digests are computed over the exact bytes of a line, so there is no JSON canonicalization to get wrong.
Checkpoints
A c2sp.org/tlog-checkpoint signed note. The operator signs with Ed25519, and witnesses cosign as c2sp.org/tlog-witness describes. Inclusion and consistency are proved with the Merkle tree.
Timestamps
Any RFC 3161 time-stamping authority works. One timestamp covers every record before it, so you stamp checkpoints, not records.
Receipts
A note signed with a key separate from the checkpoint key. dlog receipt issue / check, dlog prove, dlog serve. The verification page is static, and the receipt sits in the URL fragment, which browsers never send to a server.
What it cannot prove
That a source told the truth. A compromised host can record a lie. Ship records off the host as soon as they are written, have sources sign, and record from more than one vantage point. Against quantum computers, ML-DSA-44 cosignatures are planned.
Specifications
The chain, checkpoints and the trust model. For operations, see the guide.
License
Apache-2.0. GitHub.
Related
tsutome works out who must do what, and by when, from rules and a record; it reads and writes a deedlog chain. shinten keeps form input encrypted on every server, and kangoh runs a shared reward program without a customer database. They are sister projects built on the same principle: hold no more than you need.

Talk to us

Ask us about deciding what to record, fitting deedlog into the systems you have, and running witnesses and timestamps. The software is free to use. What costs money is help with design and integration.

What you send is used only to answer your enquiry, and is not stored on this site. See our privacy policy.