What Concept Scanner gives you, shown on a real scan.
We ran the current release on groupcache, a public Go caching library, on one computer with the default local model. Here is what came back, how to check it, the decisions you make, and what you leave with.
What you get
The engineering decisions in a project, each written up in plain language: what it does, the problem it solves, how, and its parts.
How you check it
Every concept names its file and lines, quotes the line its reasoning rests on, and lists the tests that exercise it.
What you decide
You approve, reject with a reason, or skip each finding, and correct the figure. What you share is the record you corrected.
What it leaves to people
Whether anything is new, inventive, eligible for a patent, or whose it is. Those are questions for you and a practitioner.
The scan
We pointed the app at a copy of groupcache: twelve Go files of caching code, with its tests and its full git history. It ran unattended with the Balanced model profile, on an Apple M4 Max with 128 GB of memory, and everything stayed on that computer.
One mechanism, written up
The concept we follow is the one the scan listed first. groupcache keeps two caches: one for the keys a server owns, and a smaller “hot” cache of popular keys copied from other servers. When memory runs out, something has to decide which cache gives up an entry. The scan found that decision and wrote it up.
This is a decision someone made once and never wrote down. Seeing it named is the first step to deciding whether it matters.
A technical field, a summary, the approach, the components and how they interact: the material an intake starts from, before anyone has been interviewed.
The code behind it
Every concept names its file and lines, worked out by the program from the declarations the concept names rather than guessed by the model, and links to them on GitHub at the exact commit scanned. Here is the heart of it, with the line its distinctiveness reasoning rests on highlighted:
groupcache.go, lines 352 to 368, at commit 2c02b82
// Evict items from cache(s) if necessary.
for {
mainBytes := g.mainCache.bytes()
hotBytes := g.hotCache.bytes()
if mainBytes+hotBytes <= g.cacheBytes {
return
}
// TODO(bradfitz): this is good-enough-for-now logic.
// It should be something based on measurements and/or
// respecting the costs of different resources.
victim := &g.mainCache
if hotBytes > mainBytes/8 {
victim = &g.hotCache
}
victim.removeOldest()
}
What to notice
The ruleThe hot cache gives up an entry once it holds more than an eighth as much as the main cache; otherwise the main cache does. The scan cited this line, and the program checked that the line it cited is there.
What the author saidThe comment above it calls this “good-enough-for-now logic”. The scan rated the mechanism distinctive; the person who wrote it thought of it as a placeholder. Only a person can weigh that.
Where the write-up slipsOne of the scan's notes says it “evicts from the larger one”. The code evicts from the hot cache once it passes an eighth of the main cache, which is not the same thing. Your review is where that gets caught.
Across this scan the program checked 17 quotes behind distinctiveness claims: 14 were found in the cited file, 2 were not, and 1 was too short to check. It reports the misses rather than hiding them.
The tests that exercise it
Each shipped concept is paired with the tests that use the code it cites. For this one the scan named eight, among them TestCacheEviction at line 189 of groupcache_test.go. All twelve concepts in this scan were paired with tests.
The model can also be asked what those tests assert, and a statement is kept only if it quotes the test. Here the program rejected the model's claim that the eviction test checks eviction from “the larger cache”, because that wording is not in the test. The tests are read, not run: whether they pass is a question for the people who own the code.
A ready list of the tests to point to when someone asks how you know it works.
Where to look for evidence that the mechanism operates as described, and a prompt to ask whether those tests have been run.
Who wrote it
The scan runs git blame over the cited lines. For this concept: 41 lines by Brad Fitzpatrick, all from groupcache's first commit on 23 July 2013. The record carries its own caveat beside that list: “Code authors are not necessarily legal inventors; inventorship requires human determination.”
A dated trail of who wrote what, which helps when you reconstruct how an idea came about.
A starting point for the inventorship conversation, not its answer. With AI-written code, who typed and who conceived are often different people.
A figure, corrected by a person
The scan can draw how a concept's components connect, one model call per figure. Every box cites one of the concept's own components; a box the model added on its own would be drawn dashed. The first drawing missed the rule itself, so we added two arrows: the hot cache is chosen once it exceeds an eighth of the main cache, and the main cache otherwise. Arrows a person draws are exported with the concept; the model's own are not.
Your review
Nothing is exported until you decide. For each finding you approve, reject with a reason, or skip. In this scan we approved the eviction concept, rejected a second concept that described the same eviction rule again as a duplicate, and rejected a concept about choosing an HTTP transport per request as routine, a common Go pattern.
Reviewing your own scan? How to check a concept against its code and correct it, worked on this same concept.
What you take away
Every scan writes a summary file that lays each concept out under the headings a reader expects: technical field, summary, figure, detailed description, what is unusual, comparable techniques, where it lives in the code, and its signals, with your decisions marked. It is rewritten as you review. Export then writes each concept you approved as its own file, recording the repository, the exact commit it describes, your arrows and the authorship caveat.
From the exported concept (abridged)
"review_status": "approved",
"location": { "file": "groupcache.go", "start_line": 346, "end_line": 469 },
"component_edges": [
{ "from": "c2", "to": "c5", "label": "chosen when hot bytes exceed 1/8 of main" },
{ "from": "c1", "to": "c5", "label": "chosen otherwise" }
],
"source_audit": {
"repository": "https://github.com/golang/groupcache",
"commit_hash": "2c02b8208cf8c02a3e358cb1d9b60950647543fc"
}
A concept record is engineering documentation. It is not an invention disclosure and not a patent application, though it is a far better starting point for either than a blank form.
The questions it leaves
A good record ends in better questions. From this one concept:
Was the one-eighth rule a considered choice or, as the comment says, good enough for now? What else was tried? Did anyone measure it?
Who conceived the rule, and when? This code has been in a public repository since 2013, so what does that mean for anything built on it? What do the tests show, and do they pass?
What left the computer during this scan.
Nothing. The scan above ran against a local model through Ollama, so the code, the model's answers and the results stayed on the computer. That is the default. Here is how it changes with the setup you choose.
| Setup | Where your code goes |
|---|---|
| Default: Ollama on your computer | Nowhere. The scan's own summary records where its code went, so you can check. |
| A cloud provider you choose, on your own key | To that provider, under its terms. |
| The GitHub Action | To the provider named in your workflow file, or nowhere beyond your runner if it runs Ollama itself. |
| Checking for updates | Only if you say yes: it asks GitHub whether a newer release exists. No code is sent. |
Scanning confidential code? --local-only makes local a hard rule, and every other connection is listed there.
What a scan does not tell you.
These are the questions a scan helps you ask. Answering them is work for people.
Whether it is new
The scanner reads one codebase. It does not search patents or publications, so it cannot say whether anyone has done the same thing.
Whether it could be patented
Eligibility, novelty and non-obviousness are legal questions about claims, decided by a practitioner and the patent office.
Who invented it, or who owns it
Git history shows who wrote the lines. Who conceived the idea, and who holds the rights, are separate questions. Why that matters when AI wrote the code.
Whether the description is right
The program checks that a cited line exists and that a quote matches it. Whether the explanation is accurate is what your review is for.
Questions people ask.
How long does a scan take?
It runs unattended, so you can get on with your work. Time grows with the size of the project and depends on the model and the computer. The twelve-file scan above took 26 minutes 30 seconds on an Apple M4 Max, and an earlier release took about 39 minutes over the much larger PX4 flight stack. A larger model profile surfaces more and takes longer.
Can it read documents as well as code?
Yes. Point it at a folder of Markdown, text, PDF or Word documents and it reads them the same way, which suits design documents and proposals written before the code. PDFs need a text layer; a scanned page is an image and is not read. Repository scans are the path we have measured most; tell us how documents work for you.
Which languages does it read?
It reads most common languages, among them Go, Python, TypeScript, JavaScript, Rust, C and C++, Java, Kotlin, C#, Ruby and Swift. Line numbers are found for Go, TypeScript, JavaScript and Python, from the declarations a concept names; in other languages a concept points to its file. Associated tests are paired for Go and Python.
Should I trust the scores?
Treat them as a structured reading of each mechanism, on four named levels, that you can compare and argue with. They are not a ranking of value: in a labelled test the default order separated worth-reading mechanisms from routine ones at 0.54, where 0.50 is chance. Read the whole list.
What do I give a patent practitioner?
The scan's summary file, with your decisions in it, and the concepts you exported. Our page for practitioners shows what they will look for in it.
See what your own code contains.
A larger example: 27 concepts from the PX4 flight-control codebase.