# Open WebUI Computer serves your whole machine to any browser

> cptr is a Python and SvelteKit application that exposes your files, shell, git state, browser and AI agents to any browser on your network, and it keeps running sessions alive between devices. It suits a developer who wants one workstation reachable from a phone, and it is a full remote shell by design, which deserves careful thought before it is exposed.

**open-webui/computer** — Your Computer. Anywhere.

- Repository: https://github.com/open-webui/computer
- Website: https://openwebui.com/computer
- Stars: 704 · Forks: 99
- Language: Python
- License: NOASSERTION
- Published: 2026-10-21 · Updated: 2026-10-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/open-webui-computer

## One Python process serves the whole workstation surface

The project's own summary is blunt: Open WebUI Computer, invoked as cptr, runs on your machine and serves your whole computer to any browser, covering files, terminal, editor, git, browser tabs, running sessions, AI agents and tools. The description then says it literally is your computer, and the homepage carries the tagline Your Computer. Anywhere. The architecture follows from that. The Python package cptr is a FastAPI application with a SvelteKit frontend bundled inside it, and the pyproject metadata shows the shape: fastapi[standard] for the server, click for the command line, watchdog for file system watching, sqlalchemy with the asyncio extra and aiosqlite for storage, alembic for schema migrations, and python-socketio[asgi] for the streaming the interface needs. The console entry point is registered as cptr = cptr.cli:main, and the frontend is excluded from the wheel build and force-included from a prebuilt directory, so the Python package carries the compiled frontend as an artefact.

## The install is a pip install, and the interface opens on port 8000

Installation is two commands:

```bash
pip install cptr
cptr run
```

After that the interface opens in your browser at http://localhost:8000. Optional features are grouped as extras rather than bundled. MCP tool servers need the optional MCP dependencies, installed with pip install 'cptr[mcp]', and pip install 'cptr[all]' pulls in every optional feature group. The Docker image includes all optional feature groups, which is the shortest route if you want the whole surface on a server. If you prefer uv, the README gives uvx cptr@latest run. There is a Windows specific note as well: if opening a terminal reports a missing VCRUNTIME140.dll or Universal CRT DLL, you install Microsoft's Visual C++ Redistributable and restart cptr. The base install requires Python 3.10 or newer, and the project ships a uv.lock so the dependency set is pinned for reproducible installs.

## Getting a phone to reach it means binding an interface or opening a tunnel

The default only serves localhost, which is the right default and also the reason the next paragraph exists. On the same Wi-Fi, you bind to all interfaces with a host flag:

```bash
cptr run --host 0.0.0.0
```

Then you open http://your-computer-ip:8000 on the phone. Off the local network, the README lists three tunnel options and marks Tailscale as recommended because it creates a private mesh network between your devices. Cloudflare Tunnel gives a permanent URL through Cloudflare's edge, and ngrok gives a public URL in one command. The practical detail is that most tunnels forward to localhost, so the default cptr run works, but if your tunnel connects to a specific interface you bind accordingly with the same host flag. There is also a third route the project mentions, skipping networking entirely by connecting a messaging bot instead, which is the option to consider if exposing port 8000 in any form is not acceptable on your network.

## Sessions survive the tab, so the terminal keeps running

The feature table makes one promise that separates this from a remote shell emulator, and it is worth testing first if you adopt it. Terminal keeps running when you close the tab, and you come back on any device. In practice that means a long build, a running dev server or an agent working in the background is not killed because you picked up your phone. The rest of the surface is a working environment rather than a viewer. There is a real file browser where you can navigate, create, rename, upload and drag and drop, with icons by type and sizes at a glance. The editor is syntax highlighted with tabs, and you can open several files side by side. Git is exposed as a visual interface for staging, committing, diffing, branching and pushing, with a changes view and no command line required. The terminal is a full shell in the browser, so your own tools and scripts run as usual. Browser tabs can be a Proxy, a private managed Chrome profile or your own personal Chrome session, workspaces let you keep several projects in one instance, and search covers file names and contents, with a jump straight to a matching line.

## The agent layer is pluggable across model providers and coding agents

The AI half is designed so you bring your own access rather than buying a subscription to the tool. You can supply an API key for OpenAI, Anthropic, Ollama or any OpenAI-compatible endpoint, or connect a coding agent you already subscribe to, and the agent 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. The feature list is detailed about the controls that matter for trust. There is a plan mode where you request an implementation plan before the AI writes a single line, and output editing so you can review and edit AI generated changes before applying them. File tools read, write, edit and search your codebase, command execution runs in the foreground or the background, web browsing navigates pages and clicks elements, and there are scheduled recurring tasks, reusable instruction sets called skills that you mention with a dollar sign, and file mentions with an at sign. Long conversations are automatically summarised to stay fast, which the table calls context compaction. Voice mode, text to speech and reasoning views for models that expose a chain of thought are also listed.

