GitBus

Per i team che lavorano con agenti di programmazione

Governa e dimostra il lavoro dei tuoi agenti.

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.

  • Qualunque agente, qualunque modello
  • Open source (AGPL-3.0)
  • Dati in Svizzera o nell'UE
La coda delle decisioni nella console di GitBusLa coda delle decisioni nella console di GitBus
La coda delle decisioni su un telefonoLa coda delle decisioni su un telefono
  1. Intentoobiettivo e criteri
  2. Verificato3/3 in sandbox
  3. RischioCLAUDE.md cambiato
  4. Tocca a tela policy chiede una persona
  5. Unitocon provenienza firmata

Funziona con gli agenti che usi già

  • Claude Code
  • OpenAI Codex
  • Cursor
  • Gemini CLI
  • GitHub Copilot
  • Windsurf
  • opencode
  • Hermes Agent
  • qualunque agente MCP

Perché GitBus

Gli agenti scrivono più codice di quanto un team riesca a leggere.

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.

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.

Troppi permessi

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.

Nessuna prova

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

Dal compito al merge, con le tue regole a ogni fermata.

Ogni modifica fa lo stesso viaggio. La console ti mostra a che fermata è e se aspetta te.

  1. Scrivi un intento

    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/**'
  2. L'agente lavora

    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.

  3. GitBus verifica

    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.

  4. La policy decide

    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/**"]
  5. Unito e firmato

    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

Una sala di controllo, non un browser di diff.

Prima la decisione, poi le prove, il diff per ultimo. Ogni schermata è pensata per chi supervisiona molti agenti.

Solo quello che aspetta te

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.

  • Rischio come segnale principale, con i motivi
  • Verifica, perimetro e provenienza prima del diff
  • Anche da Slack, Teams, email e notifiche sul telefono
Decisioni: Solo quello che aspetta teDecisioni: Solo quello che aspetta te

Il lavoro descritto come risultati

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

  • Percorsi prenotati, senza agenti che si pestano i piedi
  • Lo stesso intento a più agenti: vince il cambio migliore
  • Dipendenze e piani per gli obiettivi grandi
Intenti: Il lavoro descritto come risultatiIntenti: Il lavoro descritto come risultati

Ogni agente con il suo mandato

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.

  • Identità per agente, mai token condivisi
  • Budget di calcolo che ferma la spesa
  • Costo per intento unito, per agente e per modello
Agenti: Ogni agente con il suo mandatoAgenti: Ogni agente con il suo mandato

Il perché di ogni riga

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.

  • Storia dei file legata ai changeset
  • Esportazione Agent Trace
  • Rapporto di release e SBOM per ogni tag
Chi l'ha scritto: Il perché di ogni rigaChi l'ha scritto: Il perché di ogni riga

Tutto quello che succede, in diretta

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

  • Bus di eventi in streaming
  • Webhook firmati, Slack e Teams
  • API OpenAPI, SDK TypeScript e Python
Eventi: Tutto quello che succede, in direttaEventi: Tutto quello che succede, in diretta

GitHub e GitLab

Inizia sul repository che hai già.

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.

  1. Osserva gratis

    GitBus dice cosa avrebbe deciso su ogni pull request degli agenti, senza bloccare nessuno. Per qualche settimana vedi i numeri sul tuo codice.

  2. Proteggi

    Il controllo di GitBus diventa obbligatorio: le modifiche rischiose aspettano una persona, quelle sicure passano senza review.

  3. Sposta quando vuoi

    Quando il team è pronto, GitBus diventa la fonte e GitHub resta un mirror. Oppure no: il guardiano funziona anche per sempre.

Funzioni

Tutto quello che serve per fidarsi del lavoro di un agente.

Mandati e budget

Per repository, percorsi, azioni, scadenza e calcolo. Avviso prima della scadenza, revoca immediata.

Policy versionata

.gitbus/policy.toml sul ramo principale decide cosa entra da solo. L'agente non può cambiarla nel proprio changeset.

Rischio che capisce gli agenti

Test indeboliti, dipendenze nuove, CODEOWNERS, CLAUDE.md, AGENTS.md, .mcp.json e istruzioni nascoste: rischio alto per default.

Verifica in sandbox

gVisor senza rete, utente senza privilegi, limiti di risorse e cache delle dipendenze.

Analisi del codice

I risultati degli scanner, in SARIF, entrano nella verifica e nella decisione. L'agente li riceve per correggere.

Memoria del repository

GitBus impara dai rifiuti e dai commenti. Le lezioni sono voci che le persone modificano, servite agli agenti a ogni intento.

Flotte e gare

Lo stesso intento a più agenti o modelli: vince il cambio migliore. Gli obiettivi grandi diventano piani di intenti.

Costo per modello

Tentativi, verifiche fallite, calcolo e tempo per intento unito, per ogni agente e ogni modello, sul tuo codice.

Pipeline sovrane

.gitbus/pipelines.toml sugli eventi, ambienti protetti, rete solo verso un elenco. Importa GitHub Actions e GitLab CI.

Decidi ovunque

Slack, Teams, email e notifiche push, con pulsanti che chiedono conferma. La console si installa sul telefono.

Blame con provenienza

Per ogni riga: intento, agente, modello e chi ha approvato. Commit firmati e chiavi SSH verificati.

Eventi, API e SDK

Bus di eventi tipizzati, webhook firmati, OpenAPI, SDK TypeScript e Python, server MCP per gli agenti.

Conformità

Prove che un auditor può verificare.

La provenienza di GitBus esce dalla piattaforma in formati standard, firmata e verificabile anche senza GitBus.

  • Attestazioni in-toto e SLSA per ogni changeset, in una busta DSSE firmata.
  • SBOM CycloneDX per ogni tag, letto dai lock file.
  • Agent Trace quali righe ha scritto un'AI, con quale modello.
  • Rapporto di release chi ha scritto cosa, chi ha approvato, quali verifiche: in PDF e JSON.
  • Registro delle vulnerabilità quale changeset le ha introdotte e quale le ha corrette, per le scadenze del CRA.
  • Cyber Resilience Act
  • AI Act
  • NIS2
  • DORA
  • FINMA

GitBus fornisce le prove; la conformità resta una responsabilità della tua organizzazione.

Attestazione in-toto firmata, abbreviata
{
  "_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à

I tuoi dati restano dove decidi tu.

GitBus non è legato a nessun hyperscaler: gira su provider sovrani in Svizzera e nell'UE, o sui tuoi server.

Svizzera o UE

Ogni organizzazione sceglie dove stanno i suoi dati. Fuori da Svizzera e UE, anche sui cloud più diffusi.

Open source

Il nucleo è AGPL-3.0: lo stesso prodotto del servizio gestito, che puoi leggere, verificare e installare.

Anche senza internet

Un pacchetto unico per le reti chiuse: immagini, chart e CLI, senza nulla da scaricare all'avvio.

Segreti cifrati

Segreti cifrati a riposo con chiavi per organizzazione, backup continui e disaster recovery dal primo giorno.

Accesso aziendale

SSO con OpenID Connect e SAML, SCIM, passkey, due fattori, ruoli per repository e log di audit esportabile.

Uscita sempre possibile

Esportazione completa e cancellazione in un clic. Nessun modello AI ospitato: porti il tuo agente e il tuo modello.

Per gli agenti

Un comando per collegare il tuo agente.

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

Paghi per team e per il calcolo, non per posto.

Persone e agenti si aggiungono senza sovrapprezzo. Il costo cresce con le verifiche che fai girare.

Gratis

Per provare GitBus con il tuo team

0 CHF

per sempre

  • Intenti, verifiche, mandati, policy e provenienza
  • Minuti di sandbox inclusi ogni mese
  • Modalità osservazione su GitHub e GitLab
  • Qualunque agente, qualunque modello
Crea un account

Enterprise

Per banche, assicurazioni, industria e amministrazioni

Su misura

servizio dedicato o sui tuoi server

  • Installazione sui tuoi server, anche senza internet
  • SSO SAML e SCIM
  • Supporto per audit e prove di conformità
  • Contratto, DPA e supporto dedicato
Contattaci

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

Sui nostri server o sui tuoi, lo stesso GitBus.

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.

  • Servizio gestito

    Un'organizzazione pronta in un minuto, su celle in Svizzera o nell'UE, con backup continui e disaster recovery.

  • Cella dedicata

    La tua istanza separata dagli altri clienti, nella regione e presso il provider che scegli.

  • Sui tuoi server

    Un binario con HTTPS automatico, o il chart Helm per qualunque Kubernetes. Anche in reti senza internet.

Domande frequenti

Prima di iniziare

Devo lasciare GitHub o GitLab?

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.

Quali agenti posso usare?

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.

GitBus usa un suo modello di AI?

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.

Le persone devono ancora fare review?

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.

Dove sono i miei dati?

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 mi rende conforme all'AI Act o al CRA?

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.

Cosa vuol dire open core?

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.

È compatibile con Git?

Sì. Cloni e fai push come sempre, via HTTPS o SSH, con commit firmati. Un mirror può tenere sincronizzato qualunque altro host Git.

Metti i tuoi agenti al lavoro, con le tue regole.

Crea un'organizzazione gratis, collega il tuo agente e scrivi il primo intento in pochi minuti.