Aug. 202611 min read

A Patent Demand Letter Takes a Professional Search and Weeks to Answer. Nightshift Reads 2,000 Patents in 4 Minutes for $34 and Finds the Reference the Examiner Missed.

Every existing prior-art tool is a retrieval system: rank a corpus, show a human the top few dozen. That has a measurable ceiling: on the strongest embedding available, a top-50 shortlist still misses 59.7% of the references a USPTO examiner actually applied. Nightshift is a judgment system: a vector pass narrows 171,695 patents, then Gemini reads two thousand of them, not fifty, deciding for each whether it discloses each limitation. Blinded against real USPTO office-action citations: 97.5% recall of examiner-applied anticipation refs (n=40), 92.5% on obviousness (n=40), 18.8% on a control set never cited. On the demo run, 4 minutes across 10 Cloud Run tasks, $34.57, it independently surfaced the examiner's own X-cite at depth 218, plus a 1998 reference the examiner missed that teaches six of seven limitations outright.

AllThingsAgenticTheTaskmasterGoogle CloudVertex AIGeminiBigQueryCloud Run JobsUSPTOPrior ArtPatent LitigationShowDev

Watch the demo Open Nightshift live Source code

Built for the All Things Agentic Hackathon, track: The Taskmaster. Prior-art evidence dossier, not a legal opinion. Nightshift produces evidence for review by licensed patent counsel; it reports what a reference discloses, it does not decide whether a claim is invalid. #allthingsagentic

The claim in one sentence: non-practicing entities filed 55.4% of US patent cases in 2025, defending one with under $1M at risk costs a median of $600,000, and the first real question in any of them (is this patent already invented) is priced out of reach of exactly the companies most often sued. Nightshift answers it autonomously in about 4 minutes for $34.57 a run, and against a blinded eval graded by USPTO examiners it re-finds 97.5% of the anticipation references the examiner applied (n=40) while staying quiet on 81.2% of references the examiner never cited (n=80). On the demo run it also surfaced US 6,564,189, filed 1998, absent from the examiner's citations, teaching six of seven limitations outright where the examiner's own reference teaches two.

Nightshift home screen: enter the asserted patent number, or hand it the demand letter. Finished runs stay open; a new search is gated because it costs money. — Public reading, gated spending. Every finished run and claim chart is open with no key and no sign-in. Starting a new search is the one action that costs real money (2,000 patents read by Gemini, about $34), so it takes two independent limits: a token gate on the run endpoint, and a daily-ceiling counter claimed in a Firestore transaction so two concurrent presses cannot both pass. The cost of a run is the central design constraint of the whole system.

Why retrieval alone has a ceiling

Every existing prior-art tool is a retrieval system: rank a corpus, show a human the top few dozen results. Ranking this corpus with `gemini-embedding-001`, the strongest embedding available, a top-50 shortlist still misses 59.7% of the references a USPTO examiner actually applied to anticipate a claim. Better ranking does not fix it. Reading further down the list does. Depth 20 finds 26.6% of anticipation references, depth 50 finds 40.3%, depth 500 finds 71.0%, depth 2,000 finds 83.9%. The prefilter is not asked to be right, only asked not to lose the answer.

Core log for a Nightshift run: 171,694 patents in CPC G06Q, 126,787 dropped as not prior art, 44,907 eligible after the priority-date gate, 2,000 read by Gemini across 10 Cloud Run tasks. — Nightshift is a judgment system. A vector pass narrows 171,695 patents down to candidates, then Gemini reads two thousand of them, not fifty, deciding for each one whether it discloses each limitation of the asserted claim. Cloud Run Jobs fans the work out across 10 tasks with `MOD(rank, TASK_COUNT) = TASK_INDEX` so the load balances by construction.

Graded by USPTO examiners, not by me

Blinded: the model never sees the reference's patent number, title, assignee, or dates, so it cannot lean on anything it may have memorized. On 40 references a USPTO examiner applied as §102 anticipation, the screener flags 97.5%. On 40 references applied as §103 obviousness, 92.5%. On a control set of 80 references the examiner never cited, drawn from the same corpus and passing the same priority-date gate, 18.8%. The control is what makes the other two mean anything: recall alone is trivially gamed by flagging everything, so the same screener runs over references the examiner did not cite. End-to-end (prefilter × screener) at 2,000 candidates: 81.8% on X-cites, 62.8% on Y-cites.

Accuracy page graded against USPTO examiners: blinded, re-finds 97.5% of anticipation references, stays quiet on 81.2% never cited by the examiner. — This is recall against the examiner, not against ground truth. An examiner's own search recall is itself 45 to 85%, so every reference Nightshift finds that the examiner missed scores here as a miss. The number is a floor on performance, not an estimate of it.

The demo run, end to end

