OpenBot self-hosted su VPS: coworker AI in container
Scopri come eseguire OpenBot su un VPS: supervisor, container e browser isolati, policy del gateway e RAM necessaria per ogni coworker AI.
Cosa ottieni quando esegui in self-hosting i coworker AI OpenBot
Esegui in self-hosting i coworker AI OpenBot avviando un server gateway sull'hardware sotto il tuo controllo, insieme a un supervisor che assegna a ogni bot un proprio container dedicato. Quel container per singolo bot esiste solo quando COMPUTER_SUPERVISOR_URL è impostato. Senza di esso, ogni bot condivide lo stesso computer su AGENT_COMPUTER_URL. Con il supervisor attivo, ogni container del bot trasporta il proprio browser Chromium e il proprio volume di workspace, con un profilo browser che persiste tra le sessioni. Ogni azione che un bot compie su un computer, un file, un server MCP (model context protocol) o un componente dell'interfaccia utente passa attraverso quel gateway, che la verifica rispetto a una policy prima dell'esecuzione e la registra successivamente. Se il loop dell'agente racchiuso dal gateway è ancora un territorio sconosciuto, il percorso guidato in imparare a creare agenti AI da zero ti permette di scriverne uno piccolo autonomamente prima di affidare a un bot un browser e le tue credenziali di accesso.
OpenBot è pubblicato da CopilotKit con licenza MIT su github.com/CopilotKit/openbot. La prima release con tag, v0.0.1, è stata pubblicata il 17 agosto 2026. Al 3 novembre 2026 l'ultima versione è v0.2.0, pubblicata il 12 ottobre 2026, e il README attuale descrive il progetto come beta e in fase di sviluppo attivo. Consideralo un design serio con spigoli tipici delle fasi iniziali. Il deployment descritto di seguito utilizza la versione v0.2.0; la versione attuale main assegna a ogni persona un container e fornisce a ogni bot contrassegnato come Isolated un proprio container dedicato.
La parte interessante di questa architettura è anche quella più onerosa. Un browser per ogni agente rappresenta il costo in termini di memoria che la maggior parte delle persone dimentica di pianificare, pertanto il dimensionamento precede l'installazione in questa guida.
Come il gateway decide ogni azione
Il server API sulla porta 3001 è il percorso sottoposto a controllo per raggiungere il computer di un bot. Il computer espone anche endpoint di servizio di livello inferiore protetti da token. Il progetto indica di mantenerli privati e di non usarli mai per aggirare il gateway. Il gateway resta quindi l'unico percorso solo finché tali endpoint non sono raggiungibili. Prima di eseguire un'azione nel browser, il gateway risolve la destinazione a partire da uno snapshot della pagina, valuta le regole dei criteri CEL (Common Expression Language) rispetto al contesto, scrive una riga di audit con la decisione e solo dopo chiama il container. Se l'esecuzione fallisce in seguito, scrive una seconda riga. La documentazione definisce chiaramente il confine: il computer non decide i criteri; il gateway del server è il confine delle azioni. Questa separazione ha un nome al di fuori di OpenBot, perché il ciclo, le definizioni degli strumenti, i controlli delle autorizzazioni e lo stato della sessione formano insieme l'harness che avvolge un modello, e questo gateway ne rappresenta la parte relativa alle autorizzazioni.
La valutazione dei criteri adotta il fail-closed e le regole di negazione vengono valutate prima di quelle di autorizzazione. La direzione del fallimento è più importante della sintassi delle regole. Un criterio mancante o vuoto non autorizza nulla. Una regola non valida causa il blocco, sia che si tratti di una regola di negazione sia di una regola di autorizzazione. Un errore nei criteri causa quindi il blocco del bot, non il suo accesso incontrollato ai tuoi account. I criteri forniti da OpenBot sono un caso diverso. Il valore predefinito all'avvio è deny: [] con allow: ["true"]. Questo consente ogni azione finché AGENT_COMPUTER_POLICY o una policy amministrativa salvata non lo sostituisce. Scrivi quindi una policy personalizzata prima che un bot interagisca con dati o sistemi reali. Questo livello controlla ciò che fa un bot, non ciò che legge. Una pagina che contiene istruzioni rivolte all'agente resta quindi un problema distinto. È la stessa superficie di prompt injection che accetti quando fornisci a un agente i risultati della tua istanza SearXNG.
Il registro di audit risiede in PostgreSQL, quindi sopravvive a un riavvio. I passaggi di controllo vengono registrati come computer.help_requested, computer.control_taken e computer.control_released. In questo modo puoi vedere quando un bot chiede l'intervento di una persona e quando la persona restituisce il controllo. I secret vengono registrati come conteggi dei caratteri, mai come valori. Le letture, le scritture e gli elenchi di file compaiono nella scheda Activity. Un file salvato viene mostrato con il relativo percorso e le dimensioni, mai con il contenuto. Questa visualizzazione viene mantenuta nel browser e non costituisce il record di audit. Se vuoi lo stesso confine di controllo senza un browser a gestirlo, controllare le azioni degli agenti AI tramite approvazioni tratta questo caso più circoscritto.
Quanto consumano un singolo Bot in RAM e su disco
Il progetto pubblica valori misurati per un singolo Bot su arm64. Questi sono i dati di dimensionamento riportati nella documentazione di deployment. Descrivono un solo bot su una sola architettura, quindi vanno considerati un punto di partenza, non un piano di capacità.
I dati alla base di questo grafico
[
{
"label": "Measured, one Bot",
"memory_gb": 0.55,
"disk_gb": 1.4,
"vcpu": 0.06
},
{
"label": "Documented minimum",
"memory_gb": 2,
"disk_gb": 4,
"vcpu": 1
},
{
"label": "Documented recommended",
"memory_gb": 4,
"disk_gb": 8,
"vcpu": 2
}
]La memoria di picco misurata è stata di 0.55 GB per un singolo Bot. Il minimo documentato è 2 GB, mentre il valore consigliato è 4 GB. La differenza tra il valore misurato e il minimo lascia margine per la crescita del consumo di Chromium sotto carico. Il consumo di memoria del browser dipende infatti dalle pagine aperte, non dal processo inattivo. La documentazione considera ogni pagina aggiuntiva aperta contemporaneamente pari a circa 100-200 MB. Il consumo della CPU in idle è quasi nullo: raggiunge 0.06 di un core al valore massimo misurato. La CPU, quindi, non è la risorsa principale da dimensionare. L'immagine occupa 1.4 GB, a fronte di un volume consigliato di 8 GB. La differenza lascia spazio per /workspace, dove il bot conserva i propri file. L'immagine include soltanto i browser della famiglia Chromium. Firefox e WebKit di Playwright non sono inclusi.
Questi dati non indicano quanto costi eseguire più bot insieme, e il progetto non pubblica alcun valore per questo scenario. Un minimo documentato è il valore che un progetto ritiene ragionevole pubblicare, non necessariamente quello osservato da qualcuno sotto carico. Per questo anche la scelta tra PhotoPrism e Immich dipende dai valori minimi di RAM misurati, non da quelli pubblicati. Misura il tuo ambiente. Avvia un bot, assegnagli un'attività reale con una pagina aperta e monitora il container mentre lavora.
docker stats --no-stream
free -mUsa la colonna MEM USAGE relativa al container del bot come valore per singolo bot. Aggiungi il consumo del gateway e di PostgreSQL, quindi moltiplica il valore per bot per il numero di bot che prevedi di eseguire contemporaneamente. Un bot inattivo mantiene aperto il browser fino alla scadenza del timeout di inattività, impostato per impostazione predefinita su 30 minuti. Includi quindi anche i browser inattivi nel moltiplicatore. Il calcolo è lo stesso usato per dimensionare RAM e CPU di una VPS per un coding agent. La parte relativa al browser è descritta in eseguire un browser headless per agent su una VPS.
Un dettaglio di Chromium incide sui piani più piccoli. OpenBot avvia Chromium con --disable-dev-shm-usage, quindi il browser scrive in /tmp invece che in /dev/shm. In questo modo si evita il crash che si verifica sugli host con un /dev/shm di dimensioni ridotte. La pressione viene però spostata sul filesystem root, ed è un ulteriore motivo per cui lo spazio su disco consigliato è maggiore delle dimensioni dell'immagine.
Come si esegue l'hosting autonomo di OpenBot su una VPS?
Sono necessari Docker, Bun 1.3 o versioni successive, un progetto e una licenza CopilotKit Intelligence e l'accesso a un modello, tramite una API key o un login presso un provider supportato. Il v0.2.0 README richiede Bun 1.3+ per l'applicazione e il server API; la versione main attuale ha alzato il requisito a 1.4+, quindi consulta il README del tag che cloni. Il login diretto presso un provider può sostituire una API key a partire dalla versione v0.0.15. La documentazione di sviluppo richiede inoltre la presenza di lsof, openssl e curl sul sistema, oltre a npx da Node per il provisioning di Intelligence. Clona una release con tag invece di main, poiché main in un progetto beta cambia senza preavviso. Se utilizzi già un'installazione v0.1.x, leggi le note di rilascio v0.2.0 prima di procedere: l'aggiornamento copia le connessioni Composio memorizzate in una nuova tabella e il rollback alla versione v0.1.2 nasconde qualsiasi account collegato dopo l'aggiornamento.
git clone --branch v0.2.0 https://github.com/CopilotKit/openbot.git
cd openbot
cp .env.example .env
bun installEffettua il provisioning del progetto Intelligence. I primi due comandi eseguono l'accesso e selezionano il progetto. Lo script di supporto esegue quindi il provisioning della chiave di runtime del progetto, crea o riutilizza il relativo container openbot Learning e scrive entrambe le impostazioni nel file di ambiente.
npx --yes copilotkit@latest login
npx --yes copilotkit@latest project select
bun scripts/setup-learning.tsGenera la chiave che crittografa le credenziali memorizzate e inserisci l'output in .env come KEY_ENCRYPTION_KEY. Aggiungi la tua OPENAI_API_KEY nello stesso file. Il Bot proof-of-concept utilizza OpenAI. Per il Bot LangGraph puoi impostare BOT_PROVIDER su anthropic o google e aggiungere la chiave corrispondente. Per utilizzare un login al modello invece di una chiave, il v0.2.0 .env.example accetta CLAUDE_CODE_OAUTH_TOKEN, il token da claude setup-token e CHATGPT_AUTH_FILE, il file scritto da un piano ChatGPT autenticato. Il server API li legge per i suoi agenti integrati e compose li passa all'harness del Bot selezionato.
openssl rand -base64 32Mentre .env è aperto, controlla le impostazioni del computer. .env.example lascia vuoti COMPUTER_SUPERVISOR_URL e SUPERVISOR_TOKEN e punta AGENT_COMPUTER_URL all'unico computer condiviso sulla porta 4100. Il file compose include il supervisor e scripts/start.sh abilita i computer per singolo bot per impostazione predefinita, fornendo COMPUTER_SUPERVISOR_URL e SUPERVISOR_TOKEN al server. Se avvii il server autonomamente, imposta entrambi i valori; senza un URL del supervisor, ogni bot condivide quel browser e i relativi login.
Quindi avvia.
bash scripts/start.shscripts/start.sh avvia i servizi Docker, esegue le migrazioni del database, avvia il server, il worker di routine e l'applicazione, verificandone lo stato di salute. Al termine, l'applicazione risponde sulla porta 3010 e l'API sulla porta 3001. Lo script segnala conflitti di porta e non interferisce con un servizio corrispondente già in esecuzione, quindi eseguirlo due volte è sicuro.
Verifica dal server stesso prima di esporre qualsiasi cosa.
curl -sS -o /dev/null -w '%{http_code}\n' http://127.0.0.1:3010
ss -ltnp | grep -E ':(3010|3001|4100|4500|5432)'Un 200 dal primo comando indica che l'applicazione è in esecuzione. Il secondo comando mostra a quali indirizzi sono vincolate le porte, ed è questa la risposta rilevante su una VPS. Una riga che riporta 127.0.0.1:3001 è privata per il sistema. Una riga che riporta 0.0.0.0:3001 significa che chiunque possa instradare verso il server può raggiungerlo.
L'immagine container singola
La documentazione di distribuzione include anche un'unica immagine che contiene l'applicazione, l'API e Chromium, esposti sulla porta 3001. Viene pubblicata come ghcr.io/copilotkit/openbot con tag di versione, oppure è possibile crearla dal proprio clone.
docker build -t openbot .
docker run -p 127.0.0.1:3001:3001 --env-file .env \
-e EMBEDDED_POSTGRES=on -v openbot-data:/var/lib/postgresql openbotEMBEDDED_POSTGRES=on esegue PostgreSQL all'interno del container e applica le migrazioni all'avvio. Il volume denominato conserva la cronologia degli audit tra un nuovo deployment e l'altro; senza questo volume, ogni nuova build elimina la cronologia. Montarlo nella directory padre, /var/lib/postgresql, e non direttamente nella directory dei dati. La documentazione avverte che il mount della directory dei dati può lasciare il cluster non inizializzato; in questo caso l'applicazione risponde con un 502. Se si indica a DATABASE_URL di usare invece un database gestito, è necessario abilitare su quel database l'estensione vector. Servizi gestiti come RDS, Cloud SQL e Azure Database supportano l'estensione, ma nessuno di questi servizi la abilita automaticamente. Le migrazioni richiedono inoltre che il ruolo che le esegue sia il proprietario dell'estensione. Se l'estensione è stata creata da un ruolo diverso, le migrazioni si interrompono con must be owner of extension vector.
Eseguire le migrazioni come fase del rilascio quando il database è esterno.
docker run --rm --env-file .env --entrypoint sh openbot \
-c "cd /app/server && bun scripts/migrate.ts"Usare scripts/migrate.ts e non drizzle-kit migrate, perché la CLI drizzle-kit è una dipendenza di sviluppo e non è inclusa nell'immagine di produzione. Mantenere --entrypoint sh, perché senza questa opzione l'API si avvia prima dell'esecuzione delle migrazioni.
Questa immagine lascia intenzionalmente non pubblicata la porta del browser. Inoltre non include il supervisore, perché il supervisore richiede il socket Docker, che le piattaforme serverless non mettono a disposizione. Senza il supervisore, tutti i bot condividono un unico browser e quindi lo stesso insieme di credenziali; viene così meno l'isolamento che giustificava l'esecuzione di container separati per ogni bot. Questo percorso con un solo container è l'unico che non assegna a ciascun bot un container dedicato. Se il motivo per cui stai usando questa soluzione è avere credenziali separate per ogni bot, esegui lo stack compose con COMPUTER_SUPERVISOR_URL e SUPERVISOR_TOKEN impostati, su un host in cui accetti questo compromesso. Un processo che può comunicare con il socket Docker può avviare un container privilegiato; in pratica, dispone quindi dei privilegi di root sull'host. Questo è un buon motivo per mantenere OpenBot su una macchina dedicata, seguendo lo stesso principio di assegnare agli agenti di coding una VM usa e getta.
Perché OPENBOT_SINGLE_USER è un'impostazione per laptop
.env.example viene fornito con OPENBOT_SINGLE_USER=true. Questa impostazione tratta ogni richiesta come proveniente da un unico amministratore fisso e salta completamente l'accesso. Su un laptop è una comodità, perché l'unico client che può raggiungere la porta sei tu. Su un VPS, invece, chiunque raggiunga la porta 3010 diventa quell'amministratore, su un sistema che memorizza credenziali crittografate e controlla un browser già autenticato ai tuoi account.
Il server ora protegge parzialmente questo scenario. Se OPENBOT_SINGLE_USER=true è impostato e una voce OPENBOT_PUBLIC_URL, OPENBOT_APP_URL o TRUSTED_ORIGINS è instradata pubblicamente, il server rifiuta di avviarsi e indica l'indirizzo. Per un indirizzo privato viene mostrato un avviso. Il controllo legge gli URL presenti nella configurazione, non le interfacce su cui Docker pubblica le porte. Per questo i valori predefiniti localhost superano il controllo anche quando una porta è aperta a Internet. Il binding resta a tuo carico.
Esistono due modalità corrette per eseguire l'applicazione. Mantieni OPENBOT_SINGLE_USER=true, associa ogni porta a 127.0.0.1 e raggiungi l'applicazione soltanto tramite un tunnel SSH o un'interfaccia di rete privata.
ssh -N -L 3010:127.0.0.1:3010 -L 3001:127.0.0.1:3001 you@your-vpsL'applicazione è quindi disponibile all'indirizzo http://localhost:3010 nel tuo browser. Questo viene considerato un contesto sicuro, quindi il browser conserva i cookie di accesso Secure. La schermata operativa non richiede invece un contesto sicuro: la documentazione di deployment specifica che l'applicazione non dipende da nessuna delle API del browser disabilitate da http:// semplice. L'altra possibilità consiste nel disattivare la modalità single-user e configurare un identity provider reale. Sono supportati Google, Microsoft Entra, Okta, SAML e OIDC. Google, Entra e Okta vengono configurati nell'ambiente, mentre i provider SAML e OIDC vengono registrati in Admin, Identity providers, dopo l'avvio del deployment. Ogni provider richiede inoltre BETTER_AUTH_SECRET con almeno 32 caratteri, BETTER_AUTH_URL impostato sull'URL pubblico di base dell'API per i callback OAuth e INITIAL_ADMIN_EMAILS. TRUSTED_ORIGINS non fa parte dell'elenco obbligatorio, ma contiene le origini dell'applicazione accettate dall'API e ogni host presente nel documento di discovery di un provider OIDC registrato. Per impostazione predefinita, OPENBOT_APP_URL usa la prima voce, quindi impostalo sull'origine pubblica dell'applicazione. Le credenziali del provider devono essere complete, perché un provider configurato solo parzialmente impedisce l'avvio invece di ripiegare sull'accesso aperto. Se il motivo per cui stai aggiungendo gli account è che ogni persona del team vuole un proprio agente, anziché un proprio browser, OneCLI è progettato fin dall'inizio per questo modello, con un agente isolato in una sandbox per ogni persona e le chiavi dei modelli conservate in un unico gateway.
Se l'applicazione è raggiungibile tramite un nome pubblico, anteponi TLS (transport layer security). Una pagina servita tramite http:// semplice su qualsiasi host diverso da localhost non è un contesto sicuro. Di conseguenza, i cookie contrassegnati con Secure non vengono memorizzati e l'accesso non riesce in un modo che sembra un bug di OpenBot.
Proteggere con il firewall le porte di livello inferiore
La nota di sicurezza di OpenBot specifica che gli endpoint dei servizi di livello inferiore sono protetti da token, che devono restare privati e che non devono essere usati per aggirare il gateway. I token costituiscono la seconda protezione. La prima consiste nel fatto che la porta non sia raggiungibile.
agent-computer è in ascolto sulla porta 4100 e richiede COMPUTER_TOKEN. Gli endpoint del bot sono in ascolto sulle porte 4200 e 4201, mentre l'agent harness è in ascolto sulla porta 4202. supervisor è in ascolto sulla porta 4500 dell'host e sulla porta 4300 all'interno del container; il file compose lo associa a 127.0.0.1:4500. PostgreSQL è in ascolto sulla porta 5432. Nessuna di queste porte deve essere esposta su un'interfaccia pubblica. In una distribuzione per un singolo utente, lo stesso vale per l'applicazione e per l'API.
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow 22/tcp
sudo ufw enable
sudo ufw status verboseQui c'è un problema che sorprende chi presume che il firewall sia sufficiente. La pubblicazione di una porta del container con -p 3001:3001 induce Docker a installare una regola DNAT. Il traffico viene quindi gestito nel percorso FORWARD e non attraversa mai la catena INPUT, sulla quale si applica il deny predefinito di ufw. La porta resta aperta anche se ufw status continua a mostrare Status: active. Associa la porta pubblicata all'interfaccia di loopback direttamente nella mappatura, come in -p 127.0.0.1:3001:3001, oppure imposta l'indirizzo dell'host nel file compose. Verifica con ss -ltnp, non con ufw status. Questo comportamento non è specifico di OpenBot. Esegui quindi lo stesso controllo su ogni altro container pubblicato sul server, incluso quello che fornisce una libreria Jellyfin ricostruita come un videonoleggio degli anni '90'.
OpenBot può essere eseguito offline con Intelligence self-hosted
Considera questo aspetto prima di pianificare il deployment. OpenBot dipende da un progetto CopilotKit Intelligence, che mantiene thread persistenti e memoria delle conversazioni sul servizio ospitato o sulla tua infrastruttura. Il server v0.2.0 fissato convalida INTELLIGENCE_API_URL, INTELLIGENCE_GATEWAY_WS_URL e INTELLIGENCE_API_KEY all'avvio. Verifica i tre parametri come un insieme e rifiuta l'avvio se ne manca uno. COPILOTKIT_LICENSE_TOKEN è facoltativo e viene utilizzato solo da una Intelligence self-hosted dotata di licenza propria. A partire dal 3 novembre 2026, l'Intelligence ospitata gratuita include 1.000 interazioni per organizzazione ogni mese, ma da v0.1.0 OpenBot mostra un banner di self-hosting a meno che il deployment non disponga di un piano Intelligence a pagamento o imposti OPENBOT_SELF_HOST_BANNER=false. L'Intelligence è essa stessa auto-ospitabile, quindi un deployment completamente locale è possibile con un lavoro maggiore rispetto a quanto mostrato nella guida rapida. Il deployment in produzione offline richiede il piano Annual; il pagamento a consumo per il self-hosted deve connettersi per segnalare l'utilizzo ai fini della fatturazione. La Developer Edition gratuita supporta la valutazione locale non in produzione con una licenza rinnovabile di 30 giorni; l'installazione e il rinnovo richiedono l'accesso a Internet. La CLI di Intelligence locale scrive la sua chiave come CPK_INTELLIGENCE_API_KEY, mentre la release v0.2.0 fissata legge solo INTELLIGENCE_API_KEY, quindi copia il valore per questa release. L'attuale main accetta direttamente la chiave della CLI e le dà la precedenza.
Il modello è la seconda dipendenza. Nulla viene fornito preinstallato. BOT_PROVIDER accetta openai, anthropic o google per il LangGraph Bot, e OPENAI_BASE_URL punta il percorso OpenAI verso qualsiasi endpoint compatibile, che è dove si inserisce l'esecuzione di Ollama su una VPS per l'hosting locale di un LLM se desideri che i token rimangano sul tuo hardware. Il controllo del browser richiede molto a un modello, quindi testa un modello locale su un'attività reale prima di impegnarti.
Scalare oltre una replica
Il gateway risolve i riferimenti agli elementi rispetto a uno snapshot della pagina. Ora lo snapshot risiede in PostgreSQL, quindi una seconda replica può operare sullo snapshot creato dalla prima. Il chart Helm ufficiale esegue 2 repliche dell’API per impostazione predefinita e mantiene in PostgreSQL tutto ciò che deve sopravvivere al riavvio o alla sostituzione di una replica. Disabilita inoltre il browser integrato e impedisce di installarne uno insieme a più di una replica. Un browser all’interno del pod dell’API conserverebbe le sessioni di accesso di un bot, mentre lo scaling dell’API le moltiplicherebbe. Il caso con una sola immagine richiede particolare attenzione: ogni replica contiene il proprio browser, quindi le sessioni di accesso di un bot restano sull’istanza che le ha gestite. Su un solo VPS, il browser di ogni bot continua a essere eseguito sullo stesso host, quindi per aumentare la capacità è necessario potenziare il server. L’isolamento tra i bot deriva comunque dai container dedicati a ciascun bot, come i sandbox per agenti self-hosted separano gli errori di un agente da quelli degli altri.
Modalità di errore e relativi segnali
L'avvio termina subito dopo la compilazione di .env. Il server convalida la configurazione prima di fornire qualsiasi servizio. Ognuna di queste condizioni interrompe l'avvio invece di produrre un degrado silenzioso: un blocco Intelligence parziale, KEY_ENCRYPTION_KEY mancante, un provider OAuth con client ID ma senza secret oppure la modalità single-user insieme a un URL pubblico. Leggi il primo errore, correggi quel campo e avvia nuovamente il server.
Le migrazioni non riescono su un database gestito. Le cause probabili sono due. L'estensione vector potrebbe non essere abilitata e il ruolo che esegue la migrazione non può crearla; di conseguenza, la migrazione incontra un tipo di colonna sconosciuto a PostgreSQL. Oppure l'estensione è stata creata da un altro ruolo e la migrazione si interrompe con must be owner of extension vector. Crea l'estensione con il ruolo che esegue le migrazioni, quindi ripeti il passaggio di migrazione.
L'applicazione viene caricata, ma l'accesso non rimane attivo. Il servizio è pubblicato tramite http:// non cifrato su un indirizzo pubblico, quindi non si trova in un contesto sicuro e il cookie Secure viene scartato. Configura TLS davanti all'applicazione oppure usa il tunnel SSH, in modo che il browser rilevi localhost.
I bot condividono account che avrebbero dovuto essere separati. Il supervisor non è in uso, quindi non esiste un computer dedicato per ogni bot e tutti i bot utilizzano il browser condiviso in AGENT_COMPUTER_URL. Verifica che COMPUTER_SUPERVISOR_URL sia impostato e che il supervisor possa raggiungere il socket Docker.
Un bot si arresta e chiede assistenza. È il comportamento previsto dal design. Il registro di audit memorizza computer.help_requested; puoi prendere il controllo dalla schermata attiva e il passaggio di consegne viene registrato da entrambe le parti.
FAQ
È sicuro lasciare OPENBOT_SINGLE_USER attivo per un deployment su VPS?
Solo se il gateway non è raggiungibile da Internet. OPENBOT_SINGLE_USER=true accetta ogni richiesta come un unico amministratore fisso senza autenticazione; chiunque riesca ad aprire la porta ottiene il controllo del deployment, delle credenziali salvate e del browser autenticato. In questa modalità, il server rifiuta di avviarsi quando un URL pubblico o un'origine attendibile sono configurati per il routing pubblico, ma tale controllo non può verificare come le porte siano effettivamente pubblicate. È accettabile solo quando ogni porta è vincolata a 127.0.0.1 e l'accesso all'applicazione avviene tramite tunnel SSH o interfaccia di rete privata. Su un'interfaccia pubblica, disattivalo e configura Google, Microsoft Entra, Okta o OIDC insieme a BETTER_AUTH_SECRET, BETTER_AUTH_URL e INITIAL_ADMIN_EMAILS, impostando TRUSTED_ORIGINS sull'origine pubblica della tua applicazione.
Quanta RAM richiede un bot OpenBot?
I dati pubblicati dal progetto per un singolo bot su architettura arm64 indicano un picco di memoria di 0.55 GB, con 2 GB come minimo documentato e 4 GB raccomandati. Non esiste un dato ufficiale per più bot simultanei, poiché ognuno gestisce la propria istanza di Chromium. Esegui un bot su un task reale, leggi la memoria del container in docker stats, aggiungi il consumo del gateway e del database, quindi moltiplica per il numero di bot che prevedi di eseguire contemporaneamente.
È necessario un account CopilotKit per l'auto-hosting di OpenBot?
Sì. OpenBot dipende da un progetto CopilotKit Intelligence per la persistenza dei thread e della memoria; il server v0.2.0, nella versione bloccata, rifiuta di avviarsi a meno che l'URL dell'Intelligence API, l'URL del WebSocket del gateway e la chiave API non siano tutti impostati. È disponibile un piano gratuito in hosting a partire dal 3 novembre 2026; il deployment in produzione offline è supportato con Intelligence in auto-hosting (piano Annual) e un modello locale. È inoltre necessario fornire l'accesso al proprio modello, una chiave API del modello o un login di un provider supportato, poiché nessun modello viene distribuito insieme a OpenBot.
Perché ogni bot utilizza il proprio browser invece di condividerne uno?
Perché un profilo browser rappresenta un'identità. Un browser condiviso implica cookie e sessioni condivise: un bot autenticato su un account significherebbe che tutti i bot sono autenticati su quell'account. I container per singolo bot forniscono a ogni collaboratore il proprio profilo e i propri login, ma solo quando COMPUTER_SUPERVISOR_URL punta il server verso il supervisore. Senza questa configurazione, ogni bot condivide lo stesso browser. Il costo è in termini di memoria, dato che un'istanza di Chromium per bot rappresenta la voce di consumo maggiore nel dimensionamento.
Quali porte di OpenBot devono essere aperte sul firewall?
Nessuna di quelle a basso livello. L'agent-computer sulla porta 4100, gli endpoint dei bot sulle porte 4200 e 4201, l'agent harness sulla 4202, il supervisore sulla 4500 e PostgreSQL sulla 5432 devono rimanere privati. Il progetto li protegge tramite token e richiede comunque di mantenerli inaccessibili. Pubblica solo ciò che un utente deve aprire e ricorda che una porta di un container pubblicata con -p 3001:3001 è raggiungibile a prescindere da una regola di default-deny di ufw, poiché la regola DNAT di Docker instrada quel traffico nel percorso FORWARD invece che in INPUT.