Code intelligence for agentic development
Know the code before your agents change it.
ArchBeagle indexes every repository you connect: its modules, functions, calls and complexity, and what depends on what. Your agents ask it before they edit. Every pull request is checked against the architecture you approved.
GitHub sign-in · Python, JavaScript, TypeScript, Go, Java, PHP and Ruby

One index, four ways in
Every repository, from the account down to a single function.
01 · Map
See where the weight is
One repository a level at a time: components, folders, files and functions, what uses each and what it uses, marked where complexity crosses a threshold.
02 · Explore
Open any function
Its complexity, lines and parameters, its module, and the calls in and out, with the tests that reach it.
03 · Impact
Know what a change reaches
Walk back through what calls, uses, imports, extends or implements it, with the calls that reach it from other repositories over HTTP and RPC.
04 · Enforce
Hold the architecture
Every pull request checked against the model you approved. Each rule blocks, asks for approval, warns or only watches.
02 · Explore
Open any function.
How complex it is, and how many functions are simpler. Where it lives, who calls it and what it calls, two steps each way, each call exact or matched by name only, so you know which to check. One link out, to the lines on GitHub.

03 · For Claude Code, Codex and Cursor
Your agents ask before they edit.
One MCP server, one token per agent and person. The agent reads the same index you see, and every answer says how fresh it is.
change_impact({
"repo": "acme/shop",
"symbols": ["shop.orders.cart.Cart.total"]
})“I'm changing how discounts round. Who depends on Cart.total?”
{
"changed": 1,
"affected": [
{ "qualified_name": "shop.web.checkout.place_order",
"path": "src/shop/web/checkout.py",
"lines": [14, 61], "word": "Complex", "depth": 1 },
{ "qualified_name": "shop.orders.invoice.render",
"path": "src/shop/orders/invoice.py",
"lines": [8, 40], "word": "Simple", "depth": 1 }
],
"affected_total": 6,
"tests_total": 3
}find_symbol
A function, method or class by name, with its file, lines and complexity.
symbol_context
What calls it, what it calls, the tests that reach it, and links from other repositories.
trace_calls
The calls to or from a symbol, up to five levels deep.
change_impact
Everything that depends on the files or symbols you're about to change.
code_complexity
Complexity for a repository, a module or a function, against the thresholds.
check_planned_change
Whether an import you plan is allowed by the approved architecture.
A hook in Claude Code and Codex asks before each edit, and can stop one the architecture doesn't allow. Set up an agent
04 · Enforce
Then hold the architecture.
Keep a model of your components, layers and owners in Git, or draft one from the code. Every pull request is checked against it, by people and by agents. Each finding names its rule, file and line; approvals, exceptions and an append-only audit log record who allowed what.

What each one sees
- A linter
- One file at a time: style, bugs, banned patterns.
- An AI reviewer
- One pull request's diff. Its comments are suggestions.
- ArchBeagle
- The whole codebase's calls and the architecture you approved, before an agent edits and on every pull request, with a recorded result.
Questions
What does it need from me?
A GitHub organisation or account with the ArchBeagle GitHub App, and the repositories you choose. The code index needs nothing else. For the architecture check, a model of your architecture: one you keep in Git, or one ArchBeagle drafts from your code for you to approve.
Where does my code go?
The code index reads each repository's main in a sandbox and keeps only paths, names, line ranges and metrics. The architecture check runs in your own CI and keeps its result as a build artifact, which ArchBeagle reads through the GitHub App.
What do agents see?
Only what their token opens over MCP: the code index, the model, the rules and the open findings. Each token belongs to one agent and person and is stored as a hash.
Which languages?
Python, JavaScript, TypeScript, Go, Java, PHP and Ruby, function by function. Where a language's calls are only partly resolved, the app says so in one sentence, with how many.
Facts, never code
We read your code in a sandbox, and keep only what it says about itself.
Read in a sandbox
Each repository's main is fetched and indexed apart, with a token held for the fetch alone. Nothing of yours is run.
Paths, names and numbers
ArchBeagle keeps paths, names, line ranges and metrics. Never the source code.
Your organisations only
Every read keeps to the organisations you belong to. Agent tokens are stored as hashes, and no secret is ever sent back.
See your code the way your agents will.
Sign in with GitHub, connect an organisation or your own account, and choose the repositories ArchBeagle indexes.
Works with GitHub · GitHub Actions · Claude Code · Codex · Cursor · Slack · Backstage · OpenTelemetry, and more. Every integration