Run `10163121-c398c4bc`, a real Cloud Run execution. Target: US 10,163,121 (targeted marketing and consumer resource management), prosecuted against US 7,606,730 (multiple-merchant stored-value card), which a USPTO examiner applied as a category-X anticipation rejection. Blinded, without ever seeing the file history, Nightshift independently surfaced that same reference at depth 218, past every shortlist a person is shown. The two patents share almost no vocabulary: one calls itself targeted marketing, the other a stored-value card, and both describe accumulating loyalty value and redeeming it at a merchant point of sale. That is why keyword search misses it and why the judgment stage has to read rather than match. Wall time ~4 minutes across 10 Cloud Run tasks. Cost $34.57.

The claim chart for US 7,606,730 at depth 218, a reference a USPTO examiner applied. Every limitation of claim 1 is mapped, each passage quoted. — The chart is limitation-by-limitation with pin cites into the reference. This is the artifact the attorney reads: for each claim limitation, which passage of the reference discloses it, and if a passage does not exist, that gap is named too.

The result that matters more

Re-finding what an examiner already found proves the method works. Finding what the examiner missed is the product, and this run did. US 6,564,189, filed 1998-12-22, nearly eight years before this patent's priority date, appears nowhere in the examiner's citations. It teaches six of seven limitations outright where the examiner's own reference teaches two. Against Nightshift's own metric, that counts here as a miss, because the eval is measured against the examiner and not against ground truth. That is the honest reading of every recall number in this post: they are floors on performance, not estimates of it. Which reference makes the better invalidity case depends on claim construction and argument, and those are questions for counsel.

US 6,564,189 at depth 1,129, filed 1998, absent from the examiner's citations, teaching more of this claim than the reference the examiner used. — Depth 1,129 is past every shortlist a person is ever shown. This is the reason the whole system has to read further than a top-50 list: the reference that teaches the most of the claim was not the reference the examiner used.

Architecture, and why cost drove it

Querying the public patents table per request is not survivable: a single description lookup scans 1,052 GB, and one target fetch joining claims scans 40 GB, because those tables are neither partitioned nor clustered on patent id. So the corpus is materialized once and clustered. A target fetch went from 40.16 GB to 0.20 GB, a factor of about 200. Gemini runs on Vertex AI (not the AI Studio endpoint) so no API key is required and the AI Studio free-tier caps that make thousands-of-candidates work unusable are avoided; the service account authenticates. Cloud Run Jobs fans the work across 10 tasks using the Cloud Run task index to distribute candidates by `MOD(rank, TASK_COUNT) = TASK_INDEX`.

Nightshift architecture: Cloud Run orchestrates, BigQuery holds the corpus materialized once, Vertex AI reads each candidate, Firestore holds all state. — Corpus and prefilter on BigQuery (171,695 CPC G06Q publications, clustered on patent id). Model: Gemini 3.5 Flash on Vertex AI. Fan-out workers: Cloud Run Jobs. Work distribution: Cloud Run task index. Run state: Firestore. The whole system is designed around the cost of a run being the central constraint, not an afterthought.

What I take from this build: the grader problem is what actually separates a governance-shaped project that wins from one that loses. Nightshift's numbers are not from my own test suite, they are recall against real USPTO examiner citations from `uspto_office_actions_citations.enriched_citations`, filtered to categories X and Y, with the file history hidden from the model. When I found US 6,564,189 (a reference the examiner did not cite that teaches six of seven limitations), it scored as a miss against that grader, and reporting it as a miss rather than moving the goalposts is the whole reason the 97.5% number is worth anything.

Try it out:

Nightshift live (open, no sign-in)The demo run (US 10,163,121)The examiner-missed reference (US 6,564,189)Source on GitHub (Apache-2.0)Watch the demo (4 min)1-min overview (YouTube Short)

Related project

Nightshift: A Patent Demand Letter Takes a Professional Search and Weeks to Answer. Nightshift Ranks 171,695 Patents, Reads the 2,000 Closest Against Every Claim Limitation, and Hands Your Attorney the Answer for $34.

View the project

Python Can't Weakref a ValueError. Sentry's Deduplication Found Out the Expensive Way: 1024 KB per Live Asyncio Task.

sentry-python's DedupeIntegration stops the same error being reported twice by remembering the last exception. Remembering an exception is exactly what you must not do: an exception holds its traceback, a traceback holds its frames, a frame holds every local. The SDK knew this and stored a weakref.ref(exc). The three lines under the comment `# we can only weakref non builtin types` do the one thing the weakref existed to prevent: an `except TypeError:` catches Python's refusal to weakref a builtin and quietly holds the exception itself. Under asyncio each task keeps its own copy in a ContextVar, so 200 long-lived sessions pin 205 MB, all reachable after gc.collect(). Two attempts before the fix, a value fingerprint that fails the SDK's own tests, an id-based fingerprint that collapses 2000 distinct errors into 2 keys, then the identity-token approach that keeps behaviour unchanged and takes retained down to 0.5 MB.

Aug. 202612 min read