yolo-cage: agenti di codifica autonomi che non causano danni

Sei un ingegnere responsabile. Non lasceresti mai che un'IA imperversi nei tuoi sistemi e codebase più sensibili.

Ecco perché non spegneresti mai le protezioni per uno strumento come Claude Code. Chiede il permesso per ogni azione pericolosa! Sicuro!

Quindi aspetti. E rispondi. Subentra la stanchezza decisionale. E allora accade.

I messaggi di permesso trascurano l'anello più debole del modello di minaccia: un utente stanco. E se potessimo dare potere all'agente limitandone il raggio d'azione, rinviando le tue decisioni fino alla revisione della PR?

Sarebbe fantastico! E questo sarebbe yolo-cage.

Provalo

curl -fsSL https://github.com/borenstein/yolo-cage/releases/latest/download/yolo-cage -o yolo-cage
chmod +x yolo-cage && sudo mv yolo-cage /usr/local/bin/
yolo-cage build --interactive --up

Poi crea una sandbox e inizia a programmare:

yolo-cage create feature-branch
yolo-cage attach feature-branch   # Attachesi all'agente in tmux

Prerequisiti: Vagrant con libvirt (Linux) o QEMU (macOS, sperimentale), 8GB di RAM, 4 CPU, GitHub PAT (ambito repo), account Claude. Vedi documentazione di setup per i dettagli.

Cosa viene bloccato

Segreti in HTTP/HTTPS - il proxy di uscita scansiona corpi delle richieste, header, URL:

• sk-ant-*, AKIA*, ghp_*, chiavi private SSH, pattern generici di credenziali

Operazioni Git - il dispatcher impone l'isolamento dei rami:

• Push verso qualsiasi ramo eccetto il ramo assegnato
• git remote, git clone, git config, git credential

GitHub CLI - il dispatcher blocca comandi pericolosi:

• gh pr merge, gh repo delete, gh api

GitHub API - il proxy blocca a livello HTTP:

• PUT /repos/*/pulls/*/merge, DELETE /repos/*, modifiche ai webhook

Siti di exfiltrazione: pastebin.com, file.io, transfer.sh, ecc.

Vedi Architettura per il modello di minaccia completo.

Come funziona

┌──────────────────────────────────────────────────────────────────────────┐
│ Runtime (Vagrant VM + MicroK8s)                                          │
│                                                                          │
│  ┌────────────────────────────────────────────────────────────────────┐  │
│  │ Sandbox                                                            │  │
│  │                                                                    │  │
│  │  Agent (Claude Code in YOLO mode)                                  │  │
│  │       │                                                            │  │
│  │       ├── git/gh ──▶ Dispatcher ──▶ GitHub                         │  │
│  │       │              • Branch isolation enforcement                │  │
│  │       │              • TruffleHog pre-push scanning                │  │
│  │       │                                                            │  │
│  │       └── HTTP/S ──▶ Egress Proxy ──▶ Internet                     │  │
│  │                      • Secret scanning (LLM-Guard)                 │  │
│  │                      • Domain blocklist                            │  │
│  └────────────────────────────────────────────────────────────────────┘  │
│                                                                          │
└──────────────────────────────────────────────────────────────────────────┘

Una sandbox per ramo. Gli agenti possono solo fare push al loro ramo assegnato. Tutto il traffico in uscita è filtrato.

CLI

Inoltro porta

Accedi alle app web in esecuzione all'interno di una sandbox:

yolo-cage port-forward feature-x 8080           # localhost:8080 → sandbox:8080
yolo-cage port-forward feature-x 9000:3000      # localhost:9000 → sandbox:3000
yolo-cage port-forward feature-x 8080 --bind 0.0.0.0  # Accessibile in LAN

Vedi Configurazione per bypass proxy, hook e limiti di risorse.

Documentazione

• Glossario - Linguaggio onnipresente e terminologia
• Architettura - Modello di minaccia, logica di design
• Configurazione - Politica di uscita, bypass proxy, hook
• Personalizzazione - Aggiunta di strumenti, limiti di risorse
• Security Audit - Guida ai test di fuga

Limitazioni

Questo riduce il rischio. Non lo elimina.

• Exfiltrazione DNS - dati codificati in query DNS
• Canali laterali temporali - informazioni trapelate tramite tempi di risposta
• Steganografia - segreti nascosti in immagini o dati binari
• Codifica sofisticata - bypass del pattern matching

Utilizza credenziali con ambito limitato. Non utilizzare segreti di produzione dove l'exfiltrazione sarebbe catastrofica. Vedi Security Audit per testarlo tu stesso.

Licenza

MIT. Vedi LICENSE.