Two models. One job each.
Almost everything Limn shows you is arithmetic — counted, not predicted. Two questions resist counting, and each has a model of its own built for it: how serious is this comment, and is that good compared to everybody else?
Both are built and run by us. Neither sends your code or your comments anywhere.
How serious is this comment?
A review bot leaves forty comments on a pull request. Two of them will change whether the code works. The rest are preferences, tidy-ups and things somebody already knew. Nothing in the comments themselves tells you which is which — and the vendor’s own labels are marking their own homework.
So the first model reads each comment and says how serious it is: a nit, something minor, something major, or something critical. It is the same judgement a senior engineer makes in a second and cannot make four hundred times a week.
How it was built
We collected millions of real review-bot comments from public repositories on GitHub — every major vendor, across projects of every size — and taught the model on those rather than on anything invented. Under the hood it is a fine-tuned ModernBERT, which is a language model small enough to run on the ordinary processor in a laptop or a server: no graphics card, no cloud, nothing sent out, and nothing metered.
It does one thing, and that is the point. It is not a general assistant being asked nicely to have an opinion; it was trained for this single question and does nothing else.
How we know it works
We took a batch of real bot comments, hid every label they already carried, and had them graded from scratch by a human expert. Then we compared.
The model chose the same severity as the expert seven times in ten. To know whether that is good, we needed something to compare it against — so we checked how often two human experts agreed with each other on the same comments. Also seven times in ten. The model is reading these comments about as well as the question can be answered.
On those same comments, CodeRabbit’s own severity labels matched the expert fewer than five times in ten. That gap is the whole reason we grade independently instead of passing the vendor’s label through.
What it feeds
- The severity badge on every bot comment, wherever you read it.
- The “needs a look” counts on a pull request, so a wall of forty threads has a top.
- The keep / tune / noisy verdict on each vendor, and the over-calling line beside it.
Free on every tier · the grade, everywhere it appears. The ruler is never the paid part.
And is that good, or normal?
Say your team acts on half of what CodeRabbit tells it. Is that good? There is no way to know from inside your own repositories. Half might be excellent. Half might mean the bot is badly configured and everyone has quietly started ignoring it.
The second model answers that by building the missing half of the comparison: what the same bot does in other people’s repositories.
How it was built
Every public action on GitHub is published as a public event stream. We read it to find repositories running each review vendor, drew a sample of 2,204 of them across seven vendors, and then visited each one to collect what actually happened: how much the bot said, how much of it people replied to, resolved, or left sitting.
Repositories are then grouped with others of a similar size and pace, because a quiet internal service and a busy monorepo are not the same test. Your repository is placed against its own group, never against the average of all of them.
Which repositories to sample was decided in code, with a fixed seed and a written record of every choice, so the cohort is reproducible rather than hand-picked. It is rebuilt as the corpus grows, and the page tells you how old the current one is.
How we know it works
By refusing. Some groups have plenty of comparable repositories behind them and some have a handful, and a comparison drawn from a handful is a number that will move on its own next month. Where a group is too thin, the panel says so in words instead of printing a figure.
There are fourteen different ways it can decline to answer, and each one names which comparison it is declining and why. Every figure it does print carries how many repositories are behind it and which group they were.
What it feeds
- Where each of your bots sits against the same bot running in comparable repositories.
- What a typical team gets out of that vendor, so your own rate has something to mean.
- A written refusal wherever the comparison would not be honest.
Pro · the comparison. The independent grade underneath it stays free.
Everything else here is counting, and counting is better at it.
Two models, on two questions, and that is the end of the list. How many pull requests merged, how long they waited, whose turn it is, what is stalled, what a change touches, who was holding it — all of that is arithmetic over your own data. It is exact, it is reproducible, and you can check it.
A model would make every one of those worse. It would turn a number you can verify into an estimate you have to trust, and estimates are how dashboards stop being believed.
There is a third place Limn uses AI, and it is separate from both models on this page: short written summaries — a paragraph on a long pull request, a read on a red build, the reason beside an item in your queue. Those are language, not measurement, and they are clearly marked as writing wherever they appear.
No number on any screen comes from them, and nothing in the product acts on a model’s output on its own. A grade changes what a list is sorted by. It never resolves a thread, merges a pull request or closes anything.
Free answers one pull request. Pro answers the fortnight.
Limn is open core. The free tier is the product, not a trial — it has no repository limit, no user limit and no expiry, and every action you take on a pull request lives in it. Pro is what happens when you need the same truth one grain up: across repositories, across people, across a period.
What is waiting on me?
The whole worklist, ranked. My Turn, review requests, red builds, conflicts — across every repository.
Same list, with a written reason on each of the top items and a line saying what can safely wait.
What happened on this pull request?
Every thread triaged — untouched, replied, likely addressed, resolved. Blast radius, blockers, merge verdict.
A short written summary, a read on what a red build means, and a check on whether a comment was really addressed.
Can I act without leaving?
Reply, resolve, approve, merge, merge-when-ready, update from trunk, resolve conflicts hunk by hunk.
Everything free does. Acting on a pull request is never the paid part.
Which review bots are worth their seat?
Detect every bot, name it, set its role and record what it costs — and an independent severity grade on every comment it leaves.
The per-bot scoreboard: keep / tune / noisy, dollars per comment your team acted on, over-calling as a weekly line.
How does that compare to other teams?
—
Your bots placed against a 2,204-repository cohort, with a written refusal wherever the cohort is too thin to answer.
How is the team doing?
Flow metrics for the workspace, activity and reach by repository, open pull requests and trunk health.
A stored report per sprint or month, compared like-for-like against the last one, with the coverage stated.
Is a repository about to bite us?
Default-branch health across every repository, the commit that broke it, and the pull request that landed it.
Everything free does. Trunk health is never the paid part — it is the thing you need at the worst moment.
Where is the time actually going?
—
Chronology: every open hour attributed to a reviewer, an author, or waiting to land. Nobody is named.
What do I take into a one-to-one?
—
A report with a section per person you pick. Preparation, not a ranking — there is no leaderboard anywhere in it.
Can I keep the noise down?
Bots hidden by default, notifications only for work that is personally yours, and a per-repository mute.
Everything free does, plus a Slack digest per workspace if you would rather read it there.
Where does it run?
npx pierre-review on your machine, or the hosted service. No repository limit, no user limit.
The same two places. Pro unlocks on whichever one you already use.
Pro lists at $25 per user, and is free for a month to anyone who asks for it. A user is someone who signs in — bots never count, and there is no per-repository charge.
What a free account actually sees. The paid panes are listed and locked rather than hidden, so you can tell what you are not buying before you buy it — and the free metrics above them are the ones that moved here off another tab.
Start free. Every repository, nothing missed.
Sign in with GitHub and the first repositories are on screen in a couple of minutes, or run the whole free tier on your own machine and keep the data there. For Pro, send a message — it is free for a month, for asking.
Card payments are not switched on yet, so Pro is not sold from this page — it is given, a month at a time, to anyone who asks. No card, nothing to cancel. Or run the free tier locally: npx pierre-review