Find bugs. Skip the noise.
Corbulo is a high-precision bug detector for large codebases. It combines code structure, history, tests, architecture, conventions, and pull requests to find failures that line-by-line tools miss.
The standard
The best bug detector in the world.
90% precision. The highest recall we can reach. Almost no false positives. If a finding cannot be verified against the codebase, it does not belong in the result.
Most analysis stops at the matching line. Corbulo keeps going.
Code graph
Follow callers, callees, data flow, contracts, and execution paths across the repository.
Repository data
Use churn, co-change, bug-fix history, test reach, and module boundaries to judge impact.
Codebase context
Compare each change against the architecture, conventions, and patterns already in the system.
Claims and evidence stay separate.
Find candidates
Deterministic rules and model-guided analysis propose claims about specific code.
Assemble the evidence
Source, callers, callees, and dependencies are collected without inheriting the claim's verdict.
Adjudicate separately
A separate pass tests whether the defect is reachable, triggerable, and harmful before deciding how it ships.
Issues
Bugs that only appear in context
Corbulo follows values, calls, contracts, error paths, tests, and sibling implementations across the repository. Every finding includes the code needed to verify the failure and decide what to change.
Explore the issue list
Dashboards
Know where the codebase is getting weaker
Health, consistency, architecture, tests, pull requests, and engineering friction are measured from the same analysis. Follow bugs, structural coverage, coupling, churn, hotspots, and bug magnets from the project down to the file.
Explore the dashboardsPull request review
Review the change against the whole codebase.
The diff says what changed. Corbulo checks the intent, affected callers and APIs, architecture zones, repository conventions, parallel work, and bugs introduced by the change before returning a merge decision.
Intent and scope
Classifies primary intent, secondary intents, change type, risk signals, and scope drift.
Graph and zone impact
Follows changed symbols into callers and breaking APIs, then maps touched architecture zones and owners.
Findings in the diff
Anchors security, runtime, testing, and maintainability findings to the lines that introduced them.
Codebase fit
Checks convention drift, hotspots, bug magnets, and co-change warnings around the files being changed.
Parallel work
Detects overlapping or semantic conflicts with open PRs, stacked relationships, and merge-order constraints.
Health and merge verdict
Projects category scores, counts issues added and fixed, and returns ready, needs review, or blocked.
Diff, CI checks, GitHub reviews, and discussion stay in the same review.
Explore pull request reviewZero configuration
Connect the repositories. Corbulo detects the rest.
No language setup, package maps, test configuration, or architecture files required.
Detect the repository
Corbulo identifies languages, build systems, packages, configuration, tests, generated code, and monorepo boundaries automatically.
Map the system
Symbols, callers, dependencies, history, conventions, and architecture zones become one model across a monorepo or related repositories.
Cross-check the findings
Static analyzers, graph rules, repository data, and model-based analysis check one another before a finding is shown.
Integrations
Put Corbulo's code intelligence in the agent loop.
The MCP server gives coding agents access to projects, symbols, callers, callees, findings, health, architecture, conventions, and pull request analysis. Push selected findings to GitHub Issues when they need an owner.
{
"created_at": "2026-03-11T21:01:21+01:00",
... +50 lines (ctrl+o to expand)
... +120 lines (ctrl+o to expand)
... +30 lines (ctrl+o to expand)
Multi-repository systems
The codebase is bigger than one repository.
Modern applications do not live in a single repository. They are made up of multiple services, shared libraries, and independently evolving components. Group related repositories into one project, compare their health, and keep the analysis in one place. Graph traversal stays scoped to the repository it can prove.
Project-level health
Compare repositories, track health trends, and identify which parts of the system need attention.
Repository-scoped graphs
Search symbols, callers, callees, routes, and affected paths without inventing links between repositories.
One project view
Keep findings, dashboards, repositories, pull requests, and settings together for the team.
Pricing
Simple pricing. Scale when you're ready.
Free
Get started. No credit card required.
- 1 project, 1 repository
- Unlimited Analysis Engine PR reviews
- Code health scoring and convention detection
Indie
For solo developers.
- 3 projects, 3 repositories
- 100 LLM Powered PR reviews/month
- Weekly deep analysis, architecture review, living documentation
Pro
For growing teams.
- 5 users included
- Unlimited projects & repositories
- 500 LLM Powered PR reviews/month
- Weekly deep analysis, architecture review, living documentation
Need more? Talk to us about Enterprise.
Find the bugs. Keep the signal.
Start with one repository. See the evidence behind each finding.
Start free. Scale when ready.