PatentChecker

Buyers Start Here (10 minutes)

Install the public runtime bundle, verify public demo artifacts offline, and optionally inspect the signed container supply chain.

For live evaluations, we ship a buyer-ready 2-week handoff for PatentChecker patent monitoring software, with an issued evaluation key, checksums, and an activation return path.

Open v0.1.52 release View PatentChecker pricing Patent monitoring overview Download runner receipt All downloads Verification & Audit Guide Self-hosting

Easy start

Choose your path

This page is the fastest evaluation path. Start with public assets, verify something offline, then branch into modality-specific demos or a self-hosted trial if the workflow looks credible.

Recommended order

1Install and checksum the public runtime bundle first so the next verify-only commands run as documented.
2Validate one public artifact set without a license key: either the demo packet or the risk bundle.
3Use the demo hub when you want a modality-specific proof path such as viral vectors, mRNA sequences, or evidence bundles.
4Inspect supply-chain receipts only when security, procurement, or counsel needs image-level verification.

Install the public runtime

Download the standalone runtime bundle and confirm its checksum before you touch any proof asset.

Open install step ->

Verify a public packet

Use the no-license demo packet path if you want the fastest artifact validation loop.

Open packet step ->

Browse verification demos

Jump into viral-vector, mRNA-sequence, and proof-bundle demos if you want a more specific example.

Browse demos ->

Run in your environment

Switch to the self-hosting guide when you are ready for local watchlists, signed runtimes, or trial deployment.

Open self-hosting ->

Verification tracks

Viral vectorsLive LNP deliveryComing soon mRNA sequencesLive Evidence bundlesLive

Use the demo hub when the question is modality-specific: viral vectors, LNP delivery, regular mRNA sequences, or offline proof bundles.

What you get in 10 minutes

A deterministic counsel packet you can validate offline (hashes + schemas + evidence refs), no license required.
A verifiable risk timeline bundle (example synthetic platform), with stable IDs, strict fail-closed semantics, and an offline verifier script.
Optional golden demo run that emits report.md, alerts_summary.json, and underlying structured outputs.
Supply chain verification assets for v0.1.52: runner_receipt.v0.1.json, release_manifest.v0.1.json, release_manifest.v0.1.cosign.bundle.json, release_assets.sha256, release_assets.sha256.cosign.bundle.json, mirror_ops_proof.json, mirror_ops_proof.json.sha256, cosign.bundle.json, sbom.spdx.json, provenance.slsa.json.
Demo assets for v0.1.52: demo_offline_packet.zip, demo_offline_packet.zip.sha256, demo_crispr_ip_drift_inputs.tgz.
Standalone runtime assets for v0.1.52: patentchecker-linux-x64.tar.gz, patentchecker-linux-x64.tar.gz.sha256, patentchecker-macos-universal.tar.gz, patentchecker-macos-universal.tar.gz.sha256.

Quickstart (public standalone runtime)

Linux x64

BASE=https://omnisgenomics.com/patent-checker/downloads/v0.1.52

curl -L "$BASE/patentchecker-linux-x64.tar.gz" -o patentchecker-linux-x64.tar.gz
curl -L "$BASE/patentchecker-linux-x64.tar.gz.sha256" -o patentchecker-linux-x64.tar.gz.sha256
sha256sum -c patentchecker-linux-x64.tar.gz.sha256
tar -xzf patentchecker-linux-x64.tar.gz

./patentchecker/patentchecker info

macOS universal

BASE=https://omnisgenomics.com/patent-checker/downloads/v0.1.52

curl -L "$BASE/patentchecker-macos-universal.tar.gz" -o patentchecker-macos-universal.tar.gz
curl -L "$BASE/patentchecker-macos-universal.tar.gz.sha256" -o patentchecker-macos-universal.tar.gz.sha256
shasum -a 256 -c patentchecker-macos-universal.tar.gz.sha256
tar -xzf patentchecker-macos-universal.tar.gz

./patentchecker/patentchecker info

Use the unpacked ./patentchecker runtime in the next two verify-only steps. The golden demo still uses Docker because it exercises the signed container path directly.

Expected result

