Open source · Per il codice e per i documenti Office

Rivedi ciò che conta.

Le modifiche si accumulano più in fretta di quanto chiunque riesca a leggerle: pull request scritte con assistenti IA, budget e contratti modificati da molte mani. Probe confronta ogni nuova versione con l'ultima di cui ti sei fidato, ti mette davanti le poche modifiche che richiedono il tuo giudizio e ti mostra perché.

Ultima versione v0.5.1 · Le segnalazioni provengono da regole fisse, non da un modello · IA facoltativa.

Una persona che lavora serenamente a una scrivania dentro un cerchio luminoso, al centro di un tunnel di cavi aggrovigliati, notifiche e dashboard
19 / 125 righe richiedono te Probe filtra il resto.
Due strumenti, una sola disciplina

Lo stesso metodo di revisione, per gli sviluppatori e per i team aziendali.

Entrambi gli strumenti partono dall'ultima versione che hai rivisto, segnalano le modifiche rischiose con regole fisse e spiegabili e tengono traccia di ciò che è stato controllato. Un modello di IA può aiutare a spiegare una segnalazione; non decide mai cosa viene segnalato, e nulla lascia la tua macchina a meno che non sia tu a sceglierlo.

Probe per il codice

Rivedi le pull request scritte dall'IA

Per sviluppatori, tech lead e pipeline di CI.

  • Associa un diff Git a segnali di rischio: autenticazione, pagamenti, validazione rimossa, API pubbliche, dipendenze.
  • Esegue i tuoi test in container usa e getta e prova a riprodurre i problemi su entrambe le revisioni.
  • Controlla il piano di un agente prima che il codice esista, poi lascia unire le modifiche conformi a basso rischio.
CLIHub (Docker)GitHub · GitLabGo · TypeScript · Python · Rust
Probe Desktop

Sorveglia i documenti Office condivisi

Per i team di finanza, legale, vendite e operations, e per chiunque condivida file.

  • Segue i file Word, Excel e PowerPoint delle tue cartelle OneDrive o Google Drive.
  • Segnala una formula sostituita da un numero, un totale che non conta più tutte le righe, un importo o una scadenza modificati, un "deve" diventato "può".
  • Mantiene una coda di documenti da rivedere; una volta rivista, una versione diventa il riferimento per le modifiche successive.
WindowsmacOSOneDrive · Google DriveWord · Excel · PowerPoint

Quale ti serve?

Probe per il codiceProbe Desktop
SeiUno sviluppatore, un revisore, un team di piattaformaUn controller, un avvocato, un manager, un assistente
Cosa cambiaCodice sorgente, in commit Git e pull requestFile Word, Excel e PowerPoint, in OneDrive o Google Drive
Il riferimentoIl branch di base della pull requestL'ultima versione che qualcuno ha segnato come rivista
Cosa cercaCodice sensibile per la sicurezza, validazione rimossa, modifiche ad API e dipendenze, test che falliscono o mancanoFormule sostituite da valori fissi, intervalli ridotti, importi, date e obblighi modificati, fogli o slide nascosti, macro
ProveControlli eseguiti in una sandbox, problemi riprodotti, un report JSON e MarkdownIl prima e il dopo di ogni modifica segnalata, e chi l'ha salvata per ultimo
Come funzionaUno strumento da riga di comando nel tuo terminale o nella CI, oppure l'Hub per un intero accountUn'applicazione nella barra delle applicazioni o nella barra dei menu, che sorveglia in background
Probe Desktop · Per i documenti

I file condivisi cambiano in silenzio. Scopri quali modifiche contano.

