SSD Nodes Learn Hosting plans →
Gidsen Matt ConnorDoor Matt Connor · Bijgewerkt 2026-11-06

OpenBot AI-collega's zelf hosten op een VPS

Leer hoe u OpenBot zelf host met een supervisor voor individuele containers en browsers. Ontdek hoe de gateway acties valideert en wat het RAM-verbruik per bot precies is.

Wat u krijgt wanneer u OpenBot AI-coworkers zelf host

U host OpenBot AI-coworkers zelf door één gatewayserver te draaien op hardware die u beheert, plus een supervisor die elke bot een eigen container geeft. Die container per bot bestaat alleen wanneer COMPUTER_SUPERVISOR_URL is ingesteld. Zonder deze instelling delen alle bots de ene computer op AGENT_COMPUTER_URL. Met de supervisor heeft elke botcontainer een eigen Chromium-browser en een eigen werkruimtevoulme, met een browserprofiel dat tussen sessies behouden blijft. Elke actie die een bot uitvoert op een computer, bestand, MCP-server (model context protocol) of UI-component gaat via die gateway. De gateway controleert de actie vóór uitvoering aan de hand van een beleid en registreert deze daarna. Als de agentlus die door de gateway wordt ingepakt nog onbekend terrein voor u is, laat het stapsgewijze traject in AI-agents vanaf nul leren u eerst zelf een kleine agentlus schrijven voordat u een bot toegang geeft tot een browser en uw aanmeldgegevens.

OpenBot wordt door CopilotKit uitgebracht onder de MIT-licentie op github.com/CopilotKit/openbot. De eerste release met tag, v0.0.1, is gepubliceerd op 17 augustus 2026. Op 3 november 2026 is de nieuwste versie v0.2.0, gepubliceerd op 12 oktober 2026. Het huidige README-bestand beschrijft het project als bèta en als actief in ontwikkeling. Beschouw het als een serieus ontwerp met enkele vroege beperkingen. De onderstaande implementatie fixeert v0.2.0. De huidige main geeft elke gebruiker een container en geeft een bot met de markering Isolated een eigen container.

Het interessante deel van deze architectuur is ook het duurste deel. Een browser per agent veroorzaakt de meeste geheugenkosten waarmee mensen geen rekening houden. Daarom komt de dimensionering hier vóór de installatie.

Hoe de gateway elke actie bepaalt

De API-server op poort 3001 is het beheerde pad naar de computer van een bot. De computer stelt ook service-endpoints op een lager niveau bloot die met tokens zijn beveiligd. Het project schrijft voor om deze privé te houden en ze nooit te gebruiken om de gateway te omzeilen, zodat de gateway het enige pad blijft zolang die endpoints onbereikbaar zijn. Voordat een browseractie wordt uitgevoerd, bepaalt de gateway het doel op basis van een paginasnapshot, evalueert CEL (common expression language) beleidsregels op basis van de context, schrijft een audit-regel die de beslissing bevat, en roept pas daarna de container aan. Als de uitvoering daarna mislukt, schrijft het een tweede regel. De documentatie stelt de grens duidelijk: de computer bepaalt het beleid niet, de server-gateway is de actiegrens. Die splitsing heeft buiten OpenBot een naam, omdat de lus, de tooldefinities, de toegangscontroles en de sessiestatus samen het harnas vormen dat om een model heen is gewikkeld, en deze gateway is de toegangshelft daarvan.

Beleidevaluatie is standaard gesloten en weigeringsregels worden geëvalueerd vóór toestemmingsregels. De richting van de fout is belangrijker dan de syntaxis van de regel. Een ontbrekend of leeg beleid staat niets toe, en een defecte regel leidt tot blokkering, ongeacht of het een weigerings- of toestemmingsregel betreft. Een fout in uw beleid resulteert dus in een vastgelopen bot in plaats van een bot die ongecontroleerd toegang heeft tot uw accounts. Het beleid dat OpenBot standaard meelevert, is een ander verhaal. De standaardinstelling bij het opstarten is deny: [] met allow: ["true"], wat elke actie toestaat totdat AGENT_COMPUTER_POLICY of een opgeslagen beheerdersbeleid dit vervangt. Schrijf daarom uw eigen beleid voordat een bot iets daadwerkelijks aanraakt. Die laag regelt wat een bot doet en niet wat hij leest; een pagina met instructies gericht aan de agent blijft dus een apart probleem. Dit is hetzelfde oppervlak voor prompt-injectie waar u mee te maken krijgt wanneer u een agent resultaten van uw eigen SearXNG-instantie overhandigt.

