Governance

Check the record yourself.

Ecodia keeps a sealed record of how the company is instructed and run. The head of the record is logged hourly in a public transparency log nobody at Ecodia can edit, so a rewrite of anything older than the newest anchor is detectable by anyone with our public key.

The newest anchor

Read from the record and checked against the public log when this page was built, at the time shown below. When the copy we serve is an hour old, the next visit starts a rebuild and still receives that copy, so the figures here can be more than an hour old. A reload shortly after shows the rebuilt page.

Entry anchored
13,308
Signed statement
ecodia-governance-ledger/gl1 seq=13308 head=25464786854715b8186fbbb5cd3c57ec3d0bfd8f12b4a89e331962f85f77de61
SHA-256
f9da354acffe732cea9c9cd68dbbc71f9ad692d2407a76dffdf7153d3b21a494
Logged in Rekor
17 November 2026, 7:09 am AEST
Rekor entry
log index 3934894808
Anchors so far
170 since 10 November 2026

Checked against Rekor when this page was built: the digest it holds matches, the key is ours, and the signature verifies.

Page built 17 November 2026, 7:10 am AEST

The first anchor

Entry anchored
10,281
Signed statement
ecodia-governance-ledger/gl1 seq=10281 head=668fc66042c674d78873bb597efda29122d7a1bd17c9579ffb85b4823d222a4f
SHA-256
83d4d4990b830f5fb2e86d6775b7c89fab13d61a047a807c4fe4b9de7d6cceb6
Logged in Rekor
10 November 2026, 1:14 am AEST
Rekor entry
log index 3766587640

What the record holds

Each entry is the SHA-256 of an original plus a pointer to where it lives, never the content itself, and each carries the hash of the entry before it. The database refuses edits and deletions from every role except its owner, and the owner can switch that guard off, which is why the anchors exist.

Instructions from a person to EcodiaOS383
Relayed sessions, including iMessage1,239
Briefs for scheduled work2,447
Prompts to programmatic sessions685
Decisions by the gates that limit EcodiaOS5,581
Break-glass overrides of those gates145
Changes to the files that govern EcodiaOS445
Bank transactions, from imported exports2,184
Bank balances, from imported exports29
Anchors, each sealed into the record too170
The first entry1
Every entry, as this page was built13,309

How to check it

This uses the first anchor, logged 10 November 2026, 1:14 am AEST. For the newest, swap in its log index and statement from above. You need curl, jq and openssl.

  1. Download our public key and confirm its fingerprint is 7e5ced7564c19f861f101e5f57cd6d0731bc2cdb1d5175e460cd94f041f1d40f.
    openssl pkey -pubin -in anchor-key.pub.pem -outform DER | shasum -a 256
  2. List every anchor we have logged. Rekor answers from the key alone, with nothing from us.
    curl -s -X POST https://rekor.sigstore.dev/api/v1/index/retrieve \
      -H 'Content-Type: application/json' \
      -d "{\"publicKey\":{\"format\":\"x509\",\"content\":\"$(base64 < anchor-key.pub.pem | tr -d '\n')\"}}"
  3. Fetch one anchor and take out the digest and signature Rekor holds.
    curl -s "https://rekor.sigstore.dev/api/v1/log/entries?logIndex=3766587640" \
      | jq -r '.[].body' | base64 -d > body.json
    jq -r '.spec.data.hash.value' body.json
    jq -r '.spec.signature.content' body.json | base64 -d > sig.der
  4. Rebuild the statement and hash it. The result must equal the digest above, 83d4d4990b830f5fb2e86d6775b7c89fab13d61a047a807c4fe4b9de7d6cceb6.
    printf '%s' 'ecodia-governance-ledger/gl1 seq=10281 head=668fc66042c674d78873bb597efda29122d7a1bd17c9579ffb85b4823d222a4f' > statement.txt
    shasum -a 256 statement.txt
  5. Check the signature. It prints Verified OK, and a single changed character makes it fail.
    openssl dgst -sha256 -verify anchor-key.pub.pem -signature sig.der statement.txt

Walk the chain

