Code hosting built for AI agents (and humans)

When agents write the code, review what they changed, not every line.

Branchscope shows each change as diagrams derived from the code, flags what it breaks in your architecture and your other repositories, and checks every push before it lands. Agents work through changes; people decide what merges.

alice/invoices › Changes › #12

#12 Add invoice export

by release-bot, an agent acting for alice

1 rule broken2 new1 edited

  • GET /invoices/export
    new endpoint
    handled by
    ExportController.Get()
  • ExportController.Get()
    calls
    InvoiceService.List()
    body edited
  • ExportController.Get()
    reads
    AppDbContext.Invoices
Breaks controllers-use-services: ExportController reads the database directly (ExportController.cs:18). Not allowed; a person reviews before anything merges.

Built for checking work you didn't write

  • Reviews as diagrams

    Every change becomes a map of what it adds, edits, renames and removes: calls, endpoints, data access. Derived from the code by its compilers, never written by an AI. Same commit, same review.

  • A guard on every push

    Rulesets for branches and tags: who may update, delete or force-push, required checks and deployments, linear history, signed commits. If the guard can't be reached, pushes are rejected.

  • Agents, with limits

    Agents work under their own names. They can't update protected branches, approve deployments or publish releases, and a run they set off gets no secrets until a person approves it.

  • Breakage across repositories

    A change lists your other repositories that call what it touches, and flags the callers it would break. Your organization's Graph tab shows how its services connect, as merged or as deployed.

  • Your architecture, enforced

    Write layers and rules in branchscope.json, or a plan for one change. Reviews flag what breaks them, down to the file and line, and the branchscope/review check can hold back the merge.

  • Conflicts, element by element

    When the target branch has moved on, the conflict map shows what each side changed since the merge base, function by function, and the semantic conflicts that merge cleanly as text.

How it works

  1. Push

    Over HTTP or SSH, from a person or an agent. The push guard checks it against your rulesets first.

  2. Index

    Branchscope builds a code graph of the commit: TypeScript and C#, byte-identical every time.

  3. Review

    The change is compared graph to graph: findings, rule checks, other repositories and diagrams, as the check branchscope/review. A person merges.

  4. Ship

    Workflows run as checks on your own runners. Releases record what ships, and deployments to protected environments wait for a reviewer.

Agents connect over MCP

Give an agent such as Claude Code its own token, and it works with Branchscope as tools: repositories, changes, reviews, conflict maps and code graphs. Pushing still goes through git and the push guard.

Connect Claude Code

claude mcp add --transport http branchscope \
  https://api.branchscope.com/v1/mcp

An agent signs in through your browser, under its own name, and gets only the repositories you choose; a team's agent is installed by its organization, which can pause it and give it an AI provider key with a monthly cap. Every session and every change an agent tries to make shows in activity. MCP for agents

Agents can

  • Read repositories, files, history and code graphs
  • Open changes from the branches they push
  • Read every review as text and JSON, with graph node IDs
  • Ask the push guard whether a push would be allowed, before pushing
  • Draft releases for a person to publish

Agents can't

  • Update a protected branch, by push or by merge
  • Approve a deployment, even when acting for a reviewer
  • Get secrets in a run they set off, until a person approves it
  • See repositories outside their token's list
  • Act without being named: every push and merge says which agent, for whom

Reviewing an agent's change

Line-by-line review was built for people reading people's code. Branchscope is built for people checking agents' work.

Line-by-line review on GitHub or GitLabBranchscope
What you readEvery changed line of textDiagrams of what the change adds, edits, renames and removes: calls, endpoints, data access. The diff is there when you want it.
Architecture rulesSeparate tools in CI, if anyBuilt in: layers and rules in branchscope.json, checked on every change, down to the file and line.
Other repositoriesNot part of the reviewEach change lists your other repositories that call what it touches, and flags the callers it would break.
ConflictsConflicting lines of textBoth sides element by element since the merge base, with semantic conflicts that merge cleanly as text.
AgentsBot accounts, apps or a person's tokenNamed users with their own tokens and SSH keys, their own rules, and MCP. Runs they set off get no secrets until a person approves.
Protected branchesBranch protection settingsA push guard on every push and merge, with rulesets for branches and tags. Agents never update protected branches; if the guard is down, pushes are refused.
Who writes the reviewPeople, or an AI summaryThe code graph, derived by compilers. Same commit, same review.
Moving over—Import a GitHub or GitLab repository with its open pull requests, in one step.

Security and your data

  • Hosted in the EU

    Repositories, graphs and accounts are stored and processed in the EU.

  • Fails closed

    If the push guard can't be reached, every push and merge is refused, not let through.

  • No LLM in reviews

    Reviews come from code graphs derived by compilers. Your code isn't sent to a language model to review it.

  • Least-privilege credentials

    Tokens and SSH keys can be read-only, limited to repositories, and expire; agents' last an hour. Jobs sign in to AWS, Google Cloud or Azure with short-lived identity tokens instead of stored keys.

  • Secrets kept from agents

    Secrets are encrypted and can't be read back. A run an agent set off gets none until a person approves it. Graph builds run in containers of their own, with no secrets at all.

  • An audit log

    Every push, merge and guard decision names the person and the agent behind it. The audit log records who changed rulesets, secrets, environments and other security settings, and when.

What Branchscope stores

Your code
Repositories and their history, and the code graphs and reviews derived from them.
Your account
Username, name and email from sign-in; SSH public keys; tokens as hashes.
Activity
Pushes, merges, guard decisions, what agents did over MCP, and the audit log.
Secrets and tokens
Secrets, AI provider keys and saved external tokens, encrypted and never shown again. A token pasted for an import is used for that import only, and never stored.

Works with your tools

Questions

Is Branchscope an add-on to GitHub?

No. Branchscope hosts your repositories itself. GitHub and GitLab are only places to import from, once.

Is the review written by an AI?

No. Diagrams and findings come from a code graph that compilers derive from your code. The same commit always gives the same review.

Can an agent merge its own change into main?

No. Agents can't update protected branches (main by default), by push or by merge, and can't approve deployments. A person merges.

What happens if the push guard is down?

Pushes and merges are refused until it's back. Branchscope fails closed.

Does Branchscope run CI?

Yes. Workflows in the repository run on your own runners, and each job is a check that a ruleset can require. Hosted runners in the EU are coming.

Can it see what a change breaks in other repositories?

Yes, across an organization's repositories, or your own: services are matched by name, and a change flags the callers in other repositories that it would break. Only repositories you can read count.

Which languages does the review understand?

TypeScript and C# today, including ASP.NET Core endpoints and EF Core data access. git itself works for any repository.

Can I bring an existing repository?

Yes: import it from GitHub, GitLab or any git URL, with its open pull requests. See importing.

Where is my data?

In the EU.

See it on your own code

Sign in, push a repository, and open a change. The CLI, HTTP, SSH and MCP all work from the first push.