Het audit-spoor bevindt zich in PostgreSQL, waardoor het een herstart overleeft. Overdrachten van controle worden vastgelegd als computer.help_requested, computer.control_taken en computer.control_released; zo ziet u wanneer een bot om een mens vraagt en hoe de mens de controle teruggeeft. Geheimen worden vastgelegd als aantal tekens, nooit als waarden. Bestand-lees-, schrijf- en lijstacties verschijnen in het tabblad Activiteit, waar een opgeslagen bestand wordt weergegeven als het pad en de grootte, en nooit als de inhoud. Die weergave wordt in de browser vastgehouden en is niet het audit-record. Als u dezelfde controlegrens wilt zonder een browser erachter, behandelt het beveiligen van AI-agentacties achter goedkeuringen dat specifiekere geval.

Wat één bot kost aan RAM en schijfruimte

Het project publiceert gemeten cijfers voor een enkele Bot op arm64. Dit zijn de dimensiecijfers die in de implementatiedocumentatie staan. Ze beschrijven één bot op één architectuur, dus beschouw ze als een startpunt in plaats van als een capaciteitsplan.

GrafiekOpenBot published resource figures, one Bot on arm64 (October 2026)
De gegevens achter deze grafiek
[
  {
    "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
  }
]

Het piekgeheugengebruik werd gemeten op 0.55 GB voor één Bot, terwijl het gedocumenteerde minimum 2 GB is en de aanbeveling 4 GB bedraagt. Het verschil tussen de meting en het minimum is de ruimte die Chromium nodig heeft om onder belasting te groeien, omdat het geheugengebruik van een browser afhangt van de geopende pagina's en niet van het proces in ruststand. De documentatie stelt dat elke extra pagina die tegelijkertijd geopend is, ongeveer 100 tot 200 MB verbruikt. Het CPU-gebruik in ruststand is verwaarloosbaar, op 0.06 van een core aan de bovenkant van het gemeten bereik, dus CPU is niet de beperkende factor. De image is 1.4 GB, tegenover een aanbevolen volume van 8 GB. Het verschil is ruimte voor /workspace, waar de bot zijn bestanden bewaart. De image bevat alleen de Chromium-familie van browsers. Playwright's Firefox en WebKit zijn hierin niet opgenomen.

Niets hiervan vertelt u wat meerdere bots samen kosten, en het project publiceert daar geen cijfers over. Een gedocumenteerd minimum is het getal dat een project durft te publiceren in plaats van een getal dat iemand onder belasting heeft geobserveerd. Dit is ook de reden waarom kiezen tussen PhotoPrism en Immich neerkomt op hun gemeten RAM-ondergrenzen in plaats van de gepubliceerde waarden. Meet het zelf. Start één bot, geef deze een echte taak met een pagina geopend en observeer de container terwijl deze werkt.

docker stats --no-stream
free -m

Gebruik de MEM USAGE-kolom voor de container van de bot als uw cijfer per bot, tel daar de gateway en PostgreSQL bij op en vermenigvuldig het cijfer per bot met het aantal bots dat u tegelijkertijd verwacht te draaien. Een inactieve bot behoudt zijn browser totdat de inactiviteits-timeout deze sluit, standaard na 30 minuten, dus neem inactieve browsers mee in de vermenigvuldiging. De berekening is dezelfde als die wordt gebruikt voor het dimensioneren van RAM en CPU voor een coding agent VPS, en de browserkant hiervan wordt behandeld in het draaien van een headless browser voor agents op een VPS.

Eén detail over Chromium is van invloed op kleine abonnementen. OpenBot start Chromium met --disable-dev-shm-usage, waardoor de browser schrijft naar /tmp in plaats van naar /dev/shm. Dit voorkomt de crash die optreedt op hosts met een kleine /dev/shm, en het verplaatst de druk naar uw root-bestandssysteem. Dit is nog een reden waarom de aanbevolen schijfruimte groter is dan de image zelf.

Hoe host u OpenBot zelf op een VPS?