Un budget passato tra cinque persone, un contratto rielaborato dalla controparte, una presentazione per il consiglio aggiornata la sera prima. Nessuno rilegge tutto, e nessuno dovrebbe farlo. Probe Desktop sorveglia le cartelle che il tuo team usa già e ti mostra le modifiche che cambiano un numero, un impegno o un calcolo, con il prima e il dopo.

  • Vede ciò che il rilevamento delle modifiche non vede. Una formula sostituita silenziosamente dal suo valore, una somma che si ferma una riga prima, un foglio reso invisibile.
  • Funziona dove si trovano già i tuoi file. Scegli una cartella OneDrive o Google Drive sincronizzata sul tuo computer. Nessuna migrazione, nessun componente aggiuntivo, nessun account.
  • Resta sul tuo computer. I documenti vengono confrontati in locale. Una spiegazione dell'IA è facoltativa e riceve solo gli estratti segnalati e i passaggi che usano ancora un nome o un termine sostituito.
Probe Desktop · 2 documenti da rivedere
  • X Un intervallo nella formula è stato ridotto: alcune celle non vengono più conteggiate Budget 2026.xlsx · Budget!B1 · alta

    =SOMMA(A1:A3)

    =SOMMA(A1:A2)

  • X Una formula è stata sostituita dal suo valore: la cella non si aggiorna più Budget 2026.xlsx · Budget!D2 · alta

    =A2*2

    400

  • W Un obbligo è stato attenuato Contratto fornitore.docx · Paragrafo 2 · alta

    Il fornitore deve consegnare entro il 15/03/2026.

    Il fornitore può consegnare entro il 15/03/2026.

  • W Un importo o una percentuale è stato modificato Contratto fornitore.docx · Paragrafo 3 · alta

    Il prezzo è fissato in 12.000 € IVA esclusa.

    Il prezzo è fissato in 15.000 € IVA esclusa.

Probe per il codice

Gli assistenti IA scrivono in fretta pull request di grandi dimensioni. Probe ti dice quali righe leggere per prime: associa il diff a segnali di rischio, esegue i tuoi controlli in container usa e getta, prova a riprodurre i problemi con test differenziali e ti consegna un piano di revisione mirato con prove tracciabili. Uno strumento da riga di comando per Windows, Linux e macOS, e un hub Docker per un intero account GitHub o GitLab. Provalo in 2 minuti →

Probe per il codice · Il processo

Conosci l'impatto prima che il codice esista. Rivedi solo ciò che ha bisogno di te.

Il codice scritto dall'IA diventa prevedibile quando l'agente annuncia prima il suo lavoro. Probe misura il rischio del piano prima che venga scritto codice, poi verifica che la modifica abbia fatto esattamente ciò che era stato annunciato. Una modifica che segue un piano a basso rischio e supera i suoi controlli può essere unita senza che una persona legga il diff; tutto il resto va in revisione, con i motivi.

  1. Pianifica e verifica l'intento

    probe plan fa simulare all'agente la modifica in sola lettura. Regole fisse, non il modello, segnalano percorsi critici, modifiche ad API pubbliche e dipendenze, codice molto usato o non testato. Un piano segnalato passa a una persona prima che venga scritto codice.

  2. Un agente implementa il piano

    Il piano diventa un contratto: i file, i simboli e le dipendenze che l'agente può toccare. Implementa quello, e solo quello.

  3. Verifica la conformità

    probe review --plan rivaluta il piano, esegue i controlli nella sandbox e confronta il diff con il contratto: ogni file non pianificato, modifica API non annunciata, percorso critico o dipendenza viene riportato.

  4. Unisci, oppure rivedi

    Modifica conforme, piano a basso rischio, controlli superati, nient'altro segnalato: nessuna revisione umana necessaria, uscita 0, la pipeline esegue il merge. Altrimenti uscita 2: una persona rivede la pull request, partendo dai motivi elencati.

Uscita 0 merge

  1. Il piano, rivalutato al momento della review, non ha sollevato alcuna categoria di rischio ed è stato misurato completamente.
  2. Il diff resta entro il piano: nessun file, API, percorso critico o dipendenza non pianificati.
  3. Ogni controllo è stato superato; nessun segnale alto, problema riprodotto o area non verificata.

