An intellectually honest review.
Made of building blocks you can understand, trust and build on.
Facts you can check.
Judgement you can question.
Agentic exploration rediscovers your codebase on every run, answering it differently. Abstraction compiles it once, keeps it current, and hands the facts to an LLM.
Computed
From the semantic model of your codebase. The same answer on every run.
- Which functions a pull request changes, what was only renamed, and which code is generated.
- Who calls each changed function, what it calls, and who else reads or writes the state it touches.
- Your deterministic checks, on every statically traceable path, in milliseconds.
Reasoned
By an LLM, with those facts in hand.
- What each changed function now does, and whether that is a bug.
- Whether a finding holds up. A separate step drops false positives before anything is posted.
- The judgement calls no query can make, like your team’s conventions.
ExportCSV in invoices/export.go calls ProrateSeats and casts Seats to an int, so a 2.5-seat upgrade exports as 2 and the export stops matching the invoice.
One comment from the pull request above.
The reach is computed. ExportCSV lives in another package, and no line of the diff touches it. The semantic model finds every caller of ProrateSeats and shows the reviewer how they use it.
The consequence is reasoned. Reading that call, the reviewer works out what a fractional seat count does to the export.
Discuss opens the finding in a chat with our agent. Fix in opens Claude Code, Codex or Cursor on your repository with the finding as a ready-made prompt.
Name what matters.
Tags and roles are a structure you can curate yourself enabling a shared vocabulary and fast lookups.
This function writes customer data to a bucket outside the system. Tag what the code touches, and add your own tags for what your team cares about.
Once named, it can be found in one query and followed through every flow. The tag travels with the value until a sanitizer clears it, and that is what checks are written against.
Make your intent a hard constraint.
Your rules, enforced on every pull request.
The rule
Asked of our agent as "personal data never reaches a log line". It drafted the query from the codebase, and an admin approved it. Read aloud: the places personal data ends up share nothing with what loggers take in.
The counter-example
assertNoOverlap: 1 shared element
- api/invites.ts email Email
- → mail/queue.ts job.payload
- → log/logger.ts info(job) Logger
The invite handler's email flows into the queued job, and the queue hands every job to the logger. No line of the diff mentions a logger. The shared element is the value trail that breaks the rule.
No name, email or phone number reaches a log call, on any path.
Every value tagged sensitive passes a sanitizer before any database write. An agent then reads the functions this change reaches for consent handling.
Every function tagged public passes an authentication check before it handles the request, on every path.
When a prompt or Markdown file is added or changed, an agent checks it against the team’s conventions.
Nothing tagged annual reaches ProrateSeats, directly or through its callers.
AQL (Abstraction Query Language) checks are deterministic queries over the semantic model: data flow, reach and structure, on every path that can be traced statically, in milliseconds. Agent checks take the rest: code that is not statically traceable, and judgement calls like conventions and style.
A review comment that keeps coming back becomes a check. Nobody writes it twice.
01 · WriteAsk our agent in a sentence and the check runs on every repository in the workspace, or commit a check file to cover just that repository, like any CI check. Templates cover GDPR, entrypoints and more.
02 · ScopeScope it to the paths, file types, tags or roles it cares about, so it runs only where they change.
03 · EvaluateIt queries the semantic model, not the text, so it catches what code reaches, not just what it mentions.
04 · GateEach check is its own GitHub check run. Set its severity to fail, and branch protection makes it a merge requirement.
CI proves the code builds. Checks hold it to your rules, whoever wrote it. Each check you add guards every pull request after it, so trust in the review compounds.
Review your next pull request with Abstraction.
We are onboarding teams in waves. Request access and we will reach out when your spot opens.
ABSTRACTION
2026
Abstr AB · Karlavägen 50, Stockholm