U hebt Docker, Bun 1.3 of nieuwer, een CopilotKit Intelligence-project en licentie nodig. Daarnaast hebt u toegang tot een model nodig, via een API-sleutel of via de aanmelding bij een ondersteunde provider als alternatief. De v0.2.0 README vereist Bun 1.3+ voor de app en de API-server. De huidige main verhoogt dit naar 1.4+. Lees daarom de README van de tag die u clonet. De eigen aanmelding van een provider kan sinds v0.0.15 als alternatief voor een API-sleutel worden gebruikt. De ontwikkelingsdocumentatie verwacht ook lsof, openssl en curl op de server, plus npx van Node voor het inrichten van Intelligence. Clone een getagde release in plaats van main, omdat main in een bètaproject zonder waarschuwing kan wijzigen. Als u al een v0.1.x-installatie gebruikt, lees dan de v0.2.0-releaseopmerkingen voordat u hierop overstapt. Bij de upgrade worden opgeslagen Composio-verbindingen naar een nieuwe tabel gekopieerd. Als u daarna teruggaat naar v0.1.2, zijn accounts die na de upgrade zijn verbonden niet meer zichtbaar.

git clone --branch v0.2.0 https://github.com/CopilotKit/openbot.git
cd openbot
cp .env.example .env
bun install

Richt het Intelligence-project in. Met de eerste twee opdrachten meldt u zich aan en selecteert u het project. Het hulpscript richt vervolgens de runtime-sleutel van dat project in, maakt de openbot Learning-container aan of hergebruikt deze, en schrijft beide instellingen naar uw omgevingsbestand.

npx --yes copilotkit@latest login
npx --yes copilotkit@latest project select
bun scripts/setup-learning.ts

Genereer de sleutel waarmee opgeslagen referenties worden versleuteld en plaats de uitvoer in .env als KEY_ENCRYPTION_KEY. Voeg uw OPENAI_API_KEY toe aan hetzelfde bestand. De proof-of-concept-Bot gebruikt OpenAI. Voor de LangGraph Bot kunt u BOT_PROVIDER instellen op anthropic of google en de bijbehorende sleutel toevoegen. Als u een modelaanmelding in plaats van een sleutel wilt gebruiken, verwacht v0.2.0 in .env.example de waarde CLAUDE_CODE_OAUTH_TOKEN, het token uit claude setup-token, en CHATGPT_AUTH_FILE, het bestand dat een aangemeld ChatGPT-abonnement schrijft. De API-server leest deze waarden voor de ingebouwde agents. Compose geeft ze door aan de Bot-harnas die u hebt gekozen.

openssl rand -base64 32

Bekijk de computerinstellingen terwijl .env is geopend. .env.example laat COMPUTER_SUPERVISOR_URL en SUPERVISOR_TOKEN leeg en verwijst AGENT_COMPUTER_URL naar de ene gedeelde computer op poort 4100. Het compose-bestand bevat de supervisor. scripts/start.sh schakelt standaard computers per bot in door COMPUTER_SUPERVISOR_URL en SUPERVISOR_TOKEN aan de server door te geven. Als u de server zelf start, stelt u beide waarden in. Zonder supervisor-URL delen alle bots dezelfde browser en dezelfde aanmeldingen.

Start daarna de services.

bash scripts/start.sh

scripts/start.sh start de Docker-services, voert de databasemigraties uit, start de server, de periodieke worker en de app, en controleert hun status. Na voltooiing reageert de app op poort 3010 en de API op poort 3001. Het script meldt poortconflicten en laat een al actieve overeenkomende service ongemoeid. U kunt het daarom veilig twee keer uitvoeren.

Controleer dit eerst vanaf de server zelf voordat u iets extern beschikbaar maakt.

curl -sS -o /dev/null -w '%{http_code}\n' http://127.0.0.1:3010
ss -ltnp | grep -E ':(3010|3001|4100|4500|5432)'

Een 200 bij de eerste opdracht betekent dat de app verzoeken verwerkt. De tweede opdracht toont aan welke adressen deze poorten zijn gebonden. Op een VPS is dat de relevante informatie. Een regel met 127.0.0.1:3001 is alleen vanaf de server bereikbaar. Een regel met 0.0.0.0:3001 betekent dat iedereen die netwerkverkeer naar de server kan routeren, de service kan bereiken.

De container-image voor alles-in-één

De documentatie voor implementatie levert ook een enkele image die de applicatie, de API en Chromium bevat, beschikbaar op poort 3001. Deze wordt gepubliceerd als ghcr.io/copilotkit/openbot met versietags, of u kunt deze zelf bouwen vanuit uw 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 openbot