Uscita 2 revisione umana

  1. Il piano tocca qualcosa di critico, pubblico o molto usato, oppure non è stato possibile misurarlo.
  2. La modifica ha deviato dal piano.
  3. Un controllo è fallito o il report ha trovato qualcosa da guardare. Ogni motivo è elencato.
# 1. before coding: plan, and let a human validate a flagged plan
probe plan --intent-file task.md --ci
# 2. the agent implements .probe/PLAN.json
# 3-4. in CI: conformance, checks and the gate (exit 0 = merge, 2 = review)
probe review --base origin/main --plan .probe/PLAN.json --ci
Plan conformance: conforming; 0 high, 0 medium, 0 low differences from the plan.
Plan gate: no human review required (low-risk plan, conforming change, checks passed, nothing else requests review).

Il gate è una decisione di processo, non una prova di correttezza: la tua policy attendibile decide cosa è critico e quali test vengono eseguiti, e qualsiasi dubbio manda la modifica a una persona. Come decide il gate.

Test, vet, build e coverage sono tutti passati su questa modifica. Eppure ha eliminato la validazione dell'importo del rimborso e ha permesso al ruolo di supporto di emettere rimborsi. Probe ha messo entrambi i punti in cima al piano di revisione, tra 19 righe segnalate su 125.

Probe per il codice · Perché fa risparmiare tempo

Smetti di leggere i diff generati dall'IA dall'inizio alla fine.

La parte costosa della revisione di una pull request assistita dall'IA non sono le righe rischiose. È trovarle tra gli helper, i test e la documentazione che le circondano, poi capire se un sospetto è fondato. Probe fa questa cernita e raccoglie le prove prima che tu apra il diff.

Senza Probe ogni riga, stessa attenzione

  1. Fai il checkout del branch ed esegui test, vet e build a mano.
  2. Leggi 125 righe modificate nell'ordine dei file, prima gli helper.
  3. Noti, con un po' di fortuna, che una chiamata di validazione è sparita da un percorso di rimborso.
  4. Scrivi un test usa e getta per capire se è importante.
  5. Approvi senza una traccia di ciò che è stato effettivamente controllato.

Con Probe prima il rischio, prove allegate

  1. I controlli sono già stati eseguiti in un container isolato, con log e hash.
  2. Apri il report: 19 righe segnalate, ordinate per gravità, con i motivi.
  3. Inizia da payment/refund.go, dove il report mostra la validazione rimossa.
  4. Lascia che il revisore facoltativo provi a riprodurre il problema sulla base e sulla candidata.
  5. Conserva i report Markdown e JSON come traccia della revisione.

Meno da leggere per primo

Una superficie di revisione senza duplicati, conteggiata in righe realmente modificate, così le grandi modifiche generate si riducono alle parti che toccano autenticazione, pagamenti, validazione, dipendenze o API pubbliche.

Nessuna configurazione locale per ogni PR

I tuoi comandi di test, typecheck, build e coverage vengono eseguiti in container usa e getta e senza rete. Nulla del codice candidato viene eseguito sulla tua macchina.

Sapere quando fermarsi

Le aree non verificate e i controlli incompleti sono elencati esplicitamente, e --ci li trasforma in un codice di uscita. Sai cosa è stato coperto e cosa richiede ancora il tuo giudizio.

Probe per il codice · Report di esempio

Cosa apri al posto del diff grezzo

Estratto di .probe/CONFIDENCE_REPORT.md, prodotto da probe review HEAD~1..HEAD --reviewer=false --ci (v0.3.0) su un piccolo repository di e-commerce. Il commit ha aggiunto helper per il catalogo con relativi test, rielaborato i rimborsi e toccato le autorizzazioni. Non è stato usato alcun provider di IA.

.probe/CONFIDENCE_REPORT.md
## Change Summary
120 additions / 5 deletions · 5 files changed
Exit code: 2. No confidence percentage is assigned.

## Automated Checks1
- PASS test      (check-1; exit 0; 5982 ms)
- PASS typecheck (check-2; exit 0; 4866 ms)
- PASS build     (check-3; exit 0; 2835 ms)
- PASS coverage  (check-4; exit 0; 6416 ms)

