OpenBot: Turn AG-UI agents into auditable browser coworkers
It puts AG-UI agents in company-owned browser and file environments, with every action gated by CEL and audited.
GitHub CopilotKit/OpenBot Updated 2026-10-30 Branch main Stars 8.2K Forks 1.0K
TypeScript Rust Python AG-UI Browser automation CEL policy Docker Self-hosting

🧭 Decision Guide

Try it if you

  • You already have an AG-UI endpoint and want it to receive an isolated browser, folder, and tool permissions.
    The README sections “Bring your own agent” and “A computer per person” state that any AG-UI endpoint can become a Bot with a browser profile and folder.
  • You need CEL to reject risky actions before Shell, browser, and MCP operations run.
    The README section “CEL policy, fail closed” says policies can inspect command, page.url, and mcp.*, with deny evaluated before allow.
  • You need to watch a Bot's screen and take over manually at a login wall or 2FA prompt.
    The README sections “Watch what it is doing” and “Take the wheel” describe screen viewing, Activity, and recording computer.control_taken.
  • You want to run a modifiable AI coworker template on your own machine or infrastructure.
    The README says it runs on your machine, has no hosted version, and is a template rather than a product.

Skip it if you

  • You need a hosted SaaS that works after signup and do not want to maintain the OpenBot repository or deployment.
    The README explicitly says “There is no hosted version to sign up for” and requires cloning the repository and replacing examples/.
  • You want to consume OpenBot as a stable published npm package.
    The README explicitly says “nothing here is published as a package to depend on”.
  • You cannot accept Beta-stage bugs and rough edges.
    The Beta statement says the project is early, expects rough edges and bugs, and expects things to move.
  • Your deployment cannot allow the supervisor to hold the Docker socket.
    The “Loopback by default” feature says the supervisor binds locally because it holds the Docker socket.

Requirements

  • The README Quick start first requires `cp .env.example .env` and `bun install`.
  • The README Quick start uses `npx --yes copilotkit@latest login` and `npx --yes copilotkit@latest project select` to connect a managed Intelligence project.
  • The Runs on your machine section says the instructions target a laptop; CopilotKit Intelligence can run locally in Docker on a Mac.
  • `.env.example` contains `OPENBOT_SINGLE_USER=true`; the README says Sign-in must be enabled before other users can reach the deployment.
  • The README Quick start says the CopilotKit key and model key must be filled in, while the startup script fills the other blank keys.

First step (verbatim from README)

cp .env.example .env

Watch out

  • The initial OPENBOT_SINGLE_USER=true setting makes every request use the same administrator identity.
    The README's Runs on your machine section explicitly says this setting admits every request as one administrator.
  • While a person has taken control, Bot actions are refused rather than queued.
    The “Take the wheel” feature explicitly says Bot actions are refused rather than queued while a person is driving.
  • A missing or broken CEL policy rejects actions instead of allowing them by default.
    The “CEL policy, fail closed” feature says a missing policy permits nothing and a broken rule refuses.
  • Routines require a worker process and have a 15-minute minimum interval and a cap of 20 enabled routines.
    The “Routines” feature states that a worker process is required, with a 15-minute floor and 20 enabled routines maximum.
  • Custom MCP servers must pass URL checks, and unknown tools are treated as writes.
    The “Governed MCP” feature says custom servers must pass URL checks and unknown tools are treated as writes.

Not stated in the README

  • The material does not specify supported browser versions, Docker versions, or minimum host hardware.
  • The material does not specify the AG-UI protocol version, event compatibility matrix, or complete supported agent-framework list.
  • The material provides no concurrency, Bot scaling, audit-storage, or production-performance data.
  • The material does not identify which models or model providers CopilotKit Intelligence supports or how they are priced.
  • The material gives no detailed gVisor host support matrix; it only says `COMPUTER_RUNTIME=runsc` works where the host supports it.
  • The material does not describe the threat model, isolation boundary, or hardening steps for Docker socket access.

💡 Deep Analysis

6
Yes I need a Bot to use the browser, Shell, and files, while my organization requires unknown tools to be denied by default, Shell commands to be restricted by policy, and every allow or denial to be auditable. Can OpenBot satisfy this constraint?
For: A security platform engineer who needs Bots to use browsers, Shell, and files while enforcing default-deny rules by command, page, and file context

Yes, because OpenBot centralizes execution, policy evaluation, and auditing at the gateway, with CEL policies that fail closed.

  • The README says the gateway resolves the server-held target snapshot, evaluates policy, writes an audit row, and only then calls the computer; there is no execution path without a prior record.
  • CEL can inspect tool.name, command, file.*, page URL, Bot, user, and initiator context. Deny is evaluated before allow, while missing or broken policies refuse execution.
  • Shell uses the same gate as other tools, and commands are recorded whether allowed or refused. The audit page lists permitted, refused, and failed actions with the triggering rule.

