The chore nobody has time for
Patent research is a repetitive chore locked behind expensive databases, cryptic query syntax, and API-key hoops. "Who is actually filing patents in this area?" "Is this trend real or hype?" Each answer is an afternoon of manual searching - so the people who would benefit most (indie developers, founders sizing a space, students, journalists) usually just don't bother.
For the Agents for Humans Hackathon I built Patent Scout: a Strands Agents SDK agent that takes that chore off a person's plate. Ask one plain-English question, get real numbers back - on a local model, with no API key, and nothing leaving your machine.
Ask "Who files the most agentic AI patents?" and it answers from live tool calls: Salesforce (71), Stats LLC (37), Eric L. Pankey (33), Citibank (25), Aieconomy (16) - enterprises, not just AI labs. Ask "How many patents mention large language model?" and it returns ~125,048. Every figure comes from a tool result, never from the model's imagination.
Strands made the agent the easy part
The agent is a Strands Agent with eight tool functions over a real public-patent engine: count, top filers, filing trend, compare companies, company portfolio, recent filings, domain list, and a full landscape report. Strands reads the type hints and docstrings to build each tool schema, so wiring a working engine into agent capabilities took a few dozen lines of Python.
The model-provider abstraction is the quiet hero. The same agent runs on a local llama3.1:8b through Ollama today, and switching to Amazon Bedrock is literally one environment variable (PATENT_SCOUT_PROVIDER=bedrock) - the tools and the prompt don't change, only the provider. That is the drop-in path to a hosted deployment with Amazon Bedrock AgentCore.
The hard part: keeping a small local model honest
An 8B model, left to its own devices, does two things you don't want in a research tool: it invents confident numbers, and under errors it loops or panics. Three fixes turned a flaky first cut into something I trust:
- The tools do the counting, and the prompt forbids guessing. If a tool returns a rate-limit error, the agent says the data is temporarily unavailable - it never substitutes a remembered or made-up number. Honesty over confidence.
- - A tool-call loop guard. Repeat the same call with the same arguments, or exceed a per-question budget, and the tool returns a firm "stop and answer now" directive. No more 300-call loops.
- - Query normalization. Equivalent phrasings share one cache key, so answers are reproducible and the public source isn't hammered.
The honesty theme runs deeper: leaderboard counts are sampled, and the most recent 18 months undercount because patents publish about 18 months after filing. Those caveats live in the tool docstrings and the system prompt, so the agent surfaces them instead of overclaiming.
Standing on my own open source
The data engine is my prior open-source project, patent-intel (MIT): it handles the HTTP, a 24-hour cache, polite 2-second pacing, and rate-limit backoff for Google Patents' public search. I vendored it unmodified and disclosed it in the NOTICE and README. The hackathon work is the Strands layer that grounds a model in it - plus a 17-test suite and CI that pin down the trust-critical logic (normalization, loop guard, error wrapping, provider switch).
What I learned
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. Strands makes "wrap a working engine as tools, then write a careful prompt" a very short path to something a non-expert can actually use, and its provider abstraction means the code that runs free on my laptop scales onto AWS unchanged.
Built for the Agents for Humans Hackathon with the Strands Agents SDK.
Loading article