• You should end up with a local ./patentchecker directory and ./patentchecker/patentchecker info should print release metadata.
• The next verify-only steps should run without building the repo, installing Node, or fetching private dependencies.

If this fails

• If the checksum step fails, stop there and re-download the archive and its .sha256 file from the same release.
• If the launcher is missing, confirm you extracted the tarball and are running commands from the directory that now contains ./patentchecker.

Quickstart (verify-only demo packet)

Commands

# Verify-only demo (no license required).
# Assumes the public runtime bundle is unpacked as ./patentchecker.

BASE=https://omnisgenomics.com/patent-checker/downloads/v0.1.52

rm -rf demo_offline_packet demo_offline_packet.zip demo_offline_packet.zip.sha256
curl -L "$BASE/demo_offline_packet.zip" -o demo_offline_packet.zip
curl -L "$BASE/demo_offline_packet.zip.sha256" -o demo_offline_packet.zip.sha256
sha256sum -c demo_offline_packet.zip.sha256

unzip -q demo_offline_packet.zip -d demo_offline_packet

./patentchecker/patentchecker packet lint \
  --packet-dir ./demo_offline_packet \
  --validate-modules \
  --validate-views \
  --validate-zip

Tip: packet lint validates the deliverable by itself (no hidden dependencies).

Expected result

• A clean packet lint run means the demo packet is self-contained, contract-valid, and usable as a buyer-facing proof artifact.
• At that point you have already verified a real deliverable without a license key or a local repo build.

If this fails

• A hash mismatch usually means the ZIP or checksum file was corrupted or mixed with a different release tag.
• A packet lint failure usually means the packet was unpacked incorrectly or one of the required files was changed after download.

Quickstart (verify-only risk bundle)

Commands

# Verify-only risk timeline bundle (no license required).
# Assumes the public runtime bundle is unpacked as ./patentchecker.

BASE=https://omnisgenomics.com/patent-checker/downloads/v0.1.52

rm -rf risk_bundle_dir example_platform_risk_bundle.v1.zip example_platform_risk_bundle.v1.zip.sha256
curl -L "$BASE/example_platform_risk_bundle.v1.zip" -o example_platform_risk_bundle.v1.zip
curl -L "$BASE/example_platform_risk_bundle.v1.zip.sha256" -o example_platform_risk_bundle.v1.zip.sha256
sha256sum -c example_platform_risk_bundle.v1.zip.sha256

unzip -q example_platform_risk_bundle.v1.zip -d risk_bundle_dir
RUNS="$(ls -d risk_bundle_dir/run/run_* 2>/dev/null | LC_ALL=C sort | paste -sd, -)"

./patentchecker/patentchecker risk verify \
  --ontology risk_bundle_dir/example_platform_risk_ontology.v0.1.json \
  --timeline risk_bundle_dir/example_platform_risk_timeline.v0.1.json \
  --runs "$RUNS" \
  --strict --format json

Tip: VERIFY_BUNDLE.sh recomputes and fails closed on drift.

Quickstart (golden demo)

Commands

# Requires a Docker-enabled host (WSL without Docker Desktop integration will fail).
# Requires: docker, curl, tar.
# If GHCR requires auth (private package):
# echo "$GH_TOKEN" | docker login ghcr.io -u <user> --password-stdin

rm -rf ./patentchecker_demo && mkdir -p ./patentchecker_demo

BASE=https://omnisgenomics.com/patent-checker/downloads/v0.1.52

rm -rf ./demo ./contract
curl -L "$BASE/demo_crispr_ip_drift_inputs.tgz" -o demo_crispr_ip_drift_inputs.tgz
tar xzf demo_crispr_ip_drift_inputs.tgz

docker pull ghcr.io/omniscoder/patentchecker:v0.1.52
docker run --rm --entrypoint node \
  -v "$PWD/demo:/app/demo:ro" \
  -v "$PWD/contract:/app/contract:ro" \
  -v "$PWD/patentchecker_demo:/out" \
  ghcr.io/omniscoder/patentchecker:v0.1.52 \
  dist/src/cli/demo_crispr_ip_drift.js --bundle-dir /out

sed -n '1,120p' ./patentchecker_demo/report.md

