Skip to content

Self-host OpenComputer

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

Deploy on exe.dev

Shelley handles the setup. About 25 minutes. Needs a 50 GB disk: Shelley sends you a link to grow it.

Prefer a terminal?
curl -fsSL https://exe-staging.dev/deploy/opencomputer/prompt.txt | ssh exe.dev new --disk=50GB --prompt=/dev/stdin

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 with no API key, and your repositories through the GitHub integration with no token on the machine.

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.
What's running, and where
Public https://my-opencomputer.exe.xyz/slack/events Slack's events and buttons, and its OAuth redirect; nothing else
Private https://my-opencomputer.exe.xyz:3170/setup the gateway's setup page, behind your exe.dev login and a setup token
my-opencomputer.exe.xyz exe.dev VM
OpenComputer gateway The Node gateway, built from source, in Docker Compose; holds the Slack app and the sessions table :3170~/computer-gateway
nginx Passes only Slack's two endpoints to the gateway; everything else is a 404 :8000
The computer Host agent and one runner per Slack thread, as systemd services; sessions run as the agent user /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

Deploy with Shelley#

Click Deploy and Shelley will set up OpenComputer on a new VM, then check that it works. No config-file wrangling required.

OpenComputer needs a 50 GB disk, more than a new VM has. Shelley checks first and, if it's too small, gives you a link to grow it; the terminal command below makes the VM that size from the start.

Have these ready; Shelley asks for them:

  • SLACK_USER_ID: your Slack member ID (U…): in Slack, click your name, then ⋮ → Copy member ID. Only people listed in the gateway get sessions
  • GIT_NAME: the name on commits from your sessions
  • GIT_EMAIL: the email on commits from your sessions
Prefer a terminal?
curl -fsSL \
  https://exe-staging.dev/deploy/opencomputer/prompt.txt \
  | ssh exe.dev new --disk=50GB --prompt=/dev/stdin

When it's done, run this on your computer (only you can):

ssh exe.dev share set-public my-opencomputer
What Shelley is told
SLACK_USER_ID=<fill-this-in>
GIT_NAME=<fill-this-in>
GIT_EMAIL=<fill-this-in>

Set up OpenComputer on this VM by following the exe.dev recipe at https://exe-staging.dev/deploy/opencomputer.md?via=deploy from top to bottom.

The values at the top of this message are mine:
- SLACK_USER_ID: your Slack member ID (`U…`): in Slack, click your name, then ⋮ → Copy member ID. Only people listed in the gateway get sessions
- GIT_NAME: the name on commits from your sessions
- GIT_EMAIL: the email on commits from your sessions
Ask me for any that still say <fill-this-in> before you need them.

The recipe's example VM name is my-opencomputer. This VM's name is the output of `hostname`: use it wherever the recipe writes my-opencomputer. Skip the step that creates the VM; you are on it.

This recipe needs a 50GB disk, and a new VM's may be smaller. Before you install anything, run `df -h /`. If its size is under 45G, stop and ask me to grow the disk, either with this link: https://exe.dev/suggest?command=resize%20my-opencomputer%20--disk%3D50GB or, on my computer, with `ssh exe.dev resize my-opencomputer --disk=50GB`. When I say it's done, run `sudo resize2fs "$(findmnt -no SOURCE /)"`, check `df -h /` again, and carry on.

You are done when all of these are true. Check each one yourself:
- 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`.

Read the whole recipe, including the closed details. For initial setup,
run "Install by hand" first, skipping VM creation and SSH, with the
owner's SLACK_USER_ID, GIT_NAME and GIT_EMAIL. Run the provisioning
command in the background or in tmux: it takes about five minutes.
Do not run the restore or update instructions.
Never print SETUP_TOKEN, SP_STORE_KEY or the host token, except the one
setup link at the end. Do not create or install the Slack app yourself:
the owner does that in a browser. Never run share set-public (the owner
does); never publish port 3170 or the gateway's /setup or /host.
Verify /healthz on port 3170 lists the VM under hosts, the services
enabled and active, a reply from the model proxy's exe-llm profile, a
404 for / on port 8000, and a tested backup archive. Do not reboot.
Finish with the steps of "Connect Slack", including the setup link from
"Open the setup page" (this conversation is private to the owner), and
"Give it your repositories".

Finish with the URLs I should open and these commands, which only I can run, from my own computer (with this VM's name in them):
  ssh exe.dev share set-public my-opencomputer

Also at /deploy/opencomputer/prompt.txt. The recipe it follows is /deploy/opencomputer.md.

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:

    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, 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. 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 to exe.dev, then add an integration for each repository and attach it to the VM. On your computer:

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:

{
  "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):

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"}]
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:

Install by hand

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

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.

df -h /

If Size is under 45G, grow the disk with this link (with your VM's name), or on your computer with ssh exe.dev resize my-opencomputer --disk=50GB. Then, on the VM:

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:

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:

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:

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:

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.
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:

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:

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:

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, 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:

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:

sudo install -d -m 0755 /etc/opencomputer
sudo curl -fsSL -o /etc/opencomputer/AGENTS.md https://exe-staging.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 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:

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#

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.

Back up and restore

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:

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.

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:

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.

Update

Check the repository 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:

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.

Troubleshooting
  • 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.

Frequently asked questions#

How is this different from OpenComputer's hosted service?

At 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 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 with teammates who should open those links. Port 8000 is the public Slack endpoint and stays that way.

Published Nov 22, 2026 · Updated Nov 21, 2026 · tested end to end Nov 21, 2026 · Markdown · manifest.json · Something wrong? Tell us