Verifying a Jaah compliance manifest
A Jaah compliance manifest is a signed record of how AI took part in a task. Anyone can check that a
manifest is genuine and unchanged, with no Jaah account and no access to Jaah: you need the downloaded
manifest file, three standard tools (jq, base64 and openssl) and Jaah's published public key.
Check a manifest in the console
Verify a compliance manifest opens from Verify a manifest on a task's Details tab, under Summary › Compliance manifest. Any signed-in member can use it.

The page reads "Choose a manifest JSON downloaded from a task's Details tab." above Choose file, which
takes a .json file. Jaah checks the file at once and shows the result below the button; choosing the
same file again checks it again. If the check can't run, the page says The manifest could not be checked. Try
again.
Signature
The first line of the result says what Jaah found, with the file's name under it:
| Result | Meaning |
|---|---|
| Signature valid | Jaah signed this file and nothing in it has changed since. A Key line under it shows the id of the key that signed it, and the environment. |
| Signature invalid | The file was changed after it was signed, or Jaah did not sign it. |
| Unknown key | It was signed with a key this Jaah environment does not publish. |
| Not a compliance manifest | The file could not be read as a Jaah compliance manifest. |
For a valid manifest, Manifest for task #n links the task it records, with the manifest's version.
Session transcripts
One row per session transcript the manifest lists, each with its session id:
| Status | Meaning |
|---|---|
| Matches | The stored transcript is unchanged since the manifest was sealed. |
| Mismatch | The stored transcript has changed since sealing. |
| Expired | Removed under the transcript retention policy. |
| Never uploaded | The session's transcript was never stored. |
| Pending at seal | Still uploading when the manifest was sealed. |
| Missing | The stored transcript cannot be found. |
| Not visible to you | You can't see that session. |
Child tasks
For an epic, one row per child task, linking it:
| Status | Meaning |
|---|---|
| Matches | The child's manifest matches the one sealed into the epic's. |
| Mismatch | Differs from its sealed manifest. |
| Not sealed | Had no sealed manifest when the epic sealed. |
| Not visible to you | You can't see that task. |
A valid manifest with neither list says No session transcripts or child tasks to check. How manifests are sealed and downloaded: Compliance manifest.
To check a manifest without a Jaah account, use the commands below.
What the file holds
The manifest you download (jaah-manifest.json) is a small JSON envelope:
| Field | Meaning |
|---|---|
format | Always jaah.compliance-manifest.v1. |
kid | The id of the key that signed it: sha256: and the SHA-256 of the public key. |
alg | Always ECDSA_P256_SHA256: an ECDSA P-256 signature over the SHA-256 of the payload. |
payload | The manifest itself, as base64 of its exact JSON bytes. |
signature | The signature, as base64 of its DER bytes. It covers every byte of the payload. |
public_keys_url | Where the environment that signed it publishes its keys. |
The payload repeats the key id and algorithm as signing.kid and signing.alg. Trust those inner
copies: if they disagree with the outer kid or alg, treat the manifest as invalid.
Check a manifest
Run these four commands in the folder that holds jaah-manifest.json. Replace <public_keys_url> with
the URL of the environment that signed it, from the table in Where the keys are published.
Take it from that table, never from the manifest: the envelope's own public_keys_url is not covered by
the signature, so a forger could point it at a key of their own.
jq -r .payload jaah-manifest.json | base64 -d > payload.json
jq -r .signature jaah-manifest.json | base64 -d > signature.der
curl -fsS "<public_keys_url>/$(jq -r .kid jaah-manifest.json).pem" > key.pem
openssl dgst -sha256 -verify key.pem -signature signature.der payload.json >/dev/null && echo valid || echo invalid
The last command prints valid when the signature matches the payload under the published key. If even
one byte of the payload has changed, it prints invalid. On older macOS, base64 decodes with -D
instead of -d.
Then check that the signed payload names the same key, which must print same key:
[ "$(jq -r .signing.kid payload.json)" = "$(jq -r .kid jaah-manifest.json)" ] && echo "same key" || echo invalid
A manifest whose public_keys_url is not one of the URLs in the table is not a Jaah manifest.
payload.json now holds the manifest in plain JSON, ready to read or archive.
Where the keys are published
Each Jaah environment signs with its own key and publishes it, with no sign-in needed:
| Environment | Public keys URL |
|---|---|
| Jaah | https://app.jaah.ai/api/public/compliance/keys |
| Jaah development | https://app.dev.jaah.ai/api/public/compliance/keys |
The development URL answers only from Jaah's own network; a manifest you were given comes from Jaah.
The keys URL lists every key as JSON, each with its kid, alg, status and public_key_pem. A key
marked retired no longer signs new manifests but stays published, so manifests it signed still verify.
Adding /<kid>.pem to the URL returns that one key as PEM text, which is what the curl command above
fetches.
To be sure you hold the right key, check that the SHA-256 of the key you downloaded matches the
manifest's kid:
openssl pkey -pubin -in key.pem -outform DER | openssl dgst -sha256