AI code review that reads your entire codebase

Macroscope goes beyond static analysis. AI agents read your entire codebase, build deep reference graphs, and catch the semantic bugs that pattern matching misses.

GitHubGet started free

$100 in free usage and 1,000 free 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 builds a reference graph of your codebase, following function calls across files and understanding 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.

Deep reference graphs

Macroscope builds full AST-level reference graphs for every supported language. It tracks function calls, type references, and imports across your entire codebase — so when you change a function signature, it knows every caller.

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 scanningFull reference graphs across your entire codebase
Per-developer per-month pricingUsage-based — no per-seat fees
40+ languages via lintersDeep AST analysis for 8 languages (more coming)
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

Deep AST-level analysis with full reference graphs — not shallow linting. Every language gets a purpose-built analyzer.

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, build reference graphs, 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 supports Python, TypeScript, JavaScript, Kotlin, Java, Rust, Swift, and Go with deep AST-level analysis and full reference graphs. Each language gets a purpose-built analyzer that tracks function calls, type references, and imports across your entire codebase.

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

Start with $100 in free usage and 1,000 free 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 free usage to get started. No credit card required.

1,000

Free 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 free

$100 in free usage and 1,000 free 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 free
Book a demo