The intelligence layer — and the full loop.
The free board shows you everything and grades your bots. Pro adds judgement: digests with teeth, validity on threads, themes across reviews, answers on demand. Pro+ closes the loop — Claude reviews that learn, and fixes you approve — with a human hand on the wheel at every step.
A digest with teeth, as your team ships.
“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.”
Not an activity recap — an attention-and-risk report, built on the free tier’s receipt and thread states, per repo, chained from the previous one so it says what changed, with every PR a clickable #N.
Refresh manually, on an interval, or on-change. An unchanged repo costs $0, by design — Limn hashes the underlying activity and skips the model call when nothing moved.
Sprint’s end · The report you used to assemble at 9:57 for the 10:00 wrote itself — and it names the risks, not just the activity.
Is this comment worth your time? Asked and answered, inline.
“AI solutions that are almost right, but not quite”
“Almost right” is exactly what costs review time. While you review, Pro assesses the thread you’re reading: is the comment valid, does the objection still hold, and — past the free tier’s file-touch heuristic — was it actually addressed, with a confidence gauge. Long bot chains get distilled to their point, so you decide from the substance, not the scroll.
Mid-review · The gauge reads “addressed · high confidence”. You spot-check one and move on with your morning.
The questions retros are supposed to answer.
“AI’s primary role is as an amplifier, magnifying an organization’s existing strengths and weaknesses.”
No instrumentation, no extra pipeline — Limn already synced your history. Themes surface what keeps recurring across human and bot reviews — the module every reviewer trips on, the category one bot floods — and reports cut the record by severity and theme, per sprint window, re-runnable from the archive. Where the free receipt says how much, this says what about — the thematic bottleneck behind the number.
- Deploy frequency — how often work actually lands
- Lead time — from first commit to merged
- Review latency — how long PRs wait for a first review
- Merge vs CI health — how much of the pipeline is green when it counts
- CI recovery time — real red→green MTTR, from a transition log — not a proxy
Every tile clicks through to the PRs behind the number — no black-box aggregates. Mirrors, not scorecards: better conversations, never rankings.
Retro · The recurring theme was named before the meeting started. The retro argues about the fix, not the facts.
Ask the repo. Keep the answer.
Atlassian’s State of Teams 2025 put a number on hunting for answers: teams lose a quarter of their time to it. So ask in plain language — “who reviewed payments this sprint?”, “which PRs waited longest?” — grounded in your synced data, never a hallucinated dashboard. Answers arrive as charts, built ad hoc.
Useful ones come pre-built; the ones worth keeping you pin, and past reports stay viewable and re-generable — the chart that settled last retro’s argument is one click, not an archaeology dig.
Wednesday · A question asked in English, answered as a chart, pinned for the next time someone asks it.
Red CI, explained before you open the log.
“72 minutes to get back to green for the typical team, up 13% from last year”
A failing check gets a one-click diagnosis: Limn pulls the failing job log and names the root cause — with its confidence stated up front, so you know how much to trust it before you act. And when you want the fix made, the same diagnosis hands off to Pro+ below.
Red build · The diagnosis beat you to the log. You read one sentence, not a thousand lines.
- My Turn intelligence — the feed is participation-aware: events on PRs you authored, review or weighed in on are flagged as yours, never buried under a volume cap.
- Slack digests on your cadence — daily or twice daily, timezone-aware. If nothing happened, nothing posts. (Email is on the roadmap.)
- Jira & Linear links — ticket keys detected from titles and branch names, rendered as deep links. Zero convention changes.
- Reviewer suggestions drawn from who actually touched the changed paths — requested in one click, rationale shown.
The full loop.
Everything below runs a real agent against your code — reviews, fixes, conflict resolution — on your own Anthropic key, usage metered in-app, and one rule always in view: nothing posts, pushes or merges without a human click.
Reviews that are still there next week.
Most AI code review happens in a chat tab — useful in the moment, gone the moment you close it. Limn runs the review against the PR, structures the output, and saves it per commit — no digging through agent-session histories, and the old run stays in history when you re-review after a push. Claude Sonnet 5 by default; Opus 4.8 for the gnarliest diffs; Haiku 4.5 for a quick pass.
Fast path, no clone
Small, contained change touching no exported contract? The diff is inlined into the prompt — no checkout, a tight turn cap, seconds to finish. For the fix, the style pass, the refactor where the diff is the context.
Full checkout to explore
Too many files, more than one subsystem, or any exported API, schema or migration — the run earns a partial clone and an ephemeral worktree, with read-only tools to trace callers against the real tree. Ambiguous? It rounds up to deep.
A deterministic router picks the depth before a token is spent, so cost tracks complexity. Force a mode per run if you like; every run is capped by turns and by dollars, and cancelable mid-flight.
A real review, step by step.
These are the actual screens, in order. Four steps, a few seconds of your attention each — and one human decision at the end.
Open the PR, pick a depth — or let the router.
From any PR’s detail pane, open the Claude Review tab. Pick a model and a depth, or leave both on Auto — this 2-file, 72-line change earns the fast, no-clone path; touch an exported API and it rounds up to a full worktree.
It already knows how you review.
Before the run, Limn surfaces what your past reviews in this repo taught it — the finding you reworded (and how), the style nits you keep dismissing — and hands those to Claude as context. Every review feeds the next one; a chat-tab review starts from zero, every time.
Read findings, not a wall of prose.
Each finding carries a severity, a file:line anchor, its diff hunk, and an optional suggestion. Per finding you choose — post Claude’s wording, reword it in yours, simplify it to its point, or ignore it. Here the blocker and warning stay; the nits are already cut.
blocker · warning · nit · question · praise
Post one GitHub review. Yours.
Write the top-level comment in your own words, pick the verdict, and post — one GitHub review: your body, your verdict, your chosen findings inline, pinned to the head SHA so it can never land on stale code. Accepted a finding that needs code? “Generate fix from this review” hands your curated findings straight to the fixer below.
Why not just ask the CLI?
You can — and the review evaporates when the session ends. No line-anchored posting, no per-commit history, no memory of what you kept last time, and the copy-paste back into GitHub is on you. Limn keeps the same agent, and removes the same twenty minutes — per PR, per day.
Thursday · Run two doesn’t re-flag what you cut in run one. The bot is learning your taste; the noise goes down with use, not up.
From red CI to pushed fix, one click at a time.
Red CI to pushed fix, step by step.
A real failing check on a real PR. Total human effort: reading a diagnosis and approving a diff.
CI goes red. You don’t go log-spelunking.
terraform plan fails on an infrastructure PR. Normally that’s a tab into GitHub Actions and a scroll through a thousand log lines. Here the failing check is already on the PR’s pane — and the next step reads the log for you.
One click for a diagnosis, with its confidence shown.
The diagnosis names the root cause — an inverted min/max bound — why the other checks passing narrows it, and a suggested fix, with confidence stated up front. Agree? Click Fix it →.
The agent patches in a sandbox. You review a diff.
The fix runs in an ephemeral worktree — never your checkout, never the live branch — and comes back as a reviewable diff. Two lines changed here; you read it in ten seconds. Nothing has touched GitHub yet.
Push it — conflicts included, force-push excluded.
Approve the commit message and pick the target: the PR’s branch or a new one with a fresh PR. Trunk moved underneath? Limn can rebase or merge with agentic conflict resolution in the same worktree, showing you the result first. It never force-pushes anywhere but the PR’s own branch, never without your click — and a conflict the agent can’t cleanly resolve is never pushed at all.
Could you do this in your CLI?
Absolutely: clone, checkout, tail the log, paste it at the agent, apply, resolve the rebase, push — fifteen minutes when nothing surprises you, times every red build. Limn makes the loop four clicks, and the git plumbing — worktrees, conflicts, branch hygiene — is the part it never gets wrong.
Your models, your data.
Your key
Pro+ runs on your own Anthropic API key — the model spend is yours at list price, metered transparently in credits, in-app. No markup, no surprise bills, no background spend.
Coming
Metered pay-as-you-go at API list price, and OpenAI-compatible BYO endpoints — Bedrock, self-hosted, open models — for cost and privacy control.
The rule
AI never merges, posts, or pushes without a human click. Every review is yours to author; every fix is a diff you approved. That’s not a limitation — it’s the feature.
Your data is yours — private and confidential, forever. Limn never trains on it, never shares it, and in local mode it never even leaves your machine.
Fifteen dollars a seat. Fewer than the tabs it closes.
The board is free forever. Pro reads it for you; Pro+ acts on it.