GitBus

For teams that work with coding agents

Govern and prove your agents' work.

GitBus is the Git platform where Claude Code, Codex, Cursor and any other agent work by your rules. Every change is verified in an isolated sandbox, graded for risk by your policy and signed: who asked for it, which agent and model wrote it, who approved it. People decide only what matters.

  • Any agent, any model
  • Open source (AGPL-3.0)
  • Data in Switzerland or the EU
The decision queue in the GitBus consoleThe decision queue in the GitBus console
The decision queue on a phoneThe decision queue on a phone
  1. Intentgoal and criteria
  2. Verified3/3 in a sandbox
  3. RiskCLAUDE.md changed
  4. Your turnthe policy asks a person
  5. Mergedwith signed provenance

Works with the agents you already use

  • Claude Code
  • OpenAI Codex
  • Cursor
  • Gemini CLI
  • GitHub Copilot
  • Windsurf
  • opencode
  • Hermes Agent
  • any MCP agent

Why GitBus

Agents write more code than a team can read.

Today's forges are built for people who open pull requests and read them line by line. With ten agents at work, review becomes the bottleneck, and nobody can answer "who wrote this, with which AI, and who approved it?" with proof.

Too much to read

Line-by-line review can't keep up with agents.

GitBus verifies on its own and brings a person only what your policy calls risky.

Too much access

A personal token handed to an agent opens everything, forever.

Each agent gets a mandate: this repository, these paths, these actions, until this date, with a budget.

No proof

Auditors and security leads ask who delegated what.

Every merge carries signed provenance, exportable in standard formats and verifiable without GitBus.

How it works

From task to merge, with your rules at every stop.

Every change takes the same route. The console shows which stop it has reached and whether it is waiting for you.

  1. Write an intent

    The goal, the commands that prove it is reached, the paths that may change and a budget. A large goal becomes a plan of intents with their dependencies.

    gitbus intents create --repo checkout \
      --title "Round VAT to 5 centimes" \
      --criterion 'tests=pytest -q' \
      --path 'src/cart/**'
  2. The agent works

    It claims the intent with its own identity and a narrow mandate. It gets the repository's context and memory over MCP, works on a branch and submits a changeset.

  3. GitBus verifies

    The criteria run again in a gVisor sandbox with no network, together with the security scanners. The report does not depend on what the agent says.

  4. The policy decides

    Low risk merges on its own. Dependencies, weakened tests, protected paths and agent instruction files wait for a person, who decides from the console, Slack, Teams or email.

    # .gitbus/policy.toml
    [merge]
    auto_merge_max_risk = "low"
    require_approval_paths = ["src/payments/**"]
  5. Merged and signed

    The merge carries signed provenance: who delegated, which agent and model, which plan, which checks, who approved. In the blame, every line leads to its reason.

The product

A control room, not a diff browser.

The decision first, then the evidence, the diff last. Every screen is built for people who supervise many agents.

Only what is waiting for you

The queue shows the changesets the policy did not merge on its own, with the reason you see them. Approve or reject with one key, and your comment goes back to the agent.

  • Risk as the main signal, with its reasons
  • Verification, scope and provenance before the diff
  • Also from Slack, Teams, email and phone notifications
Decisions: Only what is waiting for youDecisions: Only what is waiting for you

Work described as outcomes

Intents replace issues and pull requests: a goal with the criteria that say when it is done. Agents claim them for a limited time.

  • Reserved paths, so agents don't step on each other
  • One intent to several agents: the best change wins
  • Dependencies and plans for large goals
Intents: Work described as outcomesIntents: Work described as outcomes

Every agent with its mandate

Who is working, on what, with which model and how much it uses. A mandate says what an agent may do; revoking takes effect at once, even mid-task.

  • One identity per agent, never shared tokens
  • Compute budgets that stop the spend
  • Cost per merged intent, per agent and per model
Agents: Every agent with its mandateAgents: Every agent with its mandate

The reason behind every line

GitBus blame tells you, for each line, which intent asked for it, which agent and model wrote it and who or which rule merged it.

  • File history linked to changesets
  • Agent Trace export
  • Release report and SBOM for every tag
