Trivy: one file that tells you in seconds which known holes your project carries
Trivy is a program you download as a single file, run over a folder, and within seconds it tells you which of the libraries your code uses carry known security holes, which of your settings are dangerous, and whether a password or key has been left behind inside your files. It needs no installation, no account, no special hardware. Its settings check runs even without an internet connection. The only thing it asks for is disk space, for the list of known holes it downloads once.

What it does
Picture a house ready for handover. Before you let people in, you want to know whether any of the locks came from a batch that has been recalled. Trivy does that job for software, and it does it with one command.
It is a command-line program. That means there is no window with buttons; you call it by typing a command in a terminal, a black window full of text. What makes it stand out is that the program itself is a single file. You download it, you unzip it, you run it. Nothing else has to be installed first — no programming language, no runtime, no chain of helpers. It is written in Go and has been turned into one static executable: a piece that carries everything it needs inside itself. On Windows that is a real convenience, because most tools in this category assume you have set up something else first.
So what does it look for? Three things, all with the same program.
First, known holes inside your libraries. When you write software you don’t write everything from scratch. You use ready-made pieces other people built, and you pull them in by name and version. Sometimes a particular version of such a piece has a known security flaw, a small window someone can climb through. Those flaws get recorded publicly, with an identifier, as soon as someone finds them. Trivy keeps its own list of them, looks at what you are using, and shows you which part of that list touches you.
Second, dangerous settings. Software can be fine as code and still be set up the wrong way. The example everyone understands is this: you hand a program administrator rights for no reason, or you let it run in an environment that leaves open things it never needed. Those settings live in files — a Dockerfile, for instance, the file holding the instructions that say how a package with your program and all its dependencies gets built. Trivy reads those files and flags the lines that carry risk.
Third, keys left behind. It is the most common mistake in this trade: someone is in a hurry, drops the database password or a service key straight into a code file to test something, and forgets it there. Trivy reads the files and looks for those patterns.
The doors you enter through are its subcommands: config, filesystem, image, kubernetes, repository, rootfs, sbom and vm. In plain words, you tell it what to look at: a folder of files, a settings file, a packaged piece of software, a group of machines working together, a code repository. Each time you write one command — the area, then the target.
The answer comes back as a table in the terminal, with colours and severities: critical, high, medium, low. If you want it for a machine to read, you ask for JSON — structured text any program can parse.
The project is alive, and the numbers show it. On GitHub, the aquasecurity/trivy repository has 39,049 stars, 827 forks and 297 open issues. It was created on 11 April 2019 and last saw changes on 5 November 2026. It is maintained by Aqua Security, a software security company, under the aquasecurity organisation. The licence is Apache-2.0, explicitly free and without cost.
The current version is v0.76.2, published on 5 November 2026 at 12:50 UTC, with 47 assets on the release page. This is not a lone binary someone uploaded once; it is proper release engineering, with a separate file for each platform. The release rhythm says it plainly: v0.73.0 on 3 August, v0.74.0 on 14 August, v0.75.0 on 1 October, v0.76.0 on 14 October, v0.76.1 on 21 October, v0.76.2 on 5 November. A new release every two to three weeks.
What it doesn’t do
It fixes nothing. It finds and reports; the change is yours to make. There is no “fix everything” button, and rightly so, because a program that swaps out its own dependencies can break your project without warning.
It doesn’t lie when it doesn’t know. That sounds obvious and isn’t. If you point it at a folder where the version information for your libraries is missing, it will not say “all clean”. It will say it didn’t scan. The difference between “clean” and “I didn’t look” is the whole value of the tool, and there is a measured example further down.
It is not a tool server for AI assistants. It has no MCP protocol, you declare it nowhere, and it loads nothing into an assistant’s memory before you even speak to it. It is a program you call from the shell, like any other command-line tool.
It doesn’t stand watch. You run it, it answers, it’s done. It doesn’t sit monitoring your disk all day and ping you the moment a new hole appears. Repetition is yours to arrange, by hand or inside an automated pipeline.
It doesn’t protect you while your program runs. It isn’t a firewall, it doesn’t block traffic, it doesn’t stop an attack in progress. It is a check before you ship.
It doesn’t find flaws in your own logic. If you wrote a function that lets any user see another user’s data, that is not a known hole in some library and Trivy won’t see it. It doesn’t replace the judgement of a person who knows the system.
And it isn’t infallible. It produces false findings, like every scanner: cases that look severe on paper but aren’t exploitable in your particular setup. So you read its output with a mind engaged, not blindly.
Who it’s for
For the person shipping a site who doesn’t want to learn security from the news. You don’t need to understand every identifier it prints; you need to know that you looked, and to fix what it hands you.
For the team with many projects that wants a check it can put into an automated pipeline, with an answer a machine can read, so the pipeline can stop when something critical shows up.
For the professional delivering to a client who wants a document listing findings, not a promise that “it was checked”.
And for anyone working with an AI assistant: a tool that states plainly what is wrong is the best thing you can hand an assistant so it can fix something on its own.
Installation
Installation doesn’t happen through another program. It is a zip file you download, unpack into a folder, and run from there.
First path: the release asset
Take the current version straight from the release page: https://github.com/aquasecurity/trivy/releases/tag/v0.76.2
Second, download the Windows asset named trivy_0.76.2_windows-64bit.zip. It is 51.4 MB (53,905,616 bytes).
Third, right-click it, choose Extract All, and give it a folder you’ll remember — C:\tools\trivy, say. Inside sits trivy.exe.
Fourth, open a terminal in that folder and confirm it works:
trivy --versionIt prints the version and, below it, the date of the list of known holes. To call it from anywhere without changing folders each time, add that folder to the Windows PATH variable. No administrator rights were needed for any of these steps.
Where you run the commands: inside your project folder. The dot at the end of the commands means “here, where I’m standing” — the folder you’re in.
Second path: the Windows package manager
If you’d rather have the system keep it and update it, winget is there:
winget install --id AquaSecurity.Trivy -eOne measured caveat: winget lags by one patch. The command winget show --id AquaSecurity.Trivy -e reports 0.76.1, while the release zip gives you 0.76.2. The zip path is cleaner if you want the current version; the winget path is easier if you’d rather never think about upgrading again.
Using it in each LLM
One expectation needs correcting here, because many assistants today advertise every tool as a tool server. Trivy is not a tool server and has no MCP protocol. There is nothing to declare anywhere, nothing loaded into your session before you speak to it, no configuration to maintain for it. It is a program the assistant calls from the shell when it needs it, and it answers in something the assistant can read.
The three commands an assistant actually needs are these:
trivy fs --scanners vuln --format json .trivy config .trivy fs --format json --output trivy.json .The first scans the folder’s libraries and returns the list in machine-readable form, so the assistant knows which library at which version is at fault. The second checks settings — a Dockerfile, for instance — before you push it. The third writes the result to a file, useful when the output is large and won’t fit in the window.
Claude Code
There is nothing to install inside Claude Code. You ask for the work in words and it runs the command in the shell. Something like: “Run trivy fs --scanners vuln --format json . in the project folder, read the findings, and fix the versions that carry known holes.” It runs the command, reads the JSON, opens your dependency files and proposes changes. Before pushing a Dockerfile, tell it to run trivy config . and fix what it finds, in order of severity.
Codex CLI
Same logic, because you’re talking to an assistant with a shell. You give it the command as part of the task — “run trivy fs --scanners vuln --format json . and fix anything critical or high” — and it executes, reads, writes. Since Codex often works on a repository, the library scan fits exactly: the version lock file sits inside the repo, so the scan sees real versions rather than wishes.
Cursor
In the editor, the terminal is built in. Open the terminal panel, run the same command by hand if you want to read the answer yourself, or ask the assistant to run it and bring you only the critical findings. Either way you declare nothing in any settings file: the program is already on your disk, and all it needs is to be on PATH.
Where it wins, where it loses
It wins first on installation weight. One file, no runtime, no dependencies, no account. On Windows that isn’t a detail: it is the difference between “I’ll set it up at some point” and “it took two minutes”.
It wins by doing three different jobs with the same program. Libraries, settings, secrets. Usually those need three separate tools, with three install methods and three output formats.
It wins on speed once the list of known holes is down. And it wins because the settings check needs neither network nor list: it works on a machine with no outbound connection, which matters in locked-down environments.
It loses on the first run. The list of known holes doesn’t ship with the program; it downloads the first time you scan libraries, and it is heavy. That is why the first scan isn’t instant while later ones are near-instant.
It loses when the version lock file is missing. Without it there is nothing to compare against and it tells you it didn’t scan. That is more honest than a false “clean”, but it means old projects where nobody ever locked versions need that file created first.
It loses on size: the executable itself is big, and the disk holding the list needs far more space. And it loses, like every tool in this category, on seeing only known and declared problems: a hole nobody has recorded yet, or a mistake in your own logic, will never appear in that answer.
Test
I downloaded the official Windows asset from the release page, v0.76.2, 51.4 MB (53,905,616 bytes), unpacked it into a folder of my own and ran it. First, the identity:
trivy --versionThe answer was Version: 0.76.2, with the date of the vulnerability database below it. So the release zip genuinely gives the newer version, as promised above.
Then I built a folder with deliberate mistakes: a Dockerfile starting from FROM node:latest, with no user defined for execution and no health check. I ran:
trivy config .It found exactly 3 findings, and all three were correct: DS-0001, medium — the node:latest image isn’t pinned to a version, so every build pulls whatever happens to be there. DS-0002, high — the program will run as administrator inside its environment when it should run as a plain user. DS-0026, low — the health check is missing. And the important part: it worked without an account, without a database and without a network connection. The settings check is self-contained.
Then I tested the case where a tool of this kind usually misleads. I built a folder containing only a package.json file — the declaration of the libraries I want, with their versions locked nowhere. I ran:
trivy fs --scanners vuln .The answer was an empty table with the word “Not scanned”. In other words: it doesn’t tell you “all good”. It tells you “I didn’t look”. That is the difference that makes the tool worth having.
I added a version lock file — the file recording the exact version of every library that was pulled in — and ran the same command again. This time it returned 9 findings in under a second, of which 1 critical and 4 high, for the lodash library at version 4.17.4. Same folder, same command, a completely different answer, purely because versions were now recorded.
And the timing, honestly: the first library scan is slow because it downloads the list of known holes. With the list warm, later scans are near-instant, and the settings check was instant from the first run.
I tested nothing else. Everything that follows about packaged software, groups of machines and component lists is a capability of the tool as its maker declares it, not a measurement of ours. The three numbers we measured — 3 findings on settings, “didn’t scan” without recorded versions, 9 findings with them — are the only ones we put on the table.
What it costs
The tool. Zero money. Trivy is open source under the Apache-2.0 licence and needs no subscription, no key, no account. The real cost is disk space.
The footprint in context. It is not an MCP server, so it doesn’t load tool schemas into every session: its token tax before you write a word is zero, and there is nowhere to declare it. Its weight is the program itself: 51.4 MB for the Windows download and 171.6 MiB for the executable after unpacking — a static binary, with no GPU and no local model.
The disk. The vulnerability database it downloads on the first scan takes 1.6 GB (trivy.db, measured at 1,675,390,976 bytes under %LOCALAPPDATA%\trivy\db). That, not the download size, is the tool’s true weight, and it is why you don’t put it on a disk that is running out of room.
The work. You don’t pay per scan: the program runs locally, on your own files, sending nothing to a service. The time cost we measured: the settings check is instant, the first vulnerability scan takes as long as a database download, and later ones come in under a second.
Verdict
Worth it, and worth it for a reason that doesn’t show in a feature list: because it tells you the truth when it doesn’t know. A security tool that answers “clean” when it never looked is worse than no tool at all — it sells you a peace of mind you never bought. Trivy, measured, chooses to say it didn’t scan.
The pluses, in order of importance: one file with no runtime, three checks in one program, an answer a machine can parse, a live project releasing every two to three weeks, and zero cost. The minuses: the list of known holes takes 1.6 GB of disk, it won’t scan without a version lock file, and it sees nothing beyond known problems in declared versions.
Where it fits best in practice: as a brake before every handover. Run it, read what it says, fix the critical ones, leave the rest for tomorrow. And if you work with an AI assistant, hand it the JSON command and let it do the boring part.
Sources:
https://github.com/aquasecurity/trivy