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.
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.
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.
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 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.
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: agentic prior-art search that reads 2,000 patents in 4 minutes for $34
View the project
I just published my first Udemy course: the ServiceNow catalog build I've done twenty times, plus the Now Assist Skill Kit end to end
Two years on the ServiceNow team at Cirque du Soleil, plus a stretch on client work at N2, taught me which parts of the catalog + Flow Designer + Now Assist stack you actually reach for and which parts the docs make you think matter but don't. The course is that filter, recorded from scratch on a fresh instance, ending with a Now Assist Skill Kit publish flow that isn't in the docs yet. Launch coupon inside.
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.