## Coding agent subscriptions appear as model providers

The approach to coding agents is the most interesting idea in the project and it deserves a close reading. The stated premise is to use the subscriptions you already pay for as native backends on your own machine, with no separate API key needed. The list of supported agents is Codex, Claude Code, Cursor, Grok, OpenCode, Cline, Gemini and Pi. The mechanism is that you add an agent profile from Settings, pick your models, and the agent 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. If you would rather run an agent yourself, any terminal agent, Kilo Code and Pi among others, works in the terminal tab the way it always has. So the project is not trying to replace your agent tooling, it is trying to make several of them reachable from one place, and it is explicit that a plain terminal agent remains a first class option.

## The container image builds a frontend, a wheel and a non-root runtime

The Dockerfile in the repository shows the build in three stages, which tells you what a deployment involves. The first stage builds the SvelteKit frontend from a node:22-slim base using npm ci and npm run build. The second stage uses the uv image on python3.12-bookworm-slim to build the wheel with uv build, and it copies the freshly built frontend into the package tree so the wheel carries the compiled assets. The third stage is the runtime, again on uv's python3.12-bookworm-slim, with git, gh and tini installed, a non-root user named cptr created, a /data directory owned by that user, and the wheel installed into an isolated venv with the all extra so every optional feature group is present. The image exposes port 8000, declares /data as a volume, sets CPTR_DATA_DIR to that path, and uses tini as the entrypoint with cptr run as the command. In the repository the frontend and backend are formatted separately, with ruff for the Python side and the frontend's own scripts for the SvelteKit side.

## Where this tool is the wrong choice

Three situations argue against it. The first is a machine where the contents of your home directory are not all things you want in a browser. The feature list is explicit that this is a file manager, an editor, a shell and a browser, and a shell in a browser is a shell with the full privileges of the account that started the process. The default binding to localhost limits that exposure, and the tunnel options are there to widen it deliberately, but the decision about who can reach port 8000 is the security decision of this project, and it belongs to you. Authentication is a second concern, and the pyproject dependencies show bcrypt and PyJWT in the base install and a python-pam extra for system authentication, so the mechanism exists, but the README does not describe the default authentication posture in the section available here, which means you should confirm it before exposing anything. The third is a team that wants a managed, multi-user environment. This is a single-user workstation on your own machine, and the messaging bot option is for reaching one instance from a chat app, not for giving a group of people scoped accounts. A reasonable alternative for the simple case is SSH with a key, which is smaller and has a well understood security model, and cptr earns its place when you want the files, the git UI, the browser tabs and the agent sessions in one place on a phone.

## Conclusion

Adopt Open WebUI Computer when you want your own machine to be the workstation you open from any device, and that includes a phone over a private tunnel, and keep a plain SSH session if all you need is a shell. Verify first how your tunnel exposes port 8000 and whether you have enabled authentication on it, because the tool serves a full shell and file manager, and confirm the Python version and optional dependency groups your use needs, since MCP tools, PAM authentication and document parsing are all separate extras rather than part of the base install.

## FAQ

### How do I install Open WebUI Computer?

Install the cptr package with pip install cptr and start it with cptr run, which opens the interface in your browser at http://localhost:8000. You can also use uvx cptr@latest run, or the Docker image, which includes all optional feature groups.

### How do I reach cptr from my phone?

On the same Wi-Fi, run cptr run --host 0.0.0.0 and open http://your-computer-ip:8000 on the phone. From elsewhere, the README lists Tailscale, which it recommends, plus Cloudflare Tunnel and ngrok, most of which forward to localhost so the default run works.

### Which AI backends does cptr support?

You can bring your own API key for OpenAI, Anthropic, Ollama or any OpenAI-compatible endpoint, and you can connect coding agents you already subscribe to. Supported agents listed are Codex, Claude Code, Cursor, Grok, OpenCode, Cline, Gemini and Pi, added as a profile from Settings and selected like any other provider.

### Do terminal sessions survive closing the browser tab?

Yes. The documentation states that the terminal keeps running when you close the tab and that you can come back on any device, and that browsers, terminals, files, chats and tools open in separate tabs that can be rearranged or split.

### What are the optional dependency groups in cptr?

The pyproject metadata defines pam for python-pam, mcp for the MCP client, docs for pypdf, python-docx and openpyxl, and agents for claude-agent-sdk. The mcp group is needed for MCP tool servers, and an all group includes every optional feature group.

## Sources

- [Issues](https://github.com/open-webui/computer/issues)
- [open-webui/computer on GitHub](https://github.com/open-webui/computer)
- [Project website](https://openwebui.com/computer)
- [README](https://github.com/open-webui/computer/blob/main/README.md)
- [Releases](https://github.com/open-webui/computer/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/open-webui-computer