Patent Scout

A local-first AI agent that turns repetitive patent research into one plain-language question — real numbers from public patent data, no API key, nothing leaves your machine.

Comment

Inspiration

Patent research is a repetitive chore locked behind expensive databases, cryptic query syntax, and API-key hoops. The people who'd benefit most from a quick answer — indie developers deciding what to build, founders sizing a space, students, journalists — usually just don't bother. I'd already built a zero-key patent CLI (patent-intel) for myself; the "Agents for Humans" theme was the push to turn that engine into an agent that does the repetitive lookups for a person, in plain language, on their own laptop.

What it does

Patent Scout is a Strands agent with eight tools over live public patent data. You ask, in plain English: "Who files the most agentic-AI patents, and is it rising?" — and it decides which tools to call, chains them for multi-step questions ("compare these three companies, then tell me who's rising"), and answers with real numbers a non-expert can act on. It runs against a local model via Ollama, so there's no API key, no cloud account, and nothing sensitive leaves the machine. It's honest by design: it flags that leaderboard counts are sampled and that recent years undercount because patents publish ~18 months after filing.

Example (real output): "How many patents mention large language model?" → ~125,048. "Who files the most agentic AI patents?" → Salesforce (71), Stats LLC, Eric L. Pankey, Citibank, Aieconomy — enterprises, not just AI labs.

How I built it

  • Agent: Strands Agents SDK — a system prompt that forbids inventing numbers, plus eight @tool functions (count, top filers, filing trend, compare companies, company portfolio, recent filings, list domains, full domain landscape).
  • Model: local llama3.1:8b through Strands' Ollama provider (swap via two env vars; Bedrock/AgentCore is a drop-in for a cloud deployment).
  • Data engine: I vendored my prior open-source project patent-intel (MIT) unmodified — it handles the HTTP, a 24-hour cache, polite 2-second pacing, rate-limit backoff, and parsing of Google Patents' public search. The agent layer wraps its functions as tools. (Disclosed in NOTICE/README.)

Challenges I ran into

  • Keeping a small local model grounded: the win was making the tools do the counting and writing a strict system prompt so the model reports retrieved numbers instead of guessing them.
  • Honesty about data limits — sampled facet counts and the ~18-month publication lag — baked into both the tool docstrings and the prompt so answers don't overclaim.
  • Small-model failure modes: an 8B model would sometimes loop on a tool or, on a rate-limit error, invent a plausible number. I fixed all three — a tool-call loop guard (repeat + budget), a strict "report the error, never guess" prompt, and query normalization so equivalent phrasings share one cache key — turning a flaky first cut into a grounded, reproducible demo.

Accomplishments that I'm proud of

  • It's genuinely local and keyless — a judge can clone it, ollama pull, and run it with no accounts. That keeps patent research private and free for exactly the people cloud tools price out.
  • Real, reproducible answers: e.g. "agentic AI" filings are led by enterprises like Salesforce, not just AI labs — a surprising, verifiable takeaway the agent surfaces on its own.

What I learned

Strands makes "wrap a working engine as tools + a careful prompt" a very short path to a useful agent. And the hard part of a useful agent isn't the model — it's grounding it in real data and being honest about that data's limits.

What's next

Weekly "watch this domain and tell me what changed" monitoring, official-API back ends (USPTO/EPO/KIPRIS) for exact counts, an optional Bedrock AgentCore deployment, and multilingual answers so it's useful outside English-speaking patent offices.

Built With

Share this project:

Updates