Provenance.

Check our files yourself.

A dated fingerprint of the files we publish.

Proof, not promises.

Anyone can change a file on a website and say it was always that way. Our research papers, our data, our policies and the rules our AI agents follow are files too.

So each day we record a fingerprint of each public file we cover, a short code that changes if even one character does. We call the day's list a manifest. We ask Bitcoin’s public ledger, which no single company runs, to date-stamp that record. Once a week the founder signs it with a key that never leaves their device.

That lets anyone see whether a file is unchanged since the day we recorded it. It shows a file was not altered, not that what it says is true.

Check a file.

You don't have to take our word that a file hasn't changed. Run this.

Shell is for Mac and Linux, PowerShell for Windows. Python and Node need Python 3 or Node 18 installed first.

Paste into TerminalShow the command
( set -eu
  site=https://www.orbytlabs.ai
  github=https://raw.githubusercontent.com/orbytlabs-ai/ai-agent-research/main/provenance
  file=/research/agent-leadership-governance/agent-leadership-governance.pdf
  owner_keys='orbyt-owner namespaces="orbyt-provenance" ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBJMl7pELNGVsAUl/c1J2pe9uQ/VKmoHFZ8RzRTSRLumlI2jssJPoL4cPTbxXHKxQgYgGuG3HJqQVMscsCFD4lZA=
orbyt-owner namespaces="orbyt-provenance" ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIDel/a+TT40HU7lP6NUIbSysF/u+sOpQWRbGM7Z5SC5G'
  printf 'Drag the file here and press Return: '
  IFS= read -r given || given=
  given=$(printf '%s' "$given" | sed -e 's/^[[:space:]]*//' -e 's/[[:space:]]*$//')
  case "$given" in
    \'*\') given=$(printf '%s' "$given" | sed -e "s/^'//" -e "s/'\$//" -e "s/'\\\\''/'/g") ;;
    \"*\") given=$(printf '%s' "$given" | sed -e 's/^"//' -e 's/"$//') ;;
    *) given=$(printf '%s' "$given" | sed -e 's/\\\(.\)/\1/g') ;;
  esac
  if [ -n "$given" ]; then
    [ -f "$given" ] && [ -r "$given" ] || { echo "NOT FOUND: there is no file at $given"; exit 1; }
    hash=$(shasum -a 256 < "$given" | cut -d' ' -f1)
  fi
  mkdir -p orbyt-provenance && cd orbyt-provenance
  get() { curl -fsS "$1" -o "$2" || { echo "CANNOT FETCH: $1"; exit 1; }; }
  day='^[0-9]{4}-[0-9]{2}-[0-9]{2}$'
  get "$site/provenance/index.json" index.json
  latest=$(jq -r --arg re "$day" '.latest // empty | select(test($re))' index.json)
  [ -n "$latest" ] || { echo "NOT RECORDED YET: no manifest has been recorded yet, so there is nothing to check against."; exit 1; }
  if [ -z "$given" ]; then
    echo "SITE COPY: no file given, so this checks the site's copy of $file"
    get "$site$file" site-copy.bin
    hash=$(shasum -a 256 < site-copy.bin | cut -d' ' -f1)
  fi
  check() {
    get "$site/provenance/manifests/$1.json" "manifest-$1.json"
    jq -cSj 'del(.manifest_sha256)' "manifest-$1.json" > "manifest-$1.body" || { echo "BAD MANIFEST: the $1 manifest is not valid JSON"; exit 1; }
    mh=$(shasum -a 256 < "manifest-$1.body" | cut -d' ' -f1)
    [ "$mh" = "$(jq -r .manifest_sha256 "manifest-$1.json")" ] || { echo "BAD MANIFEST: the $1 manifest does not hash to its own manifest_sha256"; exit 1; }
  }
  check "$latest"
  if [ -n "$given" ]; then
    rec=$(jq -r --arg h "$hash" '[.artifacts[] | select(.sha256 == $h) | .path][0] // empty' "manifest-$latest.json")
  else
    rec=$(jq -r --arg p "public$file" --arg h "$hash" '[.artifacts[] | select(.path == $p and .sha256 == $h) | .path][0] // empty' "manifest-$latest.json")
  fi
  [ -n "$rec" ] || { echo "NO MATCH: this file is not one we recorded in the $latest manifest"; exit 1; }
  first=$(jq -r --arg p "$rec" --arg re "$day" '[.latest_artifacts[] | select(.path == $p) | .first_recorded][0] // empty | select(test($re))' index.json)
  days=$(jq -rn --arg a "${first:-$latest}" --arg b "$latest" 'if $a <= $b then range(($a + "T00:00:00Z" | fromdate); ($b + "T00:00:00Z" | fromdate) + 1; 86400) | strftime("%Y-%m-%d") else $b end')
  : > days.txt
  for d in $(printf '%s\n' "$days"); do
    check "$d"
    jq -e --arg p "$rec" --arg h "$hash" 'any(.artifacts[]; .path == $p and .sha256 == $h)' "manifest-$d.json" > /dev/null || { echo "CHANGED: the $d manifest does not record these bytes for ${rec#public}"; exit 1; }
    echo "$d $mh" >> days.txt
  done
  d0=$(head -n 1 days.txt | cut -d' ' -f1)
  h0=$(head -n 1 days.txt | cut -d' ' -f2)
  cp "manifest-$d0.body" manifest.body
  echo "MANIFEST: the $d0 manifest hashes to $h0"
  if curl -fsS "$site/provenance/stamps/$d0.ots" -o stamp.ots 2> /dev/null; then
    echo "STAMP: the $d0 manifest has a timestamp proof, saved as orbyt-provenance/stamp.ots"
  else
    rm -f stamp.ots
    echo "NO STAMP: the $d0 manifest has no timestamp proof yet"
  fi
  printf '%s\n' "$owner_keys" > owner.allowed_signers
  weeks=$(jq -r --arg a "$d0" --arg re "$day" '.seals[].week_ending | select(test($re) and . >= $a)' index.json)
  if [ "$(jq '.seals | length' index.json)" = 0 ]; then
    echo "NO SEAL YET: the owner has not signed a weekly seal yet"
  else
    sealed=
    for w in $(printf '%s\n' "$weeks"); do
      get "$site/provenance/seals/$w.json" "seal-$w.json"
      get "$site/provenance/seals/$w.json.sig" "seal-$w.json.sig"
      said=$(ssh-keygen -Y verify -f owner.allowed_signers -I orbyt-owner -n orbyt-provenance -s "seal-$w.json.sig" < "seal-$w.json" 2>&1) || { echo "BAD SEAL: the seal for the week ending $w does not verify against the owner key in this command"; exit 1; }
      jq -r '.manifests[] | "\(.date) \(.manifest_sha256)"' "seal-$w.json" > "seal-$w.days"
      bad=$(awk 'NR == FNR { h[$1] = $2; next } ($1 in h) && (h[$1] < $2 || h[$1] > $2) { print $1; exit }' days.txt "seal-$w.days")
      [ -z "$bad" ] || { echo "REWRITTEN: the seal for the week ending $w names a different $bad manifest"; exit 1; }
      if grep -qx "$d0 $h0" "seal-$w.days"; then sealed=$w; key=$(printf '%s' "$said" | sed -n 's/.* key \(SHA256:[^ ]*\).*/\1/p'); fi
    done
    if [ -n "$sealed" ]; then
      echo "SEALED: the owner's seal for the week ending $sealed names the $d0 manifest, signed by key $key"
    else
      echo "NOT YET SEALED: no seal names the $d0 manifest yet"
    fi
  fi
  missing=
  list=owner.allowed_signers
  for d in $(printf '%s\n' "$days"); do list="$list manifest-$d.json"; done
  for w in $(printf '%s\n' "$weeks"); do list="$list seal-$w.json seal-$w.json.sig"; done
  for f in $(printf '%s\n' "$list"); do
    case "$f" in manifest-*) g="manifests/${f#manifest-}" ;; seal-*) g="seals/${f#seal-}" ;; *) g="$f" ;; esac
    code=$(curl -sS -o "github-copy" -w '%{http_code}' "$github/$g" 2> /dev/null || true)
    case "$code" in
      200) cmp -s github-copy "$f" || { echo "GITHUB DIFFERS: the GitHub copy of $g is not what this command or this site holds"; exit 1; } ;;
      *) missing="${missing:-$g}" ;;
    esac
  done
  rm -f github-copy
  if [ -n "$missing" ]; then
    echo "NOT ON GITHUB YET: the GitHub copy of $missing could not be read, so not everything was compared"
  else
    echo "GITHUB: the GitHub copies of the owner key, the manifests and the seals are the same files"
  fi
  echo "MATCH: ${rec#public} has the bytes first recorded on $d0, unchanged through $latest, sha256 $hash"
)

