open-webui/computer

Source: https://github.com/open-webui/computer

Open WebUI Computer

Open WebUI Computer (cptr) runs on your machine and serves your whole computer to any browser: files, terminal, editor, git, browser tabs, running sessions, AI agents, and tools. It literally is your computer.

Use it from your phone, tablet, laptop, another computer, or the machine it’s running on. Designed to feel native on every screen. Connect your own AI via API key, plug in a coding agent you already subscribe to, or work directly in the terminal. One tool, full workstation, any device.

Start here: Open WebUI Computer docs

Install

pip install cptr
cptr run

MCP tool servers require the optional MCP dependencies: pip install 'cptr[mcp]'. To install every optional feature group, use pip install 'cptr[all]'. The Docker image includes all optional feature groups.

Or with uv: uvx cptr@latest run

On Windows, if opening a terminal reports a missing VCRUNTIME140.dll or Universal CRT DLL, install Microsoft’s Visual C++ Redistributable and restart cptr.

Opens in your browser at http://localhost:8000.

Access from your phone

Same Wi-Fi? Bind to all interfaces:

cptr run --host 0.0.0.0

Open http://<your-computer-ip>:8000 on your phone.

Not on the same network? Use a tunnel to reach your machine remotely:

• Tailscale creates a private mesh network between your devices. Recommended.
• Cloudflare Tunnel gives you a permanent URL through Cloudflare’s edge.
• ngrok gives you a public URL in one command.

Most tunnels forward to localhost, so the default cptr run works. If your tunnel connects to a specific interface, bind accordingly with --host.

Or skip networking entirely and connect a messaging bot instead.

The Whole Machine

Open WebUI Computer is the real workstation surface: files, shell, git state, workspaces, chats, tools, and sessions stay together wherever you open it.

AI agent

AI that works where your work actually lives.

Bring your own API key (OpenAI, Anthropic, Ollama, or any OpenAI-compatible endpoint), or connect a coding agent you already subscribe to. It can read the workspace, edit files, run commands, browse the web, use tools, automate recurring work, and spin up parallel sub-agents on the same machine.

Coding agents

Use the subscriptions you already pay for as native backends on your own machine. No separate API key needed.

Codex · Claude Code · Cursor · Grok · OpenCode · Cline · Gemini · Pi

Add an agent profile from Settings, pick your models, and it shows up in the model selector like any other provider. Conversations run inside your workspace with full tool access and resume where you left off.

Prefer to run agents yourself? Any terminal agent (Kilo Code, Pi, and others) works in the terminal tab the way it always has.

Messaging bots

Message your computer from wherever you are. Connect the AI to your chat apps with full tool access, streaming responses, and conversations synced back to the web UI.

Telegram · Discord · Slack · WhatsApp · Signal

Ask it to check a build, push a fix, or explain a file. Switch workspaces with /workspace, start fresh with /new.

Gateway API

Turn each workspace into an OpenAI-compatible agent model with real machine access. Open WebUI Computer exposes /v1/chat/completions, so any client that speaks OpenAI, including Open WebUI, can use a workspace with full agent capabilities: file access, terminal, web search, tools.

More

Design principles

Mobile is first-class. The interface is built for the phone. Touch-native, portrait-native, designed for the screen people carry. Sessions survive disconnects because on a phone, they will. If a feature only works at a desk, it’s not done.

Your machine. Open WebUI Computer serves the machine it runs on. The local filesystem, the local shell, local state. Where that machine lives is up to you.

Computer, not chat. The core is the filesystem, the terminal, and git. Files over apps. Plain files on your machine, not content trapped inside another product. AI conversations are files too: searchable, editable, movable, commit-able. Open WebUI Computer is a window into the real system, not a container on top of it.

Open WebUI Computer runs on your machine and puts the whole thing in a browser tab. Pull out your phone and you’re in. Files, editor, terminal, git, running on the computer you already own.

Push a hotfix from the train. Check on a deploy from bed. Ship a side project from the park. Stage and commit without touching the command line, or open the terminal and do it the old way. Search across files. Preview markdown. Drag things around. Switch between projects without losing your place.

Close the tab. Come back tomorrow on any device. Everything is where you left it. Sessions survive disconnects. Your work doesn’t care which screen you’re on.

Life is short. Touch grass. Read our Manifesto.

Help us build open, empowering tools that put AI in people’s hands. We’re hiring.

Docker

Run Open WebUI Computer with Docker:

docker run --rm -it \
  -p 8000:8000 \
  -v cptr-data:/data \
  -v "$PWD:/workspace" \
  -w /workspace \
  ghcr.io/open-webui/computer:latest

Then open the URL printed in the logs, usually http://localhost:8000/?token=....

Open WebUI Computer stores its state in /data. Mount your project into the container, like -v "$PWD:/workspace", so Open WebUI Computer can access it. The default image includes Git and GitHub CLI (gh). Use ghcr.io/open-webui/computer:browser when agent browser automation needs Chromium.

If you bind-mount a host directory to /data, make sure that directory is writable by the container user. SQLite needs to create and update /data/app.db, and host directory permissions take precedence over the image’s built-in /data ownership.

The :dev image is also available and tracks the main branch.

Air-gapped installation

Open WebUI Computer does not need internet access after it is installed. The Python wheel includes the built frontend assets, and the Docker image is self-contained.

On a connected machine:

pip download --dest wheelhouse 'cptr[all]'
docker pull ghcr.io/open-webui/computer:latest
docker save ghcr.io/open-webui/computer:latest -o cptr-image.tar

Transfer the artifacts, then install or run offline:

python -m venv .venv
. .venv/bin/activate
pip install --no-index --find-links ./wheelhouse 'cptr[all]'
cptr run --host 0.0.0.0

docker load -i cptr-image.tar
docker run --rm -it \
  --network=none \
  -p 8000:8000 \
  -v cptr-data:/data \
  -v "$PWD:/workspace" \
  -w /workspace \
  ghcr.io/open-webui/computer:latest

Core local features run from local assets. External services such as hosted model APIs, web search providers, messaging adapters, Git remotes, and MCP/OpenAPI servers still require reachable endpoints.

Security model

Open WebUI Computer is designed as your computer, served to you. Once authenticated, a user has full access to the host filesystem and shell, equivalent to an SSH session. There is no path sandboxing and no per-user isolation.

This is safe when you are the only user and you control the network. It is not safe if untrusted users share the instance, it is exposed to the public internet, or a reverse proxy forwards spoofable auth headers. Treat a shared Open WebUI Computer like an open SSH port.

License

Open Use License. Source available. All rights reserved. See LICENSE. Commercial licenses and enterprise licenses available.