Tip: the demo bundle is deterministic; re-running produces byte-identical outputs.

Verify trust (supply chain)

Commands

# Prereqs: curl, jq, cosign, sha256sum.
# This uses only public OIDC identity + release assets (no private keys required).

BASE=https://omnisgenomics.com/patent-checker/downloads/v0.1.52

# Download the release assets (receipt + signed file checksums)
rm -f runner_receipt.v0.1.json cosign.bundle.json sbom.spdx.json provenance.slsa.json
rm -f release_manifest.v0.1.json release_manifest.v0.1.cosign.bundle.json
rm -f release_assets.sha256 release_assets.sha256.cosign.bundle.json
curl -L "$BASE/runner_receipt.v0.1.json" -o runner_receipt.v0.1.json
curl -L "$BASE/cosign.bundle.json" -o cosign.bundle.json
curl -L "$BASE/release_manifest.v0.1.json" -o release_manifest.v0.1.json
curl -L "$BASE/release_manifest.v0.1.cosign.bundle.json" -o release_manifest.v0.1.cosign.bundle.json
curl -L "$BASE/release_assets.sha256" -o release_assets.sha256
curl -L "$BASE/release_assets.sha256.cosign.bundle.json" -o release_assets.sha256.cosign.bundle.json
curl -L "$BASE/sbom.spdx.json" -o sbom.spdx.json
curl -L "$BASE/provenance.slsa.json" -o provenance.slsa.json

# Receipt is the source of truth for digest + signing identity
export DIGEST="$(jq -r '.runner.image.digest' runner_receipt.v0.1.json)" # sha256:<64>
export IDENTITY="$(jq -r '.signing.identity' runner_receipt.v0.1.json)"
export ISSUER="$(jq -r '.signing.issuer' runner_receipt.v0.1.json)"

# Verify the signed manifest + checksums (tag-independent)
cosign verify-blob \
  --bundle release_manifest.v0.1.cosign.bundle.json \
  --certificate-identity "$IDENTITY" \
  --certificate-oidc-issuer "$ISSUER" \
  release_manifest.v0.1.json
cosign verify-blob \
  --bundle release_assets.sha256.cosign.bundle.json \
  --certificate-identity "$IDENTITY" \
  --certificate-oidc-issuer "$ISSUER" \
  release_assets.sha256
sha256sum -c release_assets.sha256

# Verify the signed image (keyless)
cosign verify \
  --certificate-identity "$IDENTITY" \
  --certificate-oidc-issuer "$ISSUER" \
  ghcr.io/omniscoder/patentchecker@"$DIGEST"

# Verify SBOM + provenance attestations (keyless)
cosign verify-attestation \
  --certificate-identity "$IDENTITY" \
  --certificate-oidc-issuer "$ISSUER" \
  --type spdxjson ghcr.io/omniscoder/patentchecker@"$DIGEST"
cosign verify-attestation \
  --certificate-identity "$IDENTITY" \
  --certificate-oidc-issuer "$ISSUER" \
  --type slsaprovenance ghcr.io/omniscoder/patentchecker@"$DIGEST"

# Offline verify using only release assets + OIDC identity (no registry access)
cosign verify-blob-attestation \
  --bundle cosign.bundle.json \
  --certificate-identity "$IDENTITY" \
  --certificate-oidc-issuer "$ISSUER" \
  --digest "${DIGEST#sha256:}" \
  --digestAlg sha256

The receipt is the source of truth: use the digest and identity from runner_receipt.v0.1.jsonfor the release you are verifying.

How to buy (2-week trial → production key)

The commercial path is simple: verify the public artifacts, run the time-boxed trial in your own environment, then buy a production key if the workflow earns a permanent seat.

Step 1

Verify the public artifacts

Install the runtime, lint the demo packet, and confirm the supply chain.

Step 2

Start the 2-week trial

We issue the evaluation key, align the watchlists and review loop, and deliver the same receipts your operators will use later.

Step 3

Buy the production key

If the trial proves out, we issue the production key and close the loop with auditable licensing evidence.

Review PatentChecker pricing →Start 2-week trial →Buy production key →