Install on your repo
Add the app to a repository. It needs no config file and no workflow of its own, so there is nothing to maintain once it is running.
Code review made cheap
Jevlit reviews the diff instead of the whole repository. One model call per changed function, a median verdict in 0.68 s, and a bill of $0.010 where the agent we put it against spent $0.147 on the same repository. 15 times less, for a review that names the function and quotes the line.
Open a pull request
Jevlit reads the diff and makes one model call per changed function. The calls run in parallel, and none of them is about code you did not touch.
Get a review on the pull request
Each function gets its verdict in 0.68 s at the median, and the result lands on the pull request as a check. Every finding names its function, quotes its line and carries a probability.
Know exactly what broke
Runs are kept with the finding, the code around it and the probability behind it, so you can hand the whole report to your agent instead of digging through a CI log.
Go to run logMonitor where every token goes
Tokens, spend and requests for every service in one place. Set a budget per repository and watch what each service costs against it. Scans are billed at €0.02, and the model bill behind them counts input tokens only.
Go to consoleWhat the field costs
One scan of dsvpwa costs us $0.010, against $0.147 for GPT-5.6 Terra and $3.11 for GPT-6 Astra, which is 311× ours. On the same 32 labelled bugs, matched one-to-one by line, we score 15 of 32 against 21 for Terra: cheaper, not sharper.
Read the method
$0.00015
Cost per review
0.68 s
Median time to a verdict
15× cheaper
Than the agent we tested against
100 scans
Per dollar, on the benchmark repository
22 vs 7
Real bugs caught, Jevlit vs ruff, same diffs
7 of 177
Real fixes that raised an alarm
Only the code you changed
One model call per changed function, run in parallel. Nothing else in the repository is read, so the bill scales with the size of the change rather than the size of the codebase.
Tired of verbose AI?
Jevlit runs on TypeSafe System One. Every question it asks about your code comes back as a typed value with a probability attached, rather than as prose you have to read and interpret.
0.70
Frozen flag threshold
Read the method
Every finding carries a probability
The line that turns a probability into a flag is frozen at 0.70. It is never tuned against an answer key, so it behaves on your code the way it behaved in the benchmark.
It stays quiet on clean code
On 177 real bug-and-fix pairs it had never seen, the shipped engine raised an alarm on 7 of the fixed files, and on 7 of 172 ordinary commits.
7 of 177
Real fixes that raised an alarm
See the suite
Set to miss rather than to nag
That quiet is a trade and here is its price. At 0.70 the shipped engine caught 47 of 177 held-out bugs, about one in four. We would rather hand you four findings you read than thirty you learn to skip.
47 of 177
Real bugs caught at 0.70
See the suite
Cheap enough to leave running
A decision costs about 1.5k tokens of input, and output is free. Ten thousand reviews come to $1.46.
1.5k tokens
Per decision, output free
See pricing
Enterprise
Jevlit is available to enterprise clients on a flexible, pay-as-you-go plan: €0.02 per scan, with no seat licences, no minimum spend, and a cap you set per repository.
View pricing
Claude Code plugin
Install Jevlit as a plugin and it reviews the working tree before you commit. You get the same verdict the pull request would give you, one step earlier.
Install pluginIt finds what linters miss
On the same 79 real bug-and-fix pairs from 35 open-source projects, Jevlit flagged 22 bugs with 1 false alarm on the fixes. ruff's bug rules flagged 7 with 4; pylint flagged 11, with 11 false alarms. 17 of Jevlit's catches were missed by every free tool we ran.
22 vs 7
Real bugs caught, Jevlit vs ruff, same diffs
See the run
Fast enough to wait for
A review comes back while you are still looking at the diff: 0.68 s at the median, 0.79–0.94 s at the 95th percentile.
0.68 s
Median time to a verdict
See the numbers
One price per scan
The price is the same whoever opened the pull request, so you can add the whole team without adding a line to the invoice.
€0.02
Billed per PR scan
View pricing
Try out the new console
Tokens, spend and requests per service, per day, with the budget you set drawn across the top of them.
Now on Codex
Jevlit installs as a Codex plugin in one command and reviews from your terminal exactly as it does on a pull request.
What a review actually costs
Jevlit is billed on the tokens it reads. A decision is about 1.5k tokens of input at $0.042 per million, and the output it writes back is free.
That puts one review at $0.00015, ten thousand of them at $1.46, and the branch we measured — 122 diffs, reviewed one at a time — at $0.0179.
On the head-to-head repository it spent $0.010 where GPT-5.6 Terra spent $0.147: 15 times less, on a scan that matched 15 of 32 against 21 one-to-one by line.
Every figure on this page names the run it was measured in, and the ones that do not flatter us are on the page too.
15×
Cheaper than the agent we tested against
Cheaper than the agents
One repository, one answer key, and the axis is the bill — the only quantity measured the same way for every row. On what they caught we are behind: 15 of 32 against 21 for Terra when both are matched one-to-one by line. On what they cost, it is a fifteenth of the money.
Measured in the open
Every scanner beside us on these charts is a public run from the RealVuln dashboard, priced from its own run metadata. Ours is the same repository and the same answer key; because Jevlit does not output CWEs it is matched by file and line only, and its find count is shown beside the bars, never drawn.
13 scanners
Charted from their own runs
See the runs
A benchmark that flatters everyone
dsvpwa was written to be vulnerable. Flag every function in it without reading one and you score 20 of 32, which is why we chart what a scan costs rather than what it caught, and why the count beside our bar is the smaller of the two we have.
20 of 32
What flagging everything scores
Read the method
Nothing to set up
Install the app and open a pull request. There is no YAML to write and no runner to keep warm, and removing it later leaves nothing behind.
Read the docsMerge requests next
GitLab and Bitbucket are on the way. The review is the diff and a set of typed questions, so the only part that changes is where the comment gets posted.
Ask for itOutput tokens are free
Jevlit answers in typed values rather than essays, so the expensive half of an LLM bill never happens.
$0.042/M
Input tokens. Output free.
See pricing
56 bugs
From BugsInPy, 17 projects
Measured on real bugs
These are real defects and the commits that fixed them, taken from BugsInPy — a set someone else collected and labelled — rather than from examples we wrote for ourselves.
Fast at the tail, too
The slow reviews are still under a second: 0.79–0.94 s at the 95th percentile across three suites.
0.79–0.94 s
95th percentile
See the numbers
A verdict in your editor
The editor extension is the next thing we are building: the same typed question on the function under your cursor, before the diff is even a diff.
Ask for itA branch for two cents
The bill we actually ran up reviewing one branch of real work: 122 diffs, one review each, $0.0179 the lot.
$0.0179
122 diffs, reviewed one at a time
See pricing
Start with 150 scans on us
New accounts get €3 in credits, which is 150 pull-request scans, before anyone asks you for a card.
€3
In credits when you sign up
Sign up
Ready to try Jevlit?
Sign up today and receive €3 in credits for free, enough for 150 pull-request scans. Jevlit is currently open to developers and authorized testers.