Platform

Understand your codebase.

From planning to review.

Agent

Meet our agent.

It does not grep your codebase, it queries it from a compiled model.

Agent billing
What breaks if ProrateSeats starts returning fractional seats?
Checking who calls ProrateSeats 1
fn(ProrateSeats).callers()
→ 3 functions

ExportCSV in invoices/export.go casts Seats to an int, so a 2.5-seat upgrade exports as 2 and the export stops matching the invoice. RenderLineItems and MonthlySeats keep the fraction and are fine.

ExportCSV RenderLineItems MonthlySeats
Do any tests cover that?
Finding tests that call ExportCSV 1
fn(ExportCSV).callers().filterRole(Role.Test)
→ 2 functions

Two tests call ExportCSV, and both use whole seat counts, so neither would catch the 2.5-seat export. TestExportCSV_Upgrade is the place to add that case.

TestExportCSV_Monthly TestExportCSV_Upgrade

One agent, wherever you ask.

People and coding agents talk to the same agent, which queries the same compiled model, so nobody works from a different picture of the code.

  • In the app Beside every review, wiki page and check.
  • In Slack In a direct message or a thread, where the team already talks.
  • In pull requests Ask in a comment and the answer lands on the PR.
  • In your coding agent Claude Code, Codex and Cursor can ask our agent over MCP instead of searching files.
  • In your terminal Through the abstr command line.

In the app and Slack, the agent drafts checks and proposes concept edits as cards. Nothing changes until someone approves it.

Measured on our own code

The same coding agent, with and without Abstraction.

Same model and the same commit of our monorepo on both sides, with every answer graded against a fixed key.

Questions about structure

What eventually calls this function? Which functions call the most others, or run the longest?

  • Several times faster
  • A fraction of the cost
  • Correct in every run

Questions about how something works

How does a request get authenticated? What marks a record as dirty?

  • About as fast
  • Cheaper
  • Right more often

The widest gap: find every function that eventually calls one worker entry point.

On its own
Over ten minutes and dozens of file searches
With Abstraction
About half a minute and a couple of queries
Concepts

Reason once, reuse everywhere.

Concepts are the understanding above the code. An agent works it out once and writes it down. Every run after that reads the result, and the result never drifts.

Reason once billing
  1. 01 Read 38 files
  2. 02 Traced 112 calls
  3. 03 Followed 9 data flows
  4. 04 Wrote it down
50,000 tokens, once
Seat Proration process

Prorates seat changes to the day for monthly subscriptions. Annual plans never prorate.

ProrateSeats seatDelta RenewSeats

Cycle length comes from the subscription, not the plan, since PR #4821.

Re-verified with PR #4821
Reuse everywhere Illustrative
  • The agent, asked in Slack 2 × 1,000
  • The review of PR #4821 3 × 1,000
  • Claude Code, planning through MCP 5 × 1,000
1 exploration + 10 reads60,000 tokens
10 explorations500,000 tokens
Saved440,000 tokens

A concept can be a subsystem, a process, a glossary term, or the context around a piece of code that never fit in a comment. It is compiled and re-verified from the code on every change, so it never describes last quarter’s system. The wiki stays for people.

Diagrams

Diagrams compiled from the code.

Architecture maps and control flow diagrams, compiled from the code itself, so they cannot drift. The readability of a low-code interface, for the code you already have.

The Technology

How it works

A semantic model of your code, powering every PR review.

An abstract syntax tree compiled from each supported language in your stack. Callgraphs, control flow, and data flow derived from it. Semantic diffs apply incrementally as code changes, and every PR is reviewed against the whole model.

░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓

Compile

Every language, one semantic representation.

We compile every line of code in every service into the same abstract syntax tree. Algorithmic, deterministic, no LLM in the loop.

This is the foundation everything else is built on. We call it the Universal Syntax Compiler.

Svelte
React
JavaScript
Python
Go

Why Abstraction?

Because you can't sign off on what you don't understand.

Reviews beyond the diff

Every PR is reviewed against a structural map of your whole codebase, not just the changed lines. Catch the regression three modules away, the invariant that no longer holds, the assumption that's quietly stale.

01 / 06

Sign off with confidence

You shouldn't need to know every corner of the codebase to sign off on a change. Abstraction explains what a PR means and what it touches, so you review faster with the same trust in what you merge.

02 / 06

Keep pace with your agents

Agents open PRs around the clock. Abstraction reviews each one as it lands and tells you in Slack when it is ready, so review stops being the queue everything else waits in.

03 / 06

Reason once, reuse forever

Agentic exploration rediscovers the same structure on every run and gives a different answer each time. Abstraction does the structural reasoning once, deterministically, and every review builds on the result.

04 / 06

Knowledge that compounds

What your team learns about the codebase doesn't evaporate at the end of a session or when someone leaves. It accumulates into a shared, structured layer that every human and agent draws from.

05 / 06

Map your whole stack

From a single service to a workspace of many repositories, Abstraction builds one model of how the code fits together, and reviews every PR against it.

06 / 06