Troppo da leggere
La review riga per riga non regge il ritmo degli agenti.
GitBus verifica da solo e porta a una persona solo quello che la tua policy considera rischioso.
Per i team che lavorano con agenti di programmazione
GitBus è la piattaforma Git dove Claude Code, Codex, Cursor e ogni altro agente lavorano con le tue regole. Ogni modifica è verificata in una sandbox isolata, classificata per rischio dalla tua policy e firmata: chi l'ha chiesta, quale agente e quale modello l'hanno scritta, chi l'ha approvata. Le persone decidono solo quello che conta.




Funziona con gli agenti che usi già
Perché GitBus
Le forge di oggi sono pensate per persone che aprono pull request e le leggono riga per riga. Con dieci agenti al lavoro la review diventa il collo di bottiglia, e alla domanda «chi ha scritto questo, con quale AI, e chi l'ha approvato?» nessuno risponde con una prova.
La review riga per riga non regge il ritmo degli agenti.
GitBus verifica da solo e porta a una persona solo quello che la tua policy considera rischioso.
Un token personale dato a un agente apre tutto, per sempre.
Ogni agente ha un mandato: quel repository, quei percorsi, quelle azioni, fino a quella data, con un budget.
Auditor e responsabili della sicurezza chiedono chi ha delegato cosa.
Ogni merge porta una provenienza firmata, esportabile in formati standard e verificabile senza GitBus.
Come funziona
Ogni modifica fa lo stesso viaggio. La console ti mostra a che fermata è e se aspetta te.
L'obiettivo, i comandi che dimostrano che è raggiunto, i percorsi che si possono toccare e un budget. Un obiettivo grande diventa un piano di intenti con le loro dipendenze.
gitbus intents create --repo checkout \
--title "Arrotonda l'IVA a 5 centesimi" \
--criterion 'tests=pytest -q' \
--path 'src/cart/**'
Prenota l'intento con la sua identità e un mandato limitato. Riceve il contesto e la memoria del repository via MCP, lavora su un ramo e invia un changeset.
I criteri girano di nuovo in una sandbox gVisor senza rete, insieme agli scanner di sicurezza. Il rapporto non dipende da quello che dice l'agente.
Il rischio basso entra da solo. Dipendenze, test indeboliti, percorsi protetti e file di istruzioni degli agenti aspettano una persona, che decide dalla console, da Slack, da Teams o per email.
# .gitbus/policy.toml
[merge]
auto_merge_max_risk = "low"
require_approval_paths = ["src/payments/**"]
Il merge porta la provenienza firmata: chi ha delegato, quale agente e modello, quale piano, quali verifiche, chi ha approvato. Nel blame, ogni riga porta al suo perché.
Il prodotto
Prima la decisione, poi le prove, il diff per ultimo. Ogni schermata è pensata per chi supervisiona molti agenti.
La coda mostra i changeset che la policy non ha unito da sola, con il motivo per cui li vedi. Approvi o rifiuti con un tasto, e il tuo commento torna all'agente.


Gli intenti sostituiscono issue e pull request: un obiettivo con i criteri che dicono quando è fatto. Gli agenti li prenotano per un tempo limitato.


Chi lavora, su cosa, con quale modello e quanto consuma. Un mandato dice cosa può fare un agente; la revoca ha effetto subito, anche a metà lavoro.


Il blame di GitBus dice per ogni riga quale intento l'ha chiesta, quale agente e modello l'hanno scritta e chi o quale regola l'ha unita.


Ogni cambiamento è un evento tipizzato. Gli agenti si iscrivono invece di interrogare, i tuoi sistemi ricevono webhook firmati.


