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.
For teams that work with coding agents
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.




Works with the agents you already use
Why GitBus
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.
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.
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.
Auditors and security leads ask who delegated what.
Every merge carries signed provenance, exportable in standard formats and verifiable without GitBus.
How it works
Every change takes the same route. The console shows which stop it has reached and whether it is waiting for you.
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/**'
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.
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.
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/**"]
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
The decision first, then the evidence, the diff last. Every screen is built for people who supervise many agents.
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.


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


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.


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.


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


GitHub and GitLab
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.
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.
The GitBus check becomes required: risky changes wait for a person, safe ones go through without review.
When the team is ready, GitBus becomes the source and GitHub stays a mirror. Or not: the guard works forever too.
Upgrade requests to 2.32.4
pull request #482 · opened by codex
gitbus/criteria3 criteria passed in the sandboxgitbus/scanno new scanner findingsgitbus/riskdependency changed: a person must approvegitbus/provenancesigned · codex · gpt-5-codexFeatures
Per repository, paths, actions, expiry and compute. A warning before expiry, immediate revocation.
.gitbus/policy.toml on the main branch decides what merges on its own. An agent cannot change it in its own changeset.
Weakened tests, new dependencies, CODEOWNERS, CLAUDE.md, AGENTS.md, .mcp.json and hidden instructions: high risk by default.
gVisor with no network, an unprivileged user, resource limits and a dependency cache.
Scanner findings, in SARIF, feed the verification and the decision. The agent gets them to fix.
GitBus learns from rejections and comments. Lessons are entries people edit, served to agents with every intent.
One intent to several agents or models: the best change wins. Large goals become plans of intents.
Attempts, failed checks, compute and time per merged intent, for every agent and model, on your code.
.gitbus/pipelines.toml on events, protected environments, network only to an allow list. Imports GitHub Actions and GitLab CI.
Slack, Teams, email and push notifications, with buttons that ask for confirmation. The console installs on your phone.
For every line: intent, agent, model and who approved. Signed commits and SSH keys verified.
A typed event bus, signed webhooks, OpenAPI, TypeScript and Python SDKs, an MCP server for agents.
Compliance
GitBus provenance leaves the platform in standard formats, signed and verifiable without GitBus.
GitBus provides the evidence; compliance remains your organization's responsibility.
{
"_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
GitBus is not tied to any hyperscaler: it runs on sovereign providers in Switzerland and the EU, or on your own servers.
Each organization chooses where its data lives. Outside Switzerland and the EU, on the major clouds too.
The core is AGPL-3.0: the same product as the managed service, which you can read, audit and install.
A single bundle for closed networks: images, chart and CLI, with nothing to download at start.
Secrets encrypted at rest with per-organization keys, continuous backups and disaster recovery from day one.
SSO with OpenID Connect and SAML, SCIM, passkeys, two factors, per-repository roles and an exportable audit log.
Full export and deletion in one click. No hosted AI model: you bring your agent and your model.
For agents
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
Add people and agents at no extra cost. The price grows with the verifications you run.
To try GitBus with your team
0 CHF
forever
Recommended
For teams putting agents into production
Per-team fee
plus sandbox compute as you use it
For banks, insurers, industry and public administration
Tailored
dedicated service or on your servers
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
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.
An organization ready in a minute, on cells in Switzerland or the EU, with continuous backups and disaster recovery.
Your own instance, separate from other customers, in the region and with the provider you choose.
A single binary with automatic HTTPS, or the Helm chart for any Kubernetes. Air-gapped networks too.
FAQ
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.
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.
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.
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.
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.
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.
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.
Yes. Clone and push as always, over HTTPS or SSH, with signed commits. A mirror can keep any other Git host in sync.
Create a free organization, connect your agent and write your first intent in a few minutes.