Download verify.ps1, then run it in the folder you saved it to:

Run
powershell -ExecutionPolicy Bypass -File verify.ps1
verify.ps1Show the script
# Check a file against the Orbyt Labs provenance record.
# https://www.orbytlabs.ai/provenance
# Windows PowerShell 5.1 or PowerShell 7, nothing to install. The weekly seal is checked with ssh-keygen.
# It only reads from the site and from GitHub, and writes what it downloads to .\orbyt-provenance.
# Usage: powershell -ExecutionPolicy Bypass -File verify.ps1 [file]   (with no file it asks; press Return to check the site's copy)
$ErrorActionPreference = "Stop"
$ProgressPreference = "SilentlyContinue"

$SITE = "https://www.orbytlabs.ai"
$GITHUB = "https://raw.githubusercontent.com/orbytlabs-ai/ai-agent-research/main/provenance"
$FILE = "/research/agent-leadership-governance/agent-leadership-governance.pdf"
$OUT = "orbyt-provenance"
$OWNER_KEYS = @(
    'orbyt-owner namespaces="orbyt-provenance" ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBJMl7pELNGVsAUl/c1J2pe9uQ/VKmoHFZ8RzRTSRLumlI2jssJPoL4cPTbxXHKxQgYgGuG3HJqQVMscsCFD4lZA='
    'orbyt-owner namespaces="orbyt-provenance" ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIDel/a+TT40HU7lP6NUIbSysF/u+sOpQWRbGM7Z5SC5G'
)
$DAY_RE = '^\d{4}-\d{2}-\d{2}$'
$HERE = (Get-Location).ProviderPath
$OUT_DIR = Join-Path $HERE $OUT
$INVARIANT = [Globalization.CultureInfo]::InvariantCulture
if ($PSVersionTable.PSVersion.Major -lt 6) {
    # Windows PowerShell 5.1 can default to old TLS versions; the site and GitHub need 1.2.
    [Net.ServicePointManager]::SecurityProtocol = [Net.ServicePointManager]::SecurityProtocol -bor [Net.SecurityProtocolType]::Tls12
}

function say([string]$message) {
    [Console]::Out.WriteLine($message)
}

function stop([string]$message) {
    say $message
    exit 1
}

function fetch([string]$url) {
    try {
        $response = Invoke-WebRequest -Uri $url -UseBasicParsing -TimeoutSec 60 -ErrorAction Stop
        return @([int]$response.StatusCode, $response.RawContentStream.ToArray())
    } catch {
        return @(0, [byte[]]@())
    }
}

function get([string]$url) {
    $response = fetch $url
    if ($response[0] -ne 200) { stop "CANNOT FETCH: $url" }
    return ,$response[1]
}

function save([string]$name, [byte[]]$data) {
    [IO.File]::WriteAllBytes((Join-Path $OUT_DIR $name), $data)
}

function sha256([byte[]]$data) {
    $hasher = [Security.Cryptography.SHA256]::Create()
    try { $hash = $hasher.ComputeHash($data) } finally { $hasher.Dispose() }
    return ([BitConverter]::ToString($hash) -replace "-", "").ToLowerInvariant()
}

function utf8([string]$text) {
    return ,([Text.Encoding]::UTF8.GetBytes($text))
}

function given_path([string]$text) {
    $text = $text.Trim()
    if ($text.Length -ge 2 -and $text[0] -eq [char]"'" -and $text[-1] -eq [char]"'") {
        return $text.Substring(1, $text.Length-2).Replace("'\''", "'")
    }
    if ($text.Length -ge 2 -and $text[0] -eq [char]'"' -and $text[-1] -eq [char]'"') {
        return $text.Substring(1, $text.Length-2)
    }
    if ([Environment]::OSVersion.Platform -eq [PlatformID]::Win32NT) { return $text }
    return [regex]::Replace($text, '\\(.)', '$1')
}

# Strings compare as Python compares them: both strings, byte for byte, case kept.
function same($a, $b) {
    return ($a -is [string]) -and ($b -is [string]) -and [string]::Equals([string]$a, [string]$b)
}

function is_day($value) {
    return ($value -is [string]) -and [regex]::IsMatch($value, $DAY_RE)
}

# JSON, read the way Python's json module reads it: an object is a dictionary with exact keys,
# an array a list, a number keeps the text Python would write back for it.
$TOKEN = [regex]'\G[ \t\n\r]*(?:("(?:[^"\\\x00-\x1f]|\\["\\/bfnrt]|\\u[0-9a-fA-F]{4})*")|(-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][-+]?[0-9]+)?)|([{}\[\]:,])|(true|false|null|NaN|Infinity|-Infinity))'
$ESCAPE = [regex]'\\(?:u([0-9a-fA-F]{4})|(.))'
$UNESCAPE = [Text.RegularExpressions.MatchEvaluator]{
    param($m)
    if ($m.Groups[1].Success) { return [string][char][Convert]::ToInt32($m.Groups[1].Value, 16) }
    switch -CaseSensitive ($m.Groups[2].Value) {
        "b" { return [string][char]8 }
        "f" { return [string][char]12 }
        "n" { return "`n" }
        "r" { return "`r" }
        "t" { return "`t" }
    }
    return $m.Groups[2].Value
}
$STRICT_UTF8 = New-Object Text.UTF8Encoding($false, $true)

function new_object {
    return ,([Collections.Generic.Dictionary[string, object]]::new([StringComparer]::Ordinal))
}

function new_list {
    return ,([Collections.Generic.List[object]]::new())
}

function number_text([string]$text) {
    if ($text -match '^-?[0-9]+$') {
        if ($text -eq "-0") { return "0" }
        return $text
    }
    try {
        $value = [double]::Parse($text, $INVARIANT)
    } catch {
        # Windows PowerShell 5.1 refuses a number too large for a double; Python reads it as infinity.
        if ($text.StartsWith("-")) { $value = [double]::NegativeInfinity } else { $value = [double]::PositiveInfinity }
    }
    return (float_text $value)
}