The hash chain itself is published: for every entry, its number, its kind, the hash of the entry before it, and its own hash. Nothing else leaves the record, not even the content hash. Start at the index, which lists the files. Each file is read from the record at most an hour before you fetch it and says when. Keep a copy and you can compare any later download against it. You need curl, jq, awk and python3, run in the folder that holds the key from the steps above.

  1. Download every file and flatten the chain to one line per entry. It prints FAILED for any file that did not come down whole; run it again before going on.
    curl -sf https://ecodia.au/governance/chain.json > chain.json || echo "FAILED: index"
    jq -r '.segments[]' chain.json | while read -r u; do
      curl -sf "$u" | jq -er '.rows[] | @tsv' || echo "FAILED: $u" >&2
    done > chain.tsv
  2. Walk it. Each entry must follow the one before and carry that entry's hash, starting from 64 zeros. It stops at the first entry that breaks, or prints how many entries linked and the head. The count can differ from the index by the few entries sealed between the moments the two files were read.
    awk -F'\t' -v listed="$(jq .entries chain.json)" '
      $1 != NR || $3 != (NR == 1 ? sprintf("%064d", 0) : p) { bad = 1; print "BROKEN at entry " NR; exit 1 }
      { p = $4 }
      END { if (!bad) print NR " entries linked, head " p " (the index listed " listed ")" }' chain.tsv
  3. Collect the digest of every anchor Rekor holds under our key. This fetches each entry in turn and takes two to three minutes.
    curl -s -X POST https://rekor.sigstore.dev/api/v1/index/retrieve \
      -H 'Content-Type: application/json' \
      -d "{\"publicKey\":{\"format\":\"x509\",\"content\":\"$(base64 < anchor-key.pub.pem | tr -d '\n')\"}}" \
      | jq -r '.[]' | while read -r id; do
        curl -s "https://rekor.sigstore.dev/api/v1/log/entries/$id" \
          | jq -r '.[].body' | base64 -d | jq -r '.spec.data.hash.value'
      done > rekor.txt
  4. Check that every one of them is the signed statement for some entry of the chain. An anchor logged after the newest file was read can be missing until the next hour. An older one that is missing means the history under it was rewritten.
    python3 - <<'EOF'
    import hashlib
    chain = set()
    for line in open("chain.tsv"):
        seq, kind, prev, head = line.rstrip("\n").split("\t")
        statement = f"ecodia-governance-ledger/gl1 seq={seq} head={head}"
        chain.add(hashlib.sha256(statement.encode()).hexdigest())
    rekor = open("rekor.txt").read().split()
    missing = [d for d in rekor if d not in chain]
    print(f"{len(rekor) - len(missing)} of {len(rekor)} anchors re-derive from the chain")
    for d in missing:
        print("NOT IN THE CHAIN:", d)
    EOF

What this does not prove

  • It shows the record was not altered after sealing. It does not show the record is complete: something never sealed leaves no trace.
  • The chain is published without the rest of each entry. You can walk every link and confirm every anchor re-derives from it, but you cannot recompute an entry's own hash, because it also covers what we keep private: the content hash, where the original lives, its size, its review flags and its timestamps. Content hashes stay private because they could not be checked against the chain from what is public, and a short or predictable original, such as a bank payment, could be guessed and confirmed against one.
  • Entries newer than the newest anchor, up to about 90 minutes of them, are not yet protected, even though they appear in the published chain.
  • The signing key sits on a Mac that Ecodia runs, so whoever operates it can add anchors. Nobody can remove one from Rekor.
  • No one outside Ecodia reviews the record yet. Rekor holds the anchors, not the rows, and no second person holds the key.
  • Who wrote an entry is recorded by our own systems, not attested to a verified person.
  • Money enters the record only when a bank export is imported, so the newest bank entry can be weeks old. It is not a live link to the bank.
  • A check only bites if someone runs it.

Where this comes from

Rekor is the public transparency log run by the Sigstore project. The record is sealed every 30 minutes by our own governance-ledger job, which anchors at most once an hour. How Ecodia is governed, and how to raise a grievance, is on Governance.