EMBEDDED_POSTGRES=on draait PostgreSQL binnen de container en voert migraties uit bij het opstarten. Het named volume behoudt de audit-geschiedenis na een herimplementatie; zonder dit volume gaat die geschiedenis bij elke herbouw verloren. Mount dit op de bovenliggende map, /var/lib/postgresql, en niet op de datamap zelf. De documentatie waarschuwt dat het mounten van de datamap ertoe kan leiden dat het cluster niet wordt geïnitialiseerd, waarna de applicatie reageert met een 502-foutmelding. Als u DATABASE_URL in plaats daarvan naar een beheerde database laat verwijzen, moet de vector-extensie daarop zijn ingeschakeld. Beheerde diensten zoals RDS, Cloud SQL en Azure Database ondersteunen deze extensie, maar geen van deze diensten schakelt deze automatisch voor u in. De migraties verwachten bovendien dat de rol die ze uitvoert de eigenaar is van de extensie; als de extensie onder een andere rol is aangemaakt, stoppen ze met must be owner of extension vector.

Voer migraties uit als een release-stap wanneer de database extern is.

docker run --rm --env-file .env --entrypoint sh openbot \
  -c "cd /app/server && bun scripts/migrate.ts"

Gebruik scripts/migrate.ts en niet drizzle-kit migrate, omdat de drizzle-kit CLI een ontwikkelingsafhankelijkheid is die niet in de productie-image aanwezig is. Behoud --entrypoint sh, omdat de API anders start voordat de migraties zijn uitgevoerd.

Die image laat de browserpoort bewust ongepubliceerd. Ook de supervisor ontbreekt, omdat de supervisor toegang nodig heeft tot de Docker-socket, wat serverless-platformen niet bieden. Zonder de supervisor deelt elke bot één browser en dus één set inloggegevens, wat de isolatie tenietdoet die het draaien van containers per bot juist waardevol maakte. Dit alles-in-één-pad is de optie waarbij een bot nooit een eigen container krijgt. Als u hier bent voor aparte inloggegevens per bot, draai dan de compose-stack met COMPUTER_SUPERVISOR_URL en SUPERVISOR_TOKEN ingesteld, op een host waar u de afweging accepteert. Een proces dat kan communiceren met de Docker-socket kan een geprivilegieerde container starten, waardoor het in de praktijk root-toegang heeft op de host. Dat is een goede reden om OpenBot op een eigen machine te draaien, in dezelfde geest als het geven van een wegwerp-VM aan programmeer-agents.

Waarom OPENBOT_SINGLE_USER een laptop-instelling is

.env.example wordt geleverd met OPENBOT_SINGLE_USER=true. Die instelling accepteert elk verzoek als één vaste beheerder en slaat het inloggen volledig over. Op een laptop is dit handig, omdat de enige client die de poort kan bereiken u bent. Op een VPS betekent dit dat iedereen die poort 3010 bereikt die beheerder is, op een systeem dat versleutelde inloggegevens opslaat en een browser aanstuurt die al is ingelogd op uw accounts.

De server bewaakt nu een deel hiervan. Als OPENBOT_SINGLE_USER=true is ingesteld en een OPENBOT_PUBLIC_URL, OPENBOT_APP_URL of TRUSTED_ORIGINS-item publiekelijk wordt gerouteerd, weigert de server te starten en benoemt het adres. Een privaat adres start met een waarschuwing. Die controle leest de URL's in uw configuratie, niet de interfaces waarop Docker publiceert, dus de standaard localhost-waarden passeren deze controle, zelfs wanneer een poort openstaat naar het internet. Het binden van poorten blijft uw verantwoordelijkheid.

Er zijn twee correcte manieren om dit te draaien. Behoud OPENBOT_SINGLE_USER=true, bind elke poort aan 127.0.0.1 en bereik de app alleen via een SSH-tunnel of een private netwerkinterface.

ssh -N -L 3010:127.0.0.1:3010 -L 3001:127.0.0.1:3001 you@your-vps