## Reproduced Issues2
No issue was reproduced by a passing baseline
and failing candidate experiment.

## Suggested Human Review3
- high auth/auth.go:7 (new): Authentication or
  authorization function body changed
- high payment/refund.go:21–22 (new): Payment-sensitive
  function body changed
- high payment/refund.go:25–26 (new): Exported Go
  declaration added; Payment-sensitive function body changed
- high payment/refund.go:21 (old): Configured sensitive
  path changed; No nearby test file changed;
  Possible input validation removed
- medium catalog/format.go:9 (new): Exported Go
  declaration added
  … 11 more medium signals in catalog/

## Review Surface4
Focused review: 19 / 125 changed lines.

## Changed-line Execution5
Of 67 added Go lines, 44 were executed at least once,
0 were not executed, 23 are not inside any
instrumented block.
  1. I controlli sono fatti, e non sono la risposta. Ogni comando configurato è passato in un container isolato. Proprio per questo il resto del report conta.
  2. Prove, non opinioni. Un problema riprodotto richiede un test che passa sulla base e fallisce sulla candidata. Senza un provider di IA qui non si afferma nulla, e il report lo dice.
  3. Il tuo ordine di lettura. Prima i segnali alti: una regola di autorizzazione e un percorso di rimborso sono cambiati, e una chiamata di validazione è stata rimossa senza alcuna modifica ai test vicini. È lì che si trova il bug.
  4. La dimensione del lavoro. 19 delle 125 righe modificate portano un segnale. Leggi prima quelle, poi decidi quanta attenzione merita il resto.
  5. Un'osservazione, non una prova. Il nuovo codice dei rimborsi è stato eseguito durante i test, eppure nessun test verifica il controllo dell'importo. Probe riporta l'esecuzione ma non la presenta mai come prova che il codice sia testato.
Probe per il codice

Come funziona

  1. Confronta commit immutabili

    Entrambi i riferimenti vengono risolti in ID di commit. Rinomine, eliminazioni, file binari e semantica del merge base sono gestiti; vengono rivisti solo i file committati, così le modifiche locali non finiscono mai nel risultato.

  2. Raccogli i segnali di rischio

    Il confronto dell'AST Go, euristiche lessicali etichettate e regole sui percorsi sensibili segnalano autenticazione, pagamenti, dipendenze, validazione rimossa, costrutti non sicuri e test mancanti in Go, TypeScript/JavaScript, Python e Rust.

  3. Esegui in una sandbox

    I tuoi comandi di test, typecheck e build vengono eseguiti come array argv in container usa e getta, non-root e senza rete, con limiti di CPU, memoria, PID e tempo.

  4. Riprodurre, non affermare

    Un revisore facoltativo scrive test temporanei. Un test che passa sulla baseline e fallisce sulla candidata supporta un problema riprodotto; tutto il resto resta UNVERIFIED.

Da una prima prova a ogni pull request

Provalo sul tuo ultimo commit senza configurazione, senza Docker e senza chiave API. Quando lo adotti, committa una policy sul tuo branch di base: viene letta dalla base, così una pull request non può allentare le proprie regole.

Segui la guida per iniziare →

# try it: compare with the previous commit
probe lint HEAD~1..HEAD

# adopt it: once, in your repository
probe init
git add .probe.json && git commit -m "Add review policy"

# on every pull request
probe review --base main --ci
Probe per il codice · Docker

Oppure eseguilo per un intero account: Probe Hub

L'hub è l'immagine Docker complementare. Avvia un container, accedi con GitHub o GitLab, e a ogni repository ancora privo di .probe.json viene proposta una policy con un clic, con un'anteprima prima del commit sul branch predefinito.

I repository che hanno una policy possono essere sorvegliati: ogni nuovo commit viene analizzato e il suo report si apre da solo. Un cursore di gravità filtra gli avvisi da bassa a critica, e un clic su uno di essi mostra ogni modifica che riguarda, con le righe segnalate evidenziate nel diff.

