Every pull request,readtestedreviewedmerged.
inline reads every pull request against the rest of your codebase: it follows the functions a diff touches, runs your test suite in a sandbox, and keeps the merge check red until the change holds up.
Installs as a GitHub App · about 4¢ a review
From push to merge,
on its own.
Every push takes the same path. The cheap stages run on everything; the slow, thorough read only fires when the change earns it.
- You push
A webhook fires the moment a commit lands, with lockfiles and generated noise filtered out first.
- Fast triage
A cheap pass decides whether the change is worth a deep read. Seconds, a fraction of a cent.
- Deep review
The thorough read: the functions, imports and tests around the diff, before a word is posted.
- Guards the merge
Findings land on the line. The check blocks the merge until the change holds up.
expiresAtis never returned, so the client can't refresh and sessions expire silently.
A swarm of agents over your whole codebase.
A big diff doesn't get skimmed. inline fans out: readers spread across the files, call sites and tests a change touches, each mapping its patch at once, then collapse back into one clean review.
It traces your diff
through the codebase.
A linter sees the line you changed. inline follows it outward, to the functions that call it, the modules that import it, and the tests that should cover it, then reviews the change in that context.
- Follows multi-file call chains, not single-line diffs
- Splits large PRs across parallel readers to map them fast
- Knows the idioms of TypeScript, React, Next.js, React Native and C#
It comments on the line, in plain English.
Every finding lands on the exact line, says what breaks and why, and points at the code that proves it. Low-confidence guesses never post, so you don't wade through nitpicks to find the one catch that mattered.
- Tagged by severity so you triage at a glance
- Threaded and resolvable, with the merge check watching the thread
- Suppressed findings are kept with the reason, not dropped
41 const token = await mint(user);42- return res.json({ token });42+ return res.json({ token, expiresAt });A 40-file PR,
read in order.
inline keeps one comment per PR and rewrites it as the review lands, so you read a single up-to-date summary instead of a stack of bot replies. It groups the diff into layers: schema before the service that uses it, service before the API on top, each with its own summary.
- One comment that updates on every push, not twelve
- Layers ordered by what depends on what
- Opens as a hosted page you can share without a GitHub login
It runs your PR
in a real sandbox.
inline checks out the PR head in a throwaway sandbox, installs it, and runs your test suite. When the change touches code nothing covers, it writes throwaway tests to exercise it, then posts the pass and fail counts under the review with a link to every command it ran.
- A fresh sandbox per PR; your secrets stay yours and nothing sticks around
- Writes tests for uncovered code instead of nagging about coverage
- Pass and fail counts on the PR, with a public page of every step
A green check that
actually means green.
inline posts one status check on the PR head. Run it as a report, or block the merge by severity. A finding stays open until its thread resolves or a later push changes the flagged code, so the check clears itself the moment the work is done.
- Modes: off, report, or block on high, medium or low
- Findings clear when a push fixes the flagged code
- A monthly budget caps spend and falls back to triage, and says so
It learns how
your team works.
When a PR closes, inline reads what happened to each comment: the reaction, whether the thread resolved, whether the flagged code actually changed. It folds that back in. A per-repo memory holds your conventions, and an acceptance rate shows how much of its feedback your team keeps.
- A repo memory of your stack, conventions and fragile files
- Teach it a rule with @inline learn, or accept one it proposes
- An acceptance rate that tracks the findings your team keeps
Made for code that
can't afford to leak.
In a regulated environment a review isn't finished when the logic checks out. inline reads every change against live vulnerability feeds and the agreements you've signed, so a dependency carrying a known CVE, or a vendor with no BAA on file, never reaches production unnoticed.
- Known CVE in a new dependencylodash@4.17.20 · CVE-2026-4203flagged on the PR
- New vendor with no BAA on filetwilio added in package.jsonmerge blocked
- PHI store open to the publicstorage/phi-export · public accessfix attached
Checked against your signed agreements and live CVE feeds, with every result kept as evidence.HIPAASOC 2BAA
It watches the systems around your code.
The engine that reviews your code also watches what runs it: your cloud, your pipelines, your dependencies. It only spends a model call when there's something new to report.
Cloud posture
Connect Azure with one command and no stored secrets. Eight collectors feed findings, each with a fix to apply.
CI root-cause
Every workflow run is watched. Failures get a one-line cause; flaky and slowing jobs get flagged.
Breaking changes
Removed exports and changed signatures are grepped across your other repos. It names the files that break.
Vendor & BAA coverage
New third-party providers in a diff are checked against your signed agreements before they ship.
About four cents
a review.
Cost per PR is the number we optimize first. Cheap stages run on everything, the slow model runs only on substantive changes, and the shared prompt is cached, so reviews stay thorough without the bill climbing.
- Every review carries its own token and dollar breakdown
- Set a monthly budget; past the cap, reviews fall back to triage
Let inline review your next pull request.
Install the GitHub App and point it at a repo. It needs no CI changes and nothing to maintain; your next push gets reviewed.
The client refreshes on
expiresAt, but it's never returned here, so sessions will silently expire without a refresh.mint()already computes it; surface it in the response.