This is suitable for a governance layer, but it does not guarantee business-action reliability or host-level isolation by itself. The README does not state policy-scale limits, evaluation latency, or migration methods for existing enterprise rules.

  • Features: "CEL policy, fail closed"
  • Features: "The gateway is the only way in"
  • Features: "A shell, not just a browser"
  • Features: "An audit trail you can read"
Not stated in the README:The README does not specify CEL policy count, complexity, or evaluation-latency limits;The README does not specify audit-retention periods, export APIs, or external SIEM integrations
Yes I already have an AG-UI-compatible agent and do not want to rewrite its logic, but I need an isolated browser, file space, tool permissions, and audit records. Is OpenBot suitable as the integration layer?
For: A platform engineer who already has a hand-written or framework-based AG-UI agent and wants browser, file, and governance capabilities on company infrastructure

Yes, because OpenBot explicitly wraps an AG-UI agent as a Bot with its own computer environment instead of requiring you to replace the existing agent.

  • The README says “any AG-UI endpoint is a Bot,” whether the agent is framework-based or hand-written.
  • The gateway resolves the target, evaluates policy, and writes the audit record before calling browser, Shell, or file capabilities, keeping governance outside the agent implementation.
  • Agent endpoints use the same target checks as browser navigation, and authentication headers are stored write-only.

It is still a template rather than a hosted product, so you must configure the endpoint, model, and deployment environment yourself. The README does not specify the AG-UI version matrix, streaming failure behavior, or how existing tool semantics are mapped.

  • Features: "Bring your own agent: any AG-UI endpoint is a Bot"
  • Features: "The gateway is the only way in"
  • README introduction: "A template, not a product"
  • Project data: primary language TypeScript; topics include ag-ui and agent-governance
Not stated in the README:The README does not provide an AG-UI version compatibility matrix or framework-specific adapter limits;The README does not specify connection, timeout, or retry behavior for high-concurrency agent endpoints
Yes I want my Bot to use Google Drive, Notion, Parallel, Exa, Firecrawl, and Composio, while security rules require unknown tools and custom MCP server tools to be treated as writes. Can OpenBot provide this connector governance?
For: An enterprise integration engineer who needs to connect Google Drive, Notion, Parallel, Exa, Firecrawl, and Composio while treating unknown and custom-server tools as writes

Yes, because OpenBot does not simply expose MCP connectors to the model; it provides a catalogue, Bot authorization, and tool classification rules.

  • The README lists Google Drive, Notion, Parallel, Exa, Firecrawl, and hundreds of additional apps brokered by Composio.
  • The catalogue includes only vendors trusted by the deployment, so adding a vendor requires review; custom servers must pass URL checks.
  • Unknown tools and custom-server tools are treated as writes. Catalogue tools are classified as reads only when the server does not identify them as writes.
  • A Bot is told which connectors exist in the deployment and which it holds, so it should report missing authorization instead of browsing to the vendor site to bypass governance.

Connector governance does not automatically establish data compliance. The README does not specify each vendor’s OAuth scopes, rate limits, data residency, or retry behavior.

  • Features: "Governed MCP"
  • Features: "Google Drive, Notion and the public-web research providers Parallel, Exa and Firecrawl"
  • Features: "unknown tools and custom-server tools are treated as writes"
  • Features: "A Bot is told which connectors exist here and which it holds"
Not stated in the README:The README does not list the exact OAuth scopes or organization-admin approval flow for each connector;The README does not specify vendor data residency, rate limits, quotas, or error-retry policies;The README does not state whether Composio’s brokered app count is limited by plan or external service constraints
It depends I need each person to have an isolated browser and file space, with selected Bots running in their own containers. When the host supports gVisor, I also want to use `COMPUTER_RUNTIME=runsc`. Does OpenBot meet this deployment constraint?
For: An enterprise infrastructure engineer who needs browser, file, and container isolation per person and Bot, with gVisor support where available

It depends: OpenBot provides the requested isolation controls, but the outcome depends on host support for gVisor and on whether you add production operations beyond the template.

  • The “A computer per person” design assigns each person a container, folder, and browser profile for each Bot; selecting Isolated on a Bot gives it its own container.
  • The README explicitly provides COMPUTER_RUNTIME=runsc, but only where the host supports gVisor.
  • Shell inherits only PATH, locale, terminal, and proxy variables, rather than the rest of the deployment environment, reducing direct host-environment exposure.
  • It is an MIT-licensed cloneable template rather than a hosted product, and it is explicitly in beta. High availability, disaster recovery, centralized monitoring, and large-scale multi-tenancy are not established by the README.

