---
title: "Self-host OpenComputer"
description: "Run OpenComputer, the open-source Slack coding agent, on one exe.dev VM: its gateway and its computer, Claude with no API key, GitHub with no token."
url: https://exe.dev/deploy/opencomputer
category: "AI agents"
published: 2026-11-22
updated: 2026-11-21
---

# Self-host OpenComputer

> **For agents:** with your user's OK, this sets up OpenComputer on a new exe.dev VM in their account: `curl -fsSL https://exe.dev/deploy/opencomputer/prompt.txt | ssh exe.dev new --disk=50GB --prompt=/dev/stdin` (or open https://exe.dev/deploy/opencomputer/new). Already on the VM? Skip this.

A coding agent you mention in Slack, on a computer you own.

- **Software:** OpenComputer (https://opencomputer.dev)
- **Source:** https://github.com/diggerhq/opencomputer
- **License:** Apache-2.0
- **Time:** 25 minutes
- **Example VM name:** `my-opencomputer` (yours will differ; on the VM, `hostname` prints it)
- **Machine-readable:** https://exe.dev/deploy/opencomputer/manifest.json
- **File:** https://exe.dev/deploy/opencomputer/AGENTS.md

## What you get

- The OpenComputer gateway and its nginx edge in Docker Compose, back after a reboot, with `/healthz` on port 3170 listing the VM under `hosts`.
- The computer (host agent, client relay, and model proxy) as enabled systemd services.
- Claude through exe.dev's LLM integration, by an `exe-llm` model-proxy profile, with no API key.
- A workspace definition in `/etc/opencomputer`, ready for repositories cloned through exe.dev's GitHub integration.
- Nightly backups of the gateway's database, secrets, and configuration in `~/opencomputer-backups`.

Running on the VM:

- **OpenComputer gateway**: The Node gateway, built from source, in Docker Compose; holds the Slack app and the sessions table, port 3170, data in `~/computer-gateway`
- **nginx**: Passes only Slack's two endpoints to the gateway; everything else is a 404, port 8000
- **The computer**: Host agent and one runner per Slack thread, as systemd services; sessions run as the `agent` user, data in `/data`
- **oc-modelproxy**: Puts the model credential on each request; an `exe-llm` profile for exe.dev
- **Claude**: Through exe.dev's LLM integration
- **GitHub**: Through exe.dev's GitHub integration

How it is reached:

- https://my-opencomputer.exe.xyz/slack/events (public): Slack's events and buttons, and its OAuth redirect; nothing else
- https://my-opencomputer.exe.xyz:3170/setup (private): the gateway's setup page, behind your exe.dev login and a setup token

## Deploy with Shelley

Open https://exe.dev/deploy/opencomputer/new to create a VM whose agent, Shelley, follows this recipe. From a terminal:

```sh
curl -fsSL https://exe.dev/deploy/opencomputer/prompt.txt | ssh exe.dev new --disk=50GB --prompt=/dev/stdin
```

It needs a 50 GB disk. The terminal command makes the VM that size; after the button, Shelley checks and, if the disk is smaller, gives you a link to grow it.

Then, on your own computer:

```sh
ssh exe.dev share set-public my-opencomputer
```

Or follow the steps below by hand.

[OpenComputer](https://github.com/diggerhq/opencomputer) is an
open-source coding agent that lives in Slack. Mention it in a channel with
a task and a Claude Code session starts working in the thread, on its own
computer: you watch it run commands and edit files as it goes, steer it
mid-turn, approve tools with buttons, and get a pull request at the end.
Each thread gets its own `git worktree` of your repositories, so threads
never step on each other.

OpenComputer's hosted service runs that computer in its cloud, and its
self-hosting guide rebuilds the whole service on Cloudflare. This page
puts everything on one exe.dev VM instead: the project's self-hosted Node
gateway, which Slack calls, and the computer it drives, which is the VM
itself. exe.dev supplies the rest: an HTTPS address that Slack can reach,
Claude through the [LLM integration](/docs/integrations-llm) with no API
key, and your repositories through the
[GitHub integration](/docs/integrations-github) with no token on the
machine.

## Connect Slack

The gateway creates its Slack app for you from a manifest, so this takes a
few clicks. You need to be allowed to install apps in the Slack
workspace.

1. Make the Slack endpoint public, on your computer:

   ```bash
   ssh exe.dev share set-public my-opencomputer
   ```

   Only Slack's two paths reach the gateway on port 8000; the setup page
   and everything else stay private.

2. Get a Slack configuration token. At
   [api.slack.com/apps](https://api.slack.com/apps), under **Your App
   Configuration Tokens**, click **Generate Token**, pick the workspace,
   and copy the **refresh token** (`xoxe-1-…`).

3. Open the setup page: the link Shelley gave you, or the one from
   [Open the setup page](#open-the-setup-page). Under **1. Slack app**,
   paste the refresh token and click **Create the Slack app**, then
   **Connect URLs**. Slack checks the app's URLs right away, so this is
   where a VM that isn't public yet fails.

4. Click the install link, which goes to `/slack/install`, and allow the
   app in your workspace. The page then says the app is installed.

Ignore steps 2 to 5 on the setup page: the GitHub App, the Claude
credential, people, and host tokens are all configured on the VM instead.
The page asks for `GITHUB_ORG` only because it offers to create a GitHub
App.

The app is called **Computer**. Invite it to a channel (`/invite
@computer`) and mention it:

```
@computer what's in your workspace, and which model are you?
```

The thread shows the agent's timeline as it works, then its answer with
the model and the time it took. Type `!help` in a thread for its
commands: `!stop`, `!! <text>` to interrupt and redirect, `!mode` for
permission modes, `+smart` and `+fast` for other Claude models, and
`!status`.

## Give it your repositories

Sessions work in clones of the repositories you list in the VM's
workspace definition, fetched through exe.dev's GitHub integration. First
[connect GitHub](/docs/integrations-github) to exe.dev, then add an
integration for each repository and attach it to the VM. On your computer:

```bash
ssh exe.dev integrations add github --name my-app \
  --repository your-org/my-app --attach vm:my-opencomputer
```

By default pushes and pull requests show up as exe.dev's GitHub App; add
`--act-as-user` to make them yours, or `--readonly` for a repository the
agent should only read.

Then list the repository in `/etc/opencomputer/workspace.json` on the VM,
with its `github.int.exe.xyz` address:

```json
{
  "name": "exe",
  "repos": [
    { "name": "my-app", "remote": "https://github.int.exe.xyz/your-org/my-app.git" }
  ],
  "rootFiles": { "AGENTS.md": "AGENTS.md" }
}
```

and restart the host agent (running sessions keep going):

```bash
sudo systemctl restart slack-presence-host
sleep 10
sudo journalctl -u slack-presence-host --since -1min | grep workspaces
```

Expect `workspaces: cloned my-app into /data/people/…`. A repository can
also have `"branch"`, `"setup"` (commands run once after cloning, such
as `["npm ci"]`), and `"clone": "lazy"` to clone it only when a session
asks for it. The file next to it, `/etc/opencomputer/AGENTS.md`, is what
every session reads first: it tells the agent to push through the
integration and to run `gh` with `GH_HOST=github.int.exe.xyz`. Add your
team's conventions to it.

Now ask for real work:

```
@computer in my-app, add a --version flag and open a pull request
```

## Add your team

Only people in `SP_PEOPLE` get sessions. Each entry names their Slack
member ID, a directory for their workspace, and the name and email for
their commits. To add someone, edit `~/computer-gateway/.env` on the VM,
add an object to the JSON list on the `SP_PEOPLE` line, and restart the
gateway:

```
SP_PEOPLE=[{"slackUserId":"U01AAAA","dir":"u01aaaa","gitName":"Ada","gitEmail":"ada@example.com","admin":true},{"slackUserId":"U02BBBB","dir":"u02bbbb","gitName":"Linus","gitEmail":"linus@example.com"}]
```

```bash
cd ~/computer-gateway && docker compose up -d
```

`admin` lets a person manage workspace-wide secrets and who may drive
any session. Taking someone off the line doesn't remove them from the
gateway's database; also run
`sqlite3 ~/computer-gateway/data/gateway.db "DELETE FROM people WHERE slack_user_id = 'U02BBBB'"`
before the restart.

Whoever starts a thread owns it; `!access` in the thread sets who else
may drive it.

## Setup and upkeep

Deploy runs the installation on a new VM and asks for your Slack member ID
and your name and email for commits. To do it yourself:

<details id="create-the-vm" data-manual-setup class="dp-details">
<summary>Install by hand</summary>

On your computer (any free name works for the VM):

```bash
ssh exe.dev new --name=my-opencomputer --disk=50GB
ssh my-opencomputer.exe.xyz
```

The rest runs on the VM, as `exedev`.

### Room on the disk

The computer pulls a 4 GB session image and installs Node, Go,
Playwright, and Chromium; your repositories and sessions need room after
that.

```bash
df -h /
```

If **Size** is under 45G, grow the disk with
[this link](https://exe.dev/suggest?command=resize%20my-opencomputer%20--disk%3D50GB)
(with your VM's name), or on your computer with
`ssh exe.dev resize my-opencomputer --disk=50GB`. Then, on the VM:

```bash
sudo resize2fs "$(findmnt -no SOURCE /)"
df -h /
```

### Get the source

OpenComputer has no release of its Slack agent yet; this page pins the
commit it was tested with. Fetch just that commit:

```bash
OC_COMMIT=3680bf5fc53ece948df07c5124f27c140bd23f70
git init -q ~/opencomputer
git -C ~/opencomputer fetch -q --depth 1 https://github.com/diggerhq/opencomputer.git "$OC_COMMIT"
git -C ~/opencomputer checkout -q FETCH_HEAD
git -C ~/opencomputer log -1 --format='%h %cs'
```

Expect `3680bf5 2026-11-20`. The Slack agent is the `computer/`
directory.

### Build the gateway

Enable Docker at boot (exe.dev starts it on demand otherwise, which
wouldn't bring the gateway back after a reboot), then build the gateway's
image from the repository's Dockerfile:

```bash
sudo systemctl enable --now docker.service
cd ~/opencomputer/computer
docker build -q --build-arg SP_VERSION="$(git rev-parse --short=8 HEAD)" \
  -t opencomputer-gateway .
```

Expect a `sha256:` image ID after a minute or two.

### Configure the gateway

Fill in your Slack member ID (in Slack: your name, then ⋮ → Copy member
ID) and the name and email for your commits, then generate the gateway's
secrets into one file only you can read:

```bash
SLACK_USER_ID='<fill-this-in>'
GIT_NAME='<fill-this-in>'
GIT_EMAIL='<fill-this-in>'

mkdir -p ~/computer-gateway/data && cd ~/computer-gateway
SP_PEOPLE=$(python3 -c 'import json,sys; u,n,e=sys.argv[1:]; print(json.dumps([{"slackUserId":u,"dir":u.lower(),"gitName":n,"gitEmail":e,"admin":True}],separators=(",",":")))' "$SLACK_USER_ID" "$GIT_NAME" "$GIT_EMAIL")
(umask 077; cat > .env <<EOF
SP_ORIGIN=https://$(hostname).exe.xyz
SETUP_TOKEN=$(openssl rand -hex 24)
SP_STORE_KEY=$(openssl rand -hex 32)
SP_HOST_TOKENS=sph_$(openssl rand -hex 32)
MODEL_PROFILE=exe-llm
MODEL_TOKEN=exe-gateway
SP_PEOPLE=$SP_PEOPLE
EOF
)
ls -l .env
```

`SP_ORIGIN` is the address Slack calls. `SETUP_TOKEN` opens the setup
page. `SP_STORE_KEY` encrypts the Slack app's credentials in the
gateway's database, so a backup of the database is useless without it.
`SP_HOST_TOKENS` is the token the computer signs in to the gateway with.
`MODEL_PROFILE` sends every model request through the `exe-llm` profile
set up below; `MODEL_TOKEN` is a placeholder, since exe.dev's LLM gateway
needs no key.

The edge: nginx on port 8000, the port exe.dev's proxy can make public,
passes Slack's events (and its buttons, which arrive on the same path)
and its OAuth redirect to the gateway, and answers 404 to everything
else. The gateway itself listens on port 3170, which exe.dev keeps
private:

```bash
cd ~/computer-gateway
cat > nginx.conf <<'EOF'
server {
    listen 80;
    client_max_body_size 10m;

    # Slack: events and interactivity, and the OAuth redirect after install.
    location ~ ^/slack/(events|oauth_redirect)$ {
        proxy_pass http://gateway:8080;
        proxy_set_header Host $http_host;
        proxy_set_header X-Forwarded-Proto https;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }

    location / {
        return 404;
    }
}
EOF
cat > compose.yaml <<'EOF'
services:
  gateway:
    image: opencomputer-gateway
    restart: unless-stopped
    env_file: .env
    ports:
      - "3170:8080"
    volumes:
      - ./data:/data
  edge:
    image: nginx:stable-alpine
    restart: unless-stopped
    ports:
      - "8000:80"
    volumes:
      - ./nginx.conf:/etc/nginx/conf.d/default.conf:ro
    depends_on: [gateway]
EOF
docker compose up -d
sleep 5
curl -s localhost:3170/healthz; echo
curl -s -o /dev/null -w '%{http_code}\n' localhost:8000/
```

Expect `{"ok":true,"mode":"setup",…,"hosts":[]}` and `404`. The gateway
waits in setup mode until it has a Slack app.

### Prepare exeuntu for the computer

OpenComputer's `provision.sh` turns a plain Ubuntu 24.04 VM into a
computer. Three things about exe.dev's image need help first:

- It installs Claude Code with npm, which won't overwrite the `claude`
  binary exeuntu ships. The npm one replaces it, for you and for the
  agent.
- It loads an AppArmor profile for the sessions' container network, and
  exe.dev's kernel runs without AppArmor (and doesn't need the profile).
  A stand-in `apparmor_parser` skips that step only when AppArmor is off.
- It tells the model proxy which upstream to use through profile files:
  `exe-llm` is exe.dev's LLM gateway, set up as OpenComputer's README
  describes for any Anthropic-compatible gateway.

```bash
sudo rm -f /usr/local/bin/claude
sudo tee /usr/local/sbin/apparmor_parser > /dev/null <<'EOF'
#!/bin/sh
# exe.dev kernels run without AppArmor; OpenComputer only loads a profile for pasta.
[ -d /sys/kernel/security/apparmor ] && exec /usr/sbin/apparmor_parser "$@"
echo "apparmor_parser: AppArmor is off in this kernel, skipping: $*" >&2
EOF
sudo chmod 0755 /usr/local/sbin/apparmor_parser

sudo install -d -m 0755 /etc/oc-modelproxy/profiles.d
sudo tee /etc/oc-modelproxy/profiles.d/exe-llm.json > /dev/null <<'EOF'
{
  "exe-llm": {
    "upstream": "https://llm.int.exe.xyz/anthropic",
    "routes": {
      "POST /v1/messages": {},
      "POST /v1/messages/count_tokens": {}
    },
    "set": { "X-Api-Key": "{token}" },
    "remove": ["Cookie"],
    "report": ["retry-after", "request-id", "anthropic-ratelimit-*"],
    "harness": { "claude": { "tokenEnv": "ANTHROPIC_API_KEY" } }
  }
}
EOF
```

### Install the computer

A computer installs from a release bundle: a git bundle of `computer/`
with the model proxy built in, which is also how it updates. Build it
and put it where the boot scripts expect it:

```bash
cd ~/opencomputer/computer
deploy/bundle.sh /tmp/opencomputer.bundle
sudo install -d -m 0755 /opt/bootstrap
sudo install -m 0644 /tmp/opencomputer.bundle /opt/bootstrap/calvin.bundle
sudo rm -rf /opt/bootstrap/calvin-src
sudo git clone -q --branch main /opt/bootstrap/calvin.bundle /opt/bootstrap/calvin-src
```

The bundle script prints the release commit. Then provision, pointing
the computer at the gateway on this VM. It takes about five minutes:

```bash
HOST_TOKEN=$(sed -n 's/^SP_HOST_TOKENS=//p' ~/computer-gateway/.env)
sudo env CLOUD=none ALLOW_NO_DATA_VOLUME=1 SP_IMAGE_BRANCH=1 \
  REPO_URL=/opt/bootstrap/calvin.bundle REPO_REF=main \
  SP_GATEWAY_URL=ws://127.0.0.1:3170/host SP_HOST_TOKEN="$HOST_TOKEN" SP_HOST_ID="$(hostname)" \
  bash /opt/bootstrap/calvin-src/deploy/vm/provision.sh < /dev/null 2>&1 \
  | tee /tmp/opencomputer-provision.log | grep -E '^(==>|WARNING|ERROR)'
```

It ends with `==> done: release …, data on /data (root disk)`. The
settings: `CLOUD=none` skips Azure, AWS, and GCP specifics;
`ALLOW_NO_DATA_VOLUME=1` keeps `/data` on the VM's disk instead of a
second one, which is fine here because the VM's disk persists (the
`NOT replaceable` warning is about clouds where VMs are disposable);
`SP_IMAGE_BRANCH=1` uses the session image the project publishes for
this commit. The full log is in `/tmp/opencomputer-provision.log`.

The installer replaced exeuntu's Codex with its own copy (0.170.0). Point
the `codex` command at it again:

```bash
sudo ln -sfn /usr/local/lib/codex/bin/codex /usr/local/bin/codex
codex --version
```

### Let it reach exe.dev's integrations

OpenComputer blocks the agent and its services from
`169.254.169.254`, where clouds keep instance credentials. On exe.dev
that address is the VM's DNS resolver and the front door of every
[integration](/docs/integrations), so the block leaves sessions without
DNS and the model proxy without Claude. Allow DNS and HTTPS there, ahead
of the block, for the three users that need it (`agent` runs sessions,
`sp-host` the host agent, `modelproxy` the proxy); other ports stay
blocked:

```bash
sudo tee /etc/systemd/system/opencomputer-exe-integrations.service > /dev/null <<'EOF'
[Unit]
Description=Let OpenComputer reach exe.dev DNS and integrations on 169.254.169.254
After=slack-presence-imds-block.service sp-host-imds-block.service
Before=oc-modelproxy.socket slack-presence-host.service

[Service]
Type=oneshot
RemainAfterExit=yes
ExecStart=/bin/sh -c "for u in agent sp-host modelproxy; do for p in udp:53 tcp:53 tcp:443; do r=\"-d 169.254.169.254 -p $${p%%:*} --dport $${p#*:} -m owner --uid-owner $$u -j ACCEPT\"; iptables -C OUTPUT $$r 2>/dev/null || iptables -I OUTPUT $$r; done; done"

[Install]
WantedBy=multi-user.target
EOF
sudo systemctl daemon-reload
sudo systemctl enable --now opencomputer-exe-integrations.service
sudo -u agent getent hosts github.com
sudo -u modelproxy curl -s https://llm.int.exe.xyz/anthropic/v1/messages \
  -H 'content-type: application/json' -H 'anthropic-version: 2023-06-01' \
  -d '{"model":"claude-sonnet-5-5","max_tokens":16,"messages":[{"role":"user","content":"Say ok"}]}' | head -c 200; echo
```

Expect an address for github.com and a JSON message from
`claude-sonnet-5-5`. With integrations reachable, a session can use any
integration you attach to this VM, so attach only what the agent should
have.

### Set up the workspace

The workspace definition lists the repositories each person's sessions
work in, and the `AGENTS.md` every session starts from. Install an empty
one and the `AGENTS.md` from this page, and point the host agent at them
with a drop-in, which reinstalling OpenComputer leaves alone:

```bash
sudo install -d -m 0755 /etc/opencomputer
sudo curl -fsSL -o /etc/opencomputer/AGENTS.md https://exe.dev/deploy/opencomputer/AGENTS.md
sudo tee /etc/opencomputer/workspace.json > /dev/null <<'EOF'
{
  "name": "exe",
  "repos": [],
  "rootFiles": { "AGENTS.md": "AGENTS.md" }
}
EOF
sudo install -d -m 0755 /etc/systemd/system/slack-presence-host.service.d
sudo tee /etc/systemd/system/slack-presence-host.service.d/30-exe.conf > /dev/null <<'EOF'
[Service]
Environment=SP_DEFINITION=/etc/opencomputer/workspace.json
EOF
sudo systemctl daemon-reload
sudo systemctl restart slack-presence-host
sleep 10
systemctl is-active slack-presence-host slack-presence-wire oc-modelproxy-api.socket
curl -s localhost:3170/healthz; echo
```

Expect `active` three times and the VM's name in `"hosts"`. The
[AGENTS.md](https://exe.dev/deploy/opencomputer/AGENTS.md) replaces
OpenComputer's default, which describes its hosted service's GitHub App
and automations.

### Set up nightly backups

What you can't rebuild is the gateway: its database (the Slack app's
credentials, sessions, people) and the `.env` that holds the key to it.
Back those up with the VM's own configuration every night:

```bash
cat > ~/opencomputer-backup.sh <<'EOF'
#!/bin/sh
set -eu
dest="$HOME/opencomputer-backups"
stage=$(mktemp -d)
trap 'rm -rf "$stage"' EXIT
mkdir -p "$dest" "$stage/computer-gateway/data" "$stage/etc"
sqlite3 "$HOME/computer-gateway/data/gateway.db" ".backup '$stage/computer-gateway/data/gateway.db'"
cp -p "$HOME/computer-gateway/.env" "$HOME/computer-gateway/compose.yaml" \
  "$HOME/computer-gateway/nginx.conf" "$stage/computer-gateway/"
cp -rp /etc/opencomputer /etc/oc-modelproxy/profiles.d/exe-llm.json \
  /etc/systemd/system/opencomputer-exe-integrations.service \
  /etc/systemd/system/slack-presence-host.service.d/30-exe.conf "$stage/etc/"
(umask 077; tar -czf "$dest/opencomputer-$(date +%F).tar.gz" -C "$stage" .)
find "$dest" -name 'opencomputer-*.tar.gz' -mtime +14 -delete
EOF
chmod 0755 ~/opencomputer-backup.sh

sudo tee /etc/systemd/system/opencomputer-backup.service > /dev/null <<EOF
[Unit]
Description=Back up the OpenComputer gateway and configuration

[Service]
Type=oneshot
User=exedev
ExecStart=/home/exedev/opencomputer-backup.sh
EOF
sudo tee /etc/systemd/system/opencomputer-backup.timer > /dev/null <<'EOF'
[Unit]
Description=Nightly OpenComputer backup

[Timer]
OnCalendar=*-*-* 03:30:00
RandomizedDelaySec=30m
Persistent=true

[Install]
WantedBy=timers.target
EOF
sudo systemctl daemon-reload
sudo systemctl enable --now opencomputer-backup.timer
sudo systemctl start opencomputer-backup.service
ls -l ~/opencomputer-backups
tar -tzf ~/opencomputer-backups/opencomputer-$(date +%F).tar.gz
```

Expect one archive listing `./computer-gateway/.env`,
`./computer-gateway/data/gateway.db`, and the files under `./etc/`. The
archive holds `SP_STORE_KEY` and the setup token, so keep copies
somewhere private.

### Open the setup page

```bash
echo "https://$(hostname).exe.xyz:3170/setup?token=$(sed -n 's/^SETUP_TOKEN=//p' ~/computer-gateway/.env)"
```

Open that link in your browser and sign in to exe.dev if asked. It sets
a cookie for 12 hours; open the link again after that. Then
[connect Slack](#connect-slack).

</details>

<details id="back-up-and-restore" class="dp-details">
<summary>Back up and restore</summary>

The nightly archives in `~/opencomputer-backups` hold the gateway and
the VM's OpenComputer configuration. Copy them off the VM now and then.
On your computer:

```bash
scp 'my-opencomputer.exe.xyz:opencomputer-backups/*' ./
```

The sessions themselves live in `/data/people/<person>/sessions`, and
leave the VM through git: work that was pushed is safe in GitHub, and
work that wasn't lives only on the VM. For a copy of the whole disk, see
[VM backups](/docs/vm-backups).

To restore onto a VM with the same name (so Slack's URLs still point at
it), run "Install by hand" through "Set up the workspace", then put the
archive on the VM and, on the VM:

```bash
mkdir -p /tmp/restore && tar -xzf ~/opencomputer-*.tar.gz -C /tmp/restore
cd ~/computer-gateway && docker compose down
cp -p /tmp/restore/computer-gateway/.env /tmp/restore/computer-gateway/compose.yaml \
  /tmp/restore/computer-gateway/nginx.conf ~/computer-gateway/
rm -f data/gateway.db*
cp -p /tmp/restore/computer-gateway/data/gateway.db data/
sudo cp -rp /tmp/restore/etc/opencomputer/. /etc/opencomputer/
sudo cp -p /tmp/restore/etc/exe-llm.json /etc/oc-modelproxy/profiles.d/
HOST_TOKEN=$(sed -n 's/^SP_HOST_TOKENS=//p' .env)
sudo sed -i "s/^SP_HOST_TOKEN=.*/SP_HOST_TOKEN=$HOST_TOKEN/" /etc/slack-presence/host.env
docker compose up -d
sudo systemctl restart slack-presence-host
sleep 10
curl -s localhost:3170/healthz; echo
```

Expect `"mode":"slack"` and the VM in `"hosts"`. On a VM with a
different name, also change `SP_ORIGIN` in `.env`, run `docker compose
up -d` again, and click **Point the app at this origin** on the setup
page, so Slack sends events to the new address.

</details>

<details id="update" class="dp-details">
<summary>Update</summary>

Check [the repository](https://github.com/diggerhq/opencomputer/commits/main/computer)
for changes to `computer/`, and read them: there are no release notes
yet. Then fetch a newer commit, rebuild the gateway, and reinstall the
computer from a new bundle. On the VM:

```bash
OC_COMMIT=<the commit to update to>
git -C ~/opencomputer fetch -q --depth 1 https://github.com/diggerhq/opencomputer.git "$OC_COMMIT"
git -C ~/opencomputer checkout -q FETCH_HEAD
~/opencomputer-backup.sh

cd ~/opencomputer/computer
docker build -q --build-arg SP_VERSION="$(git rev-parse --short=8 HEAD)" -t opencomputer-gateway .
(cd ~/computer-gateway && docker compose up -d)

deploy/bundle.sh /tmp/opencomputer.bundle
sudo install -m 0644 /tmp/opencomputer.bundle /opt/bootstrap/calvin.bundle
sudo git -C /opt/bootstrap/calvin-src fetch -q /opt/bootstrap/calvin.bundle main
sudo git -C /opt/bootstrap/calvin-src reset -q --hard FETCH_HEAD
sudo rm -f /usr/local/bin/claude
HOST_TOKEN=$(sed -n 's/^SP_HOST_TOKENS=//p' ~/computer-gateway/.env)
sudo env CLOUD=none ALLOW_NO_DATA_VOLUME=1 SP_IMAGE_BRANCH=1 \
  REPO_URL=/opt/bootstrap/calvin.bundle REPO_REF=main \
  SP_GATEWAY_URL=ws://127.0.0.1:3170/host SP_HOST_TOKEN="$HOST_TOKEN" SP_HOST_ID="$(hostname)" \
  bash /opt/bootstrap/calvin-src/deploy/vm/provision.sh < /dev/null 2>&1 \
  | tee /tmp/opencomputer-provision.log | grep -E '^(==>|WARNING|ERROR)'
sudo ln -sfn /usr/local/lib/codex/bin/codex /usr/local/bin/codex
curl -s localhost:3170/healthz; echo
```

The new release starts beside the old one: running threads finish on
the version they started with, and `!restart` in a thread moves it to the
new one. Your `exe-llm` profile, workspace, and drop-in are kept.

</details>

<details id="troubleshooting" class="dp-details">
<summary>Troubleshooting</summary>

- **Connect URLs fails, or Slack says the URL didn't respond:** port
  8000 isn't public yet. Run `ssh exe.dev share set-public my-opencomputer`
  on your computer. Once the app is created, `curl -s -o /dev/null -w
  '%{http_code}\n' -X POST https://my-opencomputer.exe.xyz/slack/events`
  from anywhere answers `401` (an unsigned request) when Slack can reach
  it; `404` means the gateway has no Slack app yet.
- **The bot doesn't answer a mention:** is it in the channel
  (`/invite @computer`), and are you in `SP_PEOPLE`? Then
  `cd ~/computer-gateway && docker compose logs --tail=50 gateway`.
- **A thread says it started but never answers:** the model proxy can't
  reach Claude. `sudo journalctl -u oc-modelproxy -n 20` shows
  `"error_type":"connect"` when the integrations unit isn't running
  (`systemctl status opencomputer-exe-integrations`).
- **`provision.sh` stops at `Claude Code CLI` with `EEXIST`:** exeuntu's
  `claude` is back; `sudo rm /usr/local/bin/claude` and run it again.
- **`provision.sh` stops at `AppArmor profile for pasta`:** the stand-in
  `/usr/local/sbin/apparmor_parser` is missing.
- **`hosts` is empty in `/healthz`:** `sudo journalctl -u
  slack-presence-host -n 30`. `401` means `SP_HOST_TOKEN` in
  `/etc/slack-presence/host.env` doesn't match `SP_HOST_TOKENS` in the
  gateway's `.env`.
- **A session can't clone or push:** the repository needs a GitHub
  integration attached to this VM, and its remote in `workspace.json`
  must be `https://github.int.exe.xyz/<owner>/<repo>.git`.
- **A session's own logs:** `sudo journalctl _UID=1500 -n 50`; each
  thread is a `sp-runner-*` unit of the `agent` user.
- **Disk full:** `df -h /` and `sudo du -sh /data/people/*/sessions
  /data/containers`.

</details>

## Frequently asked questions

### How is this different from OpenComputer's hosted service?

At [app.opencomputer.dev](https://app.opencomputer.dev) OpenComputer runs the gateway and your organization's computer in its own cloud. Here both run on one VM you own: Slack talks to it directly, your code and sessions stay on it, and Claude is billed through your exe.dev plan. The hosted service's dashboard, automations, the `opencomputer` CLI and preview URLs aren't part of this setup.

### Why not OpenComputer's own self-hosting guide?

[That guide](https://docs.opencomputer.dev/self-hosting/overview) rebuilds the hosted service: Cloudflare Workers, a domain on Cloudflare, WorkOS sign-in and a GitHub App, plus one cloud VM per organization. This page uses the self-hosted Node gateway from the same repository instead, and exe.dev's proxy, LLM and GitHub integrations in place of the rest.

### Who can use it?

Anyone you list in `SP_PEOPLE` in `~/computer-gateway/.env`; anyone else who mentions the bot gets a private note that they have no access. Every session runs as the same `agent` user on the VM, so the people you list can read each other's workspaces. List people you'd give a shell on the VM.

### Does it work with Codex?

OpenComputer runs `+codex` threads with an `OPENAI_API_KEY`, sent to api.openai.com. This page doesn't set one up, since that key would bypass exe.dev's LLM integration; Claude threads need no key.

### What does it cost?

OpenComputer is free and open source (Apache-2.0). The VM is part of your exe.dev plan, and Claude's tokens count against your plan's LLM usage, like Shelley's.

### Can people see what the agent builds?

A session can serve an app on any port from 3000 to 9999 at `https://my-opencomputer.exe.xyz:<port>/`, behind exe.dev sign-in: [share the VM](/docs/sharing) with teammates who should open those links. Port 8000 is the public Slack endpoint and stays that way.


## Related

- [Run Claude Code on a remote server](https://exe.dev/deploy/claude-code.md): A computer for Claude. A breather for your laptop.
- [Self-host OpenClaw on an always-on server](https://exe.dev/deploy/openclaw.md): An AI sidekick with its own computer. Your laptop can take a nap.
- [Self-host Hermes Agent](https://exe.dev/deploy/hermes-agent.md): An agent that remembers you, on a computer that never sleeps.
- [Running Agents](https://exe.dev/deploy/agents.md): Use exe.dev VMs as a sandbox
- [Run Codex on a remote server](https://exe.dev/deploy/codex.md): A computer for Codex. An early night for your laptop.
- [Run Codex remote control on a server](https://exe.dev/deploy/codex-remote-control.md): Codex on an always-on VM, steered from the ChatGPT app on your phone.