Who wrote it: The reason behind every lineWho wrote it: The reason behind every line

Everything that happens, live

Every change is a typed event. Agents subscribe instead of polling, and your systems receive signed webhooks.

  • Streaming event bus
  • Signed webhooks, Slack and Teams
  • OpenAPI, TypeScript and Python SDKs
Events: Everything that happens, liveEvents: Everything that happens, live

GitHub and GitLab

Start on the repository you already have.

No need to move your code. GitBus connects to GitHub as a check on pull requests, and to GitLab on merge requests: it verifies, grades the risk, signs the provenance and says whether it can merge. The merge stays where it has always been.

  1. Observe free

    GitBus says what it would have decided on every agent pull request, without blocking anyone. For a few weeks you see the numbers on your own code.

  2. Protect

    The GitBus check becomes required: risky changes wait for a person, safe ones go through without review.

  3. Move when you like

    When the team is ready, GitBus becomes the source and GitHub stays a mirror. Or not: the guard works forever too.

Features

Everything you need to trust an agent's work.

Mandates and budgets

Per repository, paths, actions, expiry and compute. A warning before expiry, immediate revocation.

Versioned policy

.gitbus/policy.toml on the main branch decides what merges on its own. An agent cannot change it in its own changeset.

Risk that understands agents

Weakened tests, new dependencies, CODEOWNERS, CLAUDE.md, AGENTS.md, .mcp.json and hidden instructions: high risk by default.

Sandbox verification

gVisor with no network, an unprivileged user, resource limits and a dependency cache.

Code analysis

Scanner findings, in SARIF, feed the verification and the decision. The agent gets them to fix.

Repository memory

GitBus learns from rejections and comments. Lessons are entries people edit, served to agents with every intent.

Fleets and contests

One intent to several agents or models: the best change wins. Large goals become plans of intents.

Cost per model

Attempts, failed checks, compute and time per merged intent, for every agent and model, on your code.

Sovereign pipelines

.gitbus/pipelines.toml on events, protected environments, network only to an allow list. Imports GitHub Actions and GitLab CI.

Decide anywhere

Slack, Teams, email and push notifications, with buttons that ask for confirmation. The console installs on your phone.

Blame with provenance

For every line: intent, agent, model and who approved. Signed commits and SSH keys verified.

Events, API and SDKs

A typed event bus, signed webhooks, OpenAPI, TypeScript and Python SDKs, an MCP server for agents.

Compliance

Evidence an auditor can verify.

GitBus provenance leaves the platform in standard formats, signed and verifiable without GitBus.

  • in-toto and SLSA attestations for every changeset, in a signed DSSE envelope.
  • CycloneDX SBOM for every tag, read from the lock files.
  • Agent Trace which lines an AI wrote, with which model.
  • Release report who wrote what, who approved, which checks ran: in PDF and JSON.
  • Vulnerability register which changeset introduced and which fixed each one, for the CRA deadlines.
  • Cyber Resilience Act
  • AI Act
  • NIS2
  • DORA
  • FINMA

GitBus provides the evidence; compliance remains your organization's responsibility.

Signed in-toto attestation, shortened
{
  "_type": "https://in-toto.io/Statement/v1",
  "subject": [{ "name": "checkout",
    "digest": { "gitCommit": "ed40dbb0…" } }],
  "predicateType": "https://slsa.dev/provenance/v1",
  "predicate": { "buildDefinition": {
    "externalParameters": {
      "intent": "Add a discount helper",
      "author": "claude-code",
      "model": "claude-sonnet-4-5",
      "delegated_by": "giulia",
      "decision": "policy",
      "risk": "low",
      "checks": [{ "name": "tests", "passed": true }]
  } } }
}

Security and sovereignty

Your data stays where you decide.

GitBus is not tied to any hyperscaler: it runs on sovereign providers in Switzerland and the EU, or on your own servers.

Switzerland or the EU

Each organization chooses where its data lives. Outside Switzerland and the EU, on the major clouds too.

