AI code review that reads your entire codebase

Macroscope goes beyond static analysis. AI agents read your entire codebase, explore the code around every change, and catch the semantic bugs that pattern matching misses.

GitHubGet started

$100 in usage credit and 1,000 agent credits every month. No seat fees.

services/billing/handler.go
func ProcessRefund(ctx context.Context, req *RefundRequest) error {
user, _ := s.users.GetUser(ctx, req.UserID)
return s.stripe.Refund(user.StripeID, req.Amount)
}

// Static analysis: ✅ No issues found
// Linter: ✅ Passes all rules
macroscope[bot]Bug
Ignored error on user lookup. The error from GetUser is discarded with _. If the user doesn't exist, user is nil and user.StripeID will panic. Either return the error or handle the nil case before calling Refund.

What Macroscope does differently

Static analysis is valuable. Macroscope takes a different approach that goes deeper.

Semantic bugs need more than pattern matching

Traditional static analysis catches style issues and known anti-patterns. But the bugs that break production — cross-file data flow errors, race conditions, broken API contracts — require understanding what code actually does.

Custom rules should be easy to write

Configuring linting tools means learning DSLs, YAML schemas, and tool-specific rule syntax. Macroscope lets you write rules in plain English — a markdown file is the rule.

Code review needs full codebase context

Scanning files individually misses the big picture. Macroscope explores the surrounding code in your repository to understand how changes propagate.

Pricing should scale with usage, not headcount

Per-seat pricing grows linearly with team size. Macroscope uses usage-based pricing — your cost reflects how much code is reviewed, not how many developers you have.

A Different Approach

AI agents that read your codebase end-to-end — with deep reference graphs, custom rules in plain English, and the precision to only flag what matters.

Full-repository context

Macroscope reviews every language the same way. For each change, it explores the surrounding code in your repository, so when you change a function signature, it can check the code that calls it.

Rules in plain English

A markdown file IS the rule. Write what to check in natural language — no DSL, no regex patterns, no tool-specific configuration. The agent reads it and enforces it on every PR.

AI that reads your code

Macroscope agents read the full repository — not just the diff. They can grep, navigate references, run git log and blame, read config files. They understand context the way a human reviewer does.

98% precision

The highest of any AI code reviewer, per our published benchmark. No more drowning in false positives — Macroscope only flags issues that are real, reachable, and serious.

Choose your model

Each check specifies which LLM to use — Claude Opus for deep security audits, Sonnet for lightweight checks. Tune reasoning depth and effort level per agent for cost control.

Connected integrations

Agents pull context from your team's tools — Sentry for errors, Linear for tickets, BigQuery for data, Slack for notifications. Not just code scanning in isolation.

Proof, not promises

98%

Precision in our published benchmark — highest of any AI code review tool. Highest bug-detection rate across 8 languages.

Read the benchmark results
Customer logoCustomer logoCustomer logoCustomer logoCustomer logoCustomer logo

How Macroscope compares

Different approaches to code quality. Here's how they compare.

Static analysis toolsMacroscope
Third-party linters (ESLint, PMD, Pylint, etc.)Purpose-built AI agents with deep code understanding
Pattern matching (regex, AST rules)Semantic analysis with full codebase context
Tool-specific rule configurationRules in plain English markdown files
Per-file scanningAgentic review with full-repository context
Per-developer per-month pricingUsage-based — no per-seat fees
40+ languages via lintersEvery language, reviewed with full-repository context
Quality gates on coverage thresholdsCustom agents that block or advise — per check
AI layer on top of static analysisAI is the review engine
GitHub, GitLab, BitbucketGitHub (GitLab and Bitbucket on roadmap)

Languages supported

Every language is reviewed the same way, with full-repository context, not shallow linting.

Python
TypeScript
JavaScript
Kotlin
Java
Rust
Swift
Go

Frequently Asked Questions

Codacy is a static analysis platform that aggregates third-party linting tools and adds an AI reviewer on top. Macroscope is AI code review — it uses AI agents that read your entire codebase, explore the surrounding code beyond the diff, and understand code semantically.

It catches cross-file bugs, logic errors, and architectural issues that pattern-matching misses.

Yes. If you use Codacy for SAST, SCA, or secrets scanning, you can keep those alongside Macroscope. Macroscope focuses on the code review side — catching bugs, enforcing custom rules, and reviewing PRs with full codebase context.

Many teams use Macroscope for code review and keep their existing security scanning tools.

Macroscope reviews every language the same way, including Python, TypeScript, JavaScript, Kotlin, Java, Rust, Swift, and Go, plus configuration, documentation, and scripts (subject to file exclusions). For each change, it explores the surrounding code in your repository to understand context beyond the diff.

Macroscope uses usage-based pricing — $0.05 per KB reviewed — with no per-seat fees.

Start with $100 in usage credit and 1,000 agent credits every month. Most teams pay less than per-seat tools.

About 60 seconds. Install the Macroscope GitHub App, and it starts reviewing your pull requests immediately. Custom rules are plain-English markdown files in your repo — no configuration files, no CI pipeline changes.

Macroscope reviews code at the PR stage, where the full context of changes is visible. PR-level review catches bugs that IDE linting misses — like breaking changes that span multiple files, or logic errors that only emerge when you see the complete diff.

Macroscope has 98% precision per our published benchmark — the highest of any AI code reviewer. Macroscope's AI reads your code semantically, so it only flags issues that are real, reachable, and serious. See our benchmark results.

A rule is a markdown file in .macroscope/check-run-agents/ in your repository. Frontmatter sets the dials — model, reasoning depth, include/exclude file globs, and whether failures block merging. The body is plain-English instructions.

Each rule becomes an agentic check run on every PR. Agents can browse your full codebase, run git commands, read GitHub metadata, and pull context from connected integrations. See the full docs.

Simple, usage-based pricing

No per-seat fees. Pay for what you use. Most teams pay less than per-developer pricing models.

$100

In usage credit to get started. Usage-based, never per seat.

1,000

Agent credits every month for custom check run agents.

$0

Per-seat fees. Ever. Pricing scales with usage, not headcount.

60s

To set up. Install the GitHub App and start catching bugs immediately.

Try AI code review that reads your codebase

Go beyond pattern matching. Macroscope catches semantic bugs across your entire codebase. Get started in 60 seconds.

GitHubGet started

$100 in usage credit and 1,000 agent credits every month. No seat fees.

Beyond Static AnalysisCheck Run AgentsAI Code ReviewBenchmark Results

Ready to Get Started?

Join teams building with Macroscope to catch more bugs and merge PRs faster than ever. Simple usage-based pricing. No seat fees, no surprises.

GitHubGet started
Book a demo