Skip to content
ArchBeagle

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

The code map: a module's files, walk.py marked Very complex 31, with what uses it on the left and what it uses on the right, and its facts in a side panel
Code · MapArchBeagle · the app

One index, four ways in

Every repository, from the account down to a single function.

  1. 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.

  2. 02 · Explore

    Open any function

    Its complexity, lines and parameters, its module, and the calls in and out, with the tests that reach it.

  3. 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.

  4. 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.

A function's page: get_lineage, Simple with complexity 7, its lines, parameters and how it compares, its module's functions and its calls in and out
Code · A functionArchBeagle · the app

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.

agent:claude-code → MCP
change_impact({
  "repo": "acme/shop",
  "symbols": ["shop.orders.cart.Cart.total"]
})

“I'm changing how discounts round. Who depends on Cart.total?”

ArchBeagle answers
{
  "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.

An agent's pull request: merged, nothing blocked it, and four findings worth a look, each with its rule, file and line
Pull requests · An agent's changeArchBeagle · the app

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.

How we keep it

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