Open source

The core is AGPL-3.0: the same product as the managed service, which you can read, audit and install.

Even without internet

A single bundle for closed networks: images, chart and CLI, with nothing to download at start.

Encrypted secrets

Secrets encrypted at rest with per-organization keys, continuous backups and disaster recovery from day one.

Enterprise access

SSO with OpenID Connect and SAML, SCIM, passkeys, two factors, per-repository roles and an exportable audit log.

Always free to leave

Full export and deletion in one click. No hosted AI model: you bring your agent and your model.

For agents

One command to connect your agent.

gitbus setup registers the GitBus MCP server, writes the workflow where the agent reads it and sets up Git without tokens in URLs.

With opencode and Hermes Agent the model can be open and run on your servers too: agent, model and code stay in your jurisdiction.

# the CLI, from your organization
$ curl -fsSL https://acme.gitbus.ch/downloads/install.sh | sh
# one command per agent
$ gitbus setup claude-code
$ gitbus setup codex
$ gitbus setup opencode --model apertus-70b \
    --model-endpoint https://llm.acme.internal/v1
✓ Agents configured. Try: "take the next intent in checkout"

Pricing

Pay per team and for compute, not per seat.

Add people and agents at no extra cost. The price grows with the verifications you run.

Free

To try GitBus with your team

0 CHF

forever

  • Intents, verification, mandates, policy and provenance
  • Sandbox minutes included every month
  • Observe mode on GitHub and GitLab
  • Any agent, any model
Create an account

Enterprise

For banks, insurers, industry and public administration

Tailored

dedicated service or on your servers

  • Install on your servers, even without internet
  • SAML SSO and SCIM
  • Help with audits and compliance evidence
  • Contract, DPA and dedicated support
Contact us

Team plan prices will be published at launch. The GitBus core is open source (AGPL-3.0) and free to install on your own servers.

Enterprise and self-hosted

On our servers or yours, the same GitBus.

The managed service and the self-hosted install share the same code and the same chart. Choose by your rules, and change your mind whenever you like.

  • Managed service

    An organization ready in a minute, on cells in Switzerland or the EU, with continuous backups and disaster recovery.

  • Dedicated cell

    Your own instance, separate from other customers, in the region and with the provider you choose.

  • On your servers

    A single binary with automatic HTTPS, or the Helm chart for any Kubernetes. Air-gapped networks too.

FAQ

Before you start

Do I have to leave GitHub or GitLab?

No. You can start with GitBus as a check on GitHub pull requests or GitLab merge requests, first observing and then required. Your code stays where it is. If one day you want to, GitBus becomes the source and GitHub stays a mirror.

Which agents can I use?

Claude Code, OpenAI Codex, Cursor, Gemini CLI, GitHub Copilot, Windsurf, opencode, Hermes Agent and any agent that speaks MCP. One repository can have different agents, each with its own mandate.

Does GitBus use its own AI model?

No. GitBus neither hosts nor picks models and never sends your code to an AI provider. You bring your agent and your model, open and on your own servers if you like.

Do people still review code?

Only where it matters. The policy in the repository decides what merges on its own and what waits for a person: protected paths, dependencies, weakened tests, agent instruction files. Everything else is verified in a sandbox and merged with its evidence.

Where is my data?

On the managed service, in Switzerland or the EU with sovereign providers; for customers outside Switzerland and the EU, in the major clouds' regions too. Self-hosted, wherever you decide.

Does GitBus make me compliant with the AI Act or the CRA?

GitBus gives you the evidence: signed provenance, SBOMs, release reports, a vulnerability register. Compliance remains your organization's responsibility, but with GitBus the documentation is ready.

What does open core mean?

The GitBus core is open source under AGPL-3.0 and is the same code that runs the managed service. The managed service, dedicated cells, support and some large-company features are paid.

Is it Git compatible?

Yes. Clone and push as always, over HTTPS or SSH, with signed commits. A mirror can keep any other Git host in sync.

Put your agents to work, by your rules.

Create a free organization, connect your agent and write your first intent in a few minutes.