Continuous patent monitoring for biotech sequences
Watchlists that detect patent drift and emit deterministic Evidence Packets you can forward, rerun, and audit.
Not legal advice. Not infringement. Not FTO.
Decision-grade receipts so counsel and R&D can triage faster with better inputs.
{
"packet_fileset_hash": "sha256:<...>",
"deterministic": true,
"artifacts": {
"packet_zip": "demo_offline_packet.zip",
"packet_zip_sha256": "demo_offline_packet.zip.sha256",
"run_packet_index": "run_packet_index.v0.1.json",
"counsel_packet_index": "index.json"
}
}Every run ships forwardable artifacts: a human report, a machine triage summary, and a counsel packet index that can be verified offline.
Continuous patent monitoring: why it matters
Patent risk is not static.
The moment a new application publishes, a claim is amended, or a family expands into a new jurisdiction, your exposure changes. A one-time patent search or periodic review is not defensible when risk evolves continuously.
Most patent tools optimize for exploration — dashboards, filters, similarity scores. They do not optimize for proof.
When a question becomes: “What changed, when did it change, and can you prove it?” Most tools cannot answer.
That is why continuous patent monitoring needs receipts, not screenshots.
PatentChecker is built specifically for that problem.
PatentChecker treats patent monitoring as an evidence pipeline, not a UI.
Every monitoring run produces deterministic, replayable artifacts that answer three questions unambiguously:
- • What changed
- • Why it changed
- • What exactly was examined
Those answers are captured as structured outputs, not screenshots or transient dashboards.
Each run emits a complete, self-contained record:
- • A run manifest describing inputs, parameters, corpus coverage, and outputs
- • A run digest summarizing material changes in human-readable form
- • Hash-addressed evidence artifacts for every detected delta
- • Adapter provenance, including adapter identity, contract version, and configuration hash
- • Pinned corpus snapshots with explicit coverage and content hashes
Nothing is implicit. Nothing is inferred later.
PatentChecker is deterministic by construction:
- • Same inputs produce the same outputs
- • Outputs are sorted, canonicalized, and hashed
- • Multi-sequence watchlists execute in a stable, documented order
- • Run identifiers and artifact paths are predictable and reproducible
This means results can be replayed, compared, and audited long after the fact.
PatentChecker outputs can be verified offline, without:
- • access to source code
- • access to private repositories
- • access to the registry
- • trust in the operator
A verifier only needs the run directory. Using the built-in verification tooling, reviewers can independently confirm:
- • schema validity
- • artifact integrity (hash checks)
- • corpus consistency
- • adapter contract compatibility
- • run completeness
This is critical for legal review, procurement, and air-gapped environments.
The PatentChecker runner is distributed as a signed container image.
- • Signatures are keyless, issued via GitHub Actions OIDC
- • The image and its signatures are publicly verifiable
- • Verification does not require credentials
This provides a clear chain of custody from source to execution to output.
PatentChecker intentionally avoids hiding complexity behind visual layers.
Instead, it produces artifacts that stand on their own:
- • suitable for internal review
- • suitable for external counsel
- • suitable for regulatory or litigation contexts
Dashboards can be built later. Evidence cannot.
PatentChecker exists because:
- • Patent risk is continuous
- • Proof matters more than presentation
- • Verification should not depend on trust
If you need inspection-ready, replayable evidence of patent change over time, this is the system designed for that job.
Why it exists
Most teams treat sequence-to-patent checks as a one-time snapshot.
- • What changed since the last run
- • Why does it matter
That fails because the patent landscape moves while your program is still moving.
What it does
You give us sequences tied to a program as watchlists. We monitor public patent sequence corpora over time and detect material deltas.
- • New publications in known families
- • Family expansions across jurisdictions
- • Similarity band changes
- • Coverage shifts
- • Region overlap changes
Every delta comes with an Evidence Packet: scope, provenance, and similarity traces in canonical JSON so you can rerun and diff results over time.
What you get every run
Three deliverables every run: a human digest, a machine summary, and Evidence Packets you can forward and audit.
Human-readable posture report with explicit interpretation guardrails.
Machine-readable triage summary (plus deterministic NDJSON/CSV views for routing).
Single deliverable with hashes + schemas + evidence refs; independently verifiable offline.
What makes this different
Built as an evidence contract: declared scope, deltas, determinism, and receipts you can forward.
One search is a demo. A watchlist is a budget line item.
Family level dedup and cooldown suppression to avoid alert spam.
Every run declares what was checked and what was not. No ambiguity.
Deterministic pipeline, stable ordering, canonical JSON, no system clock dependence.
Signed container with SBOM and provenance. Customer run or managed in your environment.
What this is not
To be explicit:
- • Does not produce legal opinions
- • Does not claim full recall
- • Does not replace counsel review
It produces evidence and change receipts so teams can decide sooner.
Who uses it
Sequence-heavy programs where drift is expensive:
- • Therapeutic proteins
- • Gene therapy and cell therapy constructs
- • Diagnostic assay sequences
- • Platform teams generating many variants
Pilot Kit (4 to 6 weeks)
Start with 1 to 3 watchlists and ship deterministic Evidence Packets + weekly digests.
- • 1 to 3 watchlists
- • Weekly cadence
- • Threshold tuning and one triage session per week
- • Deliver report.md, alerts_summary, and counsel packet artifacts
- • Upstream similarity results in BLAST TSV, MMseqs TSV, or CSV
- • Metadata map
- • Corpus manifest declaring source, jurisdictions, date range
Trust and verification
This is intentionally built as a contract artifact, not a black box.
- • Contract anchor: Diff Engine Spec v0.1 at commit 2bdaed1
- • Reference implementation: v0.1.1 at commit 63a2e0d
- • Runner: ghcr.io/omniscoder/patentchecker v0.1.28 (signed, with SBOM and provenance)
PatentChecker is new. The right way to evaluate it is not testimonials. It is artifacts.
- • Download demo_offline_packet.zip + demo_offline_packet.zip.sha256
- • Verify ZIP sha256
- • Run packet lint (packet-only)
- • Optionally verify signed runner image
If the receipts hold up, the tool holds up.
Pricing
Pilot Kit: 15k to 40k. Annual subscription: 60k to 300k plus depending on watchlists, cadence, and deployment mode.
Continuous patent monitoring FAQ
Short answers for teams evaluating watchlists, cadence, evidence, and offline verification.
Continuous patent monitoring is a watchlist workflow that checks for new publications, amendments, and family expansions on a fixed cadence so teams can react to material change instead of re-running one-off searches.
A patent search is a snapshot. Continuous patent monitoring is a repeatable process: declared scope, stable inputs, and comparable outputs over time so you can answer what changed and when.
A human report (report.md), a machine-readable alert summary (alerts_summary), and a counsel packet index that enumerates every artifact with hashes for offline verification.
Because counsel and R&D need receipts they can forward, audit, and verify offline. Deterministic artifacts reduce ambiguity about what was checked and make historical comparisons defensible.
No. PatentChecker is an evidence pipeline that produces monitoring artifacts; it does not provide legal opinions, infringement determinations, or FTO conclusions.
Verify a demo packet (offline)
Download a single deliverable, verify hashes + schemas + evidence refs offline, and keep the receipts.
Use the built-in packet linter to validate deliverable integrity and internal coherence.
A historical in silico simulation derived from public-like patent artifacts and synthetic protected assets. No license required to verify.
Two reference bundles: an escalation scenario and a low-signal baseline. Verification is license-free; new analyses are license-gated.
unzip -q example_platform_risk_bundle.v1.zip -d bundle_dir
cd bundle_dir
# Verify (no license required).
RUNS="$(ls -d run/run_* 2>/dev/null | LC_ALL=C sort | paste -sd, -)"
docker pull ghcr.io/omniscoder/patentchecker:v0.1.28
docker run --rm -v "$PWD:/bundle" -w /bundle \
ghcr.io/omniscoder/patentchecker:v0.1.28 \
patentchecker risk verify \
--ontology example_platform_risk_ontology.v0.1.json \
--timeline example_platform_risk_timeline.v0.1.json \
--runs "$RUNS" \
--strict --format json