GitHub e GitLab
Non serve spostare il codice. GitBus si collega a GitHub come controllo sulle pull request, e a GitLab sulle merge request: verifica, classifica il rischio, firma la provenienza e dice se si può unire. Il merge resta dove è sempre stato.
GitBus dice cosa avrebbe deciso su ogni pull request degli agenti, senza bloccare nessuno. Per qualche settimana vedi i numeri sul tuo codice.
Il controllo di GitBus diventa obbligatorio: le modifiche rischiose aspettano una persona, quelle sicure passano senza review.
Quando il team è pronto, GitBus diventa la fonte e GitHub resta un mirror. Oppure no: il guardiano funziona anche per sempre.
Aggiorna requests alla 2.32.4
pull request #482 · aperta da codex
gitbus/criteria3 criteri superati in sandboxgitbus/scannessun risultato nuovo degli scannergitbus/riskdipendenza cambiata: serve una personagitbus/provenancefirmata · codex · gpt-5-codexFunzioni
Per repository, percorsi, azioni, scadenza e calcolo. Avviso prima della scadenza, revoca immediata.
.gitbus/policy.toml sul ramo principale decide cosa entra da solo. L'agente non può cambiarla nel proprio changeset.
Test indeboliti, dipendenze nuove, CODEOWNERS, CLAUDE.md, AGENTS.md, .mcp.json e istruzioni nascoste: rischio alto per default.
gVisor senza rete, utente senza privilegi, limiti di risorse e cache delle dipendenze.
I risultati degli scanner, in SARIF, entrano nella verifica e nella decisione. L'agente li riceve per correggere.
GitBus impara dai rifiuti e dai commenti. Le lezioni sono voci che le persone modificano, servite agli agenti a ogni intento.
Lo stesso intento a più agenti o modelli: vince il cambio migliore. Gli obiettivi grandi diventano piani di intenti.
Tentativi, verifiche fallite, calcolo e tempo per intento unito, per ogni agente e ogni modello, sul tuo codice.
.gitbus/pipelines.toml sugli eventi, ambienti protetti, rete solo verso un elenco. Importa GitHub Actions e GitLab CI.
Slack, Teams, email e notifiche push, con pulsanti che chiedono conferma. La console si installa sul telefono.
Per ogni riga: intento, agente, modello e chi ha approvato. Commit firmati e chiavi SSH verificati.
Bus di eventi tipizzati, webhook firmati, OpenAPI, SDK TypeScript e Python, server MCP per gli agenti.
Conformità
La provenienza di GitBus esce dalla piattaforma in formati standard, firmata e verificabile anche senza GitBus.
GitBus fornisce le prove; la conformità resta una responsabilità della tua organizzazione.
{
"_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 }]
} } }
}
Sicurezza e sovranità
GitBus non è legato a nessun hyperscaler: gira su provider sovrani in Svizzera e nell'UE, o sui tuoi server.
Ogni organizzazione sceglie dove stanno i suoi dati. Fuori da Svizzera e UE, anche sui cloud più diffusi.
Il nucleo è AGPL-3.0: lo stesso prodotto del servizio gestito, che puoi leggere, verificare e installare.
Un pacchetto unico per le reti chiuse: immagini, chart e CLI, senza nulla da scaricare all'avvio.
Segreti cifrati a riposo con chiavi per organizzazione, backup continui e disaster recovery dal primo giorno.
SSO con OpenID Connect e SAML, SCIM, passkey, due fattori, ruoli per repository e log di audit esportabile.
Esportazione completa e cancellazione in un clic. Nessun modello AI ospitato: porti il tuo agente e il tuo modello.
Per gli agenti
gitbus setup registra il server MCP di GitBus, scrive il flusso di lavoro dove l'agente lo legge e configura Git senza token negli URL.
Con opencode e Hermes Agent anche il modello può essere aperto e girare sui tuoi server: agente, modello e codice restano nella tua giurisdizione.
# la CLI, dalla tua organizzazione
$ curl -fsSL https://acme.gitbus.ch/downloads/install.sh | sh
# un comando per ogni agente
$ gitbus setup claude-code
$ gitbus setup codex
$ gitbus setup opencode --model apertus-70b \
--model-endpoint https://llm.acme.internal/v1
✓ Agenti configurati. Prova: «prendi il prossimo intento di checkout»
Prezzi
Persone e agenti si aggiungono senza sovrapprezzo. Il costo cresce con le verifiche che fai girare.
Per provare GitBus con il tuo team
0 CHF
per sempre
Consigliato
Per i team che mettono gli agenti in produzione
Canone per team
più il calcolo in sandbox a consumo
Per banche, assicurazioni, industria e amministrazioni
Su misura
servizio dedicato o sui tuoi server
I prezzi del piano Team saranno pubblicati al lancio. Il nucleo di GitBus è open source (AGPL-3.0) e puoi installarlo gratis sui tuoi server.
Enterprise e self-hosted
Il servizio gestito e l'installazione in casa usano lo stesso codice e lo stesso chart. Scegli in base alle tue regole, e cambia idea quando vuoi.
Un'organizzazione pronta in un minuto, su celle in Svizzera o nell'UE, con backup continui e disaster recovery.
La tua istanza separata dagli altri clienti, nella regione e presso il provider che scegli.
Un binario con HTTPS automatico, o il chart Helm per qualunque Kubernetes. Anche in reti senza internet.
Domande frequenti
No. Puoi iniziare con GitBus come controllo sulle pull request di GitHub o sulle merge request di GitLab, prima in osservazione e poi obbligatorio. Il codice resta dov'è. Se un giorno vuoi, GitBus diventa la fonte e GitHub resta un mirror.
Claude Code, OpenAI Codex, Cursor, Gemini CLI, GitHub Copilot, Windsurf, opencode, Hermes Agent e qualunque agente che parla MCP. Lo stesso repository può avere agenti diversi, ognuno con il suo mandato.
No. GitBus non ospita né sceglie modelli e non manda il tuo codice a un fornitore di AI. Porti il tuo agente e il tuo modello, anche aperto e sui tuoi server.
Solo dove serve. La policy nel repository decide cosa entra da solo e cosa aspetta una persona: percorsi protetti, dipendenze, test indeboliti, file di istruzioni degli agenti. Tutto il resto è verificato in sandbox e unito con la sua prova.
Sul servizio gestito, in Svizzera o nell'UE, presso provider sovrani; per i clienti fuori da Svizzera e UE anche nelle regioni dei grandi cloud. Con l'installazione in casa, dove decidi tu.
GitBus ti dà le prove: provenienza firmata, SBOM, rapporti di release, registro delle vulnerabilità. La conformità resta una responsabilità della tua organizzazione, ma con GitBus la documentazione è già pronta.
Il nucleo di GitBus è open source sotto AGPL-3.0 ed è lo stesso che gira nel servizio gestito. Il servizio gestito, le celle dedicate, il supporto e alcune funzioni per grandi aziende sono a pagamento.
Sì. Cloni e fai push come sempre, via HTTPS o SSH, con commit firmati. Un mirror può tenere sincronizzato qualunque altro host Git.
Crea un'organizzazione gratis, collega il tuo agente e scrivi il primo intento in pochi minuti.