Independent verification
Do not take our word for the proof trail. Check it offline.
Download one bounded synthetic Forge proof, its separately stored test-key pin, and an edited copy. The original verifies. The edited copy does not. After download, the check needs no Forge account, API credential, or network connection.
Run the check
One valid proof. One changed field. Two different results.
This small checker is built only for the bounded public proof. It imports no Forge code.
Enterprise review includes the full production record contract and verifier without publishing
them on the open web. The public check uses the open-source
cryptography package; the reviewed hash-pinned lock also includes
its required transitive packages.
mkdir forge-proof-check && cd forge-proof-check
curl --proto '=https' --fail --silent --show-error \
https://forgeorbital.com/verify/files/forge_verify_public_proof.py -O
curl --proto '=https' --fail --silent --show-error \
https://forgeorbital.com/verify/files/requirements-verifier.lock -O
curl --proto '=https' --fail --silent --show-error \
https://forgeorbital.com/verify/files/response.json -O
curl --proto '=https' --fail --silent --show-error \
https://forgeorbital.com/verify/files/tampered_response.json -O
curl --proto '=https' --fail --silent --show-error \
https://forgeorbital.com/verify/files/trust_root.json -O
curl --proto '=https' --fail --silent --show-error \
https://forgeorbital.com/verify/files/substitute_trust_root.json -O
python3.11 -m venv .venv
.venv/bin/python -m pip install --require-hashes --only-binary=:all: \
-r requirements-verifier.lock
KEY_ID=$(.venv/bin/python -c \
'import json; print(json.load(open("trust_root.json"))["key_id"])')
.venv/bin/python forge_verify_public_proof.py response.json \
--expect-key-id "$KEY_ID"
! .venv/bin/python forge_verify_public_proof.py tampered_response.json \
--expect-key-id "$KEY_ID"
SUBSTITUTE_KEY_ID=$(.venv/bin/python -c \
'import json; print(json.load(open("substitute_trust_root.json"))["key_id"])')
! .venv/bin/python forge_verify_public_proof.py response.json \
--expect-key-id "$SUBSTITUTE_KEY_ID"
Expected result: the first command prints VERIFIED : True. The edited copy and substitute
key both exit non-zero and print VERIFIED : False. The fixture key is disposable and
verifies only this public synthetic example. It is not the Forge production identity.
The delivered public proof has not changed since the pinned key signed it.
The signature covers every field in the bounded public payload. The checker also derives the signer identity from the public-key bytes and requires the full independently supplied key ID.
Attribution
The embedded public key must derive to the separately supplied full key ID.
Integrity
A valid Ed25519 signature binds the complete public payload to that identity.
Rejection
Changing a delivered decision field changes the signed basis and the verifier fails closed.
Public boundary
The property is public. The engine is not.
The download is a sanitized projection of a verified synthetic engine response. It shows the decision menu, the disposition, the evidence count, the authority boundary, and a hash binding to the undisclosed source response. It does not publish the source request, engine trace, calibration contract, thresholds, or solver internals.
The checker is deliberately small: require a separate full key pin, reconstruct the public payload bytes, verify the Ed25519 signature, and fail closed on a changed field or substituted key. Enterprise onboarding supplies the richer production contract under technical review.
What this does not prove
Not source truth
It does not prove that customer-supplied evidence was true, complete, or independently verified.
Not policy correctness
It does not prove that a customer-authored rule was lawful, sufficient, or appropriate.
Not outcome correctness
It does not prove that the selected action produced a good outcome. Calibration requires authorized outcomes over time.
Not execution authority
Forge does not execute the customer action. The protected customer boundary remains authoritative.
Not a compliance certificate
Verification does not certify compliance, underwriting, safety, legality, or fitness for a particular use.
Not deterministic replay by itself
A signature proves integrity and attribution. Replay separately tests reproducibility under the same pinned engine and configuration.
Trust bootstrap
The key inside a record is not its own reference.
Production attribution requires a full public-key-derived key ID delivered through authenticated enterprise onboarding or another customer-approved channel. A key returned by the same system being verified cannot authorize its own replacement. Tenant integrations may use tenant-specific identities.
A shared-secret MAC can prove that somebody holding the secret produced a value. It cannot provide independent signer attribution to another holder of the same secret, because every verifier can also mint a valid value. Forge decision records use public-key signatures for that reason.
Ready to test one real workflow?
The public fixture proves the verification boundary without publishing the engine. Enterprise onboarding adds the scoped API contract, managed credential, separately delivered production pin, deployment boundary, and acceptance tests for one customer decision.