De app bevindt zich dan op http://localhost:3010 in uw eigen browser, wat telt als een veilige context, waardoor de browser de Secure-inlogcookies behoudt. Het live-scherm zelf heeft geen veilige context nodig: de implementatiedocumentatie stelt dat de app niet afhankelijk is van browser-API's die door standaard http:// worden geblokkeerd. De andere manier is om de single-user-modus uit te schakelen en een echte identiteitsprovider te configureren. Google, Microsoft Entra, Okta, SAML en OIDC worden ondersteund. Google, Entra en Okta worden ingesteld in de omgeving, terwijl SAML- en OIDC-providers worden geregistreerd onder Admin, Identity providers, zodra de implementatie draait. Elke provider heeft ook BETTER_AUTH_SECRET nodig van 32 tekens of meer, BETTER_AUTH_URL ingesteld op de publieke API-basis-URL voor OAuth-callbacks, en INITIAL_ADMIN_EMAILS. TRUSTED_ORIGINS staat niet op die lijst met vereisten, maar het bevat de app-origins die de API accepteert, plus elke host in het discovery-document van een geregistreerde OIDC-provider, en OPENBOT_APP_URL gebruikt standaard het eerste item, dus stel dit in op uw publieke app-origin. Provider-inloggegevens moeten volledig zijn, omdat een half geconfigureerde provider de opstart stopt in plaats van terug te vallen op open toegang. Als de reden dat u accounts toevoegt is dat elk teamlid een eigen agent wil in plaats van een eigen browser, dan is OneCLI vanaf het begin rond die vorm gebouwd, met één gesandboxte agent per persoon en de modelsleutels opgeslagen in één gateway.

Als de app bereikbaar is op een publieke naam, plaats dan TLS (transport layer security) ervoor. Een pagina die wordt geserveerd via standaard http:// op iets anders dan localhost is geen veilige context, waardoor cookies gemarkeerd als Secure niet worden opgeslagen en het inloggen mislukt op een manier die lijkt op een bug in OpenBot.

Beveilig de poorten op laag niveau

De eigen beveiligingsnotitie van OpenBot stelt dat de service-endpoints op laag niveau worden beschermd door tokens, dat u deze privé moet houden en dat u ze niet moet gebruiken om de gateway te omzeilen. Tokens vormen de tweede beschermingslaag. De eerste is dat de poort in het geheel niet bereikbaar is.

De agent-computer luistert op 4100 en vereist COMPUTER_TOKEN. De bot-endpoints luisteren op 4200 en 4201, en de agent harness luistert op 4202. De supervisor luistert op 4500 op de host en op 4300 binnen de container, en het compose-bestand bindt deze aan 127.0.0.1:4500. PostgreSQL luistert op 5432. Geen van deze hoort op een publieke interface thuis, en bij een implementatie voor één gebruiker geldt dit ook voor de app en de API.

sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow 22/tcp
sudo ufw enable
sudo ufw status verbose

Er is hier een valkuil waar mensen in trappen die aannemen dat de firewall voldoende is. Het publiceren van een containerpoort met -p 3001:3001 zorgt ervoor dat Docker een DNAT-regel installeert, waardoor verkeer in het FORWARD-pad wordt afgehandeld en nooit de INPUT-chain passeert die door de standaard deny-regel van ufw wordt beheerd. De poort blijft open terwijl ufw status nog steeds Status: active weergeeft. Bind de gepubliceerde poort aan de loopback in de mapping zelf, zoals -p 127.0.0.1:3001:3001, of stel het hostadres in uw compose-bestand in. Controleer dit met ss -ltnp, niet met ufw status. Niets aan deze valkuil is specifiek voor OpenBot, dus voer dezelfde controle uit voor elke andere container die u op de machine heeft gepubliceerd, inclusief alles wat dient als een Jellyfin-bibliotheek herbouwd als een videotheek uit de jaren 90.

OpenBot kan offline draaien met zelfgehoste Intelligence

