InventorLab
Capture the inventions in your code, as you build them.
Watch a short video overview of the IP-capture paradigm
InventorLab is a plugin for AI coding agents — Claude Code, Codex, and Cursor — that watches what you build, evaluates each candidate against prior art and the USPTO obviousness standard, and surfaces only what's actually patentable. The whole pipeline lives inside the agent you already use: skills, an MCP server for structured prior-art search, working documents that persist as files in your repo. You don't change tools or workflows; IP capture happens in the editor you're already in.
Under the hood: a six-pillar obviousness analysis grounded in Graham v. John Deere and KSR v. Teleflex, a two-phase prior-art search (claim-driven plus examiner-style combination hunting across patent indexes, academic literature, and the web), a bidirectional amendment loop that adversarially probes each surviving framing, and a verbatim copy of the USPTO November 2025 Revised Inventorship Guidance bundled so the operative legal standard is always quotable when judgment calls come close to the line.
Why I built it
If you've ever been on the patent side of an invention, you know the process: someone notices that something they built might be patentable, they wait to schedule a disclosure session with a patent attorney, the attorney runs the session, the attorney drafts something, prior art gets searched, a back-and-forth ensues about what's actually novel and in what way, and eventually — months later, often after several people have been involved — there's a real assessment of the invention.
That gap is where inventions die. Not because they aren't novel; because the moment of conception is fresh exactly once, and the path from "I just built something" to "I understand what's actually patentable about it" is too long. By the time the conversation happens, the inventor has moved on, the context has decayed, and the framing that made the invention obvious-to-articulate at the moment of creation is gone.
InventorLab collapses that path into something that happens in the background as you code. Recognizing an invention, isolating it, determining whether it's novel, and if it's novel — in what way — used to be a multi-party, multi-month process. Now it's a passive layer on top of your existing work. The disclosure happens at the moment of creation, not weeks after.
What surprised me
Two things.
First, how many of the off-the-wall ideas I had for this tool were actually possible. There are three prior-art APIs that InventorLab uses through MCP — and going in, I wasn't sure coding agents could even reach them. They can. The infrastructure I needed turned out to already exist; I just had to recognize that the pieces could be wired together.
Second, how much value the tool provides on the non-novel side. The framing I started with was "InventorLab surfaces novel inventions" — which is true, but it undersells the other half of what it does. Most of what you build isn't novel. InventorLab knows that, stays quiet, and lets you keep coding. The result is a tool you can leave on all the time without thinking about it. If something promising surfaces, you'll be the first to know. If nothing does, you carry on without a care.
That second part — the silent-most-of-the-time profile — is what makes the thing actually usable. Forget about InventorLab. Just code in your flow state. It'll do its job in the background, and the only time you'll think about it is when it has something to tell you.