Un solo container Docker, nessun database, nessun servizio esterno: un'azienda può installarlo internamente sulla propria istanza GitHub Enterprise o GitLab. Nella modalità predefinita non esegue mai il codice analizzato.

Ospitato su app.probe.technology: la stessa immagine che puoi eseguire sulla tua rete.

# one container, on your own network
$ docker run -p 8080:8080 \
    -e PROBE_HUB_BASE_URL=https://hub.example.com \
    -e PROBE_HUB_GITHUB_CLIENT_ID=... \
    -e PROBE_HUB_GITHUB_CLIENT_SECRET=... \
    -v hub-data:/var/lib/probe-hub \
    gvinsot/probe-hub

Sign in · bootstrap the missing policies · watch pushes
Reports open by themselves, filtered by severity.
Probe per il codice

Funzionalità

Superficie di revisione mirata

Intervalli di revisione senza duplicati con coordinate vecchie e nuove, conteggiati in righe effettivamente modificate, ordinati per gravità.

Prove differenziali

I test generati vengono eseguiti sulla baseline e sulla candidata in ambienti nuovi. L'esecuzione Go è verificata a partire da eventi di test strutturati.

Esecuzione delle righe modificate

Misura facoltativamente quali righe Go aggiunte sono state eseguite da un'esecuzione registrata, riportato come osservazione, mai come prova di test.

Analisi d'impatto

Un indice statico di Go, TypeScript/JavaScript, Python e Rust elenca i chiamanti non modificati di ogni funzione modificata e i test esistenti che la raggiungono.

Test su entrambe le revisioni

Test impattati e test della baseline modificati, fuzzing differenziale e mutazione delle righe aggiunte vengono eseguiti sulla base e sulla candidata, registrati come prove, mai come verdetto.

Pianifica, poi verifica l'ambito

probe plan valuta il piano di un agente prima che esista il codice; --plan segnala poi ogni file o API esportata che la modifica ha toccato senza annunciarlo.

Revisore IA con limiti

Usa qualsiasi provider compatibile con OpenAI. Gli strumenti sono limitati: lettura di file oscurati, ricerca ed esecuzione di test. Niente shell, niente download di URL.

Pronto per la CI

Un workflow GitHub Actions riutilizzabile, codici di uscita significativi, report JSON con ID di commit, prove e hash degli artefatti, più SARIF e un commento alla PR con le sole segnalazioni supportate da prove.

Pensato per gli agenti

Gli agenti di coding eseguono lint e review prima di consegnare il lavoro e riportano cosa è stato riprodotto e cosa resta aperto.

Cosa Probe non afferma

Uno strumento di revisione si guadagna la fiducia essendo preciso sui propri limiti. Probe non assegna percentuali di confidenza e non approva mai una modifica sulla parola di un modello. Per il codice, rinuncia alla revisione umana solo tramite il plan gate, quando è stato seguito un piano a basso rischio e ogni controllo automatico ha dato esito pulito. Per i documenti, decide sempre una persona.

  • I segnali sono motivi per indagare, non bug confermati.
  • Test superati e una piccola superficie di revisione non garantiscono la correttezza.
  • Una riga eseguita è un'osservazione, non la prova che sia testata.
  • L'affermazione di un modello non è mai una prova; lo è solo una differenza riprodotta.
  • Il plan gate dice che l'ambito annunciato e a basso rischio è stato rispettato, non che il codice sia corretto.
  • L'esecuzione non ripiega mai sul tuo host quando Docker manca.
  • Un documento segnato come rivisto è una decisione umana, non una garanzia che le sue cifre siano giuste.
  • Un documento senza segnalazioni è comunque cambiato: l'elenco completo delle modifiche resta a un clic di distanza.

Dedica il tuo tempo di revisione a ciò che conta.

Open source, con licenza AGPL-3.0. Uno strumento da riga di comando per il codice, un'applicazione per i documenti, entrambi pubblicati a ogni release.