Stel dit vast voordat u de implementatie plant. OpenBot is afhankelijk van een CopilotKit Intelligence-project. Dat project bevat persistente threads en gespreksgeheugen op de gehoste service of op uw eigen infrastructuur. De vastgezette v0.2.0-server valideert INTELLIGENCE_API_URL, INTELLIGENCE_GATEWAY_WS_URL en INTELLIGENCE_API_KEY bij het opstarten. De server controleert deze drie waarden als één geheel en start niet als er een ontbreekt. COPILOTKIT_LICENSE_TOKEN is optioneel. Alleen zelfgehoste Intelligence met een eigen licentie gebruikt deze waarde. Op 3 november 2026 bevat de gratis gehoste Intelligence 1,000 interacties per organisatie per maand. Sinds v0.1.0 toont OpenBot echter een banner over zelfhosting, tenzij de implementatie een betaald Intelligence-abonnement heeft of OPENBOT_SELF_HOST_BANNER=false instelt. Intelligence kan zelf worden gehost. Een volledig lokale implementatie is daarom mogelijk, maar vereist meer werk dan de quickstart beschrijft. Voor een offline productie-implementatie is Annual vereist. Self-hosted pay as you go moet verbinding maken om gebruik voor facturering te rapporteren. De gratis Developer Edition ondersteunt lokale evaluatie buiten productie met een verlengbare licentie van 30 dagen. Voor de installatie en verlenging is internettoegang vereist. De lokale Intelligence CLI schrijft de sleutel naar CPK_INTELLIGENCE_API_KEY. De vastgezette v0.2.0-release leest echter alleen INTELLIGENCE_API_KEY. Kopieer de waarde daarom voor deze release naar die locatie. De huidige main accepteert de CLI-sleutel rechtstreeks en geeft daaraan voorrang.

Het model is de tweede afhankelijkheid. Er wordt geen model meegeleverd. BOT_PROVIDER accepteert openai, anthropic of google voor de LangGraph Bot. OPENAI_BASE_URL verwijst het OpenAI-pad naar elk compatibel endpoint. Daarvoor is bijvoorbeeld Ollama op een VPS draaien om een LLM zelf te hosten geschikt als u de tokens op uw eigen hardware wilt houden. Browserbesturing stelt hoge eisen aan een model. Test daarom een lokaal model met een echte taak voordat u zich eraan committeert.

Schalen voorbij één replica

De gateway lost elementverwijzingen op aan de hand van een paginasnapshot. Die snapshot bevindt zich nu in PostgreSQL, waardoor een tweede replica kan werken met een snapshot die door de eerste is gemaakt. De officiële Helm chart draait standaard twee API-replica's en slaat alles wat een replica nodig heeft om te overleven op in PostgreSQL. Ook wordt de ingebouwde computer uitgeschakeld en is het niet toegestaan om er een te installeren naast meer dan één replica. Een browser binnen de API-pod zou de inloggegevens van één bot bevatten, en het schalen van de API zou deze vermenigvuldigen. De enkele image is het punt om in de gaten te houden, omdat elke replica zijn eigen browser draait; de inloggegevens van een bot blijven dus op het exemplaar dat ze heeft verwerkt. Op één VPS draait de browser van elke bot nog steeds op dezelfde host, dus u schaalt door de server krachtiger te maken. Isolatie tussen bots wordt nog steeds gewaarborgd door de containers per bot, op dezelfde manier waarop self-hosted agent sandboxes de fouten van de ene agent gescheiden houden van de andere.

Foutmodi en wat u zult zien

De opstartprocedure stopt onmiddellijk nadat u .env heeft ingevuld. De server valideert de configuratie voordat deze services aanbiedt. Elk van de volgende punten blokkeert het opstarten in plaats van dat de server in een beperkte modus verdergaat: een onvolledig Intelligence-blok, een ontbrekende KEY_ENCRYPTION_KEY, een OAuth-provider met een client ID maar zonder secret, of de single-user modus in combinatie met een publieke URL. Lees de eerste foutmelding, corrigeer dat specifieke veld en start opnieuw.

Migraties mislukken op een beheerde database. Er zijn twee waarschijnlijke oorzaken. De vector-extensie is mogelijk niet ingeschakeld en de migrerende rol heeft onvoldoende rechten om deze aan te maken, waardoor de migratie vastloopt op een kolomtype dat PostgreSQL niet herkent. Of de extensie is aangemaakt onder een andere rol, waardoor de migratie stopt met must be owner of extension vector. Maak de extensie aan met de rol die de migraties uitvoert en voer de migratiestap daarna opnieuw uit.

De applicatie laadt, maar het inloggen blijft niet behouden. U gebruikt een onbeveiligde http://-verbinding op een publiek adres. Dit wordt niet beschouwd als een veilige context, waardoor het Secure-cookie wordt geweigerd. Plaats TLS voor de applicatie of gebruik een SSH-tunnel zodat de browser localhost ziet.

Bots delen inloggegevens die gescheiden hadden moeten zijn. De supervisor is niet in gebruik, waardoor er geen per-bot computeromgeving is en elke bot de gedeelde browser op AGENT_COMPUTER_URL gebruikt. Controleer of COMPUTER_SUPERVISOR_URL is ingesteld en of de supervisor de Docker-socket kan bereiken.

