Continuous patent monitoring for biotech sequences
Biotech patent monitoring software with 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.
Grammar, proof, and trust layers. Independent implementations. Frozen claim classes.
Verify outputs offline, without source code or registry access.
Run PatentChecker in your container environment (licensed distribution).
Control plane, runners, scheduling, webhooks, triage, and retention.
WIPO/PCT polymerase analysis, patent-text provenance, and T7-based candidate ranking.
Translate BLAST/MMseqs/CSV outputs into contract-grade match sets.
Quickstart + supply chain verification for v0.1.52.
Signed image digest sha256:1b3e02309d2… plus receipt, SBOM, and provenance.
Weekly monitoring by default, with tighter cadence for high-volatility programs.
Human digest, machine alert summary, and a counsel packet index with hashes.
Reviewers can verify packet integrity without source access or registry credentials.
{
"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
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.
PatentChecker ships as public standalone runtime bundles and a signed container image.
- • Standalone bundles are published on the public mirror for Linux x64 and macOS
- • 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.
Not just software. A protocol.
PatentChecker is the reference implementation of a protocol for machine-checkable patent claims. The artifact format is designed to outlive the company that created it.
Multiple implementations (Node.js, Python) prove the specification is unambiguous. Same inputs produce identical hashes across languages.
Claim classes A-E are frozen until v0.2. Normative boundaries are documented. No swamp monster schemas.
- • Class A: Publication ingestion
- • Class C: Overlap/diff
- • Class E: Legal monitor
Bundles have canonical citation formats that survive Word/PDF/email chains. Lawyers can cite pc:ep:v0.1:sha256:3f8c... in briefs.
- • Another team implemented verifier (Python)
- • Another machine reproduces hash (CI determinism)
- • External field test (awaiting first dry run)
- • Live workflow citation (templates ready)
The infrastructure is complete enough. Now we test the social reality of the object.
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.
Engineered enzyme and IVT patent analysis
PatentChecker now includes an enzyme-platform lane for mRNA manufacturing disclosures: WIPO sequence-listing ingest, patent-text provenance, T7-based candidate ranking, and typed comparisons in a single deterministic report.
- • Start from a signed sequence-listing evidence pack or a `WO...` publication via `compile-wipo`.
- • Use the pinned T7 RNAP preset by default, so the common operator path is zero-config on the reference side.
- • Generate one deterministic report with candidate ranking, patent-text provenance, raw artifact references, and typed comparisons.
This workflow is designed for platform IP review: what was disclosed, which sequence is the plausible polymerase candidate, and which patent-text sections support the finding.
Compile directly from a WIPO publication or from an existing signed evidence pack with the same report contract.
Abstract, claims, and description each carry source, extraction method, confidence tier, hash, and raw-artifact path.
Disclosed proteins are ranked against canonical T7 RNAP using offset-tolerant motif and N-terminal signals before full review.
DNA and RNA disclosures are not treated as protein hits; mismatches are surfaced explicitly instead of producing invalid alignments.
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.
The same evidence model now handles polymerase and IVT patent disclosures, not just sequence watchlists.
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 standalone bundles plus a signed container image, with receipts, SBOM, and provenance.
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
- • mRNA manufacturing and IVT enzyme teams
- • Gene therapy and cell therapy constructs
- • Diagnostic assay sequences
- • IP counsel reviewing polymerase and process-patent disclosures
- • Platform teams generating many variants
2-week trial
Start with 1 to 3 watchlists, ship deterministic Evidence Packets across a 2-week evaluation, then decide whether to buy the production key.
- • 1 to 3 watchlists
- • Issued evaluation key
- • Weekly cadence
- • Threshold tuning and one triage session per week
- • Deliver report.md, alerts_summary, and counsel packet artifacts
- • Production-key decision at the end of the trial
- • 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
- • Public runtime bundles: patentchecker-linux-x64.tar.gz and patentchecker-macos-universal.tar.gz (v0.1.52)
- • Signed runner image: ghcr.io/omniscoder/patentchecker@sha256:1b3e02309d2...
PatentChecker is new. The right way to evaluate it is not testimonials. It is artifacts.
- • Download and unpack a public standalone runtime bundle
- • Download demo_offline_packet.zip + demo_offline_packet.zip.sha256
- • Verify ZIP sha256
- • Run packet lint with the shipped CLI
- • Optionally verify the signed runner image and attestations
If the receipts hold up, the tool holds up.
Pricing
Trial first, production key second. Pricing is scoped from watchlists, cadence, and deployment mode instead of monthly self-serve tiers.
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.
Yes. PatentChecker now includes an enzyme-platform workflow for polymerase and IVT disclosures: WIPO sequence-listing ingest, patent-text provenance, T7-based candidate ranking, and typed comparisons that explicitly flag DNA or RNA versus protein mismatches.
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.
Live drift pages, delivery-risk scoring, and signed proof bundles now sit under one PatentChecker demos hub so buyers can inspect the whole surface instead of a single artifact.
Vector blocking analysis across capsid overlap, licensing dependency, manufacturing sensitivity, and exclusivity zones.
Live posture report for sequence-watchlist drift: baseline, delta, open actions, and monitoring queues.
Downloadable drift packet with checksums, manifest verification, and contract-validated Evidence Packet JSON.
Verifiable runner-image quickstart for the signed PatentChecker evaluation path.
Replay-verifiable PTAB evidence bundle with decision metadata, captures, provenance, and verifier scripts.
Signed deterministic proof bundle for an engineering and procurement review workflow.
A signed, replay-verifiable bundle capturing a PTAB reversal decision: structured metadata, decision PDF, portal captures, provenance, and a replay verifier.
A deterministic viral-vector blocking readout for a Prime-style CNS program: capsid overlap, licensing dependency, manufacturing sensitivity, and exclusivity zones in one forwardable report.
A signed, deterministic proof bundle for a naval anti-biofouling coating use case: structured inputs, evidence artifacts, risk events, and a cross-platform replay verifier.
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.
# Assumes the public standalone runtime is unpacked as ./patentchecker. unzip -q example_platform_risk_bundle.v1.zip -d bundle_dir # Verify (no license required). RUNS="$(ls -d bundle_dir/run/run_* 2>/dev/null | LC_ALL=C sort | paste -sd, -)" ./patentchecker/patentchecker risk verify \ --ontology bundle_dir/example_platform_risk_ontology.v0.1.json \ --timeline bundle_dir/example_platform_risk_timeline.v0.1.json \ --runs "$RUNS" \ --strict --format json