# Browser Use e Browser Harness: guida e installazione

> Fonte: https://francescogruner.it/browser-use-browser-harness-guida/

Un coding agent può modificare il codice, lanciare test e interrogare API. Con Browser Harness può anche aprire Chrome, usare una sessione già autenticata e completare un lavoro dentro un’applicazione web.

 

La demo ufficiale rende bene l’idea: l’agente apre un profilo X, trova gli ultimi 20 post con video e li scarica. Lo stesso approccio si può usare per collaudare un’app, esportare report, lavorare su un back office o raccogliere prove per un articolo.

 

Browser Use faceva già automazione su Chrome. La novità di Browser Harness non è il browser: è l’integrazione con coding agent come Hermes, Claude Code e Codex. In questa guida vediamo la differenza concreta, come installarlo, come gestire login e sessioni e quando ha senso usarlo anche su una VPS senza interfaccia grafica.

 

![Homepage ufficiale di Browser Harness con il titolo Self-healing browser agents.](https://francescogruner.it/wp-content/uploads/2026/08/browser-harness-homepage.png)

La homepage ufficiale presenta Browser Harness come un harness self-healing costruito direttamente su CDP. Screenshot originale acquisito per questo articolo.   

Indice dei contenuti

 [Toggle](#) 

- [Browser Use: il framework Python che decide il percorso](#Browser_Use_il_framework_Python_che_decide_il_percorso)
- [Browser Harness: CDP diretto e helper che restano](#Browser_Harness_CDP_diretto_e_helper_che_restano)
- [Browser Use e Browser Harness: le differenze pratiche](#Browser_Use_e_Browser_Harness_le_differenze_pratiche)
- [Browser Use o Browser Harness?](#Browser_Use_o_Browser_Harness)
- [Il metodo più semplice: dallo direttamente al coding agent](#Il_metodo_piu_semplice_dallo_direttamente_al_coding_agent)

- [Su una VPS senza interfaccia grafica](#Su_una_VPS_senza_interfaccia_grafica)
- [Login, account e sessioni](#Login_account_e_sessioni)
- [Hermes Agent](#Hermes_Agent)
- [Claude Code](#Claude_Code)
- [OpenClaw](#OpenClaw)
- [DeepSeek Harness](#DeepSeek_Harness)
- [Codex e gli altri coding agent](#Codex_e_gli_altri_coding_agent)
- [Quattro prompt pronti per iniziare](#Quattro_prompt_pronti_per_iniziare)
- [Come installare Browser Harness manualmente](#Come_installare_Browser_Harness_manualmente)

- [Prima prova dal terminale](#Prima_prova_dal_terminale)
- [Come installare Browser Use come libreria Python](#Come_installare_Browser_Use_come_libreria_Python)
- [A cosa può servire davvero](#A_cosa_puo_servire_davvero)

- [Ricerca con prove verificabili](#Ricerca_con_prove_verificabili)
- [Test di applicazioni web](#Test_di_applicazioni_web)
- [Back office e attività ripetitive](#Back_office_e_attivita_ripetitive)
- [Raccolta di prove per articoli e video](#Raccolta_di_prove_per_articoli_e_video)
- [Monitoraggio di prezzi e disponibilità](#Monitoraggio_di_prezzi_e_disponibilita)
- [Test di moduli e percorsi di registrazione](#Test_di_moduli_e_percorsi_di_registrazione)
- [Riproduzione di bug segnalati dagli utenti](#Riproduzione_di_bug_segnalati_dagli_utenti)
- [Portali senza API](#Portali_senza_API)
- [Archiviazione di contenuti propri](#Archiviazione_di_contenuti_propri)
- [Migrazioni tra servizi web](#Migrazioni_tra_servizi_web)
- [Controllo editoriale prima della pubblicazione](#Controllo_editoriale_prima_della_pubblicazione)
- [Task personali con sessione autenticata](#Task_personali_con_sessione_autenticata)
- [Benchmark fra primo e secondo giro](#Benchmark_fra_primo_e_secondo_giro)
- [Come sfruttarlo al massimo senza trasformarlo in un rischio](#Come_sfruttarlo_al_massimo_senza_trasformarlo_in_un_rischio)
- [Come lo usiamo noi e cosa cambierò](#Come_lo_usiamo_noi_e_cosa_cambiero)
- [Cosa non mi convince ancora](#Cosa_non_mi_convince_ancora)
- [Conclusione: quale scegliere](#Conclusione_quale_scegliere)

- [Browser Harness](#Browser_Harness)
- [Repository browser-harness](#Repository_browser-harness)
- [Repository browser-use](#Repository_browser-use)
- [Installazione Browser Harness](#Installazione_Browser_Harness)
- [The Bitter Lesson of Agent Harnesses](#The_Bitter_Lesson_of_Agent_Harnesses)
- [Web Agents That Actually Learn](#Web_Agents_That_Actually_Learn)
- [Skills System di Hermes Agent](#Skills_System_di_Hermes_Agent)
- [Skills in OpenClaw](#Skills_in_OpenClaw)
- [Skill di Claude Code](#Skill_di_Claude_Code)
- [Skill in DeepSeek Harness](#Skill_in_DeepSeek_Harness)

 

## Browser Use: il framework Python che decide il percorso

 

Browser Use rende le pagine web utilizzabili da un agente. Il framework gestisce il browser, raccoglie DOM e screenshot, espone le azioni disponibili e mantiene il ciclo del task. Tu definisci l’obiettivo; il modello decide quali pagine aprire, cosa cliccare e quando fermarsi.

 

La libreria è adatta quando vuoi integrare la navigazione dentro un’applicazione Python, scegliere il provider LLM, strutturare l’output o eseguire molte sessioni isolate. È il modello che uso oggi nel servizio browser del mio ufficio: `Agent + ChatOpenAI + Browser`, Chromium headless, limiti sui passaggi e un gateway LLM controllato.

 

Questo approccio funziona, ma ha un costo: il modello deve interpretare a ogni passo ciò che vede. Nei miei log reali compaiono CAPTCHA, errori DNS e task incompleti. Il rischio più serio è una sintesi plausibile prodotta anche quando la pagina non è stata osservata fino in fondo. Per questo una frase finale dell’agente non basta: servono verifiche sul risultato.

 

![Screenshot del repository GitHub browser-use/browser-use con il framework Python, esempi, skill e release.](https://francescogruner.it/wp-content/uploads/2026/08/browser-use-repository-github.png)

La repository di Browser Use contiene il framework Python, gli esempi, la documentazione e le integrazioni per costruire agenti web. 

## Browser Harness: CDP diretto e helper che restano

 

Browser Harness è uno strato più sottile. Collega un coding agent come Hermes, Codex o Claude Code direttamente al browser tramite il Chrome DevTools Protocol. La skill insegna un flusso operativo: leggere l’albero di accessibilità, trovare un elemento, ricavarne le coordinate, agire e verificare il cambiamento.

 

La differenza più utile è nel workspace. Se manca una funzione per caricare un file, gestire un widget particolare o recuperare una sessione, l’agente può scriverla in `agent_helpers.py`. L’helper rimane disponibile per i task successivi. Il sito diventa meno sconosciuto a ogni esecuzione.

 

Il team lo definisce “self-healing”, ma prenderei il termine alla lettera solo entro confini precisi: l’agente può correggere e ampliare i propri helper; non significa che ogni errore venga risolto in modo affidabile o che l’automazione sia automaticamente sicura.

 

![Screenshot del repository GitHub browser-use/browser-harness con cartelle del progetto e licenza MIT.](https://francescogruner.it/wp-content/uploads/2026/08/browser-harness-repository-github.png)

Browser Harness vive in una repository separata e distribuisce la skill, gli helper e il collegamento diretto a CDP. 

## Browser Use e Browser Harness: le differenze pratiche

 

![Diagramma originale che confronta Browser Use, framework Python con loop agente, e Browser Harness, controllo CDP diretto per coding agent.](https://francescogruner.it/wp-content/uploads/2026/08/browser-use-vs-browser-harness-diagramma.png)

Diagramma originale: stesso ecosistema, ma architetture e casi d’uso differenti. **Campo 1****Forma****Browser Use**Framework e libreria Python**Browser Harness**CLI, skill e helper per coding agent**Campo 1****Chi orchestra****Browser Use**Il loop del framework**Browser Harness**Il coding agent che scrive le azioni**Campo 1****Controllo browser****Browser Use**API del framework, DOM e screenshot**Browser Harness**CDP diretto, AX tree, JavaScript e helper**Campo 1****Memoria operativa****Browser Use**Configurazioni e stato dell’agente**Browser Harness**Helper persistenti nel workspace**Campo 1****Browser locale****Browser Use**Possibile tramite configurazione**Browser Harness**Caso d’uso centrale, anche con sessione già autenticata**Campo 1****Scala****Browser Use**Codice Python o Browser Use Cloud**Browser Harness**Browser locali, cloud isolati e sessioni parallele**Campo 1****Quando lo sceglierei****Browser Use**Prodotto, pipeline o servizio Python**Browser Harness**Coding agent, debug, test e web app variabili 

I due progetti oggi si toccano anche nella distribuzione: la CLI di Browser Use usa Browser Harness come motore per il flusso dedicato ai coding agent. La libreria Python `browser-use` resta però un prodotto distinto, con il proprio `Agent`, i modelli e le API.

 

## Browser Use o Browser Harness?

 

Browser Use poteva già avviare Chromium o collegarsi al Chrome del sistema. Nel flusso classico, però, costruisci un agente dentro la tua applicazione Python: configuri `Agent`, modello e browser, poi lasci che il loop di Browser Use gestisca osservazione, decisione e azione.

 

Con Browser Harness l’agente principale è quello che stai già usando per lavorare sul codice: Hermes, Claude Code, Codex o un altro coding agent. Non deleghi il task a un secondo agente web. Il coding agent riceve primitive CDP, istruzioni operative e un file `agent_helpers.py` che può ampliare quando incontra un’azione non ancora coperta.

 

Qui nasce anche il termine “self-healing”: se per un sito manca una funzione, il coding agent può aggiungerla a `agent_helpers.py`, provarla e conservarla. Non sta addestrando il modello; sta costruendo una piccola libreria operativa che ritroverà nel task successivo.

 

## Il metodo più semplice: dallo direttamente al coding agent

 

Se usi già Hermes, OpenClaw, Claude Code, Codex o DeepSeek Harness, non serve preparare tutto a mano. Incolla nel coding agent questo prompt:

 

```
Install or upgrade browser-harness to the latest stable version with uv using Python 3.12, register the skill from `browser-harness skill`, and connect it to my browser. Ask whether I want local browser recordings enabled; default to no and preserve my existing preference on upgrades. Follow https://github.com/browser-use/browser-harness/blob/main/install.md if setup or connection fails.
```

 

Questo è il prompt ufficiale pubblicato nella repository di Browser Harness per Claude Code e Codex. Funziona come istruzione anche per Hermes, OpenClaw, DeepSeek Harness e gli altri coding agent che possono eseguire comandi e caricare skill. Ho lasciato il testo originale in inglese per evitare che una traduzione cambi percorsi o condizioni operative.

 

Durante il primo collegamento l’agente apre `chrome://inspect/#remote-debugging`. Chrome mostra una casella che va selezionata manualmente una sola volta per consentire il collegamento:

 

![Schermata Chrome Remote debugging con la casella Allow remote debugging for this browser instance.](https://francescogruner.it/wp-content/uploads/2026/08/browser-harness-chrome-remote-debugging.png)

Al primo avvio abilita “Allow remote debugging for this browser instance”. È un passaggio manuale: l’agente non può selezionarlo finché CDP non è disponibile. 

### Su una VPS senza interfaccia grafica

 

Una VPS headless non rende Browser Harness inutile. Chrome e Chromium funzionano anche senza una finestra visibile: il coding agent può aprire pagine, eseguire JavaScript, compilare moduli, scaricare file e acquisire screenshot. È il modello giusto per test automatici, ricerche, portali operativi e attività schedulate.

 

Quello che manca è il profilo personale già aperto sul portatile. Sulla VPS si usa quindi un profilo dedicato e persistente, un browser remoto raggiungibile via CDP oppure Browser Use Cloud. Se invece vuoi far lavorare l’agente proprio nel Chrome del tuo computer, Browser Harness deve girare su quel computer o su un nodo che possa raggiungerne l’endpoint CDP.

 

### Login, account e sessioni

 

Non serve un account Google per usare Chrome. Un agente può lavorare in quattro modi:

 

1. **Senza login.** Per siti pubblici, test e raccolta di informazioni basta un profilo pulito.
2. **Account dedicato.** Per back office, community e servizi operativi conviene creare un utente con i soli permessi necessari.
3. **Profilo persistente.** Si effettua il login una volta e si conserva il profilo del browser sulla VPS o sulla macchina dell’agente. Le esecuzioni successive riutilizzano cookie e sessione finché restano validi.
4. **Chrome locale già autenticato.** Browser Harness si collega al browser in uso e ritrova le sessioni esistenti.

 

In un’infrastruttura agentica le credenziali possono arrivare da un vault autorizzato. Il componente che esegue il login recupera il segreto al momento dell’uso e lo inserisce nel campo corretto, senza copiarlo nel prompt, in `agent_helpers.py`, nelle registrazioni o nei log. Per gli account più delicati preferisco comunque una sessione preparata in anticipo oppure un account dedicato, così il coding agent lavora con i cookie e non continua a maneggiare la password.

 

MFA, CAPTCHA e consensi possono richiedere un bootstrap controllato. Una volta completato, il profilo persistente consente alla VPS di continuare a lavorare senza GUI finché la sessione resta valida. Se il servizio permette l’accesso senza Google, non c’è alcun motivo per aggiungere un account Google; se richiede Google SSO, si può usare un account dedicato e con privilegi limitati.

 

`browser-harness auth login` è un’altra cosa: autentica il client verso **Browser Use Cloud**, non verso i siti visitati.

 

Questo è il percorso che consiglierei a chi vuole provarlo subito. Il coding agent installa il comando, crea la skill nel posto corretto e verifica la connessione. Se preferisci sapere esattamente dove vengono scritti i file, i comandi manuali sono qui sotto.

 

### Hermes Agent

 

```
uv tool install --python 3.12 --upgrade --force browser-harness
mkdir -p "${HERMES_HOME:-$HOME/.hermes}/skills/browser-harness"
browser-harness skill > "${HERMES_HOME:-$HOME/.hermes}/skills/browser-harness/SKILL.md"
browser-harness --doctor
```

 

Apri una nuova sessione Hermes e scrivi, per esempio:

 

```
Usa browser-harness. Apri la mia applicazione locale, prova il flusso di registrazione
senza inviare il form, salva uno screenshot e indicami il primo punto che non funziona.
```

 

### Claude Code

 

```
uv tool install --python 3.12 --upgrade --force browser-harness
mkdir -p "$HOME/.claude/skills/browser-harness"
browser-harness skill > "$HOME/.claude/skills/browser-harness/SKILL.md"
browser-harness --doctor
```

 

Claude Code carica le skill personali da `~/.claude/skills`. Dopo l’installazione puoi invocarla esplicitamente con `/browser-harness` oppure descrivere un task web e lasciare che Claude la selezioni.

 

### OpenClaw

 

```
uv tool install --python 3.12 --upgrade --force browser-harness
mkdir -p "$HOME/.openclaw/workspace/skills/browser-harness"
browser-harness skill > "$HOME/.openclaw/workspace/skills/browser-harness/SKILL.md"
openclaw skills list
browser-harness --doctor
```

 

OpenClaw monitora le cartelle delle skill, ma una sessione già aperta potrebbe usare ancora il catalogo precedente. In quel caso avvia una nuova sessione con `/new`. Puoi richiamare la skill con `$browser-harness` dentro un prompt o con il relativo comando slash.

 

### DeepSeek Harness

 

DeepSeek Harness riconosce le skill di progetto in `.dsh/skills` e quelle compatibili con lo standard Agent Skills in `.agents/skills`. Dentro la repository su cui vuoi lavorare:

 

```
uv tool install --python 3.12 --upgrade --force browser-harness
mkdir -p .dsh/skills/browser-harness
browser-harness skill > .dsh/skills/browser-harness/SKILL.md
browser-harness --doctor
npx @deepseek-ai/dsh web
```

 

Il vantaggio del percorso di progetto è che puoi versionare la skill insieme al codice e farla trovare agli altri agenti che lavorano sulla stessa repository. Prima di commetterla, rileggi il file e verifica che non contenga percorsi, account o istruzioni specifiche della tua macchina.

 

### Codex e gli altri coding agent

 

Per Codex il percorso ufficiale è `${CODEX_HOME:-$HOME/.codex}/skills/browser-harness`. Per un agente che supporta lo standard [Agent Skills](https://agentskills.io/), crea una directory `browser-harness` nella sua radice delle skill e salva lì l’output del comando.

 

```
uv tool install --python 3.12 --upgrade --force browser-harness
mkdir -p "${CODEX_HOME:-$HOME/.codex}/skills/browser-harness"
browser-harness skill > "${CODEX_HOME:-$HOME/.codex}/skills/browser-harness/SKILL.md"
browser-harness --doctor
```

 

### Quattro prompt pronti per iniziare

 

```
# Test di una web app
Usa browser-harness per aprire l’applicazione, eseguire il percorso principale,
fermarti prima di ogni invio irreversibile e consegnarmi screenshot ed errori osservati.

# Ricerca verificabile
Cerca le informazioni su queste fonti, estrai i dati in una tabella e allega URL
e screenshot che dimostrino cosa hai realmente letto.

# Download ripetitivo
Apri il portale già autenticato, scarica i report disponibili, verifica nome e data
di ogni file e non modificare alcuna impostazione dell’account.

# Creazione di un helper
Completa il task con browser-harness. Se manca una funzione riutilizzabile, aggiungila
ad agent_helpers.py senza salvare segreti o dati specifici dell’utente. Poi ripeti il
task e confronta il numero di passaggi del primo e del secondo giro.
```

 

## Come installare Browser Harness manualmente

 

La guida ufficiale consiglia **Python 3.12** e **uv**. Il comando seguente installa o aggiorna la versione stabile senza modificare gli altri tool Python presenti sulla macchina.

 

```
uv tool install --python 3.12 --upgrade --force browser-harness
```

 

Controlla subito la connessione al browser:

 

```
browser-harness --doctor
```

 

Per Codex, registra la skill nel suo spazio:

 

```
mkdir -p "${CODEX_HOME:-$HOME/.codex}/skills/browser-harness"
browser-harness skill > "${CODEX_HOME:-$HOME/.codex}/skills/browser-harness/SKILL.md"
```

 

Con Claude Code, Hermes o un altro agente compatibile, il principio è lo stesso: crea una skill chiamata `browser-harness` usando come contenuto l’output del comando seguente.

 

```
browser-harness skill
```

 

La prima connessione al Chrome locale può richiedere l’abilitazione del remote debugging. Su una VPS il browser può invece essere avviato headless con un profilo persistente. Per i siti privati scegli fra account dedicato, credenziali recuperate dal vault al momento dell’uso o una sessione preparata in anticipo.

 

### Prima prova dal terminale

 

```
browser-harness <<'PY'
print(page_info())
PY
```

 

Per aprire una pagina e leggerne lo stato:

 

```
browser-harness <<'PY'
new_tab("https://example.com")
wait_for_load()
print(page_info())
PY
```

 

La documentazione insiste su un punto corretto: se una richiesta HTTP basta, non aprire il browser. Il browser serve per JavaScript, interazione, sessioni autenticate, pagine protette e casi in cui un semplice fetch restituisce solo una shell vuota.

 

## Come installare Browser Use come libreria Python

 

Browser Use richiede Python 3.11 o superiore. In un progetto gestito con uv:

 

```
uv init browser-agent
cd browser-agent
uv add browser-use
uv run playwright install chromium
```

 

Poi crea un file `agent.py`. Qui uso il client Browser Use indicato nel quickstart ufficiale; puoi sostituirlo con un provider supportato e la relativa chiave.

 

```
import asyncio
from browser_use import Agent, ChatBrowserUse

async def main():
    agent = Agent(
        task="Apri la repository browser-use/browser-harness e restituisci licenza e data dell’ultima release",
        llm=ChatBrowserUse(model="openai/gpt-5.2"),
    )
    history = await agent.run()
    print(history.final_result())

asyncio.run(main())
```

 

Avvio:

 

```
export BROWSER_USE_API_KEY="la-tua-chiave"
uv run python agent.py
```

 

Non mettere chiavi dentro lo script e non stampare variabili d’ambiente nei log. Se usi OpenAI, Anthropic, Google o un gateway compatibile, segui il client documentato per quel provider invece di cambiare solo il nome del modello alla cieca.

 

## A cosa può servire davvero

 

La demo ufficiale qui sotto mostra un task concreto: aprire un profilo X, trovare gli ultimi 20 post con video e scaricarli. Non è una registrazione ricostruita per l’articolo; è il video distribuito dal progetto Browser Harness.

 Demo ufficiale di Browser Harness: download degli ultimi 20 video pubblicati su un profilo X. 

### Ricerca con prove verificabili

 

Un agente può aprire le fonti, estrarre dati e salvare screenshot del percorso. Il risultato va accompagnato dagli URL e da controlli deterministici: pagina visitata, elemento trovato, file prodotto.

 

### Test di applicazioni web

 

Browser Harness è interessante per test esplorativi, iframe, Shadow DOM e interfacce che cambiano. Il coding agent può scendere a CDP o JavaScript senza aspettare che il framework esponga una nuova azione.

 

### Back office e attività ripetitive

 

Download di report, aggiornamenti su portali, esportazioni e raccolta di dati sono casi adatti, soprattutto quando la sessione locale è già autenticata. Le operazioni irreversibili devono comunque fermarsi prima dell’invio finale.

 

### Raccolta di prove per articoli e video

 

Browser Harness può registrare screenshot e tracce locali. Le registrazioni sono disattivate nelle installazioni nuove e vanno abilitate consapevolmente perché possono contenere dati sensibili.

 

```
browser-harness recordings enable
browser-harness recordings
browser-harness recordings disable
```

 

### Monitoraggio di prezzi e disponibilità

 

Può controllare prodotti, voli, eventi o annunci che richiedono JavaScript e interazioni. Il task deve registrare prezzo, data, URL e condizioni osservate; non deve acquistare o prenotare senza una richiesta separata.

 

### Test di moduli e percorsi di registrazione

 

È utile per compilare un form con dati di prova, verificare validazioni, messaggi d’errore e responsive design. Il prompt deve imporre lo stop prima dell’invio quando il form crea un account, manda una richiesta o modifica dati reali.

 

### Riproduzione di bug segnalati dagli utenti

 

Un coding agent può seguire i passaggi di un ticket, raccogliere screenshot, errori JavaScript e richieste di rete, quindi consegnare una sequenza riproducibile allo sviluppatore.

 

### Portali senza API

 

Molti gestionali permettono di esportare report solo dall’interfaccia. Browser Harness può aprire il portale già autenticato, applicare filtri, scaricare il file e verificarne nome e data. È un ripiego utile quando non esiste un’API, non una scusa per ignorare un’API disponibile.

 

### Archiviazione di contenuti propri

 

La demo dei 20 video mostra il caso più immediato: recuperare media pubblicati sul proprio profilo, catalogarli e prepararli per un archivio o un nuovo montaggio. Su account e contenuti altrui vanno rispettati autorizzazioni, licenze e condizioni della piattaforma.

 

### Migrazioni tra servizi web

 

L’agente può leggere dati da un vecchio pannello e prepararli per il nuovo sistema. Separerei sempre estrazione e importazione: prima un file controllabile, poi una seconda operazione approvata, evitando una catena cieca fra due account reali.

 

### Controllo editoriale prima della pubblicazione

 

Può aprire una bozza WordPress, verificare titoli, immagini, link, tabella mobile e metadati. La pubblicazione resta un’azione distinta. È il modo corretto per usare il browser come controllo qualità, non come semplice telecomando.

 

### Task personali con sessione autenticata

 

Il collegamento al Chrome locale permette di lavorare su strumenti dove sei già entrato: calendario, pannelli, community e servizi in abbonamento. Per i task continuativi userei un account dedicato o un profilo isolato, con credenziali fornite dal vault solo al componente autorizzato e permessi ridotti al minimo necessario.

 

### Benchmark fra primo e secondo giro

 

Il caso d’uso più interessante per chi sviluppa agenti è misurare l’apprendimento operativo. Esegui un task, lascia che l’agente aggiunga un helper, poi ripetilo in una sessione pulita. Confronta passaggi, tempo, token, errori e qualità delle prove. Se il secondo giro non migliora, l’helper non sta creando valore.

 

## Come sfruttarlo al massimo senza trasformarlo in un rischio

 

1. **Usa HTTP prima del browser.** Riduci tempo, token e superficie d’errore.
2. **Separa i workspace.** Gli helper appresi per un cliente o un’applicazione non devono finire in un contesto diverso.
3. **Fai verificare ogni mutazione.** Dopo click, upload o salvataggio, rileggi lo stato esatto del bersaglio.
4. **Conserva solo helper generici.** Nessuna password, token, dato cliente o URL privato dentro `agent_helpers.py`.
5. **Usa browser isolati per task rischiosi.** La sessione Chrome personale è comoda, ma espone cookie e account già autenticati.
6. **Registra solo quando serve.** Le tracce sono prove utili, ma possono diventare un archivio di informazioni sensibili.
7. **Misura il secondo giro.** Il vantaggio self-healing esiste se il task successivo usa meno passaggi, meno token o meno tempo. Altrimenti hai solo aggiunto codice generato.
8. **Limita il perimetro.** Domini consentiti, timeout, numero massimo di azioni e stop prima di pagamenti, pubblicazioni o invii.

 

## Come lo usiamo noi e cosa cambierò

 

Nel mio ufficio è già presente un servizio Browser Use con Browser Harness e CDP installati. Il percorso in produzione usa però ancora il loop classico di Browser Use: browser headless, immagini inviate al modello e azioni decise passo dopo passo.

 

Ho installato la versione stabile di Browser Harness anche nell’istanza Hermes sulla VPS. La skill è disponibile, le registrazioni sono disattivate e il passo successivo è collegarla a un Chromium headless con profilo dedicato. Il confronto utile è mettere i due percorsi in parallelo sullo stesso compito, senza toccare il servizio attuale:

 

- stesso sito e stesso obiettivo;
- stesso modello quando possibile;
- tempo totale, numero di passaggi, token e costo;
- recovery dopo una tab guasta;
- iframe, Shadow DOM, upload e download;
- riuso degli helper al secondo giro;
- qualità delle prove prodotte.

 

È il secondo giro che mi interessa. Se Browser Harness impiega molto al primo task ma dimezza il lavoro al successivo, ha imparato qualcosa di utile. Se continua a esplorare da zero, la promessa non regge.

 

## Cosa non mi convince ancora

 

**Gli helper generati sono codice.** Vanno revisionati, versionati e confinati. Un agente che può migliorare il proprio harness può anche consolidare un errore.

 

**La sessione reale aumenta il rischio.** Per questo separerei il profilo personale da quello operativo: account dedicato, permessi minimi e segreti recuperati dal vault solo quando servono.

 

**Self-healing non significa deterministico.** L’agente può adattarsi, ma un sito può cambiare, bloccare l’automazione o presentare un flusso inatteso.

 

**Le metriche pubbliche non bastano.** Stelle GitHub e demo mostrano interesse e possibilità, non il costo per task completato. Servono misure riproducibili.

 

## Conclusione: quale scegliere

 

Sceglierei **Browser Use** per costruire una pipeline Python, integrare un agente in un prodotto o controllare centralmente modelli, output e sessioni. Sceglierei **Browser Harness** quando il protagonista è già un coding agent e voglio dargli accesso diretto al browser, possibilità di debug e helper persistenti.

 

Nel mio caso non sostituirò il servizio esistente sulla base del README. Costruirò un ambiente isolato, ripeterò lo stesso task con entrambi e pubblicherò i numeri. Browser Harness sarà davvero utile se il suo workspace renderà il secondo task più breve e più verificabile del primo.

  Browser Use e Browser Harness sono lo stesso progetto?

Fanno parte dello stesso ecosistema e la CLI moderna li integra, ma hanno ruoli diversi. **Browser Use** è il framework Python completo; **Browser Harness** è il livello diretto su CDP pensato per coding agent e helper modificabili.

 Browser Harness è gratuito?

Sì, la repository è pubblicata con licenza MIT. L’uso del browser locale non richiede una chiave Browser Use. Restano eventuali costi del modello e dei browser cloud.

 Serve Python 3.12?

La guida di installazione di Browser Harness raccomanda esplicitamente **Python 3.12** con uv, per evitare che venga scelta una release vecchia compatibile con versioni precedenti. Browser Use come libreria richiede Python 3.11 o superiore.

 Può usare il mio Chrome già autenticato?

Sì. Può anche usare un profilo persistente su VPS, un account dedicato oppure lavorare senza account Google. In un sistema aziendale le credenziali possono essere recuperate da un vault autorizzato senza inserirle in prompt, helper o log.

 È meglio Playwright o CDP?

Dipende dal lavoro. Playwright offre API stabili e test ripetibili; CDP espone il livello più vicino a Chrome e permette al coding agent di gestire casi fuori dall’astrazione. Per flussi deterministici continuerei a preferire test scritti e versionati.

 Si può usare in produzione?

Sì, ma non come scorciatoia senza controlli. Servono isolamento, limiti, revisione degli helper, gestione dei segreti, verifiche dopo le mutazioni e stop espliciti prima delle operazioni irreversibili.

  

Per la stesura dell’articolo ho consultato le repository, la documentazione di installazione e gli approfondimenti tecnici pubblicati dal team Browser Use.

 [Sito ufficiale

### Browser Harness

Pagina ufficiale utile per verificare il posizionamento self-healing, il collegamento CDP e le modalità browser locale, cloud e Box.

Apri fonte](https://www.browser-harness.com/) [GitHub

### Repository browser-harness

Codice MIT, skill distribuita, helper, guida di installazione e struttura del progetto.

Apri fonte](https://github.com/browser-use/browser-harness) [GitHub

### Repository browser-use

Quickstart ufficiale della libreria Python, esempi, client LLM e relazione con la CLI per coding agent.

Apri fonte](https://github.com/browser-use/browser-use) [Docs

### Installazione Browser Harness

Comandi ufficiali con uv, Python 3.12, registrazione della skill, diagnostica e gestione delle registrazioni.

Apri fonte](https://github.com/browser-use/browser-harness/blob/main/install.md) [Browser Use Blog

### The Bitter Lesson of Agent Harnesses

Spiegazione tecnica della scelta di esporre CDP direttamente al modello e degli helper modificabili durante il task.

Apri fonte](https://browser-use.com/posts/bitter-lesson-agent-harnesses) [Browser Use Blog

### Web Agents That Actually Learn

Approfondimento sul riuso delle skill, sulla distinzione fra esplorazione ed esecuzione e sulla riduzione dei passaggi successivi.

Apri fonte](https://browser-use.com/posts/web-agents-that-actually-learn) [Hermes Docs

### Skills System di Hermes Agent

Documentazione ufficiale sul caricamento progressivo delle skill e sulla directory gestita da Hermes.

Apri fonte](https://hermes-agent.nousresearch.com/docs/user-guide/features/skills) [OpenClaw Docs

### Skills in OpenClaw

Percorsi delle skill, caricamento nel workspace, riferimenti espliciti e aggiornamento del catalogo nelle nuove sessioni.

Apri fonte](https://docs.openclaw.ai/tools/skills) [Anthropic Docs

### Skill di Claude Code

Riferimento ufficiale per skill personali e di progetto, struttura SKILL.md e invocazione da Claude Code.

Apri fonte](https://docs.anthropic.com/en/docs/claude-code/skills) [DeepSeek Docs

### Skill in DeepSeek Harness

Documentazione tecnica sui percorsi .dsh/skills e .agents/skills e sulla priorità di caricamento.

Apri fonte](https://github.com/deepseek-ai/deepseek-harness/blob/master/docs/subsystems/skills.md)  

Se vuoi vedere il confronto con gli stessi task e gli stessi parametri, iscriviti alla newsletter. Pubblicherò screenshot, output grezzi e numeri appena il benchmark è finito.