Een bot stopt en vraagt om hulp. Dit is het verwachte gedrag. Het audit-logboek registreert computer.help_requested, u neemt de controle over via het live-scherm en de overdracht wordt aan beide kanten vastgelegd.

FAQ

Is het veilig om OPENBOT_SINGLE_USER ingeschakeld te laten voor een VPS-implementatie?

Alleen wanneer de gateway niet vanaf internet bereikbaar is. OPENBOT_SINGLE_USER=true accepteert elk verzoek als één vaste beheerder zonder aanmelding. Iedereen die de poort kan openen, heeft daarmee toegang tot de implementatie, de opgeslagen referenties en de browser waarin u bent aangemeld. In deze modus weigert de server te starten wanneer een geconfigureerde openbare URL of vertrouwde origin openbaar wordt gerouteerd. Die controle kan echter niet zien hoe u uw poorten publiceert. Dit is acceptabel wanneer elke poort aan 127.0.0.1 is gebonden en u de app via een SSH-tunnel of een privé-netwerkinterface benadert. Schakel dit uit op een openbare interface. Configureer Google, Microsoft Entra, Okta of OIDC samen met BETTER_AUTH_SECRET, BETTER_AUTH_URL en INITIAL_ADMIN_EMAILS. Stel TRUSTED_ORIGINS in op de origin van uw openbare app.

Hoeveel RAM heeft één OpenBot-bot nodig?

De gepubliceerde cijfers van het project voor één Bot op arm64 vermelden een piekgeheugenverbruik van 0.55 GB. Het gedocumenteerde minimum is 2 GB. De aanbevolen hoeveelheid is 4 GB. Er is geen gepubliceerd cijfer voor meerdere bots tegelijk, omdat elke bot een eigen Chromium-proces gebruikt. Voer één bot een echte taak uit. Lees het geheugenverbruik van die container af in docker stats. Tel de gateway en de database erbij op. Vermenigvuldig dit vervolgens met het aantal bots dat u naar verwachting gelijktijdig gebruikt.

Heb ik een CopilotKit-account nodig om OpenBot zelf te hosten?

Ja. OpenBot is afhankelijk van een CopilotKit Intelligence-project voor permanente threads en geheugen. De vastgezette v0.2.0-server weigert te starten tenzij de Intelligence API-URL, de WebSocket-URL van de gateway en de API-sleutel allemaal zijn ingesteld. Vanaf 3 november 2026 is een gratis gehost abonnement beschikbaar. Een offline productie-implementatie wordt ondersteund met zelfgehoste Intelligence op Annual en een lokaal model. U moet daarnaast zelf toegang tot een model regelen. Gebruik daarvoor een model-API-sleutel of een aanmelding bij een ondersteunde provider. OpenBot bevat namelijk geen model.

Waarom krijgt elke bot een eigen browser in plaats van één browser te delen?

Omdat een browserprofiel een identiteit is. Een gedeelde browser betekent gedeelde cookies en gedeelde sessies. Een bot die bij een account is aangemeld, betekent dan dat elke bot bij dat account is aangemeld. Containers per bot geven elke medewerker een eigen profiel en eigen aanmeldingen. Dit werkt alleen wanneer COMPUTER_SUPERVISOR_URL de server naar de supervisor laat verwijzen. Zonder deze instelling delen alle bots één browser. Het nadeel is het geheugenverbruik, omdat één Chromium per bot de grootste afzonderlijke component van de capaciteitsberekening is.

Welke OpenBot-poorten moeten op de firewall worden opengesteld?

Geen van de onderliggende poorten. De agent-computer op 4100, de bot-eindpunten op 4200 en 4201, de agent-harnas op 4202, de supervisor op 4500 en PostgreSQL op 5432 blijven allemaal privé. Het project beveiligt deze endpoints met tokens en vraagt u ze desondanks onbereikbaar te houden. Publiceer alleen wat een gebruiker moet kunnen openen. Houd er rekening mee dat een containerpoort die met -p 3001:3001 is gepubliceerd, bereikbaar is ongeacht een ufw-regel met standaardbeleid deny. De DNAT-regel van Docker plaatst dat verkeer namelijk in het FORWARD-pad in plaats van in INPUT.

Was dit artikel nuttig?