# A float as Python's repr writes it: the shortest digits that read back, then fixed or exponent form.
function float_text([double]$value) {
    if ([double]::IsNaN($value)) { return "NaN" }
    if ([double]::IsPositiveInfinity($value)) { return "Infinity" }
    if ([double]::IsNegativeInfinity($value)) { return "-Infinity" }
    $sign = ""
    if ([BitConverter]::DoubleToInt64Bits($value) -lt 0) { $sign = "-" }
    $magnitude = [Math]::Abs($value)
    if ($magnitude -eq 0) { return $sign + "0.0" }
    for ($places = 0; $places -le 16; $places++) {
        $written = $magnitude.ToString("E" + $places, $INVARIANT)
        if ([double]::Parse($written, $INVARIANT) -eq $magnitude) { break }
    }
    $parts = $written.Split([char]"E")
    $digits = $parts[0].Replace(".", "").TrimEnd([char]"0")
    $exponent = [int]::Parse($parts[1], $INVARIANT)
    $point = $exponent + 1
    if ($point -gt -4 -and $point -le 16) {
        if ($point -le 0) { return $sign + "0." + ("0" * (-$point)) + $digits }
        if ($point -ge $digits.Length) { return $sign + $digits.PadRight($point, [char]"0") + ".0" }
        return $sign + $digits.Substring(0, $point) + "." + $digits.Substring($point)
    }
    $mantissa = $digits.Substring(0, 1)
    if ($digits.Length -gt 1) { $mantissa += "." + $digits.Substring(1) }
    $exponentSign = "+"
    if ($exponent -lt 0) { $exponentSign = "-" }
    return $sign + $mantissa + "e" + $exponentSign + ([Math]::Abs($exponent)).ToString("00", $INVARIANT)
}

function parse_json([byte[]]$bytes) {
    $text = $STRICT_UTF8.GetString($bytes)
    if ($text.Length -gt 0 -and $text[0] -eq [char]0xFEFF) { $text = $text.Substring(1) }
    $script:kinds = [Collections.Generic.List[int]]::new()
    $script:texts = [Collections.Generic.List[string]]::new()
    $end = 0
    foreach ($m in $TOKEN.Matches($text)) {
        for ($group = 1; $group -le 4; $group++) {
            if ($m.Groups[$group].Success) {
                $script:kinds.Add($group)
                $script:texts.Add($m.Groups[$group].Value)
                break
            }
        }
        $end = $m.Index + $m.Length
    }
    if (-not [regex]::IsMatch($text.Substring($end), '^[ \t\n\r]*$')) { throw "not valid JSON" }
    $script:at = 0
    $value = parse_value
    if ($script:at -ne $script:kinds.Count) { throw "not valid JSON" }
    return ,$value
}

function next_token {
    if ($script:at -ge $script:kinds.Count) { throw "not valid JSON" }
    $taken = $script:at
    $script:at++
    return @($script:kinds[$taken], $script:texts[$taken])
}

