Self-host OpenComputer
A coding agent you mention in Slack, on a computer you own.
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/stdinOpenComputer 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
/healthzon port 3170 listing the VM underhosts. - The computer (host agent, client relay, and model proxy) as enabled systemd services.
- Claude through exe.dev's LLM integration, by an
exe-llmmodel-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
https://my-opencomputer.exe.xyz/slack/events
Slack's events and buttons, and its OAuth redirect; nothing else
https://my-opencomputer.exe.xyz:3170/setup
the gateway's setup page, behind your exe.dev login and a setup token
agent user
exe-llm profile for exe.dev
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 sessionsGIT_NAME: the name on commits from your sessionsGIT_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/stdinWhen it's done, run this on your computer (only you can):
ssh exe.dev share set-public my-opencomputerWhat 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.
-
Make the Slack endpoint public, on your computer:
ssh exe.dev share set-public my-opencomputerOnly Slack's two paths reach the gateway on port 8000; the setup page and everything else stay private.
-
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-…). -
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.
-
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
claudebinary 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_parserskips that step only when AppArmor is off. - It tells the model proxy which upstream to use through profile files:
exe-llmis 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-opencomputeron your computer. Once the app is created,curl -s -o /dev/null -w '%{http_code}\n' -X POST https://my-opencomputer.exe.xyz/slack/eventsfrom anywhere answers401(an unsigned request) when Slack can reach it;404means the gateway has no Slack app yet. - The bot doesn't answer a mention: is it in the channel
(
/invite @computer), and are you inSP_PEOPLE? Thencd ~/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 20shows"error_type":"connect"when the integrations unit isn't running (systemctl status opencomputer-exe-integrations). provision.shstops atClaude Code CLIwithEEXIST: exeuntu'sclaudeis back;sudo rm /usr/local/bin/claudeand run it again.provision.shstops atAppArmor profile for pasta: the stand-in/usr/local/sbin/apparmor_parseris missing.hostsis empty in/healthz:sudo journalctl -u slack-presence-host -n 30.401meansSP_HOST_TOKENin/etc/slack-presence/host.envdoesn't matchSP_HOST_TOKENSin 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.jsonmust behttps://github.int.exe.xyz/<owner>/<repo>.git. - A session's own logs:
sudo journalctl _UID=1500 -n 50; each thread is asp-runner-*unit of theagentuser. - Disk full:
df -h /andsudo 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