Team reviews code.
Corrdex explains the codebase.

Index your repo, understand what files and functions actually do, and ask Corrdex the kinds of codebase questions grep and filename search usually miss.

Start for free ->Book a demoView pricing
•Hosted and local indexing•File and function understanding•Scoped AI and MCP context•Rules, search, and violations
Focused Benchmarks
Built for fast indexing and concrete repo understanding, not vague architecture theater.
Benchmark size
8k files
Reference repo size for the current ingestion benchmark
Ingestion speed
< 3 min
Fresh indexing for repos around the 8k-file benchmark range
Answer speed
< 10 sec
Repo-structure answers on indexed codebases
Surfaces shipped
4
Web chat, VS Code, CLI, and MCP
corrdex/acme-backend
Scanning
0files indexed
0structural risks
0critical edges
Code path map
CheckoutControllerPaymentServiceOrderRepositoryInvoiceWorker
Repo findings
RISK
Wrong-layer import
CheckoutController imports OrderRepository directly.
VIOLATION
Boundary mismatch
InvoiceWorker writes into the HTTP response layer.
IMPACT
Blast radius: 38 files
A change in PaymentService now fans out across checkout.
Last index: 2s ago · TypeScript · JavaScript · Python2 high-risk paths flagged
When repo understanding breaks down

Your codebase grows.
Team understanding does not keep up.

Every team starts with good intentions. Over time, responsibilities blur, flows get harder to trace, and the original structure becomes invisible. Reviews miss context. Documentation gets stale. And the engineer who knew how it all fit together is working on something else now.

Corrdex exists to keep repo context visible, searchable, and usable before teams have to guess.

"Why does this request path jump layers like this?"
The real execution path gets blurry as a codebase grows. People stop seeing the pattern until they are already debugging the wrong area.
"I'm terrified to touch this module."
There is no clear view of downstream impact. You do not know what a change fans out into until something breaks.
"The only map of this repo lives in one engineer's head."
Codebase knowledge evaporates with every team change. New engineers inherit files and services, but not the reasoning behind them.
"We need repo rules people can actually follow."
Review comments and docs are not enough on their own. Teams need searchable context, visible rules, and structural signals that stay attached to the codebase.
See it in action

The features that matter most

Architecture Drift Detection

Catch drift before it becomes
a crisis.

Most teams only discover architecture drift during a painful refactor sprint after years of accumulation. Corrdex monitors every file continuously and flags violations the moment a responsibility boundary gets crossed.

->Detects files accumulating the wrong responsibilities in real time
->Surfaces drift trend over time so you can see if architecture is improving or slipping
->Blocks PRs that introduce new drift while tracking legacy violations separately
Learn more ->
ControllerServiceRepository
Change Impact Analysis

Know the blast radius
before you merge.

"It's just a small change" until it takes down checkout because it touched a shared utility four layers deep. Corrdex maps the full downstream impact of every PR before you approve it.

->Blast radius scored by architectural coupling depth and dependency criticality
->Posted directly to your PR as a comment with no dashboard required
->Distinguishes high-risk structural changes from low-risk text changes
Learn more ->
StripeServiceAuthServiceCartServiceNotifyWorkerEmailServiceRefundServiceBillingServiceOrderServiceCheckoutAPIInvoiceWorkerPaymentService
Team Architecture Governance

Encode your best engineers.
Make rules that actually run.

Architecture rules should not live in docs nobody reads. They should run in CI and block merges. Corrdex lets you encode the things your senior engineers know and enforce them across every PR.

->Write rules in TypeScript with no custom DSL to learn
->Rules run at PR time and block merges automatically
->Architecture Memory ensures judgment survives team churn
Learn more ->
RulesPoliciesDecisionsPatternsReviewsGuardrailsCorrdex
Built for every role

Everyone wins when repo understanding is clear

For Developers

Stop second-guessing. Understand where code lives, what is safe to change, and how a change spreads before you touch a shared path.

File and function understanding for unfamiliar code paths
Blast radius signals before touching shared code
Structural diff, not only line diff
Ask the codebase questions in plain English
Faster onboarding into an unfamiliar repo
See developer features
For Team Leads

Your team should not depend on one person to understand the repo. Corrdex makes structural context, dependency risk, and shared rules easier to see across reviews.