function parse_value {
    $next = next_token
    $kind = $next[0]
    $text = $next[1]
    if ($kind -eq 1) {
        $inner = $text.Substring(1, $text.Length-2)
        if ($inner.IndexOf([char]"\") -lt 0) { return $inner }
        return $ESCAPE.Replace($inner, $UNESCAPE)
    }
    if ($kind -eq 2) { return @{ json = (number_text $text) } }
    if ($kind -eq 4) {
        if ($text -ceq "true") { return $true }
        if ($text -ceq "false") { return $false }
        if ($text -ceq "null") { return $null }
        if ($text -ceq "NaN") { return @{ json = "NaN" } }
        if ($text -ceq "Infinity") { return @{ json = "Infinity" } }
        return @{ json = "-Infinity" }
    }
    if ($text -ceq "{") {
        $object = new_object
        if ($script:at -lt $script:kinds.Count -and $script:texts[$script:at] -ceq "}" -and $script:kinds[$script:at] -eq 3) {
            $script:at++
            return ,$object
        }
        while ($true) {
            $key = next_token
            if ($key[0] -ne 1) { throw "not valid JSON" }
            $script:at--
            $name = parse_value
            $colon = next_token
            if (-not ($colon[0] -eq 3 -and $colon[1] -ceq ":")) { throw "not valid JSON" }
            $object[$name] = parse_value
            $after = next_token
            if ($after[0] -eq 3 -and $after[1] -ceq ",") { continue }
            if ($after[0] -eq 3 -and $after[1] -ceq "}") { return ,$object }
            throw "not valid JSON"
        }
    }
    if ($text -ceq "[") {
        $list = new_list
        if ($script:at -lt $script:kinds.Count -and $script:texts[$script:at] -ceq "]" -and $script:kinds[$script:at] -eq 3) {
            $script:at++
            return ,$list
        }
        while ($true) {
            $list.Add((parse_value))
            $after = next_token
            if ($after[0] -eq 3 -and $after[1] -ceq ",") { continue }
            if ($after[0] -eq 3 -and $after[1] -ceq "]") { return ,$list }
            throw "not valid JSON"
        }
    }
    throw "not valid JSON"
}

# The bytes Python's json.dumps(sort_keys=True, separators=(",", ":")) writes: keys sorted,
# no spaces, each character outside printable ASCII written as \uXXXX.
function canonical($value, [string]$skip) {
    $sb = New-Object Text.StringBuilder
    write_json $sb $value $skip
    return $sb.ToString()
}

function write_json([Text.StringBuilder]$sb, $value, [string]$skip) {
    if ($null -eq $value) { [void]$sb.Append("null"); return }
    if ($value -is [bool]) {
        if ($value) { [void]$sb.Append("true") } else { [void]$sb.Append("false") }
        return
    }
    if ($value -is [string]) { write_string $sb $value; return }
    if ($value -is [hashtable]) { [void]$sb.Append($value.json); return }
    if ($value -is [Collections.Generic.List[object]]) {
        [void]$sb.Append("[")
        for ($i = 0; $i -lt $value.Count; $i++) {
            if ($i -gt 0) { [void]$sb.Append(",") }
            write_json $sb $value[$i] ""
        }
        [void]$sb.Append("]")
        return
    }
    $keys = [string[]]@($value.Keys | Where-Object { -not ($skip -and $_ -ceq $skip) })
    [Array]::Sort($keys, [StringComparer]::Ordinal)
    [void]$sb.Append("{")
    for ($i = 0; $i -lt $keys.Count; $i++) {
        if ($i -gt 0) { [void]$sb.Append(",") }
        write_string $sb $keys[$i]
        [void]$sb.Append(":")
        write_json $sb $value[$keys[$i]] ""
    }
    [void]$sb.Append("}")
}

function write_string([Text.StringBuilder]$sb, [string]$text) {
    [void]$sb.Append('"')
    if ([regex]::IsMatch($text, '^[\x20\x21\x23-\x5b\x5d-\x7e]*$')) {
        [void]$sb.Append($text)
    } else {
        foreach ($c in $text.ToCharArray()) {
            $n = [int]$c
            if ($n -eq 34) { [void]$sb.Append('\"') }
            elseif ($n -eq 92) { [void]$sb.Append('\\') }
            elseif ($n -ge 32 -and $n -le 126) { [void]$sb.Append($c) }
            elseif ($n -eq 8) { [void]$sb.Append('\b') }
            elseif ($n -eq 12) { [void]$sb.Append('\f') }
            elseif ($n -eq 10) { [void]$sb.Append('\n') }
            elseif ($n -eq 13) { [void]$sb.Append('\r') }
            elseif ($n -eq 9) { [void]$sb.Append('\t') }
            else { [void]$sb.Append('\u' + $n.ToString("x4", $INVARIANT)) }
        }
    }
    [void]$sb.Append('"')
}

function field($object, [string]$name) {
    if ($object -is [Collections.Generic.Dictionary[string, object]] -and $object.ContainsKey($name)) { return ,($object[$name]) }
    return $null
}

function items($object, [string]$name) {
    $value = field $object $name
    if ($value -is [Collections.Generic.List[object]]) { return ,$value }
    return ,(new_list)
}

if ($args.Count -gt 0) {
    $given = [string]$args[0]
} else {
    [Console]::Out.Write("Drag the file here and press Return: ")
    $line = [Console]::In.ReadLine()
    if ($null -eq $line) { $given = "" } else { $given = given_path $line }
}
$data = $null
if ($given) {
    $full = $null
    try { $full = [IO.Path]::Combine($HERE, $given) } catch { }
    if ($null -eq $full -or -not [IO.File]::Exists($full)) { stop "NOT FOUND: there is no file at $given" }
    $data = [IO.File]::ReadAllBytes($full)
}

[void][IO.Directory]::CreateDirectory($OUT_DIR)
$raw = get "$SITE/provenance/index.json"
save "index.json" $raw
try {
    $index = parse_json $raw
} catch {
    stop "CANNOT FETCH: the site's index is not valid JSON"
}
$latest = field $index "latest"
if (-not (is_day $latest)) { stop "NOT RECORDED YET: no manifest has been recorded yet, so there is nothing to check against." }
if ($null -eq $data) {
    say "SITE COPY: no file given, so this checks the site's copy of $FILE"
    $data = get ($SITE + $FILE)
}
$digest = sha256 $data

$manifests = [Collections.Generic.Dictionary[string, object]]::new([StringComparer]::Ordinal)

function check([string]$date) {
    $raw = get "$SITE/provenance/manifests/$date.json"
    save "manifest-$date.json" $raw
    try {
        $manifest = parse_json $raw
    } catch {
        stop "BAD MANIFEST: the $date manifest is not valid JSON"
    }
    $body = utf8 (canonical $manifest "manifest_sha256")
    $mh = sha256 $body
    if (-not (same $mh (field $manifest "manifest_sha256"))) { stop "BAD MANIFEST: the $date manifest does not hash to its own manifest_sha256" }
    $script:manifests[$date] = @{ manifest = $manifest; mh = $mh; body = $body }
    return ,$manifest
}

$latest_manifest = check $latest
$rows = new_list
foreach ($a in (items $latest_manifest "artifacts")) {
    if ($given) {
        if (same (field $a "sha256") $digest) { $rows.Add($a) }
    } elseif ((same (field $a "path") ("public" + $FILE)) -and (same (field $a "sha256") $digest)) {
        $rows.Add($a)
    }
}
if ($rows.Count -eq 0) { stop "NO MATCH: this file is not one we recorded in the $latest manifest" }
$path = [string](field $rows[0] "path")
$first = $null
foreach ($a in (items $index "latest_artifacts")) {
    if (same (field $a "path") $path) {
        $first = field $a "first_recorded"
        break
    }
}
if (-not (is_day $first) -or [string]::CompareOrdinal($first, $latest) -gt 0) { $first = $latest }
$days = [Collections.Generic.List[string]]::new()
$walk = [datetime]::ParseExact($first, "yyyy-MM-dd", $INVARIANT)
while ($walk -le [datetime]::ParseExact($latest, "yyyy-MM-dd", $INVARIANT)) {
    $days.Add($walk.ToString("yyyy-MM-dd", $INVARIANT))
    $walk = $walk.AddDays(1)
}
foreach ($d in $days) {
    if ($manifests.ContainsKey($d)) { $manifest = $manifests[$d].manifest } else { $manifest = check $d }
    $recorded = $false
    foreach ($a in (items $manifest "artifacts")) {
        if ((same (field $a "path") $path) -and (same (field $a "sha256") $digest)) {
            $recorded = $true
            break
        }
    }
    if (-not $recorded) { stop "CHANGED: the $d manifest does not record these bytes for $($path.Substring(6))" }
}
$d0 = $days[0]
$h0 = $manifests[$d0].mh
save "manifest.body" $manifests[$d0].body
say "MANIFEST: the $d0 manifest hashes to $h0"
$stamp = fetch "$SITE/provenance/stamps/$d0.ots"
if ($stamp[0] -eq 200) {
    save "stamp.ots" $stamp[1]
    say "STAMP: the $d0 manifest has a timestamp proof, saved as $OUT/stamp.ots"
} else {
    say "NO STAMP: the $d0 manifest has no timestamp proof yet"
}

save "owner.allowed_signers" (utf8 (($OWNER_KEYS -join "`n") + "`n"))
$seals = items $index "seals"
$weeks = [Collections.Generic.List[string]]::new()
foreach ($s in $seals) {
    $w = field $s "week_ending"
    if ((is_day $w) -and [string]::CompareOrdinal($w, $d0) -ge 0) { $weeks.Add($w) }
}

# ssh-keygen reads the seal's exact bytes on its standard input, as the Python version hands it the file.
function verify_seal([string]$week) {
    $start = New-Object Diagnostics.ProcessStartInfo
    $start.FileName = "ssh-keygen"
    $start.Arguments = '-Y verify -f "' + (Join-Path $OUT "owner.allowed_signers") + '" -I orbyt-owner -n orbyt-provenance -s "' + (Join-Path $OUT "seal-$week.json.sig") + '"'
    $start.WorkingDirectory = $HERE
    $start.UseShellExecute = $false
    $start.RedirectStandardInput = $true
    $start.RedirectStandardOutput = $true
    $start.RedirectStandardError = $true
    try {
        $process = [Diagnostics.Process]::Start($start)
    } catch {
        stop "CANNOT FETCH: ssh-keygen is needed to check the seal, and it was not found"
    }
    $stdout = $process.StandardOutput.ReadToEndAsync()
    $stderr = $process.StandardError.ReadToEndAsync()
    $bytes = [IO.File]::ReadAllBytes((Join-Path $OUT_DIR "seal-$week.json"))
    try {
        $process.StandardInput.BaseStream.Write($bytes, 0, $bytes.Length)
        $process.StandardInput.Close()
    } catch { }
    $process.WaitForExit()
    return @{ code = $process.ExitCode; text = $stdout.Result + $stderr.Result }
}

if ($seals.Count -eq 0) {
    say "NO SEAL YET: the owner has not signed a weekly seal yet"
} else {
    $sealed = $null
    foreach ($w in $weeks) {
        save "seal-$w.json" (get "$SITE/provenance/seals/$w.json")
        save "seal-$w.json.sig" (get "$SITE/provenance/seals/$w.json.sig")
        $said = verify_seal $w
        if ($said.code -ne 0) { stop "BAD SEAL: the seal for the week ending $w does not verify against the owner key in this command" }
        $seal = parse_json ([IO.File]::ReadAllBytes((Join-Path $OUT_DIR "seal-$w.json")))
        foreach ($entry in (items $seal "manifests")) {
            $date = field $entry "date"
            if (($date -is [string]) -and $manifests.ContainsKey($date) -and -not (same (field $entry "manifest_sha256") $manifests[$date].mh)) {
                stop "REWRITTEN: the seal for the week ending $w names a different $date manifest"
            }
            if ((same $date $d0) -and (same (field $entry "manifest_sha256") $h0)) {
                $key = [regex]::Match($said.text, ' key (SHA256:\S+)')
                $sealed = @($w, $key.Groups[1].Value)
            }
        }
    }
    if ($null -ne $sealed) {
        say "SEALED: the owner's seal for the week ending $($sealed[0]) names the $d0 manifest, signed by key $($sealed[1])"
    } else {
        say "NOT YET SEALED: no seal names the $d0 manifest yet"
    }
}

$copies = [Collections.Generic.List[string[]]]::new()
$copies.Add([string[]]@("owner.allowed_signers", "owner.allowed_signers"))
foreach ($d in $days) { $copies.Add([string[]]@("manifests/$d.json", "manifest-$d.json")) }
if ($seals.Count -gt 0) {
    foreach ($w in $weeks) {
        foreach ($x in @("json", "json.sig")) { $copies.Add([string[]]@("seals/$w.$x", "seal-$w.$x")) }
    }
}
$missing = $null
foreach ($copy in $copies) {
    $copy_response = fetch "$GITHUB/$($copy[0])"
    if ($copy_response[0] -ne 200) {
        if ($null -eq $missing) { $missing = $copy[0] }
        continue
    }
    $local = [IO.File]::ReadAllBytes((Join-Path $OUT_DIR $copy[1]))
    if ([Convert]::ToBase64String($local) -cne [Convert]::ToBase64String([byte[]]$copy_response[1])) {
        stop "GITHUB DIFFERS: the GitHub copy of $($copy[0]) is not what this command or this site holds"
    }
}
if ($null -ne $missing) {
    say "NOT ON GITHUB YET: the GitHub copy of $missing could not be read, so not everything was compared"
} else {
    say "GITHUB: the GitHub copies of the owner key, the manifests and the seals are the same files"
}
say "MATCH: $($path.Substring(6)) has the bytes first recorded on $d0, unchanged through $latest, sha256 $digest"

Download verify.py, then run it in the folder you saved it to:

Run
python3 verify.py
verify.pyShow the script
#!/usr/bin/env python3
# Check a file against the Orbyt Labs provenance record.
# https://www.orbytlabs.ai/provenance
# Python 3, standard library only. The weekly seal is checked with ssh-keygen.
# It only reads from the site and from GitHub, and writes what it downloads to ./orbyt-provenance.
# Usage: python3 verify.py [file]   (with no file it asks; press Return to check the site's copy)
import datetime
import hashlib
import json
import os
import re
import subprocess
import sys
import urllib.error
import urllib.request

SITE = "https://www.orbytlabs.ai"
GITHUB = "https://raw.githubusercontent.com/orbytlabs-ai/ai-agent-research/main/provenance"
FILE = "/research/agent-leadership-governance/agent-leadership-governance.pdf"
OUT = "orbyt-provenance"
OWNER_KEYS = [
    'orbyt-owner namespaces="orbyt-provenance" ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBJMl7pELNGVsAUl/c1J2pe9uQ/VKmoHFZ8RzRTSRLumlI2jssJPoL4cPTbxXHKxQgYgGuG3HJqQVMscsCFD4lZA=',
    'orbyt-owner namespaces="orbyt-provenance" ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIDel/a+TT40HU7lP6NUIbSysF/u+sOpQWRbGM7Z5SC5G',
]
DAY = re.compile(r"^\d{4}-\d{2}-\d{2}$")
sys.stdout.reconfigure(line_buffering=True)


def stop(message):
    print(message)
    sys.exit(1)


def fetch(url):
    try:
        with urllib.request.urlopen(url, timeout=60) as response:
            return response.status, response.read()
    except urllib.error.HTTPError as error:
        return error.code, b""
    except Exception:
        return None, b""


def get(url):
    status, body = fetch(url)
    if status != 200:
        stop(f"CANNOT FETCH: {url}")
    return body


def save(name, data):
    with open(os.path.join(OUT, name), "wb") as f:
        f.write(data)


def sha256(data):
    return hashlib.sha256(data).hexdigest()


def given_path(text):
    text = text.strip()
    if len(text) >= 2 and text[0] == text[-1] == "'":
        return text[1:-1].replace("'\\''", "'")
    if len(text) >= 2 and text[0] == text[-1] == '"':
        return text[1:-1]
    return text if os.name == "nt" else re.sub(r"\\(.)", r"\1", text)


if len(sys.argv) > 1:
    given = sys.argv[1]
else:
    try:
        given = given_path(input("Drag the file here and press Return: "))
    except EOFError:
        given = ""
data = None
if given:
    if not os.path.isfile(given):
        stop(f"NOT FOUND: there is no file at {given}")
    with open(given, "rb") as f:
        data = f.read()

os.makedirs(OUT, exist_ok=True)
raw = get(SITE + "/provenance/index.json")
save("index.json", raw)
try:
    index = json.loads(raw)
except ValueError:
    stop("CANNOT FETCH: the site's index is not valid JSON")
latest = index.get("latest")
if not isinstance(latest, str) or not DAY.match(latest):
    stop("NOT RECORDED YET: no manifest has been recorded yet, so there is nothing to check against.")
if data is None:
    print(f"SITE COPY: no file given, so this checks the site's copy of {FILE}")
    data = get(SITE + FILE)
digest = sha256(data)

manifests = {}


def check(day):
    raw = get(f"{SITE}/provenance/manifests/{day}.json")
    save(f"manifest-{day}.json", raw)
    try:
        manifest = json.loads(raw)
    except ValueError:
        stop(f"BAD MANIFEST: the {day} manifest is not valid JSON")
    body = json.dumps({k: v for k, v in manifest.items() if k != "manifest_sha256"}, sort_keys=True, separators=(",", ":")).encode()
    mh = sha256(body)
    if mh != manifest.get("manifest_sha256"):
        stop(f"BAD MANIFEST: the {day} manifest does not hash to its own manifest_sha256")
    manifests[day] = (manifest, mh, raw, body)
    return manifest


latest_manifest = check(latest)
if given:
    rows = [a for a in latest_manifest.get("artifacts", []) if a.get("sha256") == digest]
else:
    rows = [a for a in latest_manifest.get("artifacts", []) if a.get("path") == "public" + FILE and a.get("sha256") == digest]
if not rows:
    stop(f"NO MATCH: this file is not one we recorded in the {latest} manifest")
path = rows[0]["path"]
first = next((a.get("first_recorded") for a in index.get("latest_artifacts", []) if a.get("path") == path), None)
if not isinstance(first, str) or not DAY.match(first) or first > latest:
    first = latest
days = []
day = datetime.date.fromisoformat(first)
while day <= datetime.date.fromisoformat(latest):
    days.append(day.isoformat())
    day += datetime.timedelta(days=1)
for d in days:
    manifest = manifests[d][0] if d in manifests else check(d)
    if not any(a.get("path") == path and a.get("sha256") == digest for a in manifest.get("artifacts", [])):
        stop(f"CHANGED: the {d} manifest does not record these bytes for {path[len('public'):]}")
d0 = days[0]
h0 = manifests[d0][1]
save("manifest.body", manifests[d0][3])
print(f"MANIFEST: the {d0} manifest hashes to {h0}")
status, stamp = fetch(f"{SITE}/provenance/stamps/{d0}.ots")
if status == 200:
    save("stamp.ots", stamp)
    print(f"STAMP: the {d0} manifest has a timestamp proof, saved as {OUT}/stamp.ots")
else:
    print(f"NO STAMP: the {d0} manifest has no timestamp proof yet")

save("owner.allowed_signers", ("\n".join(OWNER_KEYS) + "\n").encode())
seals = index.get("seals") or []
weeks = [s.get("week_ending") for s in seals if isinstance(s.get("week_ending"), str) and DAY.match(s["week_ending"]) and s["week_ending"] >= d0]
if not seals:
    print("NO SEAL YET: the owner has not signed a weekly seal yet")
else:
    sealed = None
    for w in weeks:
        save(f"seal-{w}.json", get(f"{SITE}/provenance/seals/{w}.json"))
        save(f"seal-{w}.json.sig", get(f"{SITE}/provenance/seals/{w}.json.sig"))
        try:
            with open(os.path.join(OUT, f"seal-{w}.json"), "rb") as seal_file:
                said = subprocess.run(
                    ["ssh-keygen", "-Y", "verify", "-f", os.path.join(OUT, "owner.allowed_signers"), "-I", "orbyt-owner",
                     "-n", "orbyt-provenance", "-s", os.path.join(OUT, f"seal-{w}.json.sig")],
                    stdin=seal_file, capture_output=True, text=True,
                )
        except FileNotFoundError:
            stop("CANNOT FETCH: ssh-keygen is needed to check the seal, and it was not found")
        if said.returncode != 0:
            stop(f"BAD SEAL: the seal for the week ending {w} does not verify against the owner key in this command")
        with open(os.path.join(OUT, f"seal-{w}.json"), "rb") as seal_file:
            seal = json.loads(seal_file.read())
        for entry in seal.get("manifests", []):
            if entry.get("date") in manifests and entry.get("manifest_sha256") != manifests[entry["date"]][1]:
                stop(f"REWRITTEN: the seal for the week ending {w} names a different {entry['date']} manifest")
            if entry.get("date") == d0 and entry.get("manifest_sha256") == h0:
                sealed = (w, (re.search(r" key (SHA256:\S+)", said.stdout + said.stderr) or [None, ""])[1])
    if sealed:
        print(f"SEALED: the owner's seal for the week ending {sealed[0]} names the {d0} manifest, signed by key {sealed[1]}")
    else:
        print(f"NOT YET SEALED: no seal names the {d0} manifest yet")

copies = [("owner.allowed_signers", "owner.allowed_signers")]
copies += [(f"manifests/{d}.json", f"manifest-{d}.json") for d in days]
copies += [(f"seals/{w}.{x}", f"seal-{w}.{x}") for w in (weeks if seals else []) for x in ("json", "json.sig")]
missing = None
for remote, local in copies:
    status, body = fetch(f"{GITHUB}/{remote}")
    if status != 200:
        missing = missing or remote
        continue
    with open(os.path.join(OUT, local), "rb") as f:
        if f.read() != body:
            stop(f"GITHUB DIFFERS: the GitHub copy of {remote} is not what this command or this site holds")
if missing:
    print(f"NOT ON GITHUB YET: the GitHub copy of {missing} could not be read, so not everything was compared")
else:
    print("GITHUB: the GitHub copies of the owner key, the manifests and the seals are the same files")
print(f"MATCH: {path[len('public'):]} has the bytes first recorded on {d0}, unchanged through {latest}, sha256 {digest}")

Download verify.mjs, then run it in the folder you saved it to:

Run
node verify.mjs
verify.mjsShow the script
// Check a file against the Orbyt Labs provenance record.
// https://www.orbytlabs.ai/provenance
// Node 18 or later, no packages. The weekly seal is checked with ssh-keygen.
// It only reads from the site and from GitHub, and writes what it downloads to ./orbyt-provenance.
// Usage: node verify.mjs [file]   (with no file it asks; press Return to check the site's copy)
import { spawnSync } from "node:child_process";
import { createHash } from "node:crypto";
import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync, writeSync } from "node:fs";
import { join } from "node:path";
import { createInterface } from "node:readline";

const SITE = "https://www.orbytlabs.ai";
const GITHUB = "https://raw.githubusercontent.com/orbytlabs-ai/ai-agent-research/main/provenance";
const FILE = "/research/agent-leadership-governance/agent-leadership-governance.pdf";
const OUT = "orbyt-provenance";
const OWNER_KEYS = [
  'orbyt-owner namespaces="orbyt-provenance" ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBJMl7pELNGVsAUl/c1J2pe9uQ/VKmoHFZ8RzRTSRLumlI2jssJPoL4cPTbxXHKxQgYgGuG3HJqQVMscsCFD4lZA=',
  'orbyt-owner namespaces="orbyt-provenance" ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIDel/a+TT40HU7lP6NUIbSysF/u+sOpQWRbGM7Z5SC5G',
];
const DAY = /^\d{4}-\d{2}-\d{2}$/;

// Written straight to the terminal, so a line is never lost when the check stops early.
const say = (message) => writeSync(1, `${message}\n`);
function stop(message) {
  say(message);
  process.exit(1);
}

async function fetchBytes(url) {
  try {
    const response = await fetch(url);
    return { status: response.status, body: Buffer.from(await response.arrayBuffer()) };
  } catch {
    return { status: null, body: Buffer.alloc(0) };
  }
}
async function get(url) {
  const { status, body } = await fetchBytes(url);
  if (status !== 200) stop(`CANNOT FETCH: ${url}`);
  return body;
}
const save = (name, data) => writeFileSync(join(OUT, name), data);
const sha256 = (data) => createHash("sha256").update(data).digest("hex");
function canonical(value) {
  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
  if (value !== null && typeof value === "object") {
    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`).join(",")}}`;
  }
  return JSON.stringify(value);
}
function givenPath(text) {
  text = text.trim();
  if (text.length >= 2 && text[0] === "'" && text.at(-1) === "'") return text.slice(1, -1).split("'\\''").join("'");
  if (text.length >= 2 && text[0] === '"' && text.at(-1) === '"') return text.slice(1, -1);
  return process.platform === "win32" ? text : text.replace(/\\(.)/g, "$1");
}
function ask(question) {
  return new Promise((resolve) => {
    const rl = createInterface({ input: process.stdin });
    let answered = false;
    writeSync(1, question);
    rl.on("line", (line) => {
      answered = true;
      rl.close();
      resolve(line);
    });
    rl.on("close", () => {
      if (!answered) resolve("");
    });
  });
}

const given = process.argv[2] ?? givenPath(await ask("Drag the file here and press Return: "));
let data = null;
if (given) {
  if (!existsSync(given) || !statSync(given).isFile()) stop(`NOT FOUND: there is no file at ${given}`);
  data = readFileSync(given);
}

mkdirSync(OUT, { recursive: true });
const indexRaw = await get(`${SITE}/provenance/index.json`);
save("index.json", indexRaw);
let index;
try {
  index = JSON.parse(indexRaw.toString("utf8"));
} catch {
  stop("CANNOT FETCH: the site's index is not valid JSON");
}
const latest = index.latest;
if (typeof latest !== "string" || !DAY.test(latest)) stop("NOT RECORDED YET: no manifest has been recorded yet, so there is nothing to check against.");
if (data === null) {
  say(`SITE COPY: no file given, so this checks the site's copy of ${FILE}`);
  data = await get(SITE + FILE);
}
const digest = sha256(data);

const manifests = new Map();
async function check(day) {
  const raw = await get(`${SITE}/provenance/manifests/${day}.json`);
  save(`manifest-${day}.json`, raw);
  let manifest;
  try {
    manifest = JSON.parse(raw.toString("utf8"));
  } catch {
    stop(`BAD MANIFEST: the ${day} manifest is not valid JSON`);
  }
  const { manifest_sha256: recorded, ...rest } = manifest;
  const body = Buffer.from(canonical(rest), "utf8");
  const mh = sha256(body);
  if (mh !== recorded) stop(`BAD MANIFEST: the ${day} manifest does not hash to its own manifest_sha256`);
  manifests.set(day, { manifest, mh, body });
  return manifest;
}

const latestManifest = await check(latest);
const rows = (latestManifest.artifacts ?? []).filter((a) => a.sha256 === digest && (given || a.path === `public${FILE}`));
if (rows.length === 0) stop(`NO MATCH: this file is not one we recorded in the ${latest} manifest`);
const path = rows[0].path;
let first = (index.latest_artifacts ?? []).find((a) => a.path === path)?.first_recorded;
if (typeof first !== "string" || !DAY.test(first) || first > latest) first = latest;
const days = [];
for (let t = Date.parse(`${first}T00:00:00Z`); t <= Date.parse(`${latest}T00:00:00Z`); t += 86_400_000) days.push(new Date(t).toISOString().slice(0, 10));
for (const d of days) {
  const manifest = manifests.has(d) ? manifests.get(d).manifest : await check(d);
  if (!(manifest.artifacts ?? []).some((a) => a.path === path && a.sha256 === digest)) {
    stop(`CHANGED: the ${d} manifest does not record these bytes for ${path.slice("public".length)}`);
  }
}
const d0 = days[0];
const h0 = manifests.get(d0).mh;
save("manifest.body", manifests.get(d0).body);
say(`MANIFEST: the ${d0} manifest hashes to ${h0}`);
const stamp = await fetchBytes(`${SITE}/provenance/stamps/${d0}.ots`);
if (stamp.status === 200) {
  save("stamp.ots", stamp.body);
  say(`STAMP: the ${d0} manifest has a timestamp proof, saved as ${OUT}/stamp.ots`);
} else {
  say(`NO STAMP: the ${d0} manifest has no timestamp proof yet`);
}

save("owner.allowed_signers", `${OWNER_KEYS.join("\n")}\n`);
const seals = Array.isArray(index.seals) ? index.seals : [];
const weeks = seals.map((s) => s.week_ending).filter((w) => typeof w === "string" && DAY.test(w) && w >= d0);
if (seals.length === 0) {
  say("NO SEAL YET: the owner has not signed a weekly seal yet");
} else {
  let sealed = null;
  for (const w of weeks) {
    save(`seal-${w}.json`, await get(`${SITE}/provenance/seals/${w}.json`));
    save(`seal-${w}.json.sig`, await get(`${SITE}/provenance/seals/${w}.json.sig`));
    const said = spawnSync(
      "ssh-keygen",
      ["-Y", "verify", "-f", join(OUT, "owner.allowed_signers"), "-I", "orbyt-owner", "-n", "orbyt-provenance", "-s", join(OUT, `seal-${w}.json.sig`)],
      { input: readFileSync(join(OUT, `seal-${w}.json`)), encoding: "utf8" },
    );
    if (said.error) stop("CANNOT FETCH: ssh-keygen is needed to check the seal, and it was not found");
    if (said.status !== 0) stop(`BAD SEAL: the seal for the week ending ${w} does not verify against the owner key in this command`);
    const seal = JSON.parse(readFileSync(join(OUT, `seal-${w}.json`), "utf8"));
    for (const entry of seal.manifests ?? []) {
      if (manifests.has(entry.date) && entry.manifest_sha256 !== manifests.get(entry.date).mh) {
        stop(`REWRITTEN: the seal for the week ending ${w} names a different ${entry.date} manifest`);
      }
      if (entry.date === d0 && entry.manifest_sha256 === h0) sealed = { w, key: (said.stdout + said.stderr).match(/ key (SHA256:\S+)/)?.[1] ?? "" };
    }
  }
  if (sealed) say(`SEALED: the owner's seal for the week ending ${sealed.w} names the ${d0} manifest, signed by key ${sealed.key}`);
  else say(`NOT YET SEALED: no seal names the ${d0} manifest yet`);
}

const copies = [["owner.allowed_signers", "owner.allowed_signers"], ...days.map((d) => [`manifests/${d}.json`, `manifest-${d}.json`])];
if (seals.length) for (const w of weeks) for (const x of ["json", "json.sig"]) copies.push([`seals/${w}.${x}`, `seal-${w}.${x}`]);
let missing = null;
for (const [remote, local] of copies) {
  const { status, body } = await fetchBytes(`${GITHUB}/${remote}`);
  if (status !== 200) {
    missing ??= remote;
    continue;
  }
  if (!readFileSync(join(OUT, local)).equals(body)) stop(`GITHUB DIFFERS: the GitHub copy of ${remote} is not what this command or this site holds`);
}
if (missing) say(`NOT ON GITHUB YET: the GitHub copy of ${missing} could not be read, so not everything was compared`);
else say("GITHUB: the GitHub copies of the owner key, the manifests and the seals are the same files");
say(`MATCH: ${path.slice("public".length)} has the bytes first recorded on ${d0}, unchanged through ${latest}, sha256 ${digest}`);

Paste it into Terminal. Drag in your file. Look for MATCH.

MATCH
This file is exactly the one we recorded.
NO MATCH
This file is not the one we recorded.

The check runs on a computer, not on a phone.

Latest record
2026-10-17 (UTC), 214 files
Bitcoin stamp
Pending. Bitcoin usually confirms a stamp within hours, and a later daily run adds the finished proof.
Weekly seal
No weekly seal has been signed yet. The founder signs the first one after the first week of records.

It proves a file is exactly the one we recorded, and when. It does not prove that what the file says is true.

Why we use Bitcoin.

A fingerprint shows a file has not changed. It does not show when we wrote the record. Anything we keep ourselves, we could rewrite.

So we put the date somewhere we do not control. Bitcoin’s public ledger (opens in a new tab) belongs to no company or government. No one party can quietly change it.

Once Bitcoin confirms our stamp, the record has a date we cannot move earlier. You can check it yourself.

Which files are covered.

Files we serve exactly as we publish them. 214 files in 6 groups.

COVEREDResearch papers and datasets
Files under /research/. 206 files.
Show files
COVEREDDecision ledger CSV
/decision-ledger.csv, 1 file
COVEREDFailure corpus CSV
/failure-corpus.csv, 1 file
COVEREDllms.txt
/llms.txt, 1 file. Our summary of the site for AI systems.
COVEREDThe Intelligence OpenAPI spec
/openapi-intelligence.yaml, 1 file. The description of the Intelligence API, for developers.
COVEREDThe check scripts
/provenance/verify.sh, verify.ps1, verify.py and verify.mjs, 4 files. So you can check the checker.
Show files
All 214 files, with hashes

What is not covered.

Files that change each time the site is built, and pages with no file to hash. 8 items in 3 groups.

NOT COVEREDThe six org JSON files
Each site update writes a new timestamp into them, so their contents change.
Show files
NOT COVEREDllms-full.txt
Each site update writes that day's date into its "Last updated" line.
NOT COVEREDBlog posts
Each post is built into a page, with no fixed file to check yet.

How it works.

  1. Open Terminal. On a Mac, press Command and Space, type Terminal, then press Return.
  2. Paste the command and press Return. When it asks, drag the file into the window and press Return.
  3. Look for a line that starts with MATCH.

On Windows, pick PowerShell above and run it in a PowerShell window. On Linux, open your terminal app.

What you will seeShow the example
Drag the file here and press Return: 
MANIFEST: the 2026-10-16 manifest hashes to f882da853962671a0a98a25f0095802d825aab25be7fcb642dd6efb17258ab6b
STAMP: the 2026-10-16 manifest has a timestamp proof, saved as orbyt-provenance/stamp.ots
SEALED: the owner's seal for the week ending 2026-10-17 names the 2026-10-16 manifest, signed by key SHA256:+dEM8nud/VuL0weVFIllT9HpDM2C45cmOEzji6uWTMU
GITHUB: the GitHub copies of the owner key, the manifests and the seals are the same files
MATCH: /research/agent-leadership-governance/agent-leadership-governance.pdf has the bytes first recorded on 2026-10-16, unchanged through 2026-10-17, sha256 d60102088795fe28ea20dd4c771e6e3f186c44adbf5b8168b71dad1cc12e7e72

Captured from one of our automated tests, using test data.

Show the technical details

The check hashes the file you drag in, finds that hash in the latest manifest, and follows it back to the day these bytes were first recorded, checking each manifest on the way.

It checks the weekly seal with ssh-keygen against the founder keys written into the command, never a key from this site, and compares the record with its copy on GitHub.

It reads from this site and GitHub only, and saves what it downloads in a new folder named orbyt-provenance. Press Return without a file to check this site's copy of the governance paper.

Each line it prints starts with one of these words:

NOT FOUND
There is no file at the path you gave.
CANNOT FETCH
A file the check needs could not be downloaded, or ssh-keygen is missing.
NOT RECORDED YET
No manifest has been recorded yet, so there is nothing to check against.
SITE COPY
You pressed Return without a file, so it checks the copy on this site.
BAD MANIFEST
A manifest on this site does not hash to the value written inside it.
NO MATCH
This file is not the one we recorded.
CHANGED
A manifest after the first recorded day lists different bytes for this file.
MANIFEST
The day these bytes were first recorded, and the hash of that day's manifest.
STAMP
That manifest has an OpenTimestamps proof, saved beside it so you can check it.
NO STAMP
That manifest has no timestamp proof yet.
NO SEAL YET
The founder has not signed a weekly seal yet.
BAD SEAL
A seal's signature does not check against the founder keys written into the command.
REWRITTEN
A seal names a different manifest for a day than the one this site serves.
SEALED
The founder's weekly seal names that day's record, and its signature checks against a key in the command.
NOT YET SEALED
No weekly seal names that manifest yet.
GITHUB DIFFERS
The GitHub copy of a record file is not the same as this site's.
NOT ON GITHUB YET
The GitHub copy could not be read, so not everything was compared.
GITHUB
The GitHub copy of the founder key, the manifests and the seals is the same files.
MATCH
This file is exactly the one we recorded.

The Shell version needs curl, shasum, jq and ssh-keygen. jq ships with macOS 15 or later; on an older Mac, run brew install jq, and on Linux, sudo apt install jq. The PowerShell version runs in the PowerShell built into Windows 10 and later, and needs ssh-keygen, which Windows includes. The Python and Node versions need Python 3 or Node 18 or later, and ssh-keygen. On Windows, the Python command may be py instead of python3.

To check the Bitcoin timestamp, install the OpenTimestamps client (pip install opentimestamps-client) and run this after the check:

Optional: check the Bitcoin timestampShow the command
( cd orbyt-provenance && ots verify -f manifest.body stamp.ots )

While a stamp is pending, ots verify says so, and ots upgrade stamp.ots fetches the finished proof once Bitcoin confirms it. To check a confirmed stamp against Bitcoin itself, the client asks a Bitcoin node; its README says how.

Our tests have run the PowerShell version on PowerShell 7. Windows starts it with Windows PowerShell 5.1, which they have not run yet.

Proves

  • That a file's bytes are the bytes a manifest recorded for it, by its SHA-256 hash and its length.
  • That the same bytes were recorded on each day from the day they were first recorded to the latest manifest.
  • That a manifest existed no later than the Bitcoin block its stamp is anchored in, once Bitcoin confirms the stamp.
  • With a weekly seal, that a founder key written into the command signed the list of that week's manifest hashes.

Does not prove

  • That the events a file describes happened, or that what a file says is correct. It proves integrity and time.
  • Anything before a file was first recorded. Nothing is backdated: each day is recorded on that day, from that day's commit, and never rebuilt.
  • That a file still matches after it changes. Its new bytes are first recorded on the day of the next manifest.
  • That the record is independent of us. The check reads the record from this site. Two parts come from elsewhere: the founder keys, written into the command itself, and a second copy of the record on GitHub. Both are ours. The Bitcoin timestamp is the one part we do not control.
Manifest hash
63300929652e2b3d48b52a578cfa583fe10c4e9e0d9cfc46dd71a1d1360a65e7
Download
2026-10-17.json, 2026-10-17.ots, index.json (all recorded days)

The command checks a seal against these founder keys only. They are written into the command, so a seal signed by any other key prints BAD SEAL. Compare them with the fingerprint ssh-keygen prints.

Active founder key
SHA256:I7qz4hXKts9QI5Gf2+KQgsLjpo0/IZzlII+oIJhF+oE
Backup founder key
SHA256:dkWsKc3H+8rqwA3qOGfroPydzLlv7Xim+QaCwIJwVZQ

If a check fails, email security@orbytlabs.ai with what it printed.

Common questions.

What is Orbyt Labs Provenance?

Provenance is a public record that lets anyone check that an Orbyt Labs file has not changed. Each day Orbyt Labs records a SHA-256 fingerprint (a short code that changes if the file does) of the files it serves exactly as published, asks Bitcoin's public ledger to date-stamp the record, and once a week the founder signs a seal over that week's records.

How do I check an Orbyt Labs file myself?

Copy the command on this page, paste it into Terminal on a Mac or Linux computer, and drag the file into the window when it asks. A PowerShell version on the same page runs on Windows, and Python and Node versions run on any computer with Python 3 or Node 18 installed. The check prints MATCH when the file is exactly the one Orbyt Labs recorded, and NO MATCH when it is not.

What does a MATCH prove?

A MATCH proves the file's bytes are identical to the bytes Orbyt Labs recorded, and that the record existed no later than the Bitcoin block its stamp is anchored in, once Bitcoin confirms the stamp. It does not prove that what the file says is true. It proves integrity and time.

Which files does Provenance cover?

Provenance covers files Orbyt Labs serves exactly as it publishes them, listed by group on this page and, once recorded, with the hash of each. Files that change each time the site is built, and pages with no fixed file to hash, are listed as not covered, so nothing is implied about them.

Who signs the Provenance weekly seal?

The founder of Orbyt Labs signs the weekly seal with an SSH key whose fingerprint is written into the check command itself. A seal signed by any other key prints BAD SEAL, and the check never trusts a key that the site serves.

Is the Provenance record independent of Orbyt Labs?

Not entirely. The check reads the record from the Orbyt Labs site and compares it with a second copy on GitHub, and Orbyt Labs controls both. The founder keys are written into the command. The Bitcoin timestamp is the one part Orbyt Labs does not control.

Can I cite the Orbyt Labs Provenance manifests?

Yes. The manifests, stamps and seals are published under CC BY 4.0, so researchers, journalists and AI systems may cite them with attribution. A ready-made citation is at the bottom of this page.

Does any other AI lab do this?

We record and timestamp our published files so anyone can check them. The methods are well established: governments sign their official journals, and open source projects timestamp their releases. As of October 17, 2026, we have not found another AI lab that does this for its published research record.

Cite the manifests

Researchers, journalists and AI systems are welcome to cite the manifests with attribution. They are licensed CC BY 4.0.

Orbyt Labs (2026). Orbyt Labs Provenance Manifests, as of 2026-10-17. https://www.orbytlabs.ai/provenance