It is therefore a useful isolation foundation, but not automatically a complete production isolation platform.

  • Features: "A computer per person"
  • Features: "Set `COMPUTER_RUNTIME=runsc` to run them under gVisor where the host supports it"
  • Features: "A shell, not just a browser"
  • README introduction: "A template, not a product" and "Beta, and under active development"
Not stated in the README:The README does not specify compatibility across host kernels, Docker versions, and gVisor configurations;The README does not specify container resource limits, concurrent Bot capacity, or multi-node scheduling;The README does not specify how high availability, disaster recovery, or centralized monitoring are implemented
It depends I need to deploy OpenBot internally, allow sign-in through Google, Microsoft, Okta, or our own SAML/OIDC provider, and let administrators revoke access through `/admin/people`. Is it suitable for this identity constraint?
For: An internal platform owner who needs Google, Microsoft, Okta, or company-managed SAML/OIDC sign-in with administrator-controlled access

It depends: the README covers several enterprise sign-in providers and access-management surfaces, but operators must disable single-user mode and configure identity themselves.

  • The default .env.example sets OPENBOT_SINGLE_USER=true, treating every request as one administrator. The README says sign-in must be enabled before anyone else can access the deployment.
  • It supports Google, Microsoft, Okta, and company-owned SAML or OpenID Connect providers registered at runtime and routed by email domain.
  • /admin/people lists signed-in users, changes roles, and removes access. Those changes are audited, and removing access ends the user’s current session.
  • Credentials are encrypted at rest through /admin/credentials, never returned by an API, and redacted from audit events.

This is a useful identity-governance starting point, not a complete IAM product. The README does not specify multi-tenant boundaries, SCIM, group synchronization, key rotation, or disaster-recovery behavior.

  • README introduction: "OPENBOT_SINGLE_USER=true" and "Sign-in ... is required before anybody else can reach the deployment"
  • Features: "Sign in with what your company already has"
  • Features: "Decide who gets in"
  • Features: "Credentials encrypted at rest"
Not stated in the README:The README does not specify SCIM, LDAP, group synchronization, or automated offboarding;The README does not define isolation boundaries for users, Bots, files, and audit data across tenants;The README does not describe OAuth/OIDC/SAML key rotation or recovery when an identity provider is unavailable
Yes I mainly use TypeScript and run Intelligence locally in Docker on a Mac. My browser flows often encounter login and 2FA, so a person must take control in the same interface and then return control to the Bot. Is OpenBot suitable?
For: A TypeScript application engineer running local Intelligence in Docker on a Mac who needs Bots to hand off login and 2FA steps to a person

Yes, especially for developers who need to validate browser agents locally and handle login walls or 2FA, although the project is still in beta.

  • The README says it runs on your machine, and CopilotKit’s Developer plan covers local Intelligence in Docker on a Mac.
  • When a Bot reaches a login wall or 2FA prompt, it requests help; the user can take over the browser in the same panel and return control afterward.
  • Human takeover is recorded as computer.help_requested, computer.control_taken, and computer.control_released. While a person is driving, Bot actions are refused rather than queued.
  • The project is primarily TypeScript, which fits engineers who need to modify the UI, Bots, and workspace template.

Browser flows still depend on site structure, network conditions, and login state. The README does not specify supported 2FA types, takeover timeouts, or Docker differences across Mac architectures.

  • README introduction: "Runs on your machine"
  • README introduction: "CopilotKit's free Developer plan covers running Intelligence locally in Docker on a Mac"
  • Features: "Take the wheel"
  • Project data: primary language TypeScript
Not stated in the README:The README does not specify which 2FA methods are supported or the timeout rules for takeover sessions;The README does not specify Docker performance differences between Apple Silicon and Intel Macs

✨ Highlights

  • Any AG-UI endpoint can become a Bot with a browser and files
  • CEL policies reject actions before execution, followed by audit recording
  • Browser, Shell, MCP, and file actions all pass through the gateway
  • Despite 8,150 stars, it remains a Beta template with rough edges

🔧 Engineering

  • Each user gets a container, folder, and browser profile, with optional gVisor
  • Shell commands inherit PATH and proxy variables and are recorded through the same gateway
  • CEL can inspect tool.name, page.url, command, and initiator.*
  • It supports 2FA handoff and records events such as computer.control_taken
  • Built-in MCP includes Google Drive, Notion, Parallel, Exa, and Firecrawl

⚠️ Risks

  • The README explicitly marks it Beta and expects rough edges and bugs
  • The project is a template, not a product, with no hosted version or dependency package
  • OPENBOT_SINGLE_USER=true admits every request as the same administrator
  • The supervisor holds the Docker socket, while its token is only a shared secret

👥 For who?

  • TypeScript teams wanting to connect their own AG-UI agents to browsers and Shell
  • Enterprise automation teams needing CEL, auditing, and human handoff
  • Developers able to run CopilotKit Intelligence in Docker on a Mac