Shared repo rules and structural expectations
PR-facing structure review for risky paths
Codebase memory that survives team changes
Drift signals before responsibilities spread further
Topology and dependency views for system context
See team features
For Engineering Orgs

Give more teams a shared way to understand large repos, preserve structural knowledge, and reduce the time lost to re-learning the same systems.

Faster onboarding across teams and projects
Persistent repo knowledge across reorganizations and departures
Shared rules and structure signals across projects
Better visibility into risky dependency surfaces
A stronger base layer for coding agents and internal tooling
See enterprise features
AI-assisted architecture reasoning

Ask your codebase
anything.

Natural language questions with architecturally grounded answers backed by the actual structure of your codebase.

•"What owns the payment flow?" traces ownership across 3 layers
•"Where is our auth logic scattered?" finds fragmented responsibility
•"Which files are most risky to change?" surfaces high-coupling nodes
•"How does data flow from API to DB in the order module?" returns a full trace
In betaTry Corrdex AI ->
Corrdex
Corrdex AI
Reasoning over your architecture · beta
Where is our payment logic scattered across the codebase?
Payment logic is spread across 6 files in 4 different layers. Here is the map:

paymentService.ts — core logic
checkoutController.ts — inline charge logic
orderRepository.ts — writes payment status
stripeWebhook.ts — handles refunds
invoiceQueue.ts — re-charges failed payments
userService.ts — subscription logic

The faded files are where drift is accumulating.
Which of these is riskiest to change right now?
checkoutController.ts is highest risk. It is imported by 9 downstream files and has only 34% test coverage.
0k
Reference repo size for the current fresh indexing benchmark
0 min
Fresh indexing time around the current 8k-file benchmark range
0%
Faster onboarding for new engineers
0.0k
Current baseline for full Corrdex AI answers after prompt compaction
Integrations

Works with your existing stack

Plugs into your PR workflow and CI pipeline without forcing a separate review surface on the team.

GitHub
GitLab
Working on it
GitHub Actions
Working on it
Pricing

Plans for every stage of your architecture

Hosted usage scales with projects, AI token quota, retention, and how much concurrent work your team needs.

Free

For developers trying Corrdex on a single hosted project.

$0
Free forever
Top Features
  • 1 Project
  • Up to 150 indexed files / project
  • 200k AI tokens / month
  • CorrdexLive MCP included
  • ~50 CorrdexLive MCP requests / month
    Based on roughly 4k tokens per request. Actual usage varies with scope, branch mode, and context size.
  • 7-day retention
  • 1 active hosted job
  • Hosted indexing and AI chat
  • Project files, violations, dependencies, and activity
  • OSS CLI and MCP stay free
  • Community support
Get Started

Pro

For individual developers and consultants using Corrdex regularly.

$24
annual billing
Everything in Free, plus
  • 5 Projects
  • 8M AI tokens / month
  • CorrdexLive MCP included
  • ~2K CorrdexLive MCP requests / month
    Based on roughly 4k tokens per request. Actual usage varies with scope, branch mode, and context size.
  • 30-day retention
  • 1 active hosted job
  • Higher hosted AI chat capacity
  • Run history and project context kept longer
  • Email support

Team

Current Team Plan

For small teams running multiple projects with shared hosted access.

$79
annual team billing
Everything in Pro, plus
  • 25 Projects
  • 40M AI tokens / month
  • CorrdexLive MCP included
  • ~10K CorrdexLive MCP requests / month
    Based on roughly 4k tokens per request. Actual usage varies with scope, branch mode, and context size.
  • 90-day retention
  • 3 concurrent hosted jobs
  • Shared team workspace
  • Shared hosted project access
  • Priority support

Enterprise

For teams that need custom limits, support, or deployment terms.

Custom
Contact us for pricing
Everything in Team, plus
  • Custom project limits
  • Custom AI token quota
  • CorrdexLive MCP included
  • Custom CorrdexLive MCP request capacity
    Sized against your token budget and expected request shape.
  • Custom retention
  • Higher concurrency
  • Private deployment options
  • Security and support terms
  • Custom onboarding
Contact Sales
Open full pricing page
Ready to keep your architecture honest?

Stop letting architecture drift.
Start enforcing it.

Your first repo is free. Start with hosted indexing, rules, and AI without a long setup cycle.

Analyze your repo free ->Book a demo