Calm above the noise.
Every repo, every team, every review bot — one quiet board above the churn: what’s stalled, whose turn it is, and what the bots are actually worth. Free, open-core, and it runs on your machine.
Or run it entirely on your machine — local mode uses your gh login and keeps no stored credentials.
The bots got fast. Review got slower. And everyone claims first place.
more PRs merged since AI-assisted coding took hold
longer those PRs now spend waiting in review
the measured relevance of the average bot review comment
vendors claiming #1 on the same code-review benchmark
Sources: Faros AI, 10,000+ developers · Fatima et al., arXiv, April 2026 · the vendors’ own blogs, 2026.
Built for the engineers keeping up.
AI multiplied what a team ships — and what a team has to read. Nobody is short of code any more; everyone is short of attention: more repos, more PRs, more commentary, arriving faster than anyone can triage by hand.
The pace isn’t coming back down. So the tools have to come up.
That’s the whole idea: complexity you can see is complexity you can manage. The churn stays out there — you get the calm layer above it.
09:04 · One app, not eleven tabs. Three repos, forty-one open PRs, two review bots, standup at half past.
09:05 · My Turn: of the forty-one, three need you.
Three hundred signals a week. Three that need you.
Review bots never stop. A busy team fields hundreds of AI review comments a week, across more repos than anyone can hold in their head — and the firehose buries the handful that genuinely needed a human. The bottleneck moved from writing the change to noticing what matters.
Limn doesn’t add another bot. It sits above the ones you already run and budgets the scarce resource — your attention. Every thread, human or bot, becomes a triaged signal.
For engineering managers
- Which of the bots you pay for earns its keep — cost, noise mix and overlap, per workspace.
- A reliable state of play — stalled PRs, waiting reviews, quiet threads — without asking anyone.
- Flow metrics you can drill into. Mirrors, not scorecards.
For engineers
- Know instantly when it’s your turn, without keeping forty tabs warm.
- Every review thread triaged: what a commit already addressed, what still needs you.
- Reply, resolve, rebase, merge — without leaving the board.
09:08 · The receipt: 214 bot comments this month. 61% nits. Your two bots agreed 58% of the time.
Every bot comment, independently graded.
Limn’s own ML model — trained on years of GitHub bot reviews, no LLM calls — labels every bot comment by severity and category, independently of the bot that wrote it. The noise question stops being a feeling: what share is nitpick, what’s correctness, where two bots overlap, and what each vendor costs per comment a human actually acted on.
Five vendors currently claim #1 on the same public benchmark. Limn’s number is about your repos. And it’s in the free tier — a measurement you’d have to pay for is a measurement you’d doubt.
The receipt, in depth →09:12 · A thread nobody answered, on the PR that ships tomorrow. Untouched — three days now.
Forty-one open PRs. Three need you.
My Turn is pull-based, not another notification pile: anything on a PR you authored, review, or were asked into is flagged as yours, full context inline. Every review thread carries one of four states — resolved · likely addressed · replied · untouched — cross-referenced against the commits that landed after it. “Likely” is a heuristic, and the UI says so.
Behind the feed sits the board: every repo, every contributor, one timeline. A long bar with no recent markers is a stalled PR — no query required. Adaptive sync keeps hot repos seconds fresh without burning your rate limit on cold ones.
Everything in the free tier →09:15 · Two PRs were ready all along. Rebase, merge, merge. You never left.
Act where you noticed.
Reply, resolve, approve, request reviewers, rebase from main, merge — real GitHub writes, gated on your real permissions. The merge control knows what GitHub knows: unstable is mergeable, behind isn’t. Failing CI? The job log is one click, in-pane. In a 700-hour field study, resuming interrupted work took twenty-five minutes on average; the point of one surface is never paying that.
09:20 · The digest reads itself: three security flags untouched, five threads need a human.
A digest with teeth.
“This sprint your bots posted 420 comments — 38% acted on. Three untouched security flags on auth PRs. Two bots agreed on twelve issues; you paid both. Five threads actually need a human.”
That’s Pro: attention-and-risk digests instead of activity recaps — plus validity checks on threads while you review, “was this addressed?” with a confidence gauge, themes and reports across human and bot reviews, chat with your repos with charts you can pin, and CI failures summarised to root cause.
The whole intelligence layer →09:24 · The null-check Claude flagged Tuesday: pick the two comments that matter, fix, push.
The whole loop, one app.
Pro+ closes the loop. Context-aware Claude reviews that learn — what you kept, cut and reworded last run informs the next, so settled decisions stay settled. Reword any finding in your voice, or simplify it to its point.
Then pick the comments that matter and generate the fix: patched in an ephemeral worktree, reviewed as a diff, pushed on your click. Every run stays on the PR’s history — no digging through agent session logs, no copy-paste between apps. Your key, your models; nothing posts, pushes or merges without a human click.
Walk through it, screen by screen →Or keep it entirely on your machine.
One command. No accounts, no hosted backend, no stored credentials — it authenticates with your gh CLI, syncs to a local SQLite file, and opens straight to the Activity console. Or self-host the same image inside your own infrastructure. Your code and AI spend stay under your control.
What happens when you run it →Free where it matters. Paid where it counts.
Free
$0, foreverThe dashboard, the timeline, My Turn — and the bot receipt.
Pro
$15/seat/moThe intelligence layer — digests with teeth, validity, themes, chat.
Pro+
$29/seat/moThe full loop — Claude review and fix, on your own key.
09:31 · Standup. You already know.
Know by 9:31.
Sign in with GitHub and the recent timeline fills in seconds, while the full history backfills behind it.